pak 0.7.3

An easy-to-use data pak format for games.
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
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112

use {
    brotli::Decompressor,
    serde::{Deserialize, Serialize},
    snap::read::FrameDecoder,
    std::io::Read,
};

#[cfg(feature = "bake")]
use {brotli::CompressorWriter, snap::write::FrameEncoder, std::io::Write};

/// Describes Brotli-based compression.
#[derive(Clone, Copy, Debug, Deserialize, Serialize)]
pub struct BrotliParams {
    /// Buffer size.
    pub buffer_size: usize,
    /// Compression quality.
    pub quality: u32,
    /// Window size.
    pub window_size: u32,
}

impl Default for BrotliParams {
    fn default() -> Self {
        Self {
            buffer_size: 4096,
            quality: 8,
            window_size: 22,
        }
    }
}

#[derive(Clone, Copy, Debug, Deserialize, Serialize)]
pub enum Compression {
    Brotli(BrotliParams),
    Snap,
}

impl Compression {
    pub fn new_reader<'a>(self, reader: impl Read + 'a) -> Box<dyn Read + 'a> {
        match self {
            Compression::Brotli(b) => Box::new(Decompressor::new(reader, b.buffer_size)),
            Compression::Snap => Box::new(FrameDecoder::new(reader)),
        }
    }

    #[cfg(feature = "bake")]
    pub fn new_writer<'a>(self, writer: impl Write + 'a) -> Box<dyn Write + 'a> {
        match self {
            Compression::Brotli(b) => Box::new(CompressorWriter::new(
                writer,
                b.buffer_size,
                b.quality,
                b.window_size,
            )),
            Compression::Snap => Box::new(FrameEncoder::new(writer)),
        }
    }
}

impl Default for Compression {
    fn default() -> Self {
        Self::Brotli(Default::default())
    }
}

#[cfg(all(test, feature = "bake"))]
mod tests {
    use {
        super::{BrotliParams, Compression},
        std::io::{Read, Write},
    };

    #[test]
    fn brotli_round_trip() {
        let compression = Compression::Brotli(BrotliParams::default());
        let input = b"lossless compression round trip".repeat(32);
        let mut compressed = Vec::new();

        {
            let mut writer = compression.new_writer(&mut compressed);
            writer.write_all(&input).unwrap();
        }

        let mut output = Vec::new();
        compression
            .new_reader(compressed.as_slice())
            .read_to_end(&mut output)
            .unwrap();

        assert_eq!(output, input);
    }

    #[test]
    fn snap_round_trip() {
        let compression = Compression::Snap;
        let input = b"lossless compression round trip".repeat(32);
        let mut compressed = Vec::new();

        {
            let mut writer = compression.new_writer(&mut compressed);
            writer.write_all(&input).unwrap();
        }

        let mut output = Vec::new();
        compression
            .new_reader(compressed.as_slice())
            .read_to_end(&mut output)
            .unwrap();

        assert_eq!(output, input);
    }
}