ciborium/de/
mod.rs

Help
1// SPDX-License-Identifier: Apache-2.0
2
3//! Serde deserialization support for CBOR
4
5mod error;
6
7pub use error::Error;
8
9use alloc::{string::String, vec::Vec};
10
11use ciborium_io::Read;
12use ciborium_ll::*;
13use serde::{de, de::Deserializer as _, forward_to_deserialize_any};
14
15trait Expected<E: de::Error> {
16    fn expected(self, kind: &'static str) -> E;
17}
18
19impl<E: de::Error> Expected<E> for Header {
20    #[inline]
21    fn expected(self, kind: &'static str) -> E {
22        de::Error::invalid_type(
23            match self {
24                Header::Positive(x) => de::Unexpected::Unsigned(x),
25                Header::Negative(x) => de::Unexpected::Signed(x as i64 ^ !0),
26                Header::Bytes(..) => de::Unexpected::Other("bytes"),
27                Header::Text(..) => de::Unexpected::Other("string"),
28
29                Header::Array(..) => de::Unexpected::Seq,
30                Header::Map(..) => de::Unexpected::Map,
31
32                Header::Tag(..) => de::Unexpected::Other("tag"),
33
34                Header::Simple(simple::FALSE) => de::Unexpected::Bool(false),
35                Header::Simple(simple::TRUE) => de::Unexpected::Bool(true),
36                Header::Simple(simple::NULL) => de::Unexpected::Other("null"),
37                Header::Simple(simple::UNDEFINED) => de::Unexpected::Other("undefined"),
38                Header::Simple(..) => de::Unexpected::Other("simple"),
39
40                Header::Float(x) => de::Unexpected::Float(x),
41                Header::Break => de::Unexpected::Other("break"),
42            },
43            &kind,
44        )
45    }
46}
47
48struct Deserializer<'b, R: Read> {
49    decoder: Decoder<R>,
50    scratch: &'b mut [u8],
51    recurse: usize,
52}
53
54impl<'de, 'a, 'b, R: Read> Deserializer<'b, R>
55where
56    R::Error: core::fmt::Debug,
57{
58    #[inline]
59    fn recurse<V, F: FnOnce(&mut Self) -> Result<V, Error<R::Error>>>(
60        &mut self,
61        func: F,
62    ) -> Result<V, Error<R::Error>> {
63        if self.recurse == 0 {
64            return Err(Error::RecursionLimitExceeded);
65        }
66
67        self.recurse -= 1;
68        let result = func(self);
69        self.recurse += 1;
70        result
71    }
72
73    #[inline]
74    fn integer(&mut self, mut header: Option<Header>) -> Result<(bool, u128), Error<R::Error>> {
75        loop {
76            let header = match header.take() {
77                Some(h) => h,
78                None => self.decoder.pull()?,
79            };
80
81            let neg = match header {
82                Header::Positive(x) => return Ok((false, x.into())),
83                Header::Negative(x) => return Ok((true, x.into())),
84                Header::Tag(tag::BIGPOS) => false,
85                Header::Tag(tag::BIGNEG) => true,
86                Header::Tag(..) => continue,
87                header => return Err(header.expected("integer")),
88            };
89
90            let mut buffer = [0u8; 16];
91            let mut value = [0u8; 16];
92            let mut index = 0usize;
93
94            return match self.decoder.pull()? {
95                Header::Bytes(len) => {
96                    let mut segments = self.decoder.bytes(len);
97                    while let Some(mut segment) = segments.pull()? {
98                        while let Some(chunk) = segment.pull(&mut buffer)? {
99                            for b in chunk {
100                                match index {
101                                    16 => return Err(de::Error::custom("bigint too large")),
102                                    0 if *b == 0 => continue, // Skip leading zeros
103                                    _ => value[index] = *b,
104                                }
105
106                                index += 1;
107                            }
108                        }
109                    }
110
111                    value[..index].reverse();
112                    Ok((neg, u128::from_le_bytes(value)))
113                }
114
115                h => Err(h.expected("bytes")),
116            };
117        }
118    }
119}
120
121impl<'de, 'a, 'b, R: Read> de::Deserializer<'de> for &'a mut Deserializer<'b, R>
122where
123    R::Error: core::fmt::Debug,
124{
125    type Error = Error<R::Error>;
126
127    #[inline]
128    fn deserialize_any<V: de::Visitor<'de>>(self, visitor: V) -> Result<V::Value, Self::Error> {
129        let header = self.decoder.pull()?;
130        self.decoder.push(header);
131
132        match header {
133            Header::Positive(..) => self.deserialize_u64(visitor),
134            Header::Negative(x) => match i64::try_from(x) {
135                Ok(..) => self.deserialize_i64(visitor),
136                Err(..) => self.deserialize_i128(visitor),
137            },
138
139            Header::Bytes(len) => match len {
140                Some(len) if len <= self.scratch.len() => self.deserialize_bytes(visitor),
141                _ => self.deserialize_byte_buf(visitor),
142            },
143
144            Header::Text(len) => match len {
145                Some(len) if len <= self.scratch.len() => self.deserialize_str(visitor),
146                _ => self.deserialize_string(visitor),
147            },
148
149            Header::Array(..) => self.deserialize_seq(visitor),
150            Header::Map(..) => self.deserialize_map(visitor),
151
152            Header::Tag(tag) => {
153                let _: Header = self.decoder.pull()?;
154
155                // Peek at the next item.
156                let header = self.decoder.pull()?;
157                self.decoder.push(header);
158
159                // If it is bytes, capture the length.
160                let len = match header {
161                    Header::Bytes(x) => x,
162                    _ => None,
163                };
164
165                match (tag, len) {
166                    (tag::BIGPOS, Some(len)) | (tag::BIGNEG, Some(len)) if len <= 16 => {
167                        let result = match self.integer(Some(Header::Tag(tag)))? {
168                            (false, raw) => return visitor.visit_u128(raw),
169                            (true, raw) => i128::try_from(raw).map(|x| x ^ !0),
170                        };
171
172                        match result {
173                            Ok(x) => visitor.visit_i128(x),
174                            Err(..) => Err(de::Error::custom("integer too large")),
175                        }
176                    }
177
178                    _ => self.recurse(|me| {
179                        let access = crate::tag::TagAccess::new(me, Some(tag));
180                        visitor.visit_enum(access)
181                    }),
182                }
183            }
184
185            Header::Float(..) => self.deserialize_f64(visitor),
186
187            Header::Simple(simple::FALSE) => self.deserialize_bool(visitor),
188            Header::Simple(simple::TRUE) => self.deserialize_bool(visitor),
189            Header::Simple(simple::NULL) => self.deserialize_option(visitor),
190            Header::Simple(simple::UNDEFINED) => self.deserialize_option(visitor),
191            h @ Header::Simple(..) => Err(h.expected("known simple value")),
192
193            h @ Header::Break => Err(h.expected("non-break")),
194        }
195    }
196
197    #[inline]
198    fn deserialize_bool<V: de::Visitor<'de>>(self, visitor: V) -> Result<V::Value, Self::Error> {
199        loop {
200            let offset = self.decoder.offset();
201
202            return match self.decoder.pull()? {
203                Header::Tag(..) => continue,
204                Header::Simple(simple::FALSE) => visitor.visit_bool(false),
205                Header::Simple(simple::TRUE) => visitor.visit_bool(true),
206                _ => Err(Error::semantic(offset, "expected bool")),
207            };
208        }
209    }
210
211    #[inline]
212    fn deserialize_f32<V: de::Visitor<'de>>(self, visitor: V) -> Result<V::Value, Self::Error> {
213        self.deserialize_f64(visitor)
214    }
215
216    #[inline]
217    fn deserialize_f64<V: de::Visitor<'de>>(self, visitor: V) -> Result<V::Value, Self::Error> {
218        loop {
219            return match self.decoder.pull()? {
220                Header::Tag(..) => continue,
221                Header::Float(x) => visitor.visit_f64(x),
222                h => Err(h.expected("float")),
223            };
224        }
225    }
226
227    fn deserialize_i8<V: de::Visitor<'de>>(self, visitor: V) -> Result<V::Value, Self::Error> {
228        self.deserialize_i64(visitor)
229    }
230
231    fn deserialize_i16<V: de::Visitor<'de>>(self, visitor: V) -> Result<V::Value, Self::Error> {
232        self.deserialize_i64(visitor)
233    }
234
235    fn deserialize_i32<V: de::Visitor<'de>>(self, visitor: V) -> Result<V::Value, Self::Error> {
236        self.deserialize_i64(visitor)
237    }
238
239    fn deserialize_i64<V: de::Visitor<'de>>(self, visitor: V) -> Result<V::Value, Self::Error> {
240        let result = match self.integer(None)? {
241            (false, raw) => i64::try_from(raw),
242            (true, raw) => i64::try_from(raw).map(|x| x ^ !0),
243        };
244
245        match result {
246            Ok(x) => visitor.visit_i64(x),
247            Err(..) => Err(de::Error::custom("integer too large")),
248        }
249    }
250
251    fn deserialize_i128<V: de::Visitor<'de>>(self, visitor: V) -> Result<V::Value, Self::Error> {
252        let result = match self.integer(None)? {
253            (false, raw) => i128::try_from(raw),
254            (true, raw) => i128::try_from(raw).map(|x| x ^ !0),
255        };
256
257        match result {
258            Ok(x) => visitor.visit_i128(x),
259            Err(..) => Err(de::Error::custom("integer too large")),
260        }
261    }
262
263    fn deserialize_u8<V: de::Visitor<'de>>(self, visitor: V) -> Result<V::Value, Self::Error> {
264        self.deserialize_u64(visitor)
265    }
266
267    fn deserialize_u16<V: de::Visitor<'de>>(self, visitor: V) -> Result<V::Value, Self::Error> {
268        self.deserialize_u64(visitor)
269    }
270
271    fn deserialize_u32<V: de::Visitor<'de>>(self, visitor: V) -> Result<V::Value, Self::Error> {
272        self.deserialize_u64(visitor)
273    }
274
275    fn deserialize_u64<V: de::Visitor<'de>>(self, visitor: V) -> Result<V::Value, Self::Error> {
276        let result = match self.integer(None)? {
277            (false, raw) => u64::try_from(raw),
278            (true, ..) => return Err(de::Error::custom("unexpected negative integer")),
279        };
280
281        match result {
282            Ok(x) => visitor.visit_u64(x),
283            Err(..) => Err(de::Error::custom("integer too large")),
284        }
285    }
286
287    fn deserialize_u128<V: de::Visitor<'de>>(self, visitor: V) -> Result<V::Value, Self::Error> {
288        match self.integer(None)? {
289            (false, raw) => visitor.visit_u128(raw),
290            (true, ..) => Err(de::Error::custom("unexpected negative integer")),
291        }
292    }
293
294    fn deserialize_char<V: de::Visitor<'de>>(self, visitor: V) -> Result<V::Value, Self::Error> {
295        loop {
296            let offset = self.decoder.offset();
297            let header = self.decoder.pull()?;
298
299            return match header {
300                Header::Tag(..) => continue,
301
302                Header::Text(Some(len)) if len <= 4 => {
303                    let mut buf = [0u8; 4];
304                    self.decoder.read_exact(&mut buf[..len])?;
305
306                    match core::str::from_utf8(&buf[..len]) {
307                        Ok(s) => match s.chars().count() {
308                            1 => visitor.visit_char(s.chars().next().unwrap()),
309                            _ => Err(header.expected("char")),
310                        },
311                        Err(..) => Err(Error::Syntax(offset)),
312                    }
313                }
314
315                _ => Err(header.expected("char")),
316            };
317        }
318    }
319
320    fn deserialize_str<V: de::Visitor<'de>>(self, visitor: V) -> Result<V::Value, Self::Error> {
321        loop {
322            let offset = self.decoder.offset();
323
324            return match self.decoder.pull()? {
325                Header::Tag(..) => continue,
326
327                Header::Text(Some(len)) if len <= self.scratch.len() => {
328                    self.decoder.read_exact(&mut self.scratch[..len])?;
329
330                    match core::str::from_utf8(&self.scratch[..len]) {
331                        Ok(s) => visitor.visit_str(s),
332                        Err(..) => Err(Error::Syntax(offset)),
333                    }
334                }
335
336                header => Err(header.expected("str")),
337            };
338        }
339    }
340
341    fn deserialize_string<V: de::Visitor<'de>>(self, visitor: V) -> Result<V::Value, Self::Error> {
342        loop {
343            return match self.decoder.pull()? {
344                Header::Tag(..) => continue,
345
346                Header::Text(len) => {
347                    let mut buffer = String::new();
348
349                    let mut segments = self.decoder.text(len);
350                    while let Some(mut segment) = segments.pull()? {
351                        while let Some(chunk) = segment.pull(&mut self.scratch)? {
352                            buffer.push_str(chunk);
353                        }
354                    }
355
356                    visitor.visit_string(buffer)
357                }
358
359                header => Err(header.expected("string")),
360            };
361        }
362    }
363
364    fn deserialize_bytes<V: de::Visitor<'de>>(self, visitor: V) -> Result<V::Value, Self::Error> {
365        loop {
366            return match self.decoder.pull()? {
367                Header::Tag(..) => continue,
368
369                Header::Bytes(Some(len)) if len <= self.scratch.len() => {
370                    self.decoder.read_exact(&mut self.scratch[..len])?;
371                    visitor.visit_bytes(&self.scratch[..len])
372                }
373
374                header => Err(header.expected("bytes")),
375            };
376        }
377    }
378
379    fn deserialize_byte_buf<V: de::Visitor<'de>>(
380        self,
381        visitor: V,
382    ) -> Result<V::Value, Self::Error> {
383        loop {
384            return match self.decoder.pull()? {
385                Header::Tag(..) => continue,
386
387                Header::Bytes(len) => {
388                    let mut buffer = Vec::new();
389
390                    let mut segments = self.decoder.bytes(len);
391                    while let Some(mut segment) = segments.pull()? {
392                        while let Some(chunk) = segment.pull(&mut self.scratch)? {
393                            buffer.extend_from_slice(chunk);
394                        }
395                    }
396
397                    visitor.visit_byte_buf(buffer)
398                }
399
400                header => Err(header.expected("expected byte buffer")),
401            };
402        }
403    }
404
405    fn deserialize_seq<V: de::Visitor<'de>>(self, visitor: V) -> Result<V::Value, Self::Error> {
406        loop {
407            return match self.decoder.pull()? {
408                Header::Tag(..) => continue,
409
410                Header::Array(len) => self.recurse(|me| {
411                    let access = Access(me, len);
412                    visitor.visit_seq(access)
413                }),
414
415                header => Err(header.expected("array")),
416            };
417        }
418    }
419
420    fn deserialize_map<V: de::Visitor<'de>>(self, visitor: V) -> Result<V::Value, Self::Error> {
421        loop {
422            return match self.decoder.pull()? {
423                Header::Tag(..) => continue,
424
425                Header::Map(len) => self.recurse(|me| {
426                    let access = Access(me, len);
427                    visitor.visit_map(access)
428                }),
429
430                header => Err(header.expected("map")),
431            };
432        }
433    }
434
435    fn deserialize_struct<V: de::Visitor<'de>>(
436        self,
437        _name: &'static str,
438        _fields: &'static [&'static str],
439        visitor: V,
440    ) -> Result<V::Value, Self::Error> {
441        self.deserialize_map(visitor)
442    }
443
444    fn deserialize_tuple<V: de::Visitor<'de>>(
445        self,
446        _len: usize,
447        visitor: V,
448    ) -> Result<V::Value, Self::Error> {
449        self.deserialize_seq(visitor)
450    }
451
452    fn deserialize_tuple_struct<V: de::Visitor<'de>>(
453        self,
454        _name: &'static str,
455        _len: usize,
456        visitor: V,
457    ) -> Result<V::Value, Self::Error> {
458        self.deserialize_seq(visitor)
459    }
460
461    fn deserialize_identifier<V: de::Visitor<'de>>(
462        self,
463        visitor: V,
464    ) -> Result<V::Value, Self::Error> {
465        self.deserialize_str(visitor)
466    }
467
468    fn deserialize_ignored_any<V: de::Visitor<'de>>(
469        self,
470        visitor: V,
471    ) -> Result<V::Value, Self::Error> {
472        self.deserialize_any(visitor)
473    }
474
475    #[inline]
476    fn deserialize_option<V: de::Visitor<'de>>(self, visitor: V) -> Result<V::Value, Self::Error> {
477        loop {
478            return match self.decoder.pull()? {
479                Header::Simple(simple::UNDEFINED) => visitor.visit_none(),
480                Header::Simple(simple::NULL) => visitor.visit_none(),
481                Header::Tag(..) => continue,
482                header => {
483                    self.decoder.push(header);
484                    visitor.visit_some(self)
485                }
486            };
487        }
488    }
489
490    #[inline]
491    fn deserialize_unit<V: de::Visitor<'de>>(self, visitor: V) -> Result<V::Value, Self::Error> {
492        loop {
493            return match self.decoder.pull()? {
494                Header::Simple(simple::UNDEFINED) => visitor.visit_unit(),
495                Header::Simple(simple::NULL) => visitor.visit_unit(),
496                Header::Tag(..) => continue,
497                header => Err(header.expected("unit")),
498            };
499        }
500    }
501
502    #[inline]
503    fn deserialize_unit_struct<V: de::Visitor<'de>>(
504        self,
505        _name: &'static str,
506        visitor: V,
507    ) -> Result<V::Value, Self::Error> {
508        self.deserialize_unit(visitor)
509    }
510
511    #[inline]
512    fn deserialize_newtype_struct<V: de::Visitor<'de>>(
513        self,
514        _name: &'static str,
515        visitor: V,
516    ) -> Result<V::Value, Self::Error> {
517        visitor.visit_newtype_struct(self)
518    }
519
520    #[inline]
521    fn deserialize_enum<V: de::Visitor<'de>>(
522        self,
523        name: &'static str,
524        _variants: &'static [&'static str],
525        visitor: V,
526    ) -> Result<V::Value, Self::Error> {
527        if name == "@@TAG@@" {
528            let tag = match self.decoder.pull()? {
529                Header::Tag(x) => Some(x),
530                header => {
531                    self.decoder.push(header);
532                    None
533                }
534            };
535
536            return self.recurse(|me| {
537                let access = crate::tag::TagAccess::new(me, tag);
538                visitor.visit_enum(access)
539            });
540        }
541
542        loop {
543            match self.decoder.pull()? {
544                Header::Tag(..) => continue,
545                Header::Map(Some(1)) => (),
546                header @ Header::Text(..) => self.decoder.push(header),
547                header => return Err(header.expected("enum")),
548            }
549
550            return self.recurse(|me| {
551                let access = Access(me, Some(0));
552                visitor.visit_enum(access)
553            });
554        }
555    }
556
557    #[inline]
558    fn is_human_readable(&self) -> bool {
559        false
560    }
561}
562
563struct Access<'a, 'b, R: Read>(&'a mut Deserializer<'b, R>, Option<usize>);
564
565impl<'de, 'a, 'b, R: Read> de::SeqAccess<'de> for Access<'a, 'b, R>
566where
567    R::Error: core::fmt::Debug,
568{
569    type Error = Error<R::Error>;
570
571    #[inline]
572    fn next_element_seed<U: de::DeserializeSeed<'de>>(
573        &mut self,
574        seed: U,
575    ) -> Result<Option<U::Value>, Self::Error> {
576        match self.1 {
577            Some(0) => return Ok(None),
578            Some(x) => self.1 = Some(x - 1),
579            None => match self.0.decoder.pull()? {
580                Header::Break => return Ok(None),
581                header => self.0.decoder.push(header),
582            },
583        }
584
585        seed.deserialize(&mut *self.0).map(Some)
586    }
587
588    #[inline]
589    fn size_hint(&self) -> Option<usize> {
590        self.1
591    }
592}
593
594impl<'de, 'a, 'b, R: Read> de::MapAccess<'de> for Access<'a, 'b, R>
595where
596    R::Error: core::fmt::Debug,
597{
598    type Error = Error<R::Error>;
599
600    #[inline]
601    fn next_key_seed<K: de::DeserializeSeed<'de>>(
602        &mut self,
603        seed: K,
604    ) -> Result<Option<K::Value>, Self::Error> {
605        match self.1 {
606            Some(0) => return Ok(None),
607            Some(x) => self.1 = Some(x - 1),
608            None => match self.0.decoder.pull()? {
609                Header::Break => return Ok(None),
610                header => self.0.decoder.push(header),
611            },
612        }
613
614        seed.deserialize(&mut *self.0).map(Some)
615    }
616
617    #[inline]
618    fn next_value_seed<V: de::DeserializeSeed<'de>>(
619        &mut self,
620        seed: V,
621    ) -> Result<V::Value, Self::Error> {
622        seed.deserialize(&mut *self.0)
623    }
624
625    #[inline]
626    fn size_hint(&self) -> Option<usize> {
627        self.1
628    }
629}
630
631impl<'de, 'a, 'b, R: Read> de::EnumAccess<'de> for Access<'a, 'b, R>
632where
633    R::Error: core::fmt::Debug,
634{
635    type Error = Error<R::Error>;
636    type Variant = Self;
637
638    #[inline]
639    fn variant_seed<V: de::DeserializeSeed<'de>>(
640        self,
641        seed: V,
642    ) -> Result<(V::Value, Self::Variant), Self::Error> {
643        let variant = seed.deserialize(&mut *self.0)?;
644        Ok((variant, self))
645    }
646}
647
648impl<'de, 'a, 'b, R: Read> de::VariantAccess<'de> for Access<'a, 'b, R>
649where
650    R::Error: core::fmt::Debug,
651{
652    type Error = Error<R::Error>;
653
654    #[inline]
655    fn unit_variant(self) -> Result<(), Self::Error> {
656        Ok(())
657    }
658
659    #[inline]
660    fn newtype_variant_seed<U: de::DeserializeSeed<'de>>(
661        self,
662        seed: U,
663    ) -> Result<U::Value, Self::Error> {
664        seed.deserialize(&mut *self.0)
665    }
666
667    #[inline]
668    fn tuple_variant<V: de::Visitor<'de>>(
669        self,
670        _len: usize,
671        visitor: V,
672    ) -> Result<V::Value, Self::Error> {
673        self.0.deserialize_any(visitor)
674    }
675
676    #[inline]
677    fn struct_variant<V: de::Visitor<'de>>(
678        self,
679        _fields: &'static [&'static str],
680        visitor: V,
681    ) -> Result<V::Value, Self::Error> {
682        self.0.deserialize_any(visitor)
683    }
684}
685
686struct TagAccess<'a, 'b, R: Read>(&'a mut Deserializer<'b, R>, usize);
687
688impl<'de, 'a, 'b, R: Read> de::Deserializer<'de> for &mut TagAccess<'a, 'b, R>
689where
690    R::Error: core::fmt::Debug,
691{
692    type Error = Error<R::Error>;
693
694    #[inline]
695    fn deserialize_any<V: de::Visitor<'de>>(self, visitor: V) -> Result<V::Value, Self::Error> {
696        let offset = self.0.decoder.offset();
697
698        match self.0.decoder.pull()? {
699            Header::Tag(x) => visitor.visit_u64(x),
700            _ => Err(Error::semantic(offset, "expected tag")),
701        }
702    }
703
704    forward_to_deserialize_any! {
705        i8 i16 i32 i64 i128
706        u8 u16 u32 u64 u128
707        bool f32 f64
708        char str string
709        bytes byte_buf
710        seq map
711        struct tuple tuple_struct
712        identifier ignored_any
713        option unit unit_struct newtype_struct enum
714    }
715}
716
717impl<'de, 'a, 'b, R: Read> de::SeqAccess<'de> for TagAccess<'a, 'b, R>
718where
719    R::Error: core::fmt::Debug,
720{
721    type Error = Error<R::Error>;
722
723    #[inline]
724    fn next_element_seed<U: de::DeserializeSeed<'de>>(
725        &mut self,
726        seed: U,
727    ) -> Result<Option<U::Value>, Self::Error> {
728        self.1 += 1;
729
730        match self.1 {
731            1 => seed.deserialize(self).map(Some),
732            2 => seed.deserialize(&mut *self.0).map(Some),
733            _ => Ok(None),
734        }
735    }
736
737    #[inline]
738    fn size_hint(&self) -> Option<usize> {
739        Some(match self.1 {
740            0 => 2,
741            1 => 1,
742            _ => 0,
743        })
744    }
745}
746
747/// Deserializes as CBOR from a type with [`impl ciborium_io::Read`](ciborium_io::Read)
748#[inline]
749pub fn from_reader<'de, T: de::Deserialize<'de>, R: Read>(reader: R) -> Result<T, Error<R::Error>>
750where
751    R::Error: core::fmt::Debug,
752{
753    let mut scratch = [0; 4096];
754
755    let mut reader = Deserializer {
756        decoder: reader.into(),
757        scratch: &mut scratch,
758        recurse: 256,
759    };
760
761    T::deserialize(&mut reader)
762}
ciborium/de/mod.rs

ciborium/de/
mod.rs
