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        Self::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        Self::InvalidTag { tag, sum_name }
50    }
51
52    fn allocation_failed(size: usize) -> Self {
53        Self::AllocationFailed(size)
54    }
55}
56
57impl<'de, R: BufReader<'de>> de::Deserializer<'de> for Deserializer<'_, R> {
58    type Error = DecodeError;
59
60    fn deserialize_product<V: de::ProductVisitor<'de>>(self, visitor: V) -> Result<V::Output, DecodeError> {
61        visitor.visit_seq_product(self)
62    }
63
64    fn validate_product<V: de::ProductVisitor<'de>>(self, visitor: V) -> Result<(), Self::Error> {
65        visitor.validate_seq_product(self)
66    }
67
68    fn deserialize_sum<V: de::SumVisitor<'de>>(self, visitor: V) -> Result<V::Output, DecodeError> {
69        visitor.visit_sum(self)
70    }
71
72    fn validate_sum<V: de::SumVisitor<'de>>(self, visitor: V) -> Result<(), Self::Error> {
73        visitor.validate_sum(self)
74    }
75
76    fn deserialize_bool(self) -> Result<bool, Self::Error> {
77        let byte = self.reader.get_u8()?;
78        match byte {
79            0 => Ok(false),
80            1 => Ok(true),
81            b => Err(DecodeError::InvalidBool(b)),
82        }
83    }
84    fn deserialize_u8(self) -> Result<u8, DecodeError> {
85        self.reader.get_u8()
86    }
87    fn deserialize_u16(self) -> Result<u16, DecodeError> {
88        self.reader.get_u16()
89    }
90    fn deserialize_u32(self) -> Result<u32, DecodeError> {
91        self.reader.get_u32()
92    }
93    fn deserialize_u64(self) -> Result<u64, DecodeError> {
94        self.reader.get_u64()
95    }
96    fn deserialize_u128(self) -> Result<u128, DecodeError> {
97        self.reader.get_u128()
98    }
99    fn deserialize_u256(self) -> Result<u256, DecodeError> {
100        self.reader.get_u256()
101    }
102    fn deserialize_i8(self) -> Result<i8, DecodeError> {
103        self.reader.get_i8()
104    }
105    fn deserialize_i16(self) -> Result<i16, DecodeError> {
106        self.reader.get_i16()
107    }
108    fn deserialize_i32(self) -> Result<i32, DecodeError> {
109        self.reader.get_i32()
110    }
111    fn deserialize_i64(self) -> Result<i64, DecodeError> {
112        self.reader.get_i64()
113    }
114    fn deserialize_i128(self) -> Result<i128, DecodeError> {
115        self.reader.get_i128()
116    }
117    fn deserialize_i256(self) -> Result<i256, DecodeError> {
118        self.reader.get_i256()
119    }
120    fn deserialize_f32(self) -> Result<f32, Self::Error> {
121        self.reader.get_u32().map(f32::from_bits)
122    }
123    fn deserialize_f64(self) -> Result<f64, Self::Error> {
124        self.reader.get_u64().map(f64::from_bits)
125    }
126
127    fn deserialize_str<V: de::SliceVisitor<'de, str>>(self, visitor: V) -> Result<V::Output, Self::Error> {
128        let slice = self.deserialize_bytes_inner()?;
129        let slice = core::str::from_utf8(slice)?;
130        visitor.visit_borrowed(slice)
131    }
132
133    fn deserialize_bytes<V: de::SliceVisitor<'de, [u8]>>(self, visitor: V) -> Result<V::Output, Self::Error> {
134        let slice = self.deserialize_bytes_inner()?;
135        visitor.visit_borrowed(slice)
136    }
137
138    fn deserialize_array_seed<V: de::ArrayVisitor<'de, T::Output>, T: de::DeserializeSeed<'de> + Clone>(
139        mut self,
140        visitor: V,
141        seed: T,
142    ) -> Result<V::Output, Self::Error> {
143        let len = self.reborrow().deserialize_len()?;
144        let seeds = itertools::repeat_n(seed, len);
145        visitor.visit(ArrayAccess { de: self, seeds })
146    }
147
148    fn validate_array_seed<V: de::ArrayVisitor<'de, T::Output>, T: de::DeserializeSeed<'de> + Clone>(
149        mut self,
150        visitor: V,
151        seed: T,
152    ) -> Result<(), Self::Error> {
153        let len = self.reborrow().deserialize_len()?;
154        let seeds = itertools::repeat_n(seed, len);
155        visitor.validate(ArrayAccess { de: self, seeds })
156    }
157}
158
159impl<'de, R: BufReader<'de>> SeqProductAccess<'de> for Deserializer<'_, R> {
160    type Error = DecodeError;
161
162    fn next_element_seed<T: de::DeserializeSeed<'de>>(&mut self, seed: T) -> Result<Option<T::Output>, DecodeError> {
163        seed.deserialize(self.reborrow()).map(Some)
164    }
165
166    fn validate_next_element_seed<T: de::DeserializeSeed<'de>>(&mut self, seed: T) -> Result<Option<()>, Self::Error> {
167        seed.validate(self.reborrow()).map(Some)
168    }
169}
170
171impl<'de, R: BufReader<'de>> SumAccess<'de> for Deserializer<'_, R> {
172    type Error = DecodeError;
173    type Variant = Self;
174
175    fn variant<V: de::VariantVisitor<'de>>(self, visitor: V) -> Result<(V::Output, Self::Variant), Self::Error> {
176        let tag = self.reader.get_u8()?;
177        visitor.visit_tag(tag).map(|variant| (variant, self))
178    }
179}
180
181impl<'de, R: BufReader<'de>> VariantAccess<'de> for Deserializer<'_, R> {
182    type Error = DecodeError;
183    fn deserialize_seed<T: de::DeserializeSeed<'de>>(self, seed: T) -> Result<T::Output, Self::Error> {
184        seed.deserialize(self)
185    }
186    fn validate_seed<T: de::DeserializeSeed<'de>>(self, seed: T) -> Result<(), Self::Error> {
187        seed.validate(self)
188    }
189}
190
191/// Deserializer for array elements.
192pub struct ArrayAccess<'a, R, T> {
193    de: Deserializer<'a, R>,
194    seeds: itertools::RepeatN<T>,
195}
196
197impl<'de, R: BufReader<'de>, T: de::DeserializeSeed<'de> + Clone> de::ArrayAccess<'de> for ArrayAccess<'_, R, T> {
198    type Element = T::Output;
199    type Error = DecodeError;
200
201    fn next_element(&mut self) -> Result<Option<T::Output>, Self::Error> {
202        self.seeds
203            .next()
204            .map(|seed| seed.deserialize(self.de.reborrow()))
205            .transpose()
206    }
207
208    fn validate_next_element(&mut self) -> Result<Option<()>, Self::Error> {
209        self.seeds
210            .next()
211            .map(|seed| seed.validate(self.de.reborrow()))
212            .transpose()
213    }
214
215    fn size_hint(&self) -> Option<usize> {
216        Some(self.seeds.len())
217    }
218}
spacetimedb_sats/bsatn/de.rs

spacetimedb_sats/bsatn/
de.rs
