spacetimedb_sats/bsatn/
de.rs

1use crate::buffer::{BufReader, DecodeError};
2use crate::de::{self, Deserializer as _, SeqProductAccess, SumAccess, VariantAccess};
3use crate::{i256, u256};
4
5/// Deserializer from the BSATN data format.
6pub struct Deserializer<'a, R> {
7    // The input to deserialize.
8    reader: &'a mut R,
9}
10
11impl<'a, 'de, R: BufReader<'de>> Deserializer<'a, R> {
12    /// Returns a deserializer using the given `reader`.
13    pub fn new(reader: &'a mut R) -> Self {
14        Self { reader }
15    }
16
17    /// Reborrows the deserializer.
18    #[inline]
19    pub(crate) fn reborrow(&mut self) -> Deserializer<'_, R> {
20        Deserializer { reader: self.reader }
21    }
22
23    /// Reads a length as a `u32` then converted to `usize`.
24    pub(crate) fn deserialize_len(self) -> Result<usize, DecodeError> {
25        Ok(self.deserialize_u32()? as usize)
26    }
27
28    /// Reads a slice of `len` elements.
29    #[inline]
30    #[doc(hidden)]
31    pub fn get_slice(&mut self, len: usize) -> Result<&'de [u8], DecodeError> {
32        self.reader.get_slice(len)
33    }
34
35    /// Reads a byte slice from the `reader`.
36    fn deserialize_bytes_inner(mut self) -> Result<&'de [u8], DecodeError> {
37        let len = self.reborrow().deserialize_len()?;
38        self.get_slice(len)
39    }
40}
41
42impl de::Error for DecodeError {
43    fn custom(msg: impl std::fmt::Display) -> Self {
44        DecodeError::Other(msg.to_string())
45    }
46
47    fn unknown_variant_tag<'de, T: de::SumVisitor<'de>>(tag: u8, expected: &T) -> Self {
48        let sum_name = expected.sum_name().map(|x| x.to_owned());
49        DecodeError::InvalidTag { tag, sum_name }
50    }
51}
52
53impl<'de, R: BufReader<'de>> de::Deserializer<'de> for Deserializer<'_, R> {
54    type Error = DecodeError;
55
56    fn deserialize_product<V: de::ProductVisitor<'de>>(self, visitor: V) -> Result<V::Output, DecodeError> {
57        visitor.visit_seq_product(self)
58    }
59
60    fn deserialize_sum<V: de::SumVisitor<'de>>(self, visitor: V) -> Result<V::Output, DecodeError> {
61        visitor.visit_sum(self)
62    }
63
64    fn deserialize_bool(self) -> Result<bool, Self::Error> {
65        let byte = self.reader.get_u8()?;
66        match byte {
67            0 => Ok(false),
68            1 => Ok(true),
69            b => Err(DecodeError::InvalidBool(b)),
70        }
71    }
72    fn deserialize_u8(self) -> Result<u8, DecodeError> {
73        self.reader.get_u8()
74    }
75    fn deserialize_u16(self) -> Result<u16, DecodeError> {
76        self.reader.get_u16()
77    }
78    fn deserialize_u32(self) -> Result<u32, DecodeError> {
79        self.reader.get_u32()
80    }
81    fn deserialize_u64(self) -> Result<u64, DecodeError> {
82        self.reader.get_u64()
83    }
84    fn deserialize_u128(self) -> Result<u128, DecodeError> {
85        self.reader.get_u128()
86    }
87    fn deserialize_u256(self) -> Result<u256, DecodeError> {
88        self.reader.get_u256()
89    }
90    fn deserialize_i8(self) -> Result<i8, DecodeError> {
91        self.reader.get_i8()
92    }
93    fn deserialize_i16(self) -> Result<i16, DecodeError> {
94        self.reader.get_i16()
95    }
96    fn deserialize_i32(self) -> Result<i32, DecodeError> {
97        self.reader.get_i32()
98    }
99    fn deserialize_i64(self) -> Result<i64, DecodeError> {
100        self.reader.get_i64()
101    }
102    fn deserialize_i128(self) -> Result<i128, DecodeError> {
103        self.reader.get_i128()
104    }
105    fn deserialize_i256(self) -> Result<i256, DecodeError> {
106        self.reader.get_i256()
107    }
108    fn deserialize_f32(self) -> Result<f32, Self::Error> {
109        self.reader.get_u32().map(f32::from_bits)
110    }
111    fn deserialize_f64(self) -> Result<f64, Self::Error> {
112        self.reader.get_u64().map(f64::from_bits)
113    }
114
115    fn deserialize_str<V: de::SliceVisitor<'de, str>>(self, visitor: V) -> Result<V::Output, Self::Error> {
116        let slice = self.deserialize_bytes_inner()?;
117        let slice = core::str::from_utf8(slice)?;
118        visitor.visit_borrowed(slice)
119    }
120
121    fn deserialize_bytes<V: de::SliceVisitor<'de, [u8]>>(self, visitor: V) -> Result<V::Output, Self::Error> {
122        let slice = self.deserialize_bytes_inner()?;
123        visitor.visit_borrowed(slice)
124    }
125
126    fn deserialize_array_seed<V: de::ArrayVisitor<'de, T::Output>, T: de::DeserializeSeed<'de> + Clone>(
127        mut self,
128        visitor: V,
129        seed: T,
130    ) -> Result<V::Output, Self::Error> {
131        let len = self.reborrow().deserialize_len()?;
132        let seeds = itertools::repeat_n(seed, len);
133        visitor.visit(ArrayAccess { de: self, seeds })
134    }
135}
136
137impl<'de, R: BufReader<'de>> SeqProductAccess<'de> for Deserializer<'_, R> {
138    type Error = DecodeError;
139
140    fn next_element_seed<T: de::DeserializeSeed<'de>>(&mut self, seed: T) -> Result<Option<T::Output>, DecodeError> {
141        seed.deserialize(self.reborrow()).map(Some)
142    }
143}
144
145impl<'de, R: BufReader<'de>> SumAccess<'de> for Deserializer<'_, R> {
146    type Error = DecodeError;
147    type Variant = Self;
148
149    fn variant<V: de::VariantVisitor<'de>>(self, visitor: V) -> Result<(V::Output, Self::Variant), Self::Error> {
150        let tag = self.reader.get_u8()?;
151        visitor.visit_tag(tag).map(|variant| (variant, self))
152    }
153}
154
155impl<'de, R: BufReader<'de>> VariantAccess<'de> for Deserializer<'_, R> {
156    type Error = DecodeError;
157    fn deserialize_seed<T: de::DeserializeSeed<'de>>(self, seed: T) -> Result<T::Output, Self::Error> {
158        seed.deserialize(self)
159    }
160}
161
162/// Deserializer for array elements.
163pub struct ArrayAccess<'a, R, T> {
164    de: Deserializer<'a, R>,
165    seeds: itertools::RepeatN<T>,
166}
167
168impl<'de, R: BufReader<'de>, T: de::DeserializeSeed<'de> + Clone> de::ArrayAccess<'de> for ArrayAccess<'_, R, T> {
169    type Element = T::Output;
170    type Error = DecodeError;
171
172    fn next_element(&mut self) -> Result<Option<T::Output>, Self::Error> {
173        self.seeds
174            .next()
175            .map(|seed| seed.deserialize(self.de.reborrow()))
176            .transpose()
177    }
178
179    fn size_hint(&self) -> Option<usize> {
180        Some(self.seeds.len())
181    }
182}
spacetimedb_sats/bsatn/de.rs

spacetimedb_sats/bsatn/
de.rs
