serde_binary/
deserializer.rs

1use serde::de::{self, DeserializeSeed, EnumAccess, MapAccess, SeqAccess, VariantAccess, Visitor};
2
3use super::{Error, Result};
4use crate::BinaryReader;
5
6/// Deserializer for binary data.
7pub struct Deserializer<'de> {
8    /// The binary reader to read from.
9    pub reader: BinaryReader<'de>,
10}
11
12impl<'de, 'a> de::Deserializer<'de> for &'a mut Deserializer<'de> {
13    type Error = Error;
14
15    fn deserialize_any<V>(self, _visitor: V) -> Result<V::Value>
16    where
17        V: Visitor<'de>,
18    {
19        panic!("deserialization of any type for binary data format is not supported")
20    }
21
22    fn deserialize_bool<V>(self, visitor: V) -> Result<V::Value>
23    where
24        V: Visitor<'de>,
25    {
26        visitor.visit_bool(self.reader.read_bool()?)
27    }
28
29    fn deserialize_i8<V>(self, visitor: V) -> Result<V::Value>
30    where
31        V: Visitor<'de>,
32    {
33        visitor.visit_i8(self.reader.read_i8()?)
34    }
35
36    fn deserialize_i16<V>(self, visitor: V) -> Result<V::Value>
37    where
38        V: Visitor<'de>,
39    {
40        visitor.visit_i16(self.reader.read_i16()?)
41    }
42
43    fn deserialize_i32<V>(self, visitor: V) -> Result<V::Value>
44    where
45        V: Visitor<'de>,
46    {
47        visitor.visit_i32(self.reader.read_i32()?)
48    }
49
50    fn deserialize_i64<V>(self, visitor: V) -> Result<V::Value>
51    where
52        V: Visitor<'de>,
53    {
54        visitor.visit_i64(self.reader.read_i64()?)
55    }
56
57    fn deserialize_u8<V>(self, visitor: V) -> Result<V::Value>
58    where
59        V: Visitor<'de>,
60    {
61        visitor.visit_u8(self.reader.read_u8()?)
62    }
63
64    fn deserialize_u16<V>(self, visitor: V) -> Result<V::Value>
65    where
66        V: Visitor<'de>,
67    {
68        visitor.visit_u16(self.reader.read_u16()?)
69    }
70
71    fn deserialize_u32<V>(self, visitor: V) -> Result<V::Value>
72    where
73        V: Visitor<'de>,
74    {
75        visitor.visit_u32(self.reader.read_u32()?)
76    }
77
78    fn deserialize_u64<V>(self, visitor: V) -> Result<V::Value>
79    where
80        V: Visitor<'de>,
81    {
82        visitor.visit_u64(self.reader.read_u64()?)
83    }
84
85    fn deserialize_f32<V>(self, visitor: V) -> Result<V::Value>
86    where
87        V: Visitor<'de>,
88    {
89        visitor.visit_f32(self.reader.read_f32()?)
90    }
91
92    fn deserialize_f64<V>(self, visitor: V) -> Result<V::Value>
93    where
94        V: Visitor<'de>,
95    {
96        visitor.visit_f64(self.reader.read_f64()?)
97    }
98
99    fn deserialize_char<V>(self, visitor: V) -> Result<V::Value>
100    where
101        V: Visitor<'de>,
102    {
103        visitor.visit_char(self.reader.read_char()?)
104    }
105
106    fn deserialize_str<V>(self, visitor: V) -> Result<V::Value>
107    where
108        V: Visitor<'de>,
109    {
110        visitor.visit_string(self.reader.read_string()?)
111    }
112
113    fn deserialize_string<V>(self, visitor: V) -> Result<V::Value>
114    where
115        V: Visitor<'de>,
116    {
117        visitor.visit_string(self.reader.read_string()?)
118    }
119
120    fn deserialize_bytes<V>(self, _visitor: V) -> Result<V::Value>
121    where
122        V: Visitor<'de>,
123    {
124        unimplemented!()
125    }
126
127    fn deserialize_byte_buf<V>(self, _visitor: V) -> Result<V::Value>
128    where
129        V: Visitor<'de>,
130    {
131        unimplemented!()
132    }
133
134    fn deserialize_option<V>(self, visitor: V) -> Result<V::Value>
135    where
136        V: Visitor<'de>,
137    {
138        let flag = self.reader.read_u8()?;
139        if flag == 0 {
140            visitor.visit_none()
141        } else {
142            visitor.visit_some(self)
143        }
144    }
145
146    fn deserialize_unit<V>(self, visitor: V) -> Result<V::Value>
147    where
148        V: Visitor<'de>,
149    {
150        self.reader.read_u8()?;
151        visitor.visit_unit()
152    }
153
154    fn deserialize_unit_struct<V>(self, _name: &'static str, visitor: V) -> Result<V::Value>
155    where
156        V: Visitor<'de>,
157    {
158        self.deserialize_unit(visitor)
159    }
160
161    fn deserialize_newtype_struct<V>(self, _name: &'static str, visitor: V) -> Result<V::Value>
162    where
163        V: Visitor<'de>,
164    {
165        visitor.visit_newtype_struct(self)
166    }
167
168    fn deserialize_seq<V>(self, visitor: V) -> Result<V::Value>
169    where
170        V: Visitor<'de>,
171    {
172        let len = self.reader.read_u32()?;
173        let access = SizeAccess::new(self, len);
174        visitor.visit_seq(access)
175    }
176
177    fn deserialize_tuple<V>(self, _len: usize, visitor: V) -> Result<V::Value>
178    where
179        V: Visitor<'de>,
180    {
181        self.deserialize_seq(visitor)
182    }
183
184    fn deserialize_tuple_struct<V>(
185        self,
186        _name: &'static str,
187        _len: usize,
188        visitor: V,
189    ) -> Result<V::Value>
190    where
191        V: Visitor<'de>,
192    {
193        self.deserialize_seq(visitor)
194    }
195
196    fn deserialize_map<V>(self, visitor: V) -> Result<V::Value>
197    where
198        V: Visitor<'de>,
199    {
200        let len = self.reader.read_u32()?;
201        let access = SizeAccess::new(self, len);
202        visitor.visit_map(access)
203    }
204
205    fn deserialize_struct<V>(
206        self,
207        _name: &'static str,
208        _fields: &'static [&'static str],
209        visitor: V,
210    ) -> Result<V::Value>
211    where
212        V: Visitor<'de>,
213    {
214        self.deserialize_map(visitor)
215    }
216
217    fn deserialize_enum<V>(
218        self,
219        _name: &'static str,
220        _variants: &'static [&'static str],
221        visitor: V,
222    ) -> Result<V::Value>
223    where
224        V: Visitor<'de>,
225    {
226        visitor.visit_enum(Enum::new(self))
227    }
228
229    fn deserialize_identifier<V>(self, visitor: V) -> Result<V::Value>
230    where
231        V: Visitor<'de>,
232    {
233        self.deserialize_str(visitor)
234    }
235
236    fn deserialize_ignored_any<V>(self, visitor: V) -> Result<V::Value>
237    where
238        V: Visitor<'de>,
239    {
240        self.deserialize_any(visitor)
241    }
242}
243
244struct SizeAccess<'a, 'de: 'a> {
245    de: &'a mut Deserializer<'de>,
246    size: u32,
247    offset: u32,
248}
249
250impl<'a, 'de> SizeAccess<'a, 'de> {
251    fn new(de: &'a mut Deserializer<'de>, size: u32) -> Self {
252        Self {
253            de,
254            size,
255            offset: 0,
256        }
257    }
258}
259
260impl<'de, 'a> SeqAccess<'de> for SizeAccess<'a, 'de> {
261    type Error = Error;
262
263    fn next_element_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>>
264    where
265        T: DeserializeSeed<'de>,
266    {
267        if self.offset < self.size {
268            self.offset += 1;
269            seed.deserialize(&mut *self.de).map(Some)
270        } else {
271            Ok(None)
272        }
273    }
274}
275
276impl<'de, 'a> MapAccess<'de> for SizeAccess<'a, 'de> {
277    type Error = Error;
278
279    fn next_key_seed<K>(&mut self, seed: K) -> Result<Option<K::Value>>
280    where
281        K: DeserializeSeed<'de>,
282    {
283        if self.offset < self.size {
284            self.offset += 1;
285            seed.deserialize(&mut *self.de).map(Some)
286        } else {
287            Ok(None)
288        }
289    }
290
291    fn next_value_seed<V>(&mut self, seed: V) -> Result<V::Value>
292    where
293        V: DeserializeSeed<'de>,
294    {
295        seed.deserialize(&mut *self.de)
296    }
297}
298
299struct Enum<'a, 'de: 'a> {
300    de: &'a mut Deserializer<'de>,
301}
302
303impl<'a, 'de> Enum<'a, 'de> {
304    fn new(de: &'a mut Deserializer<'de>) -> Self {
305        Enum { de }
306    }
307}
308
309impl<'de, 'a> EnumAccess<'de> for Enum<'a, 'de> {
310    type Error = Error;
311    type Variant = Self;
312
313    fn variant_seed<V>(self, seed: V) -> Result<(V::Value, Self::Variant)>
314    where
315        V: DeserializeSeed<'de>,
316    {
317        let val = seed.deserialize(&mut *self.de)?;
318        Ok((val, self))
319    }
320}
321
322impl<'de, 'a> VariantAccess<'de> for Enum<'a, 'de> {
323    type Error = Error;
324
325    fn unit_variant(self) -> Result<()> {
326        Ok(())
327    }
328
329    fn newtype_variant_seed<T>(self, seed: T) -> Result<T::Value>
330    where
331        T: DeserializeSeed<'de>,
332    {
333        seed.deserialize(self.de)
334    }
335
336    fn tuple_variant<V>(self, _len: usize, visitor: V) -> Result<V::Value>
337    where
338        V: Visitor<'de>,
339    {
340        de::Deserializer::deserialize_seq(self.de, visitor)
341    }
342
343    fn struct_variant<V>(self, _fields: &'static [&'static str], visitor: V) -> Result<V::Value>
344    where
345        V: Visitor<'de>,
346    {
347        de::Deserializer::deserialize_map(self.de, visitor)
348    }
349}
serde_binary/deserializer.rs

serde_binary/
deserializer.rs
