serde_dbor/de/
mod.rs

1use std::cmp;
2use std::marker::PhantomData;
3use std::io::Read as IoRead;
4use std;
5
6use serde::de::{Deserializer as SerdeDeserializer, DeserializeSeed, Visitor, Deserialize,
7    SeqAccess, MapAccess, EnumAccess, VariantAccess, IntoDeserializer};
8
9mod read;
10
11use error::*;
12use self::read::*;
13use super::WRONG_ENDIANNESS;
14
15
16#[derive(Clone, Copy, PartialEq, Eq, Debug)]
17#[repr(u8)]
18#[allow(dead_code)] // Most types are never constructed directly, instead through transmutation
19/// All storage types, including ones that exist solely for debugging purposes
20pub enum Type {
21    /// Represents a `u8`, `u16`, `u32`, or `u64`
22    Uint,
23
24    /// Represents an `i8`, `i16`, `i32`, or `i64`
25    Int,
26
27    /// Represents a `bool`, `()`, `None`, `f32`, or `f64`
28    Misc,
29
30    /// Represents a variant of an enum
31    Variant,
32
33    /// Represents an array, tuple, or struct
34    Seq,
35
36    /// Represents a string or array of bytes
37    Bytes,
38
39    /// Represents a map type
40    Map,
41
42    /// Reserved for later use
43    Reserved,
44
45    /// Used only in error messages, represents any type
46    Any, // Should never be constructed except for error messages
47
48    /// Used only in error messages, represents a `char`
49    Char, // Should never be constructed except for error messages
50}
51
52#[inline]
53// Interpret the first three bits of the byte into an enum
54fn ty(byte: u8) -> Type {
55    *unsafe { &mut *(&mut (byte >> 5) as *mut u8 as *mut Type) }
56}
57
58#[inline]
59fn val(byte: u8) -> u8 {
60    byte & 0b00011111
61}
62
63
64/// Deserialize an instance of type T from an IO stream of DBOR
65pub fn from_reader<'de, R: IoRead + 'de, T>(r: R) -> Result<T>
66where
67    T: Deserialize<'de>
68{
69    let mut deserializer = Deserializer::from_reader(r);
70    let t = T::deserialize(&mut deserializer)?;
71
72    if deserializer.input.finished() {
73        Ok(t)
74    } else {
75        Err(Error::TrailingBytes)
76    }
77}
78
79/// Deserialize an instance of type T from bytes of DBOR
80pub fn from_slice<'de, S: AsRef<[u8]> + 'de, T>(bytes: &'de S) -> Result<T>
81where
82    T: Deserialize<'de>
83{
84    let mut deserializer = Deserializer::from_slice(bytes);
85    let t = T::deserialize(&mut deserializer)?;
86
87    if deserializer.input.finished() {
88        Ok(t)
89    } else {
90        Err(Error::TrailingBytes)
91    }
92}
93
94
95/// A structure that deserializes DBOR into Rust values
96pub struct Deserializer<'de, R: Read<'de> + 'de> {
97    input: R,
98    phantom: PhantomData<&'de ()>,
99}
100
101impl<'de> Deserializer<'de, SliceReader<'de>> {
102    /// Creates a DBOR deserializer from something that converts into a `&[u8]`
103    pub fn from_slice<S: AsRef<[u8]> + 'de>(bytes: &'de S) -> Self {
104        Self {
105            input: SliceReader::new(bytes),
106            phantom: PhantomData
107        }
108    }
109}
110
111impl<'de, R: IoRead> Deserializer<'de, BufferedReader<R>> {
112    /// Creates a DBOR deserializer from an `io::Read`
113    pub fn from_reader(reader: R) -> Self {
114        Self {
115            input: BufferedReader::new(reader),
116            phantom: PhantomData
117        }
118    }
119}
120
121impl<'de, R: Read<'de>> Deserializer<'de, R> {
122    #[inline]
123    fn next(&mut self) -> Result<u8> {
124        self.input.next().ok_or(Error::Eof)
125    }
126
127    #[inline]
128    fn peek_next(&mut self) -> Result<u8> {
129        self.input.peek_next().ok_or(Error::Eof)
130    }
131
132    #[inline]
133    fn read<'a>(&'a mut self, bytes: usize, should_flip: bool) -> Result<Borrowed<'a, 'de>> {
134        self.input.read(bytes, *WRONG_ENDIANNESS && should_flip).ok_or(Error::Eof)
135    }
136
137    #[inline]
138    fn must_read<'a>(&'a mut self, bytes: usize, should_flip: bool) -> Result<Borrowed<'a, 'de>> {
139        let borrowed = self.read(bytes, *WRONG_ENDIANNESS && should_flip)?;
140
141        if borrowed.len() != bytes {
142            Err(Error::Eof)
143        } else {
144            Ok(borrowed)
145        }
146    }
147
148    // #[inline]
149    // fn peek<'a>(&'a mut self, bytes: usize) -> Result<Borrowed<'a, 'de>> {
150    //     self.input.peek(bytes).ok_or(Error::Eof)
151    // }
152
153    #[inline]
154    fn consume(&mut self, bytes: usize) -> Result<usize> {
155        self.input.consume(bytes).ok_or(Error::Eof)
156    }
157
158    #[inline]
159    fn must_consume(&mut self, bytes: usize) -> Result<()> {
160        let mut total_consumed = 0;
161
162        while total_consumed < bytes {
163            match self.input.consume(bytes - total_consumed) {
164                Some(consumed) => total_consumed += consumed,
165                None => {
166                    return Err(Error::Eof)
167                },
168            }
169        }
170
171        Ok(())
172    }
173
174    #[inline]
175    fn get_param(&mut self, value: u8) -> Result<usize> {
176        match value {
177            0...23 => Ok(value as usize),
178            24 => Ok(self.next()? as usize),
179            25 => Ok(
180                unsafe { *(self.must_read(2, true)?.as_slice().as_ptr() as *const u16) as usize }
181            ),
182            26 => Ok(
183                unsafe { *(self.must_read(4, true)?.as_slice().as_ptr() as *const u32) as usize }
184            ),
185            #[cfg(target_pointer_width = "64")]
186            27 => Ok(
187                unsafe { *(self.must_read(8, true)?.as_slice().as_ptr() as *const u64) as usize }
188            ),
189            #[cfg(not(target_pointer_width = "64"))]
190            27 => Err(Error::UsizeOverflow),
191            _ => Err(Error::UnexpectedValue(Type::Any, value)),
192        }
193    }
194
195
196    #[inline]
197    fn parse_uint<V>(&mut self, visitor: V, value: u8) -> Result<V::Value>
198    where
199        V: Visitor<'de>
200    {
201        match value {
202            0...23 => visitor.visit_u8(value as u8),
203            24 => visitor.visit_u8(self.next()? as u8),
204            25 => visitor.visit_u16(
205                unsafe { *(self.must_read(2, true)?.as_slice().as_ptr() as *const u16) }
206            ),
207            26 => visitor.visit_u32(
208                unsafe { *(self.must_read(4, true)?.as_slice().as_ptr() as *const u32) }
209            ),
210            27 => visitor.visit_u64(
211                unsafe { *(self.must_read(8, true)?.as_slice().as_ptr() as *const u64) }
212            ),
213            _ => Err(Error::UnexpectedValue(Type::Uint, value)),
214        }
215    }
216
217    #[inline]
218    fn parse_int<V>(&mut self, visitor: V, value: u8) -> Result<V::Value>
219    where
220        V: Visitor<'de>
221    {
222        match value {
223            0...15 => visitor.visit_i8(value as i8),
224            16...23 => visitor.visit_i8(value as i8 - 24),
225            24 => visitor.visit_i8(
226                unsafe { *(&mut self.next()? as *mut u8 as *mut i8) }
227            ),
228            25 => visitor.visit_i16(
229                unsafe { *(self.must_read(2, true)?.as_slice().as_ptr() as *const i16) }
230            ),
231            26 => visitor.visit_i32(
232                unsafe { *(self.must_read(4, true)?.as_slice().as_ptr() as *const i32) }
233            ),
234            27 => visitor.visit_i64(
235                unsafe { *(self.must_read(8, true)?.as_slice().as_ptr() as *const i64) }
236            ),
237            _ => Err(Error::UnexpectedValue(Type::Int, value)),
238        }
239    }
240
241    #[inline]
242    fn parse_float<V>(&mut self, visitor: V, value: u8) -> Result<V::Value>
243    where
244        V: Visitor<'de>
245    {
246        match value {
247            4 => visitor.visit_f32(
248                unsafe { *(self.must_read(4, true)?.as_slice().as_ptr() as *const f32) }
249            ),
250            5 => visitor.visit_f64(
251                unsafe { *(self.must_read(8, true)?.as_slice().as_ptr() as *const f64) }
252            ),
253            _ => Err(Error::UnexpectedValue(Type::Misc, value)),
254        }
255    }
256
257    // #[inline]
258    fn ignore_value(&mut self) -> Result<()> {
259        let byte = self.next()?;
260
261        match ty(byte) {
262            Type::Uint |
263            Type::Int => match val(byte) {
264                0...23 => {}, // Self-contained byte
265                value @ 24...27 => {
266                    // 24 => 1
267                    // 25 => 2
268                    // 26 => 4
269                    // 27 => 8
270                    let to_read = 2 << (value - 24);
271
272                    // Don't have to worry about recursive reading because we will never read more
273                    //   than the max buffer size
274                    self.must_consume(to_read)?;
275                }
276                value => return Err(Error::UnexpectedValue(ty(byte), value)),
277            }
278            Type::Misc => match val(byte) {
279                0...3 => {},
280                value @ 4...5 => {
281                    // 4 => 4
282                    // 5 => 8
283                    let to_read = 2 << (value - 2);
284
285                    // Don't have to worry about recursive reading because we will never read more
286                    //   than the max buffer size
287                    self.must_consume(to_read)?;
288                }
289                value => return Err(Error::UnexpectedValue(Type::Misc, value)),
290            }
291            Type::Variant => {
292                match val(byte) {
293                    0...23 => {}
294                    value @ 24...26 => {
295                        // 24 => 1
296                        // 25 => 2
297                        // 26 => 4
298                        let to_read = 2 << (value - 24);
299
300                        // Don't have to worry about recursive reading because we will never read more
301                        //   than the max buffer size
302                        self.must_consume(to_read)?;
303                    }
304                    27 => self.ignore_value()?, // Ignore the string variant name
305                    value => return Err(Error::UnexpectedValue(Type::Variant, value)),
306                }
307
308                // Ignore the variant content
309                self.ignore_value()?;
310            }
311            Type::Seq => {
312                let len = self.get_param(val(byte))?;
313
314                for _ in 0..len {
315                    self.ignore_value()?;
316                }
317            }
318            Type::Bytes => {
319                let len = self.get_param(val(byte))?;
320                let mut bytes_to_parse = len;
321
322                while bytes_to_parse > 0 {
323                    let bytes_to_read = cmp::min(self.input.max_instant_read(), bytes_to_parse);
324
325                    bytes_to_parse -= self.consume(bytes_to_read)?;
326                }
327            }
328            Type::Map => {
329                let len = self.get_param(val(byte))?;
330
331                for _ in 0..len {
332                    self.ignore_value()?; // key
333                    self.ignore_value()?; // value
334                }
335            }
336            Type::Reserved => return Err(Error::ExpectedType(vec![
337                Type::Uint,
338                Type::Int,
339                Type::Misc,
340                Type::Variant,
341                Type::Seq,
342                Type::Bytes,
343                Type::Map
344            ], byte)),
345            _ => return Err(Error::NotAType),
346        }
347
348        Ok(())
349    }
350}
351
352macro_rules! forward_num {
353    () => {};
354    ($fn:ident $($more:tt)*) => {
355        #[inline]
356        fn $fn <V>(self, visitor: V) -> Result<V::Value>
357            where V: Visitor<'de>
358        {
359            let byte = self.next()?;
360
361            match ty(byte) {
362                Type::Uint => self.parse_uint(visitor, val(byte)),
363                Type::Int => self.parse_int(visitor, val(byte)),
364                Type::Misc => self.parse_float(visitor, val(byte)),
365                _ => Err(Error::ExpectedType(vec![
366                    Type::Uint,
367                    Type::Int,
368                    Type::Misc,
369                ], byte)),
370            }
371        }
372
373        forward_num!($($more)*);
374    };
375}
376macro_rules! forward_to {
377    () => {};
378    ($fn:ident => $fn2:ident $($more:tt)*) => {
379        #[inline]
380        fn $fn <V>(self, visitor: V) -> Result<V::Value>
381            where V: Visitor<'de>
382        {
383            self. $fn2 (visitor)
384        }
385
386        forward_to!($($more)*);
387    };
388}
389
390impl<'de, 'a, R: Read<'de>> SerdeDeserializer<'de> for &'a mut Deserializer<'de, R> {
391    type Error = Error;
392
393    // #[inline]
394    fn deserialize_any<V>(mut self, visitor: V) -> Result<V::Value>
395    where
396        V: Visitor<'de>
397    {
398        let byte = self.peek_next()?;
399
400        if ty(byte) == Type::Variant {
401            return visitor.visit_enum(VariantVisitor::new(&mut self));
402        }
403
404        self.must_consume(1)?;
405
406        match ty(byte) {
407            Type::Uint => self.parse_uint(visitor, val(byte)),
408            Type::Int => self.parse_int(visitor, val(byte)),
409            Type::Misc => match val(byte) {
410                0 => visitor.visit_bool(false),
411                1 => visitor.visit_bool(true),
412                2 => visitor.visit_unit(),
413                3 => visitor.visit_none(),
414                4 => visitor.visit_f32(
415                    unsafe { *(self.must_read(4, true)?.as_slice().as_ptr() as *const f32) }
416                ),
417                5 => visitor.visit_f64(
418                    unsafe { *(self.must_read(8, true)?.as_slice().as_ptr() as *const f64) }
419                ),
420                _ => Err(Error::UnexpectedValue(Type::Misc, val(byte))),
421            }
422            Type::Variant => unreachable!(),
423            Type::Seq => {
424                let len = self.get_param(val(byte))?;
425
426                visitor.visit_seq(SeqVisitor::new(&mut self, len))
427            }
428            Type::Bytes => {
429                let len = self.get_param(val(byte))?;
430
431                if self.input.max_instant_read() < len {
432                    // need multiple reads to get full buffer
433
434                    let mut buf = Vec::new();
435                    let mut bytes_to_parse = len;
436
437                    while bytes_to_parse > 0 {
438                        let bytes_to_read = cmp::min(self.input.max_instant_read(), bytes_to_parse);
439
440                        let bytes = self.read(bytes_to_read, false)?;
441
442                        bytes_to_parse -= bytes.len();
443                        buf.extend_from_slice(bytes.as_slice());
444                    }
445
446                    visitor.visit_byte_buf(buf)
447                } else {
448                    match self.read(len, false)? {
449                        Borrowed::Transient(bytes) => visitor.visit_bytes(bytes),
450                        Borrowed::Permanent(bytes) => visitor.visit_borrowed_bytes(bytes),
451                        Borrowed::Copied(bytes) => visitor.visit_byte_buf(bytes),
452                    }
453                }
454            }
455            Type::Map => {
456                let len = self.get_param(val(byte))?;
457
458                visitor.visit_map(SeqVisitor::new(&mut self, len))
459            }
460            Type::Reserved => Err(Error::ExpectedType(vec![
461                Type::Int,
462                Type::Uint,
463                Type::Misc,
464                Type::Variant,
465                Type::Seq,
466                Type::Bytes,
467                Type::Map,
468            ], byte)),
469            _ => return Err(Error::NotAType),
470        }
471    }
472
473    #[inline]
474    fn deserialize_bool<V>(self, visitor: V) -> Result<V::Value>
475    where
476        V: Visitor<'de>
477    {
478        let byte = self.next()?;
479
480        if ty(byte) != Type::Misc {
481            Err(Error::ExpectedType(vec![Type::Misc], byte))
482        } else {
483            match val(byte) {
484                0 => visitor.visit_bool(false),
485                1 => visitor.visit_bool(true),
486                2...5 => Err(Error::UnexpectedValue(Type::Misc, val(byte))),
487                _ => Err(Error::UnexpectedValue(Type::Misc, val(byte))),
488            }
489        }
490    }
491
492    forward_num! {
493        deserialize_i8
494        deserialize_i16
495        deserialize_i32
496        deserialize_i64
497        deserialize_u8
498        deserialize_u16
499        deserialize_u32
500        deserialize_u64
501        deserialize_f32
502        deserialize_f64
503    }
504    forward_to! {
505        deserialize_str => deserialize_bytes
506        deserialize_string => deserialize_bytes
507        deserialize_byte_buf => deserialize_bytes
508    }
509
510    // #[inline]
511    fn deserialize_char<V>(self, visitor: V) -> Result<V::Value>
512    where
513        V: Visitor<'de>
514    {
515        let byte = self.next()?;
516
517        match ty(byte) {
518            Type::Uint => visitor.visit_char(
519                std::char::from_u32(
520                    match val(byte) {
521                        value @ 0...23 => value as u32,
522                        24 => self.next()? as u32,
523                        25 => unsafe {
524                            *(self.must_read(2, true)?.as_slice().as_ptr() as *const u16) as u32
525                        },
526                        26 => unsafe {
527                            *(self.must_read(4, true)?.as_slice().as_ptr() as *const u32)
528                        },
529                        27 => return Err(Error::UnexpectedValue(Type::Char, 27)),
530                        value => return Err(Error::UnexpectedValue(Type::Char, value)), // Unexpected value
531                    }
532                ).ok_or(Error::FailedToParseChar)?
533            ),
534            Type::Bytes => {
535                match val(byte) {
536                    bytes @ 1...4 => {
537                        match String::from_utf8(self.read(bytes as usize, false)?.into_vec()) {
538                            Ok(s) => {
539                                let mut chars = s.chars();
540
541                                let first_char = match chars.next() {
542                                    Some(ch) => ch,
543                                    None => return Err(Error::FailedToParseChar),
544                                };
545
546                                if chars.next() != None {
547                                    Err(Error::FailedToParseChar)
548                                } else {
549                                    visitor.visit_char(first_char)
550                                }
551                            },
552                            Err(_) => Err(Error::FailedToParseChar),
553                        }
554                    }
555                    value => Err(Error::UnexpectedValue(Type::Char, value)),
556                }
557            }
558            _ => Err(Error::ExpectedType(vec![Type::Bytes, Type::Uint], byte)),
559        }
560    }
561
562    #[inline]
563    fn deserialize_bytes<V>(self, visitor: V) -> Result<V::Value>
564    where
565        V: Visitor<'de>
566    {
567        let byte = self.next()?;
568
569        match ty(byte) {
570            Type::Bytes => {
571                let len = self.get_param(val(byte))?;
572
573                if self.input.max_instant_read() < len {
574                    // need multiple reads to get full buffer
575
576                    let mut buf = Vec::new();
577                    let mut bytes_to_parse = len;
578
579                    while bytes_to_parse > 0 {
580                        let bytes_to_read = cmp::min(self.input.max_instant_read(), bytes_to_parse);
581
582                        let bytes = self.read(bytes_to_read, false)?;
583
584                        bytes_to_parse -= bytes.len();
585                        buf.extend_from_slice(bytes.as_slice());
586                    }
587
588                    visitor.visit_byte_buf(buf)
589                } else {
590                    match self.read(len, false)? {
591                        Borrowed::Transient(bytes) => visitor.visit_bytes(bytes),
592                        Borrowed::Permanent(bytes) => visitor.visit_borrowed_bytes(bytes),
593                        Borrowed::Copied(bytes) => visitor.visit_byte_buf(bytes),
594                    }
595                }
596            }
597            // Type::Seq => {
598            //     let len = self.get_param(val(byte))?;
599            //     let mut buf = Vec::new();
600            //
601            //     for _ in 0..len {
602            //         let key = self.next()?;
603            //
604            //         if ty(key) != Type::Uint {
605            //             return Err(Error::ExpectedType(vec![Type::Uint], key));
606            //         }
607            //         match val(key) {
608            //             value @ 0...23 => buf.push(value),
609            //             24 => buf.push(self.next()?),
610            //             value => return Err(Error::UnexpectedValue(Type::Uint, value)),
611            //         }
612            //     }
613            //
614            //     visitor.visit_bytes(&buf[..])
615            // }
616            _ => Err(Error::ExpectedType(vec![Type::Bytes/*, Type::Seq*/], byte)),
617        }
618    }
619
620    #[inline]
621    fn deserialize_option<V>(self, visitor: V) -> Result<V::Value>
622    where
623        V: Visitor<'de>
624    {
625        let byte = self.peek_next()?;
626
627        if byte == (Type::Misc as u8) << 5 | 3 { // misc - None
628            self.must_consume(1)?;
629            visitor.visit_none()
630        } else {
631            visitor.visit_some(self)
632        }
633    }
634
635    #[inline]
636    fn deserialize_unit<V>(self, visitor: V) -> Result<V::Value>
637    where
638        V: Visitor<'de>
639    {
640        let byte = self.next()?;
641
642        if byte == (Type::Misc as u8) << 5 | 2 { // misc - ()
643            visitor.visit_unit()
644        } else {
645            if ty(byte) == Type::Misc {
646                Err(Error::UnexpectedValue(Type::Misc, val(byte)))
647            } else {
648                Err(Error::ExpectedType(vec![Type::Misc], byte))
649            }
650        }
651    }
652
653    #[inline]
654    fn deserialize_unit_struct<V>(self, _name: &'static str, visitor: V) -> Result<V::Value>
655    where
656        V: Visitor<'de>
657    {
658        self.deserialize_unit(visitor)
659    }
660
661    #[inline]
662    fn deserialize_newtype_struct<V>(self, _name: &'static str, visitor: V) -> Result<V::Value>
663    where
664        V: Visitor<'de>
665    {
666        visitor.visit_newtype_struct(self)
667    }
668
669    #[inline]
670    fn deserialize_seq<V>(mut self, visitor: V) -> Result<V::Value>
671    where
672        V: Visitor<'de>
673    {
674        let byte = self.next()?;
675
676        match ty(byte) {
677            Type::Seq => {
678                let len = self.get_param(val(byte))?;
679
680                visitor.visit_seq(SeqVisitor::new(&mut self, len))
681            }
682            _ => Err(Error::ExpectedType(vec![Type::Seq], byte))
683        }
684    }
685
686    #[inline]
687    fn deserialize_tuple<V>(mut self, len: usize, visitor: V) -> Result<V::Value>
688    where
689        V: Visitor<'de>
690    {
691        let byte = self.next()?;
692
693        match ty(byte) {
694            Type::Seq => {
695                let seq_len = self.get_param(val(byte))?;
696
697                if seq_len != len {
698                    Err(Error::UnexpectedValue(Type::Seq, val(byte)))
699                } else {
700                    visitor.visit_seq(SeqVisitor::new(&mut self, len))
701                }
702            }
703            _ => Err(Error::ExpectedType(vec![Type::Seq], byte)),
704        }
705    }
706
707    #[inline]
708    fn deserialize_tuple_struct<V>(self, _name: &'static str, len: usize, visitor: V)
709        -> Result<V::Value>
710    where
711        V: Visitor<'de>
712    {
713        self.deserialize_tuple(len, visitor)
714    }
715
716    #[inline]
717    fn deserialize_map<V>(mut self, visitor: V) -> Result<V::Value>
718        where V: Visitor<'de>
719    {
720        let byte = self.next()?;
721
722        match ty(byte) {
723            Type::Map => {
724                let len = self.get_param(val(byte))?;
725
726                visitor.visit_map(SeqVisitor::new(&mut self, len))
727            }
728            _ => Err(Error::ExpectedType(vec![Type::Map], byte))
729        }
730    }
731
732    #[inline]
733    fn deserialize_struct<V>(self, _name: &'static str, _fields: &'static [&'static str],
734        visitor: V) -> Result<V::Value>
735    where
736        V: Visitor<'de>
737    {
738        self.deserialize_seq(visitor)
739    }
740
741    #[inline]
742    fn deserialize_enum<V>(mut self, _name: &'static str, _variants: &'static [&'static str],
743        visitor: V) -> Result<V::Value>
744    where
745        V: Visitor<'de>
746    {
747        let byte = self.peek_next()?;
748
749        match ty(byte) {
750            Type::Uint => {
751                self.must_consume(1)?;
752
753                match val(byte) {
754                    value @ 0...23 => visitor.visit_enum((value as u32).into_deserializer()),
755                    24 => visitor.visit_enum((self.next()? as u32).into_deserializer()),
756                    25 => visitor.visit_enum(
757                        unsafe {
758                            *(self.must_read(2, true)?.as_slice().as_ptr() as *const u16) as u32
759                        }.into_deserializer()
760                    ),
761                    26 => visitor.visit_enum(
762                        unsafe {
763                            *(self.must_read(4, true)?.as_slice().as_ptr() as *const u32)
764                        }.into_deserializer()
765                    ),
766                    27 => Err(Error::UsizeOverflow),
767                    value => Err(Error::UnexpectedValue(Type::Uint, value)),
768                }
769            }
770            Type::Variant => visitor.visit_enum(VariantVisitor::new(&mut self)),
771            _ => Err(Error::ExpectedType(vec![Type::Uint, Type::Variant], byte)),
772        }
773    }
774
775    // #[inline]
776    fn deserialize_identifier<V>(self, visitor: V) -> Result<V::Value>
777    where
778        V: Visitor<'de>
779    {
780        let byte = self.next()?;
781
782        match ty(byte) {
783            Type::Variant => match val(byte) {
784                value @ 0...23 => visitor.visit_u32(value as u32),
785                24 => visitor.visit_u32(self.next()? as u32),
786                25 => visitor.visit_u32(
787                    unsafe {
788                        *(self.must_read(2, true)?.as_slice().as_ptr() as *const u16) as u32
789                    }
790                ),
791                26 => visitor.visit_u32(
792                    unsafe {
793                        *(self.must_read(4, true)?.as_slice().as_ptr() as *const u32)
794                    }
795                ),
796                27 => {
797                    let len = match self.next()? {
798                        value @ 0...247 => value as usize,
799                        248 => self.next()? as usize,
800                        249 => (
801                            unsafe {
802                                *(self.must_read(2, true)?.as_slice().as_ptr() as *const u16)
803                            } as usize
804                        ),
805                        250 => (
806                            unsafe {
807                                *(self.must_read(4, true)?.as_slice().as_ptr() as *const u32)
808                            } as usize
809                        ),
810                        value => return Err(Error::UnexpectedValue(Type::Variant, value)),
811                    };
812
813                    if self.input.max_instant_read() < len {
814                        // need multiple reads to get full buffer
815
816                        let mut buf = Vec::new();
817                        let mut bytes_to_parse = len;
818
819                        while bytes_to_parse > 0 {
820                            let bytes_to_read = cmp::min(self.input.max_instant_read(), bytes_to_parse);
821
822                            let bytes = self.read(bytes_to_read, false)?;
823
824                            bytes_to_parse -= bytes.len();
825                            buf.extend_from_slice(bytes.as_slice());
826                        }
827
828                        visitor.visit_byte_buf(buf)
829                    } else {
830                        match self.read(len, false)? {
831                            Borrowed::Transient(bytes) => visitor.visit_bytes(bytes),
832                            Borrowed::Permanent(bytes) => visitor.visit_borrowed_bytes(bytes),
833                            Borrowed::Copied(bytes) => visitor.visit_byte_buf(bytes),
834                        }
835                    }
836                }
837                value => Err(Error::UnexpectedValue(Type::Variant, value)),
838            }
839            _ => Err(Error::ExpectedType(vec![Type::Variant], byte)), // Unexpected type
840        }
841    }
842
843    #[inline]
844    fn deserialize_ignored_any<V>(self, visitor: V) -> Result<V::Value>
845    where
846        V: Visitor<'de>
847    {
848        self.ignore_value()?;
849
850        visitor.visit_unit()
851    }
852}
853
854struct SeqVisitor<'a, 'de: 'a, R: Read<'de> + 'de> {
855    de: &'a mut Deserializer<'de, R>,
856    index: usize,
857    len: usize,
858}
859
860impl<'a, 'de, R: Read<'de>> SeqVisitor<'a, 'de, R> {
861    #[inline]
862    pub fn new(de: &'a mut Deserializer<'de, R>, len: usize) -> Self {
863        Self {
864            de,
865            len,
866            index: 0,
867        }
868    }
869}
870
871impl<'a, 'de, R: Read<'de>> SeqAccess<'de> for SeqVisitor<'a, 'de, R> {
872    type Error = Error;
873
874    #[inline]
875    fn next_element_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>>
876    where
877        T: DeserializeSeed<'de>
878    {
879        if self.index >= self.len {
880            return Ok(None);
881        }
882
883        self.index += 1;
884
885        seed.deserialize(&mut *self.de).map(Some)
886    }
887}
888
889impl<'a, 'de, R: Read<'de>> MapAccess<'de> for SeqVisitor<'a, 'de, R> {
890    type Error = Error;
891
892    #[inline]
893    fn next_key_seed<K>(&mut self, seed: K) -> Result<Option<K::Value>>
894    where
895        K: DeserializeSeed<'de>
896    {
897        if self.index >= self.len {
898            return Ok(None);
899        }
900
901        seed.deserialize(&mut *self.de).map(Some)
902    }
903
904    #[inline]
905    fn next_value_seed<V>(&mut self, seed: V) -> Result<V::Value>
906    where
907        V: DeserializeSeed<'de>
908    {
909        self.index += 1;
910
911        seed.deserialize(&mut *self.de)
912    }
913}
914
915
916struct VariantVisitor<'a, 'de: 'a, R: Read<'de> + 'de> {
917    de: &'a mut Deserializer<'de, R>,
918}
919
920impl<'a, 'de, R: Read<'de>> VariantVisitor<'a, 'de, R> {
921    #[inline]
922    fn new(de: &'a mut Deserializer<'de, R>) -> Self {
923        Self {
924            de
925        }
926    }
927}
928
929impl<'a, 'de, R: Read<'de>> EnumAccess<'de> for VariantVisitor<'a, 'de, R> {
930    type Error = Error;
931    type Variant = Self;
932
933    #[inline]
934    fn variant_seed<V>(self, seed: V) -> Result<(V::Value, Self::Variant)>
935    where
936        V: DeserializeSeed<'de>
937    {
938        // Seed is going to call deserialize_identifier, which is where we get the variant
939        Ok((seed.deserialize(&mut *self.de)?, self))
940    }
941}
942
943impl<'de, 'a, R: Read<'de>> VariantAccess<'de> for VariantVisitor<'a, 'de, R> {
944    type Error = Error;
945
946    #[inline]
947    fn unit_variant(self) -> Result<()> {
948        let byte = self.de.next()?;
949
950        if byte == (Type::Misc as u8) << 5 | 2 {
951            Ok(())
952        } else if ty(byte) == Type::Misc {
953            Err(Error::UnexpectedValue(Type::Misc, val(byte)))
954        } else {
955            Err(Error::ExpectedType(vec![Type::Misc], byte))
956        }
957    }
958
959    #[inline]
960    fn newtype_variant_seed<T>(self, seed: T) -> Result<T::Value>
961    where
962        T: DeserializeSeed<'de>
963    {
964        seed.deserialize(self.de)
965    }
966
967    #[inline]
968    fn tuple_variant<V>(self, len: usize, visitor: V) -> Result<V::Value>
969    where
970        V: Visitor<'de>
971    {
972        self.de.deserialize_tuple(len, visitor)
973    }
974
975    #[inline]
976    fn struct_variant<V>(self, _fields: &'static [&'static str], visitor: V) -> Result<V::Value>
977    where
978        V: Visitor<'de>
979    {
980        self.de.deserialize_seq(visitor)
981    }
982}
serde_dbor/de/mod.rs

serde_dbor/de/
mod.rs
