pmtiles2 0.3.2

A low level implementation of the PMTiles format based on the standard Read and Write (or AsyncRead and AsyncWrite) traits.
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
113
114
115
116
117
118
119
120

use deku::prelude::*;

/// A compression, which is supported in `PMTiles` archives.
#[derive(DekuRead, DekuWrite, Debug, Clone, Copy, PartialEq, Eq)]
#[deku(type = "u8")]
#[deku(endian = "endian", ctx = "endian: deku::ctx::Endian")]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[cfg_attr(feature = "serde", serde(rename_all = "lowercase"))]
pub enum Compression {
    /// Unknown compression
    ///
    /// _This should almost never be used, because some reader
    /// implementations may not know how to handle this._
    Unknown = 0x00,

    /// No compression
    None,

    /// GZIP compression as defined in [RFC 1952](https://www.rfc-editor.org/rfc/rfc1952)
    GZip,

    /// Brotli compression as defined in [RFC 7932](https://www.rfc-editor.org/rfc/rfc7932)
    Brotli,

    /// Zstandard Compression as defined in [RFC 8478](https://www.rfc-editor.org/rfc/rfc8478)
    ///
    /// <div class="warning">
    ///
    /// Note that de-/compression of `ZStd` is not supported on `wasm32` targets. Passing this variant
    /// to [`compress`](crate::util::compress), [`decompress`](crate::util::decompress), or their `_async` / `_all` variants on a WASM target will return an [`Err`].
    ///
    /// </div>
    ZStd,
}

impl Compression {
    /// Returns a option containing the value to which the
    /// `Content-Encoding` HTTP header should be set, when serving
    /// tiles with this compression.
    ///
    /// Returns [`None`] if a concrete `Content-Encoding` could not be determined.
    pub const fn http_content_encoding(&self) -> Option<&'static str> {
        match self {
            Self::GZip => Some("gzip"),
            Self::Brotli => Some("br"),
            Self::ZStd => Some("zstd"),
            _ => None,
        }
    }
}

#[cfg(test)]
mod test {
    use super::*;
    use deku::bitvec::{bitvec, BitSlice, BitVec, Lsb0};

    #[test]
    fn test_http_content_encoding() {
        assert_eq!(Compression::Unknown.http_content_encoding(), None);

        assert_eq!(Compression::None.http_content_encoding(), None);

        assert_eq!(Compression::GZip.http_content_encoding(), Some("gzip"));

        assert_eq!(Compression::Brotli.http_content_encoding(), Some("br"));

        assert_eq!(Compression::ZStd.http_content_encoding(), Some("zstd"));
    }

    #[test]
    fn test_deku_read() -> Result<(), DekuError> {
        let slice = BitSlice::from_slice(&[0]);
        let (rest, val) = Compression::read(slice, deku::ctx::Endian::Little)?;
        assert_eq!(val, Compression::Unknown);
        assert_eq!(rest.len(), 0);

        let slice = BitSlice::from_slice(&[1]);
        let (_, val) = Compression::read(slice, deku::ctx::Endian::Little)?;
        assert_eq!(val, Compression::None);

        let slice = BitSlice::from_slice(&[2]);
        let (_, val) = Compression::read(slice, deku::ctx::Endian::Little)?;
        assert_eq!(val, Compression::GZip);

        let slice = BitSlice::from_slice(&[3]);
        let (_, val) = Compression::read(slice, deku::ctx::Endian::Little)?;
        assert_eq!(val, Compression::Brotli);

        let slice = BitSlice::from_slice(&[4]);
        let (_, val) = Compression::read(slice, deku::ctx::Endian::Little)?;
        assert_eq!(val, Compression::ZStd);

        Ok(())
    }

    #[test]
    fn test_deku_write() -> Result<(), DekuError> {
        let mut output = BitVec::new();
        Compression::Unknown.write(&mut output, deku::ctx::Endian::Little)?;
        assert_eq!(output, bitvec!(0, 0, 0, 0, 0, 0, 0, 0));

        let mut output = BitVec::new();
        Compression::None.write(&mut output, deku::ctx::Endian::Little)?;
        assert_eq!(output, bitvec!(0, 0, 0, 0, 0, 0, 0, 1));

        let mut output = BitVec::new();
        Compression::GZip.write(&mut output, deku::ctx::Endian::Little)?;
        assert_eq!(output, bitvec!(0, 0, 0, 0, 0, 0, 1, 0));

        let mut output = BitVec::new();
        Compression::Brotli.write(&mut output, deku::ctx::Endian::Little)?;
        assert_eq!(output, bitvec!(0, 0, 0, 0, 0, 0, 1, 1));

        let mut output = BitVec::new();
        Compression::ZStd.write(&mut output, deku::ctx::Endian::Little)?;
        assert_eq!(output, bitvec!(0, 0, 0, 0, 0, 1, 0, 0));

        Ok(())
    }
}