ordcode/
ord_de.rs

1use crate::{Error, FormatVersion, buf::TailReadBytes, Result, params::{SerializerParams, LengthEncoder }};
2use crate::params::{AscendingOrder, PortableBinary, NativeBinary};
3use crate::primitives::SerializableValue;
4use serde::de::IntoDeserializer;
5
6/// `serde` deserializer for binary data format which may preserve lexicographic ordering of values
7///
8/// Please see `Serializer` documentation for more details.
9pub struct Deserializer<R, P> {
10    reader: R,
11    params: P,
12}
13
14impl<'de, R, P> Deserializer<R, P>
15    where R: TailReadBytes,
16          P: SerializerParams,
17{
18    #[must_use]
19    pub fn new(reader: R, params: P) -> Self {
20        Deserializer { reader, params }
21    }
22    pub fn into_reader(self) -> R { self.reader }
23
24    fn visit_bytebuf<V, F>(&mut self, f: F) -> Result<V::Value>
25        where V: serde::de::Visitor<'de>,
26              F: FnOnce(&[u8]) -> Result<V::Value>
27    {
28        let len = P::SeqLenEncoder::read(&mut self.reader)?;
29        self.reader.read(len, f)
30    }
31}
32
33impl<W> FormatVersion<AscendingOrder> for Deserializer<W, AscendingOrder>  {
34    const VERSION: u32 = 1;
35}
36
37impl<W> FormatVersion<PortableBinary> for Deserializer<W, PortableBinary>  {
38    const VERSION: u32 = 1;
39}
40
41impl<W> FormatVersion<NativeBinary> for Deserializer<W, NativeBinary>  {
42    const VERSION: u32 = 1;
43}
44
45macro_rules! impl_nums {
46    ($ty:ty, $dser_method:ident, $visitor_method:ident) => {
47        #[inline]
48        fn $dser_method<V>(self, visitor: V) -> Result<V::Value>
49            where V: serde::de::Visitor<'de>,
50        {
51            let value = <$ty>::from_reader(&mut self.reader, self.params)?;
52            visitor.$visitor_method(value)
53        }
54    }
55}
56
57impl<'a, 'de: 'a, R, P> serde::Deserializer<'de> for &'a mut Deserializer<R, P>
58    where
59        R: TailReadBytes,
60        P: SerializerParams,
61{
62    type Error = Error;
63
64    fn deserialize_any<V>(self, _visitor: V) -> Result<V::Value>
65        where
66            V: serde::de::Visitor<'de>,
67    {
68        Err(Error::DeserializeAnyNotSupported)
69    }
70    impl_nums!(u8,  deserialize_u8,  visit_u8);
71    impl_nums!(u16, deserialize_u16, visit_u16);
72    impl_nums!(u32, deserialize_u32, visit_u32);
73    impl_nums!(u64, deserialize_u64, visit_u64);
74    impl_nums!(i8,  deserialize_i8,  visit_i8);
75    impl_nums!(i16, deserialize_i16, visit_i16);
76    impl_nums!(i32, deserialize_i32, visit_i32);
77    impl_nums!(i64, deserialize_i64, visit_i64);
78    impl_nums!(f32, deserialize_f32, visit_f32);
79    impl_nums!(f64, deserialize_f64, visit_f64);
80    impl_nums!(bool, deserialize_bool, visit_bool);
81
82    serde_if_integer128! {
83        impl_nums!(u128, deserialize_u128, visit_u128);
84        impl_nums!(i128, deserialize_i128, visit_i128);
85    }
86    impl_nums!(char, deserialize_char, visit_char);
87
88    fn deserialize_str<V>(self, visitor: V) -> Result<V::Value>
89        where
90            V: serde::de::Visitor<'de>,
91    {
92        self.visit_bytebuf::<V,_>(|buf| {
93            visitor.visit_str(core::str::from_utf8(buf).map_err(|_| Error::InvalidUtf8Encoding)?)
94        })
95    }
96    fn deserialize_string<V>(self, visitor: V) -> Result<V::Value>
97        where
98            V: serde::de::Visitor<'de>,
99    {
100        #[cfg(not(feature="std"))] return self.deserialize_str(visitor);
101        #[cfg(feature="std")] return self.visit_bytebuf::<V,_>(|buf| {
102            visitor.visit_string(String::from_utf8(Vec::from(buf)).
103                map_err(|_| Error::InvalidUtf8Encoding)?)
104        });
105    }
106    fn deserialize_bytes<V>(self, visitor: V) -> Result<V::Value>
107        where
108            V: serde::de::Visitor<'de>,
109    {
110        self.visit_bytebuf::<V,_>(|buf| {
111            visitor.visit_bytes(buf)
112        })
113    }
114    fn deserialize_byte_buf<V>(self, visitor: V) -> Result<V::Value>
115        where
116            V: serde::de::Visitor<'de>,
117    {
118        self.deserialize_bytes(visitor)
119    }
120    fn deserialize_option<V>(self, visitor: V) -> Result<V::Value>
121        where
122            V: serde::de::Visitor<'de>,
123    {
124        let value = <u8>::from_reader(&mut self.reader, self.params)?;
125        match value {
126            0 => visitor.visit_none(),
127            1 => visitor.visit_some(&mut *self),
128            _ => Err(Error::InvalidTagEncoding),
129        }
130    }
131    fn deserialize_unit<V>(self, visitor: V) -> Result<V::Value>
132        where
133            V: serde::de::Visitor<'de>,
134    {
135        visitor.visit_unit()
136    }
137    fn deserialize_unit_struct<V>(self, _name: &'static str, visitor: V) -> Result<V::Value>
138        where
139            V: serde::de::Visitor<'de>,
140    {
141        visitor.visit_unit()
142    }
143    fn deserialize_newtype_struct<V>(self, _name: &str, visitor: V) -> Result<V::Value>
144        where
145            V: serde::de::Visitor<'de>,
146    {
147        visitor.visit_newtype_struct(self)
148    }
149    fn deserialize_seq<V>(self, visitor: V) -> Result<V::Value>
150        where
151            V: serde::de::Visitor<'de>,
152    {
153        let len = P::SeqLenEncoder::read(&mut self.reader)?;
154        self.deserialize_tuple(len, visitor)
155    }
156    fn deserialize_tuple<V>(self, len: usize, visitor: V) -> Result<V::Value>
157        where
158            V: serde::de::Visitor<'de>,
159    {
160        visitor.visit_seq(SeqAccess { deserializer: self, len })
161    }
162
163    fn deserialize_tuple_struct<V>(
164        self,
165        _name: &'static str,
166        len: usize,
167        visitor: V,
168    ) -> Result<V::Value>
169        where
170            V: serde::de::Visitor<'de>,
171    {
172        self.deserialize_tuple(len, visitor)
173    }
174    fn deserialize_map<V>(self, visitor: V) -> Result<V::Value>
175        where V: serde::de::Visitor<'de>,
176    {
177        let len = P::SeqLenEncoder::read(&mut self.reader)?;
178        visitor.visit_map(MapAccess { deserializer: self, len })
179    }
180    fn deserialize_struct<V>(
181        self,
182        _name: &str,
183        fields: &'static [&'static str],
184        visitor: V,
185    ) -> Result<V::Value>
186        where
187            V: serde::de::Visitor<'de>,
188    {
189        self.deserialize_tuple(fields.len(), visitor)
190    }
191    fn deserialize_enum<V>(
192        self,
193        _enum: &'static str,
194        _variants: &'static [&'static str],
195        visitor: V,
196    ) -> Result<V::Value>
197        where
198            V: serde::de::Visitor<'de>,
199    {
200        impl<'a, 'de: 'a, R, P> serde::de::EnumAccess<'de> for &'a mut Deserializer<R, P>
201            where
202                R: TailReadBytes,
203                P: SerializerParams,
204        {
205            type Error = Error;
206            type Variant = Self;
207
208            fn variant_seed<V>(self, seed: V) -> Result<(V::Value, Self::Variant)>
209                where
210                    V: serde::de::DeserializeSeed<'de>,
211            {
212                let idx = P::DiscriminantEncoder::read(&mut self.reader)?;
213                let val: Result<_> = seed.deserialize(idx.into_deserializer());
214                Ok((val?, self))
215            }
216        }
217        visitor.visit_enum(self)
218    }
219    fn deserialize_identifier<V>(self, _visitor: V) -> Result<V::Value>
220        where
221            V: serde::de::Visitor<'de>,
222    {
223        Err(Error::DeserializeIdentifierNotSupported)
224    }
225
226    fn deserialize_ignored_any<V>(self, _visitor: V) -> Result<V::Value>
227        where
228            V: serde::de::Visitor<'de>,
229    {
230        Err(Error::DeserializeIgnoredAny)
231    }
232    fn is_human_readable(&self) -> bool {
233        false
234    }
235}
236
237struct SeqAccess<'a, R: TailReadBytes, P: SerializerParams> {
238    deserializer: &'a mut Deserializer<R, P>,
239    len: usize,
240}
241
242impl<'a, 'de: 'a, R: TailReadBytes, P: SerializerParams> serde::de::SeqAccess<'de> for SeqAccess<'a, R, P>
243{
244    type Error = Error;
245    fn next_element_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>>
246        where
247            T: serde::de::DeserializeSeed<'de>,
248    {
249        if self.len > 0 {
250            self.len -= 1;
251            let value = seed.deserialize(&mut *self.deserializer)?;
252            Ok(Some(value))
253        } else {
254            Ok(None)
255        }
256    }
257    fn size_hint(&self) -> Option<usize> {
258        Some(self.len)
259    }
260}
261
262struct MapAccess<'a, R: TailReadBytes, P: SerializerParams> {
263    deserializer: &'a mut Deserializer<R, P>,
264    len: usize,
265}
266impl<'a, 'de: 'a, R: TailReadBytes, P: SerializerParams> serde::de::MapAccess<'de> for MapAccess<'a, R, P>
267{
268    type Error = Error;
269    fn next_key_seed<K>(&mut self, seed: K) -> Result<Option<K::Value>>
270        where
271            K: serde::de::DeserializeSeed<'de>,
272    {
273        if self.len > 0 {
274            self.len -= 1;
275            let key = seed.deserialize(&mut *self.deserializer)?;
276            Ok(Some(key))
277        } else {
278            Ok(None)
279        }
280    }
281    fn next_value_seed<V>(&mut self, seed: V) -> Result<V::Value>
282        where
283            V: serde::de::DeserializeSeed<'de>,
284    {
285        let value = seed.deserialize(&mut *self.deserializer)?;
286        Ok(value)
287    }
288    fn size_hint(&self) -> Option<usize> {
289        Some(self.len)
290    }
291}
292
293impl<'a, 'de: 'a, R, P> serde::de::VariantAccess<'de> for &'a mut Deserializer<R, P>
294    where R: TailReadBytes,
295          P: SerializerParams,
296{
297    type Error = Error;
298
299    fn unit_variant(self) -> Result {
300        Ok(())
301    }
302    fn newtype_variant_seed<T>(self, seed: T) -> Result<T::Value>
303        where
304            T: serde::de::DeserializeSeed<'de>,
305    {
306        seed.deserialize(self)
307    }
308
309    fn tuple_variant<V>(self, len: usize, visitor: V) -> Result<V::Value>
310        where
311            V: serde::de::Visitor<'de>,
312    {
313        serde::Deserializer::deserialize_tuple(self, len, visitor)
314    }
315
316    fn struct_variant<V>(self, fields: &'static [&'static str], visitor: V) -> Result<V::Value>
317        where
318            V: serde::de::Visitor<'de>,
319    {
320        serde::Deserializer::deserialize_tuple(self, fields.len(), visitor)
321    }
322}
323
ordcode/ord_de.rs

ordcode/
ord_de.rs
