postcard/de/
deserializer.rs

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_temp(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_temp(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: &[u8] = self.flavor.try_take_n_temp(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        let sz = self.try_take_varint_usize()?;
386        let bytes: &[u8] = self.flavor.try_take_n_temp(sz)?;
387        let str_sl = core::str::from_utf8(bytes).map_err(|_| Error::DeserializeBadUtf8)?;
388
389        visitor.visit_str(str_sl)
390    }
391
392    #[inline]
393    fn deserialize_bytes<V>(self, visitor: V) -> Result<V::Value>
394    where
395        V: Visitor<'de>,
396    {
397        let sz = self.try_take_varint_usize()?;
398        let bytes: &'de [u8] = self.flavor.try_take_n(sz)?;
399        visitor.visit_borrowed_bytes(bytes)
400    }
401
402    #[inline]
403    fn deserialize_byte_buf<V>(self, visitor: V) -> Result<V::Value>
404    where
405        V: Visitor<'de>,
406    {
407        let sz = self.try_take_varint_usize()?;
408        let bytes: &[u8] = self.flavor.try_take_n_temp(sz)?;
409        visitor.visit_bytes(bytes)
410    }
411
412    #[inline]
413    fn deserialize_option<V>(self, visitor: V) -> Result<V::Value>
414    where
415        V: Visitor<'de>,
416    {
417        match self.flavor.pop()? {
418            0 => visitor.visit_none(),
419            1 => visitor.visit_some(self),
420            _ => Err(Error::DeserializeBadOption),
421        }
422    }
423
424    // In Serde, unit means an anonymous value containing no data.
425    // Unit is not actually encoded in Postcard.
426    #[inline]
427    fn deserialize_unit<V>(self, visitor: V) -> Result<V::Value>
428    where
429        V: Visitor<'de>,
430    {
431        visitor.visit_unit()
432    }
433
434    // Unit struct means a named value containing no data.
435    // Unit structs are not actually encoded in Postcard.
436    #[inline]
437    fn deserialize_unit_struct<V>(self, _name: &'static str, visitor: V) -> Result<V::Value>
438    where
439        V: Visitor<'de>,
440    {
441        self.deserialize_unit(visitor)
442    }
443
444    #[inline]
445    fn deserialize_newtype_struct<V>(self, _name: &'static str, visitor: V) -> Result<V::Value>
446    where
447        V: Visitor<'de>,
448    {
449        visitor.visit_newtype_struct(self)
450    }
451
452    #[inline]
453    fn deserialize_seq<V>(self, visitor: V) -> Result<V::Value>
454    where
455        V: Visitor<'de>,
456    {
457        let len = self.try_take_varint_usize()?;
458
459        visitor.visit_seq(SeqAccess {
460            deserializer: self,
461            len,
462        })
463    }
464
465    #[inline]
466    fn deserialize_tuple<V>(self, len: usize, visitor: V) -> Result<V::Value>
467    where
468        V: Visitor<'de>,
469    {
470        visitor.visit_seq(SeqAccess {
471            deserializer: self,
472            len,
473        })
474    }
475
476    #[inline]
477    fn deserialize_tuple_struct<V>(
478        self,
479        name: &'static str,
480        len: usize,
481        visitor: V,
482    ) -> Result<V::Value>
483    where
484        V: Visitor<'de>,
485    {
486        if name.as_ptr() == crate::byte_array::TOKEN.as_ptr() {
487            let bytes: &'de [u8] = self.flavor.try_take_n(len)?;
488            visitor.visit_borrowed_bytes(bytes)
489        } else {
490            self.deserialize_tuple(len, visitor)
491        }
492    }
493
494    #[inline]
495    fn deserialize_map<V>(self, visitor: V) -> Result<V::Value>
496    where
497        V: Visitor<'de>,
498    {
499        let len = self.try_take_varint_usize()?;
500
501        visitor.visit_map(MapAccess {
502            deserializer: self,
503            len,
504        })
505    }
506
507    #[inline]
508    fn deserialize_struct<V>(
509        self,
510        _name: &'static str,
511        fields: &'static [&'static str],
512        visitor: V,
513    ) -> Result<V::Value>
514    where
515        V: Visitor<'de>,
516    {
517        self.deserialize_tuple(fields.len(), visitor)
518    }
519
520    #[inline]
521    fn deserialize_enum<V>(
522        self,
523        _name: &'static str,
524        _variants: &'static [&'static str],
525        visitor: V,
526    ) -> Result<V::Value>
527    where
528        V: Visitor<'de>,
529    {
530        visitor.visit_enum(self)
531    }
532
533    // As a binary format, Postcard does not encode identifiers
534    #[inline]
535    fn deserialize_identifier<V>(self, _visitor: V) -> Result<V::Value>
536    where
537        V: Visitor<'de>,
538    {
539        // Will not support
540        Err(Error::WontImplement)
541    }
542
543    #[inline]
544    fn deserialize_ignored_any<V>(self, _visitor: V) -> Result<V::Value>
545    where
546        V: Visitor<'de>,
547    {
548        // Will not support
549        Err(Error::WontImplement)
550    }
551}
552
553impl<'de, F: Flavor<'de>> serde::de::VariantAccess<'de> for &mut Deserializer<'de, F> {
554    type Error = Error;
555
556    #[inline]
557    fn unit_variant(self) -> Result<()> {
558        Ok(())
559    }
560
561    #[inline]
562    fn newtype_variant_seed<V: DeserializeSeed<'de>>(self, seed: V) -> Result<V::Value> {
563        DeserializeSeed::deserialize(seed, self)
564    }
565
566    #[inline]
567    fn tuple_variant<V: Visitor<'de>>(self, len: usize, visitor: V) -> Result<V::Value> {
568        serde::de::Deserializer::deserialize_tuple(self, len, visitor)
569    }
570
571    #[inline]
572    fn struct_variant<V: Visitor<'de>>(
573        self,
574        fields: &'static [&'static str],
575        visitor: V,
576    ) -> Result<V::Value> {
577        serde::de::Deserializer::deserialize_tuple(self, fields.len(), visitor)
578    }
579}
580
581impl<'de, F: Flavor<'de>> serde::de::EnumAccess<'de> for &mut Deserializer<'de, F> {
582    type Error = Error;
583    type Variant = Self;
584
585    #[inline]
586    fn variant_seed<V: DeserializeSeed<'de>>(self, seed: V) -> Result<(V::Value, Self)> {
587        let varint = self.try_take_varint_u32()?;
588        let v = DeserializeSeed::deserialize(seed, varint.into_deserializer())?;
589        Ok((v, self))
590    }
591}
592
593fn de_zig_zag_i16(n: u16) -> i16 {
594    ((n >> 1) as i16) ^ (-((n & 0b1) as i16))
595}
596
597fn de_zig_zag_i32(n: u32) -> i32 {
598    ((n >> 1) as i32) ^ (-((n & 0b1) as i32))
599}
600
601fn de_zig_zag_i64(n: u64) -> i64 {
602    ((n >> 1) as i64) ^ (-((n & 0b1) as i64))
603}
604
605fn de_zig_zag_i128(n: u128) -> i128 {
606    ((n >> 1) as i128) ^ (-((n & 0b1) as i128))
607}
postcard/de/deserializer.rs

postcard/de/
deserializer.rs
