enfusion_pak 0.2.0

A library/cli for reading Enfusion game engine `.pak` files.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93

use std::fmt::Debug;
use std::path::Path;
use std::path::PathBuf;

#[cfg(feature = "async_vfs")]
use async_trait::async_trait;
use vfs::VfsError;

use crate::PakFile;
#[cfg(feature = "async_vfs")]
use crate::async_pak_vfs::AsyncPrime;
use crate::pak_vfs::Prime;

/// A [`PakFile`] wrapper which retains the source path from some bytes source (e.g. mmap'd file)
#[allow(unused)]
pub struct BytesPakFileWrapper<T> {
    path: PathBuf,
    source: T,
    pak_file: PakFile,
}

impl<T> BytesPakFileWrapper<T> {
    pub fn new(path: PathBuf, source: T, pak_file: PakFile) -> Self {
        Self { path, source, pak_file }
    }

    pub fn path(&self) -> &Path {
        self.path.as_path()
    }

    pub fn pak_file(&self) -> &PakFile {
        &self.pak_file
    }

    pub fn pak_file_mut(&mut self) -> &mut PakFile {
        &mut self.pak_file
    }

    pub fn source(&self) -> &T {
        &self.source
    }
}

impl<T> BytesPakFileWrapper<T>
where
    T: AsRef<[u8]>,
{
    fn source_bytes(&self) -> &[u8] {
        self.source.as_ref()
    }
}

impl<T> Debug for BytesPakFileWrapper<T>
where
    T: Debug,
{
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.debug_struct("BytesPakFileWrapper")
            .field("path", &self.path)
            .field("source", &self.source)
            .field("pak_file", &self.pak_file)
            .finish()
    }
}

impl<T> AsRef<PakFile> for BytesPakFileWrapper<T> {
    fn as_ref(&self) -> &PakFile {
        &self.pak_file
    }
}

impl<T> Prime for BytesPakFileWrapper<T>
where
    T: AsRef<[u8]>,
{
    fn prime_file(&self, file_range: std::ops::Range<usize>) -> Result<impl AsRef<[u8]>, VfsError> {
        Ok(&self.source_bytes()[file_range])
    }
}

#[cfg(feature = "async_vfs")]
#[async_trait]
impl<T> AsyncPrime for BytesPakFileWrapper<T>
where
    T: AsRef<[u8]> + Sync,
{
    async fn prime_file(
        &self,
        file_range: std::ops::Range<usize>,
    ) -> Result<impl AsRef<[u8]>, VfsError> {
        Ok(&self.source_bytes()[file_range])
    }
}