naia_shared/connection/
decoder.rs

1cfg_if! {
2    if #[cfg(feature = "zstd_support")]
3    {
4        use zstd::bulk::Decompressor;
5
6        use super::compression_config::CompressionMode;
7
8        pub struct Decoder {
9            result: Vec<u8>,
10            decoder: Option<Decompressor<'static>>,
11        }
12
13        impl Decoder {
14            pub fn new(compression_mode: CompressionMode) -> Self {
15                let decoder = match compression_mode {
16                    CompressionMode::Training(_) => None,
17                    CompressionMode::Default(_) => {
18                        Some(Decompressor::new().expect("error creating Decompressor"))
19                    }
20                    CompressionMode::Dictionary(_, dictionary) => Some(
21                        Decompressor::with_dictionary(&dictionary).expect("error creating Decompressor"),
22                    ),
23                };
24
25                Self {
26                    decoder,
27                    result: Vec::new(),
28                }
29            }
30
31            pub fn decode(&mut self, payload: &[u8]) -> &[u8] {
32                if let Some(decoder) = &mut self.decoder {
33                    self.result = decoder
34                        .decompress(
35                            payload,
36                            Decompressor::<'static>::upper_bound(payload)
37                                .expect("upper bound decode error"),
38                        )
39                        .expect("decode error");
40                    return &self.result;
41                } else {
42                    self.result = payload.to_vec();
43                    return &self.result;
44                }
45            }
46        }
47    }
48    else
49    {
50        use super::compression_config::CompressionMode;
51
52        pub struct Decoder {
53            result: Vec<u8>,
54        }
55
56        impl Decoder {
57            pub fn new(_: CompressionMode) -> Self {
58                Self {
59                    result: Vec::new(),
60                }
61            }
62
63            pub fn decode(&mut self, payload: &[u8]) -> &[u8] {
64                self.result = payload.to_vec();
65                &self.result
66            }
67        }
68    }
69}