float_pigment_consistent_bincode/de/
mod.rs

1use crate::config::{BincodeByteOrder, Options};
2use crate::io::Read;
3use alloc::{boxed::Box, string::String, vec::Vec};
4
5use self::read::{BincodeRead, IoReader, SliceReader};
6use crate::config::{IntEncoding, SizeLimit};
7use crate::{Error, ErrorKind, Result};
8use serde::de::Error as DeError;
9use serde::de::IntoDeserializer;
10
11/// Specialized ways to read data into bincode.
12pub mod read;
13
14#[derive(Debug, Clone)]
15struct SegmentSizeLimit {
16    diff: Option<usize>,
17}
18
19/// A Deserializer that reads bytes from a buffer.
20///
21/// This struct should rarely be used.
22/// In most cases, prefer the `deserialize_from` function.
23///
24/// The ByteOrder that is chosen will impact the endianness that
25/// is used to read integers out of the reader.
26///
27/// ```ignore
28/// let d = Deserializer::new(&mut some_reader, SizeLimit::new());
29/// serde::Deserialize::deserialize(&mut deserializer);
30/// let bytes_read = d.bytes_read();
31/// ```
32pub struct Deserializer<R, O: Options> {
33    pub(crate) reader: R,
34    options: O,
35    segment_size_limits: Vec<SegmentSizeLimit>,
36}
37
38macro_rules! impl_deserialize_literal {
39    ($name:ident : $ty:ty = $read:ident()) => {
40        #[inline]
41        pub(crate) fn $name(&mut self) -> Result<$ty> {
42            self.read_literal_type::<$ty>()?;
43            self.reader
44                .$read::<<O::Endian as BincodeByteOrder>::Endian>()
45                .map_err(Into::into)
46        }
47    };
48}
49
50impl<IR: Read, O: Options> Deserializer<IoReader<IR>, O> {
51    /// Creates a new Deserializer with a given `Read`er and options.
52    pub fn with_reader(r: IR, options: O) -> Self {
53        Deserializer {
54            reader: IoReader::new(r),
55            options,
56            segment_size_limits: vec![],
57        }
58    }
59}
60
61impl<'de, O: Options> Deserializer<SliceReader<'de>, O> {
62    /// Creates a new Deserializer that will read from the given slice.
63    pub fn from_slice(slice: &'de [u8], options: O) -> Self {
64        Deserializer {
65            reader: SliceReader::new(slice),
66            options,
67            segment_size_limits: vec![],
68        }
69    }
70}
71
72impl<'de, R: BincodeRead<'de>, O: Options> Deserializer<R, O> {
73    /// Creates a new Deserializer with the given `BincodeRead`er
74    pub fn with_bincode_read(r: R, options: O) -> Deserializer<R, O> {
75        Deserializer {
76            reader: r,
77            options,
78            segment_size_limits: vec![],
79        }
80    }
81
82    fn begin_segment_size_limit(&mut self) -> Result<()> {
83        let seg_size = O::IntEncoding::deserialize_u32(self)? as usize;
84        let ssl = SegmentSizeLimit {
85            diff: match self.segment_size_limits.last() {
86                Some(_) => Some(
87                    self.reader
88                        .barrier()
89                        .checked_sub(seg_size)
90                        .ok_or(ErrorKind::InvalidData)?,
91                ),
92                None => None,
93            },
94        };
95        self.segment_size_limits.push(ssl);
96        self.reader.set_barrier(seg_size);
97        Ok(())
98    }
99
100    fn end_segment_size_limit(&mut self) -> Result<()> {
101        if let Some(ssl) = self.segment_size_limits.pop() {
102            self.reader.forward_to_barrier()?;
103            self.reader
104                .set_barrier(ssl.diff.unwrap_or(core::usize::MAX));
105        }
106        Ok(())
107    }
108
109    pub(crate) fn deserialize_byte(&mut self) -> Result<u8> {
110        self.read_literal_type::<u8>()?;
111        self.reader.read_u8().map_err(Into::into)
112    }
113
114    impl_deserialize_literal! { deserialize_literal_u16 : u16 = read_u16() }
115    impl_deserialize_literal! { deserialize_literal_u32 : u32 = read_u32() }
116    impl_deserialize_literal! { deserialize_literal_u64 : u64 = read_u64() }
117
118    serde_if_integer128! {
119        impl_deserialize_literal! { deserialize_literal_u128 : u128 = read_u128() }
120    }
121
122    fn read_bytes(&mut self, count: u64) -> Result<()> {
123        self.options.limit().add(count)
124    }
125
126    fn read_literal_type<T>(&mut self) -> Result<()> {
127        use core::mem::size_of;
128        self.read_bytes(size_of::<T>() as u64)
129    }
130
131    fn read_vec(&mut self) -> Result<Vec<u8>> {
132        let len = O::IntEncoding::deserialize_len(self)?;
133        self.read_bytes(len as u64)?;
134        self.reader.get_byte_buffer(len)
135    }
136
137    fn read_string(&mut self) -> Result<String> {
138        let vec = self.read_vec()?;
139        String::from_utf8(vec).map_err(|e| ErrorKind::InvalidUtf8Encoding(e.utf8_error()).into())
140    }
141}
142
143macro_rules! impl_deserialize_int {
144    ($name:ident = $visitor_method:ident ($dser_method:ident)) => {
145        #[inline]
146        fn $name<V>(self, visitor: V) -> Result<V::Value>
147        where
148            V: serde::de::Visitor<'de>,
149        {
150            visitor.$visitor_method(O::IntEncoding::$dser_method(self)?)
151        }
152    };
153}
154
155impl<'de, 'a, R, O> serde::Deserializer<'de> for &'a mut Deserializer<R, O>
156where
157    R: BincodeRead<'de>,
158    O: Options,
159{
160    type Error = Error;
161
162    #[inline]
163    fn deserialize_any<V>(self, _visitor: V) -> Result<V::Value>
164    where
165        V: serde::de::Visitor<'de>,
166    {
167        Err(Box::new(ErrorKind::DeserializeAnyNotSupported))
168    }
169
170    fn deserialize_bool<V>(self, visitor: V) -> Result<V::Value>
171    where
172        V: serde::de::Visitor<'de>,
173    {
174        match self.deserialize_byte()? {
175            1 => visitor.visit_bool(true),
176            0 => visitor.visit_bool(false),
177            value => Err(ErrorKind::InvalidBoolEncoding(value).into()),
178        }
179    }
180
181    impl_deserialize_int!(deserialize_u16 = visit_u16(deserialize_u16));
182    impl_deserialize_int!(deserialize_u32 = visit_u32(deserialize_u32));
183    impl_deserialize_int!(deserialize_u64 = visit_u64(deserialize_u64));
184    impl_deserialize_int!(deserialize_i16 = visit_i16(deserialize_i16));
185    impl_deserialize_int!(deserialize_i32 = visit_i32(deserialize_i32));
186    impl_deserialize_int!(deserialize_i64 = visit_i64(deserialize_i64));
187
188    fn deserialize_f32<V>(self, visitor: V) -> Result<V::Value>
189    where
190        V: serde::de::Visitor<'de>,
191    {
192        self.read_literal_type::<f32>()?;
193        let value = self
194            .reader
195            .read_f32::<<O::Endian as BincodeByteOrder>::Endian>()?;
196        visitor.visit_f32(value)
197    }
198
199    fn deserialize_f64<V>(self, visitor: V) -> Result<V::Value>
200    where
201        V: serde::de::Visitor<'de>,
202    {
203        self.read_literal_type::<f64>()?;
204        let value = self
205            .reader
206            .read_f64::<<O::Endian as BincodeByteOrder>::Endian>()?;
207        visitor.visit_f64(value)
208    }
209
210    serde_if_integer128! {
211        impl_deserialize_int!(deserialize_u128 = visit_u128(deserialize_u128));
212        impl_deserialize_int!(deserialize_i128 = visit_i128(deserialize_i128));
213    }
214
215    #[inline]
216    fn deserialize_u8<V>(self, visitor: V) -> Result<V::Value>
217    where
218        V: serde::de::Visitor<'de>,
219    {
220        visitor.visit_u8(self.deserialize_byte()?)
221    }
222
223    #[inline]
224    fn deserialize_i8<V>(self, visitor: V) -> Result<V::Value>
225    where
226        V: serde::de::Visitor<'de>,
227    {
228        visitor.visit_i8(self.deserialize_byte()? as i8)
229    }
230
231    fn deserialize_unit<V>(self, visitor: V) -> Result<V::Value>
232    where
233        V: serde::de::Visitor<'de>,
234    {
235        visitor.visit_unit()
236    }
237
238    fn deserialize_char<V>(self, visitor: V) -> Result<V::Value>
239    where
240        V: serde::de::Visitor<'de>,
241    {
242        use core::str;
243
244        let error = || ErrorKind::InvalidCharEncoding.into();
245
246        let mut buf = [0u8; 4];
247
248        // Look at the first byte to see how many bytes must be read
249        self.reader.read_exact(&mut buf[..1])?;
250        let width = utf8_char_width(buf[0]);
251        if width == 1 {
252            return visitor.visit_char(buf[0] as char);
253        }
254        if width == 0 {
255            return Err(error());
256        }
257
258        if self.reader.read_exact(&mut buf[1..width]).is_err() {
259            return Err(error());
260        }
261
262        let res = str::from_utf8(&buf[..width])
263            .ok()
264            .and_then(|s| s.chars().next())
265            .ok_or_else(error)?;
266        visitor.visit_char(res)
267    }
268
269    fn deserialize_str<V>(self, visitor: V) -> Result<V::Value>
270    where
271        V: serde::de::Visitor<'de>,
272    {
273        let len = O::IntEncoding::deserialize_len(self)?;
274        self.read_bytes(len as u64)?;
275        self.reader.forward_read_str(len, visitor)
276    }
277
278    fn deserialize_string<V>(self, visitor: V) -> Result<V::Value>
279    where
280        V: serde::de::Visitor<'de>,
281    {
282        visitor.visit_string(self.read_string()?)
283    }
284
285    fn deserialize_bytes<V>(self, visitor: V) -> Result<V::Value>
286    where
287        V: serde::de::Visitor<'de>,
288    {
289        let len = O::IntEncoding::deserialize_len(self)?;
290        self.read_bytes(len as u64)?;
291        self.reader.forward_read_bytes(len, visitor)
292    }
293
294    fn deserialize_byte_buf<V>(self, visitor: V) -> Result<V::Value>
295    where
296        V: serde::de::Visitor<'de>,
297    {
298        visitor.visit_byte_buf(self.read_vec()?)
299    }
300
301    #[inline(always)]
302    fn deserialize_enum<V>(
303        self,
304        _enum: &'static str,
305        variants: &'static [&'static str],
306        visitor: V,
307    ) -> Result<V::Value>
308    where
309        V: serde::de::Visitor<'de>,
310    {
311        struct EnumDeserializer<'a, R, O: Options> {
312            de: &'a mut Deserializer<R, O>,
313            variants: &'static [&'static str],
314            len: u32,
315        }
316
317        impl<'de, 'a, R: 'a, O> serde::de::EnumAccess<'de> for EnumDeserializer<'a, R, O>
318        where
319            R: BincodeRead<'de>,
320            O: Options,
321        {
322            type Error = Error;
323            type Variant = &'a mut Deserializer<R, O>;
324
325            #[inline(always)]
326            fn variant_seed<V>(self, seed: V) -> Result<(V::Value, Self::Variant)>
327            where
328                V: serde::de::DeserializeSeed<'de>,
329            {
330                let idx: u32 = O::IntEncoding::deserialize_u32(self.de)?;
331                #[allow(clippy::if_same_then_else)]
332                let idx = if idx >= self.len {
333                    0
334                } else if self.variants[idx as usize] == "_" {
335                    0
336                } else {
337                    idx
338                };
339                let val: Result<_> = seed.deserialize(idx.into_deserializer());
340                Ok((val?, self.de))
341            }
342        }
343
344        visitor.visit_enum(EnumDeserializer {
345            de: self,
346            variants,
347            len: variants.len() as u32,
348        })
349    }
350
351    fn deserialize_tuple<V>(self, len: usize, visitor: V) -> Result<V::Value>
352    where
353        V: serde::de::Visitor<'de>,
354    {
355        struct Access<'de, 'a, 'b: 'a, R: BincodeRead<'de> + 'b, O: Options + 'a> {
356            deserializer: &'a mut Deserializer<R, O>,
357            len: usize,
358            _phantom: core::marker::PhantomData<(&'de (), &'b ())>,
359        }
360
361        impl<'de, 'a, 'b: 'a, R: BincodeRead<'de> + 'b, O: Options> serde::de::SeqAccess<'de>
362            for Access<'de, 'a, 'b, R, O>
363        {
364            type Error = Error;
365
366            fn next_element_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>>
367            where
368                T: serde::de::DeserializeSeed<'de>,
369            {
370                if self.len > 0 {
371                    self.len -= 1;
372                    let value =
373                        serde::de::DeserializeSeed::deserialize(seed, &mut *self.deserializer);
374                    match value {
375                        Ok(value) => Ok(Some(value)),
376                        Err(err) => match *err {
377                            crate::ErrorKind::SegmentEnded => Ok(None),
378                            err => Err(Box::new(err)),
379                        },
380                    }
381                } else {
382                    Ok(None)
383                }
384            }
385
386            fn size_hint(&self) -> Option<usize> {
387                Some(self.len)
388            }
389        }
390
391        visitor.visit_seq(Access {
392            deserializer: self,
393            len,
394            _phantom: core::marker::PhantomData,
395        })
396    }
397
398    fn deserialize_option<V>(self, visitor: V) -> Result<V::Value>
399    where
400        V: serde::de::Visitor<'de>,
401    {
402        let value: u8 = serde::de::Deserialize::deserialize(&mut *self)?;
403        match value {
404            0 => visitor.visit_none(),
405            1 => visitor.visit_some(&mut *self),
406            v => Err(ErrorKind::InvalidTagEncoding(v as usize).into()),
407        }
408    }
409
410    fn deserialize_seq<V>(self, visitor: V) -> Result<V::Value>
411    where
412        V: serde::de::Visitor<'de>,
413    {
414        let len = O::IntEncoding::deserialize_len(self)?;
415
416        self.deserialize_tuple(len, visitor)
417    }
418
419    fn deserialize_map<V>(self, visitor: V) -> Result<V::Value>
420    where
421        V: serde::de::Visitor<'de>,
422    {
423        struct Access<'de, 'a, 'b: 'a, R: BincodeRead<'de> + 'b, O: Options + 'a> {
424            deserializer: &'a mut Deserializer<R, O>,
425            len: usize,
426            _phantom: core::marker::PhantomData<(&'de (), &'b ())>,
427        }
428
429        impl<'de, 'a, 'b: 'a, R: BincodeRead<'de> + 'b, O: Options> serde::de::MapAccess<'de>
430            for Access<'de, 'a, 'b, R, O>
431        {
432            type Error = Error;
433
434            fn next_key_seed<K>(&mut self, seed: K) -> Result<Option<K::Value>>
435            where
436                K: serde::de::DeserializeSeed<'de>,
437            {
438                if self.len > 0 {
439                    self.len -= 1;
440                    let key =
441                        serde::de::DeserializeSeed::deserialize(seed, &mut *self.deserializer)?;
442                    Ok(Some(key))
443                } else {
444                    Ok(None)
445                }
446            }
447
448            fn next_value_seed<V>(&mut self, seed: V) -> Result<V::Value>
449            where
450                V: serde::de::DeserializeSeed<'de>,
451            {
452                let value = serde::de::DeserializeSeed::deserialize(seed, &mut *self.deserializer)?;
453                Ok(value)
454            }
455
456            fn size_hint(&self) -> Option<usize> {
457                Some(self.len)
458            }
459        }
460
461        let len = O::IntEncoding::deserialize_len(self)?;
462
463        visitor.visit_map(Access {
464            deserializer: self,
465            len,
466            _phantom: core::marker::PhantomData,
467        })
468    }
469
470    fn deserialize_struct<V>(
471        self,
472        _name: &str,
473        fields: &'static [&'static str],
474        visitor: V,
475    ) -> Result<V::Value>
476    where
477        V: serde::de::Visitor<'de>,
478    {
479        self.begin_segment_size_limit()?;
480        let r = self.deserialize_tuple(fields.len(), visitor);
481        self.end_segment_size_limit()?;
482        r
483    }
484
485    fn deserialize_identifier<V>(self, _visitor: V) -> Result<V::Value>
486    where
487        V: serde::de::Visitor<'de>,
488    {
489        let message = "Bincode does not support Deserializer::deserialize_identifier";
490        Err(Error::custom(message))
491    }
492
493    fn deserialize_newtype_struct<V>(self, _name: &str, visitor: V) -> Result<V::Value>
494    where
495        V: serde::de::Visitor<'de>,
496    {
497        visitor.visit_newtype_struct(self)
498    }
499
500    fn deserialize_unit_struct<V>(self, _name: &'static str, visitor: V) -> Result<V::Value>
501    where
502        V: serde::de::Visitor<'de>,
503    {
504        visitor.visit_unit()
505    }
506
507    fn deserialize_tuple_struct<V>(
508        self,
509        _name: &'static str,
510        len: usize,
511        visitor: V,
512    ) -> Result<V::Value>
513    where
514        V: serde::de::Visitor<'de>,
515    {
516        self.deserialize_tuple(len, visitor)
517    }
518
519    fn deserialize_ignored_any<V>(self, _visitor: V) -> Result<V::Value>
520    where
521        V: serde::de::Visitor<'de>,
522    {
523        let message = "Bincode does not support Deserializer::deserialize_ignored_any";
524        Err(Error::custom(message))
525    }
526
527    fn is_human_readable(&self) -> bool {
528        false
529    }
530}
531
532impl<'de, 'a, R, O> serde::de::VariantAccess<'de> for &'a mut Deserializer<R, O>
533where
534    R: BincodeRead<'de>,
535    O: Options,
536{
537    type Error = Error;
538
539    fn unit_variant(self) -> Result<()> {
540        self.begin_segment_size_limit()?;
541        self.end_segment_size_limit()?;
542        Ok(())
543    }
544
545    fn newtype_variant_seed<T>(self, seed: T) -> Result<T::Value>
546    where
547        T: serde::de::DeserializeSeed<'de>,
548    {
549        self.begin_segment_size_limit()?;
550        let r = serde::de::DeserializeSeed::deserialize(seed, &mut *self);
551        self.end_segment_size_limit()?;
552        r
553    }
554
555    fn tuple_variant<V>(self, len: usize, visitor: V) -> Result<V::Value>
556    where
557        V: serde::de::Visitor<'de>,
558    {
559        use serde::de::Deserializer;
560        self.begin_segment_size_limit()?;
561        let r = self.deserialize_tuple(len, visitor);
562        self.end_segment_size_limit()?;
563        r
564    }
565
566    fn struct_variant<V>(self, fields: &'static [&'static str], visitor: V) -> Result<V::Value>
567    where
568        V: serde::de::Visitor<'de>,
569    {
570        use serde::de::Deserializer;
571        self.begin_segment_size_limit()?;
572        let r = self.deserialize_tuple(fields.len(), visitor);
573        self.end_segment_size_limit()?;
574        r
575    }
576}
577static UTF8_CHAR_WIDTH: [u8; 256] = [
578    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
579    1, // 0x1F
580    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
581    1, // 0x3F
582    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
583    1, // 0x5F
584    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
585    1, // 0x7F
586    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
587    0, // 0x9F
588    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
589    0, // 0xBF
590    0, 0, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
591    2, // 0xDF
592    3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, // 0xEF
593    4, 4, 4, 4, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 0xFF
594];
595
596// This function is a copy of core::str::utf8_char_width
597fn utf8_char_width(b: u8) -> usize {
598    UTF8_CHAR_WIDTH[b as usize] as usize
599}
float_pigment_consistent_bincode/de/mod.rs

float_pigment_consistent_bincode/de/
mod.rs
