postcard/de/
deserializer.rs

Help
1use serde::de::{self, DeserializeSeed, IntoDeserializer, Visitor};
2
3use crate::de::flavors::{Flavor, Slice};
4use crate::error::{Error, Result};
5use crate::varint::{max_of_last_byte, varint_max};
6use core::marker::PhantomData;
7
8/// A `serde` compatible deserializer, generic over “Flavors” of deserializing plugins.
9///
10/// Please note that postcard messages are not self-describing and therefore incompatible with
11/// [internally tagged enums](https://serde.rs/enum-representations.html#internally-tagged).
12pub struct Deserializer<'de, F: Flavor<'de>> {
13    flavor: F,
14    _plt: PhantomData<&'de ()>,
15}
16
17impl<'de, F> Deserializer<'de, F>
18where
19    F: Flavor<'de> + 'de,
20{
21    /// Obtain a Deserializer from a slice of bytes
22    pub fn from_flavor(flavor: F) -> Self {
23        Deserializer {
24            flavor,
25            _plt: PhantomData,
26        }
27    }
28
29    /// Return the remaining (unused) bytes in the Deserializer along with any
30    /// additional data provided by the [`Flavor`]
31    pub fn finalize(self) -> Result<F::Remainder> {
32        self.flavor.finalize()
33    }
34}
35
36impl<'de> Deserializer<'de, Slice<'de>> {
37    /// Obtain a Deserializer from a slice of bytes
38    pub fn from_bytes(input: &'de [u8]) -> Self {
39        Deserializer {
40            flavor: Slice::new(input),
41            _plt: PhantomData,
42        }
43    }
44}
45
46impl<'de, F: Flavor<'de>> Deserializer<'de, F> {
47    #[cfg(target_pointer_width = "16")]
48    #[inline(always)]
49    fn try_take_varint_usize(&mut self) -> Result<usize> {
50        self.try_take_varint_u16().map(|u| u as usize)
51    }
52
53    #[cfg(target_pointer_width = "32")]
54    #[inline(always)]
55    fn try_take_varint_usize(&mut self) -> Result<usize> {
56        self.try_take_varint_u32().map(|u| u as usize)
57    }
58
59    #[cfg(target_pointer_width = "64")]
60    #[inline(always)]
61    fn try_take_varint_usize(&mut self) -> Result<usize> {
62        self.try_take_varint_u64().map(|u| u as usize)
63    }
64
65    #[inline]
66    fn try_take_varint_u16(&mut self) -> Result<u16> {
67        let mut out = 0;
68        for i in 0..varint_max::<u16>() {
69            let val = self.flavor.pop()?;
70            let carry = (val & 0x7F) as u16;
71            out |= carry << (7 * i);
72
73            if (val & 0x80) == 0 {
74                if i == varint_max::<u16>() - 1 && val > max_of_last_byte::<u16>() {
75                    return Err(Error::DeserializeBadVarint);
76                } else {
77                    return Ok(out);
78                }
79            }
80        }
81        Err(Error::DeserializeBadVarint)
82    }
83
84    #[inline]
85    fn try_take_varint_u32(&mut self) -> Result<u32> {
86        let mut out = 0;
87        for i in 0..varint_max::<u32>() {
88            let val = self.flavor.pop()?;
89            let carry = (val & 0x7F) as u32;
90            out |= carry << (7 * i);
91
92            if (val & 0x80) == 0 {
93                if i == varint_max::<u32>() - 1 && val > max_of_last_byte::<u32>() {
94                    return Err(Error::DeserializeBadVarint);
95                } else {
96                    return Ok(out);
97                }
98            }
99        }
100        Err(Error::DeserializeBadVarint)
101    }
102
103    #[inline]
104    fn try_take_varint_u64(&mut self) -> Result<u64> {
105        let mut out = 0;
106        for i in 0..varint_max::<u64>() {
107            let val = self.flavor.pop()?;
108            let carry = (val & 0x7F) as u64;
109            out |= carry << (7 * i);
110
111            if (val & 0x80) == 0 {
112                if i == varint_max::<u64>() - 1 && val > max_of_last_byte::<u64>() {
113                    return Err(Error::DeserializeBadVarint);
114                } else {
115                    return Ok(out);
116                }
117            }
118        }
119        Err(Error::DeserializeBadVarint)
120    }
121
122    #[inline]
123    fn try_take_varint_u128(&mut self) -> Result<u128> {
124        let mut out = 0;
125        for i in 0..varint_max::<u128>() {
126            let val = self.flavor.pop()?;
127            let carry = (val & 0x7F) as u128;
128            out |= carry << (7 * i);
129
130            if (val & 0x80) == 0 {
131                if i == varint_max::<u128>() - 1 && val > max_of_last_byte::<u128>() {
132                    return Err(Error::DeserializeBadVarint);
133                } else {
134                    return Ok(out);
135                }
136            }
137        }
138        Err(Error::DeserializeBadVarint)
139    }
140}
141
142struct SeqAccess<'a, 'b, F: Flavor<'b>> {
143    deserializer: &'a mut Deserializer<'b, F>,
144    len: usize,
145}
146
147impl<'a, 'b: 'a, F: Flavor<'b>> serde::de::SeqAccess<'b> for SeqAccess<'a, 'b, F> {
148    type Error = Error;
149
150    #[inline]
151    fn next_element_seed<V: DeserializeSeed<'b>>(&mut self, seed: V) -> Result<Option<V::Value>> {
152        if self.len > 0 {
153            self.len -= 1;
154            Ok(Some(DeserializeSeed::deserialize(
155                seed,
156                &mut *self.deserializer,
157            )?))
158        } else {
159            Ok(None)
160        }
161    }
162
163    #[inline]
164    fn size_hint(&self) -> Option<usize> {
165        match self.deserializer.flavor.size_hint() {
166            Some(size) if size < self.len => None,
167            _ => Some(self.len),
168        }
169    }
170}
171
172struct MapAccess<'a, 'b, F: Flavor<'b>> {
173    deserializer: &'a mut Deserializer<'b, F>,
174    len: usize,
175}
176
177impl<'a, 'b: 'a, F: Flavor<'b>> serde::de::MapAccess<'b> for MapAccess<'a, 'b, F> {
178    type Error = Error;
179
180    #[inline]
181    fn next_key_seed<K: DeserializeSeed<'b>>(&mut self, seed: K) -> Result<Option<K::Value>> {
182        if self.len > 0 {
183            self.len -= 1;
184            Ok(Some(DeserializeSeed::deserialize(
185                seed,
186                &mut *self.deserializer,
187            )?))
188        } else {
189            Ok(None)
190        }
191    }
192
193    #[inline]
194    fn next_value_seed<V: DeserializeSeed<'b>>(&mut self, seed: V) -> Result<V::Value> {
195        DeserializeSeed::deserialize(seed, &mut *self.deserializer)
196    }
197
198    #[inline]
199    fn size_hint(&self) -> Option<usize> {
200        Some(self.len)
201    }
202}
203
204impl<'de, F: Flavor<'de>> de::Deserializer<'de> for &mut Deserializer<'de, F> {
205    type Error = Error;
206
207    #[inline]
208    fn is_human_readable(&self) -> bool {
209        false
210    }
211
212    // Postcard does not support structures not known at compile time
213    #[inline]
214    fn deserialize_any<V>(self, _visitor: V) -> Result<V::Value>
215    where
216        V: Visitor<'de>,
217    {
218        // We wont ever support this.
219        Err(Error::WontImplement)
220    }
221
222    // Take a boolean encoded as a u8
223    #[inline]
224    fn deserialize_bool<V>(self, visitor: V) -> Result<V::Value>
225    where
226        V: Visitor<'de>,
227    {
228        let val = match self.flavor.pop()? {
229            0 => false,
230            1 => true,
231            _ => return Err(Error::DeserializeBadBool),
232        };
233        visitor.visit_bool(val)
234    }
235
236    #[inline]
237    fn deserialize_i8<V>(self, visitor: V) -> Result<V::Value>
238    where
239        V: Visitor<'de>,
240    {
241        visitor.visit_i8(self.flavor.pop()? as i8)
242    }
243
244    #[inline]
245    fn deserialize_i16<V>(self, visitor: V) -> Result<V::Value>
246    where
247        V: Visitor<'de>,
248    {
249        let v = self.try_take_varint_u16()?;
250        visitor.visit_i16(de_zig_zag_i16(v))
251    }
252
253    #[inline]
254    fn deserialize_i32<V>(self, visitor: V) -> Result<V::Value>
255    where
256        V: Visitor<'de>,
257    {
258        let v = self.try_take_varint_u32()?;
259        visitor.visit_i32(de_zig_zag_i32(v))
260    }
261
262    #[inline]
263    fn deserialize_i64<V>(self, visitor: V) -> Result<V::Value>
264    where
265        V: Visitor<'de>,
266    {
267        let v = self.try_take_varint_u64()?;
268        visitor.visit_i64(de_zig_zag_i64(v))
269    }
270
271    #[inline]
272    fn deserialize_i128<V>(self, visitor: V) -> Result<V::Value>
273    where
274        V: Visitor<'de>,
275    {
276        let v = self.try_take_varint_u128()?;
277        visitor.visit_i128(de_zig_zag_i128(v))
278    }
279
280    #[inline]
281    fn deserialize_u8<V>(self, visitor: V) -> Result<V::Value>
282    where
283        V: Visitor<'de>,
284    {
285        visitor.visit_u8(self.flavor.pop()?)
286    }
287
288    #[inline]
289    fn deserialize_u16<V>(self, visitor: V) -> Result<V::Value>
290    where
291        V: Visitor<'de>,
292    {
293        let v = self.try_take_varint_u16()?;
294        visitor.visit_u16(v)
295    }
296
297    #[inline]
298    fn deserialize_u32<V>(self, visitor: V) -> Result<V::Value>
299    where
300        V: Visitor<'de>,
301    {
302        let v = self.try_take_varint_u32()?;
303        visitor.visit_u32(v)
304    }
305
306    #[inline]
307    fn deserialize_u64<V>(self, visitor: V) -> Result<V::Value>
308    where
309        V: Visitor<'de>,
310    {
311        let v = self.try_take_varint_u64()?;
312        visitor.visit_u64(v)
313    }
314
315    #[inline]
316    fn deserialize_u128<V>(self, visitor: V) -> Result<V::Value>
317    where
318        V: Visitor<'de>,
319    {
320        let v = self.try_take_varint_u128()?;
321        visitor.visit_u128(v)
322    }
323
324    #[inline]
325    fn deserialize_f32<V>(self, visitor: V) -> Result<V::Value>
326    where
327        V: Visitor<'de>,
328    {
329        let bytes = self.flavor.try_take_n(4)?;
330        let mut buf = [0u8; 4];
331        buf.copy_from_slice(bytes);
332        visitor.visit_f32(f32::from_bits(u32::from_le_bytes(buf)))
333    }
334
335    #[inline]
336    fn deserialize_f64<V>(self, visitor: V) -> Result<V::Value>
337    where
338        V: Visitor<'de>,
339    {
340        let bytes = self.flavor.try_take_n(8)?;
341        let mut buf = [0u8; 8];
342        buf.copy_from_slice(bytes);
343        visitor.visit_f64(f64::from_bits(u64::from_le_bytes(buf)))
344    }
345
346    #[inline]
347    fn deserialize_char<V>(self, visitor: V) -> Result<V::Value>
348    where
349        V: Visitor<'de>,
350    {
351        let sz = self.try_take_varint_usize()?;
352        if sz > 4 {
353            return Err(Error::DeserializeBadChar);
354        }
355        let bytes: &'de [u8] = self.flavor.try_take_n(sz)?;
356        // we pass the character through string conversion because
357        // this handles transforming the array of code units to a
358        // codepoint. we can't use char::from_u32() because it expects
359        // an already-processed codepoint.
360        let character = core::str::from_utf8(bytes)
361            .map_err(|_| Error::DeserializeBadChar)?
362            .chars()
363            .next()
364            .ok_or(Error::DeserializeBadChar)?;
365        visitor.visit_char(character)
366    }
367
368    #[inline]
369    fn deserialize_str<V>(self, visitor: V) -> Result<V::Value>
370    where
371        V: Visitor<'de>,
372    {
373        let sz = self.try_take_varint_usize()?;
374        let bytes: &'de [u8] = self.flavor.try_take_n(sz)?;
375        let str_sl = core::str::from_utf8(bytes).map_err(|_| Error::DeserializeBadUtf8)?;
376
377        visitor.visit_borrowed_str(str_sl)
378    }
379
380    #[inline]
381    fn deserialize_string<V>(self, visitor: V) -> Result<V::Value>
382    where
383        V: Visitor<'de>,
384    {
385        self.deserialize_str(visitor)
386    }
387
388    #[inline]
389    fn deserialize_bytes<V>(self, visitor: V) -> Result<V::Value>
390    where
391        V: Visitor<'de>,
392    {
393        let sz = self.try_take_varint_usize()?;
394        let bytes: &'de [u8] = self.flavor.try_take_n(sz)?;
395        visitor.visit_borrowed_bytes(bytes)
396    }
397
398    #[inline]
399    fn deserialize_byte_buf<V>(self, visitor: V) -> Result<V::Value>
400    where
401        V: Visitor<'de>,
402    {
403        self.deserialize_bytes(visitor)
404    }
405
406    #[inline]
407    fn deserialize_option<V>(self, visitor: V) -> Result<V::Value>
408    where
409        V: Visitor<'de>,
410    {
411        match self.flavor.pop()? {
412            0 => visitor.visit_none(),
413            1 => visitor.visit_some(self),
414            _ => Err(Error::DeserializeBadOption),
415        }
416    }
417
418    // In Serde, unit means an anonymous value containing no data.
419    // Unit is not actually encoded in Postcard.
420    #[inline]
421    fn deserialize_unit<V>(self, visitor: V) -> Result<V::Value>
422    where
423        V: Visitor<'de>,
424    {
425        visitor.visit_unit()
426    }
427
428    // Unit struct means a named value containing no data.
429    // Unit structs are not actually encoded in Postcard.
430    #[inline]
431    fn deserialize_unit_struct<V>(self, _name: &'static str, visitor: V) -> Result<V::Value>
432    where
433        V: Visitor<'de>,
434    {
435        self.deserialize_unit(visitor)
436    }
437
438    #[inline]
439    fn deserialize_newtype_struct<V>(self, _name: &'static str, visitor: V) -> Result<V::Value>
440    where
441        V: Visitor<'de>,
442    {
443        visitor.visit_newtype_struct(self)
444    }
445
446    #[inline]
447    fn deserialize_seq<V>(self, visitor: V) -> Result<V::Value>
448    where
449        V: Visitor<'de>,
450    {
451        let len = self.try_take_varint_usize()?;
452
453        visitor.visit_seq(SeqAccess {
454            deserializer: self,
455            len,
456        })
457    }
458
459    #[inline]
460    fn deserialize_tuple<V>(self, len: usize, visitor: V) -> Result<V::Value>
461    where
462        V: Visitor<'de>,
463    {
464        visitor.visit_seq(SeqAccess {
465            deserializer: self,
466            len,
467        })
468    }
469
470    #[inline]
471    fn deserialize_tuple_struct<V>(
472        self,
473        _name: &'static str,
474        len: usize,
475        visitor: V,
476    ) -> Result<V::Value>
477    where
478        V: Visitor<'de>,
479    {
480        self.deserialize_tuple(len, visitor)
481    }
482
483    #[inline]
484    fn deserialize_map<V>(self, visitor: V) -> Result<V::Value>
485    where
486        V: Visitor<'de>,
487    {
488        let len = self.try_take_varint_usize()?;
489
490        visitor.visit_map(MapAccess {
491            deserializer: self,
492            len,
493        })
494    }
495
496    #[inline]
497    fn deserialize_struct<V>(
498        self,
499        _name: &'static str,
500        fields: &'static [&'static str],
501        visitor: V,
502    ) -> Result<V::Value>
503    where
504        V: Visitor<'de>,
505    {
506        self.deserialize_tuple(fields.len(), visitor)
507    }
508
509    #[inline]
510    fn deserialize_enum<V>(
511        self,
512        _name: &'static str,
513        _variants: &'static [&'static str],
514        visitor: V,
515    ) -> Result<V::Value>
516    where
517        V: Visitor<'de>,
518    {
519        visitor.visit_enum(self)
520    }
521
522    // As a binary format, Postcard does not encode identifiers
523    #[inline]
524    fn deserialize_identifier<V>(self, _visitor: V) -> Result<V::Value>
525    where
526        V: Visitor<'de>,
527    {
528        // Will not support
529        Err(Error::WontImplement)
530    }
531
532    #[inline]
533    fn deserialize_ignored_any<V>(self, _visitor: V) -> Result<V::Value>
534    where
535        V: Visitor<'de>,
536    {
537        // Will not support
538        Err(Error::WontImplement)
539    }
540}
541
542impl<'de, F: Flavor<'de>> serde::de::VariantAccess<'de> for &mut Deserializer<'de, F> {
543    type Error = Error;
544
545    #[inline]
546    fn unit_variant(self) -> Result<()> {
547        Ok(())
548    }
549
550    #[inline]
551    fn newtype_variant_seed<V: DeserializeSeed<'de>>(self, seed: V) -> Result<V::Value> {
552        DeserializeSeed::deserialize(seed, self)
553    }
554
555    #[inline]
556    fn tuple_variant<V: Visitor<'de>>(self, len: usize, visitor: V) -> Result<V::Value> {
557        serde::de::Deserializer::deserialize_tuple(self, len, visitor)
558    }
559
560    #[inline]
561    fn struct_variant<V: Visitor<'de>>(
562        self,
563        fields: &'static [&'static str],
564        visitor: V,
565    ) -> Result<V::Value> {
566        serde::de::Deserializer::deserialize_tuple(self, fields.len(), visitor)
567    }
568}
569
570impl<'de, F: Flavor<'de>> serde::de::EnumAccess<'de> for &mut Deserializer<'de, F> {
571    type Error = Error;
572    type Variant = Self;
573
574    #[inline]
575    fn variant_seed<V: DeserializeSeed<'de>>(self, seed: V) -> Result<(V::Value, Self)> {
576        let varint = self.try_take_varint_u32()?;
577        let v = DeserializeSeed::deserialize(seed, varint.into_deserializer())?;
578        Ok((v, self))
579    }
580}
581
582fn de_zig_zag_i16(n: u16) -> i16 {
583    ((n >> 1) as i16) ^ (-((n & 0b1) as i16))
584}
585
586fn de_zig_zag_i32(n: u32) -> i32 {
587    ((n >> 1) as i32) ^ (-((n & 0b1) as i32))
588}
589
590fn de_zig_zag_i64(n: u64) -> i64 {
591    ((n >> 1) as i64) ^ (-((n & 0b1) as i64))
592}
593
594fn de_zig_zag_i128(n: u128) -> i128 {
595    ((n >> 1) as i128) ^ (-((n & 0b1) as i128))
596}
postcard/de/deserializer.rs

postcard/de/
deserializer.rs
