messpack_serde/
decode.rs

1//! Generic MessagePack deserialization.
2
3use crate::config::sealed::SerializerConfig as _;
4use std::convert::TryInto;
5use std::error;
6use std::fmt::{self, Display, Formatter};
7use std::io::{self, Cursor, ErrorKind, Read};
8use std::marker::PhantomData;
9use std::num::TryFromIntError;
10use std::str::{self, Utf8Error};
11
12use byteorder::{self, ReadBytesExt};
13
14use serde;
15use serde::de::value::SeqDeserializer;
16use serde::de::{
17    self, Deserialize, DeserializeOwned, DeserializeSeed, IgnoredAny, MapAccess as _,
18    SeqAccess as _, Unexpected, Visitor,
19};
20use serde::forward_to_deserialize_any;
21
22use rmp;
23use rmp::decode::{
24    self, DecodeStringError, MarkerReadError, NumValueReadError, RmpRead, ValueReadError,
25};
26use rmp::Marker;
27
28use crate::config::{BinaryConfig, DefaultConfig, HumanReadableConfig, SerializerConfig};
29use crate::MSGPACK_EXT_STRUCT_NAME;
30
31/// Enum representing errors that can occur while decoding MessagePack data.
32#[derive(Debug)]
33pub enum Error {
34    /// The enclosed I/O error occurred while trying to read a MessagePack
35    /// marker.
36    InvalidMarkerRead(io::Error),
37    /// The enclosed I/O error occurred while trying to read the encoded
38    /// MessagePack data.
39    InvalidDataRead(io::Error),
40    /// A mismatch occurred between the decoded and expected value types.
41    TypeMismatch(Marker),
42    /// A numeric cast failed due to an out-of-range error.
43    OutOfRange,
44    /// A decoded array did not have the enclosed expected length.
45    LengthMismatch(u32),
46    /// An otherwise uncategorized error occurred. See the enclosed `String` for
47    /// details.
48    Uncategorized(String),
49    /// A general error occurred while deserializing the expected type. See the
50    /// enclosed `String` for details.
51    Syntax(String),
52    /// An encoded string could not be parsed as UTF-8.
53    Utf8Error(Utf8Error),
54    /// The depth limit was exceeded.
55    DepthLimitExceeded,
56}
57
58macro_rules! depth_count(
59    ( $counter:expr, $expr:expr ) => {
60        {
61            $counter -= 1;
62            if $counter == 0 {
63                return Err(Error::DepthLimitExceeded)
64            }
65            let res = $expr;
66            $counter += 1;
67            res
68        }
69    }
70);
71
72impl error::Error for Error {
73    #[cold]
74    fn source(&self) -> Option<&(dyn error::Error + 'static)> {
75        match *self {
76            Self::TypeMismatch(..) => None,
77            Self::InvalidMarkerRead(ref err) => Some(err),
78            Self::InvalidDataRead(ref err) => Some(err),
79            Self::LengthMismatch(..) => None,
80            Self::OutOfRange => None,
81            Self::Uncategorized(..) => None,
82            Self::Syntax(..) => None,
83            Self::Utf8Error(ref err) => Some(err),
84            Self::DepthLimitExceeded => None,
85        }
86    }
87}
88
89impl de::Error for Error {
90    #[cold]
91    fn custom<T: Display>(msg: T) -> Self {
92        Self::Syntax(msg.to_string())
93    }
94}
95
96impl Display for Error {
97    #[cold]
98    fn fmt(&self, fmt: &mut Formatter<'_>) -> Result<(), fmt::Error> {
99        match *self {
100            Self::InvalidMarkerRead(ref err) => write!(fmt, "IO error while reading marker: {err}"),
101            Self::InvalidDataRead(ref err) => write!(fmt, "IO error while reading data: {err}"),
102            Self::TypeMismatch(ref actual_marker) => {
103                write!(fmt, "wrong msgpack marker {actual_marker:?}")
104            }
105            Self::OutOfRange => fmt.write_str("numeric cast found out of range"),
106            Self::LengthMismatch(expected_length) => write!(
107                fmt,
108                "array had incorrect length, expected {expected_length}"
109            ),
110            Self::Uncategorized(ref msg) => write!(fmt, "uncategorized error: {msg}"),
111            Self::Syntax(ref msg) => fmt.write_str(msg),
112            Self::Utf8Error(ref err) => write!(fmt, "string found to be invalid utf8: {err}"),
113            Self::DepthLimitExceeded => fmt.write_str("depth limit exceeded"),
114        }
115    }
116}
117
118impl From<MarkerReadError> for Error {
119    #[cold]
120    fn from(err: MarkerReadError) -> Self {
121        match err {
122            MarkerReadError(err) => Self::InvalidMarkerRead(err),
123        }
124    }
125}
126
127impl From<Utf8Error> for Error {
128    #[cold]
129    fn from(err: Utf8Error) -> Self {
130        Self::Utf8Error(err)
131    }
132}
133
134impl From<ValueReadError> for Error {
135    #[cold]
136    fn from(err: ValueReadError) -> Self {
137        match err {
138            ValueReadError::TypeMismatch(marker) => Self::TypeMismatch(marker),
139            ValueReadError::InvalidMarkerRead(err) => Self::InvalidMarkerRead(err),
140            ValueReadError::InvalidDataRead(err) => Self::InvalidDataRead(err),
141        }
142    }
143}
144
145impl From<NumValueReadError> for Error {
146    #[cold]
147    fn from(err: NumValueReadError) -> Self {
148        match err {
149            NumValueReadError::TypeMismatch(marker) => Self::TypeMismatch(marker),
150            NumValueReadError::InvalidMarkerRead(err) => Self::InvalidMarkerRead(err),
151            NumValueReadError::InvalidDataRead(err) => Self::InvalidDataRead(err),
152            NumValueReadError::OutOfRange => Self::OutOfRange,
153        }
154    }
155}
156
157impl From<DecodeStringError<'_>> for Error {
158    #[cold]
159    fn from(err: DecodeStringError<'_>) -> Self {
160        match err {
161            DecodeStringError::InvalidMarkerRead(err) => Self::InvalidMarkerRead(err),
162            DecodeStringError::InvalidDataRead(err) => Self::InvalidDataRead(err),
163            DecodeStringError::TypeMismatch(marker) => Self::TypeMismatch(marker),
164            DecodeStringError::BufferSizeTooSmall(..) => {
165                Self::Uncategorized("BufferSizeTooSmall".to_string())
166            }
167            DecodeStringError::InvalidUtf8(..) => Self::Uncategorized("InvalidUtf8".to_string()),
168        }
169    }
170}
171
172impl From<TryFromIntError> for Error {
173    #[cold]
174    fn from(_: TryFromIntError) -> Self {
175        Self::OutOfRange
176    }
177}
178
179/// A Deserializer that reads bytes from a buffer.
180///
181/// # Note
182///
183/// All instances of `ErrorKind::Interrupted` are handled by this function and the underlying
184/// operation is retried.
185#[derive(Debug)]
186pub struct Deserializer<R, C = DefaultConfig> {
187    rd: R,
188    _config: PhantomData<C>,
189    is_human_readable: bool,
190    marker: Option<Marker>,
191    depth: u16,
192}
193
194impl<R: Read, C> Deserializer<R, C> {
195    #[inline]
196    fn take_or_read_marker(&mut self) -> Result<Marker, MarkerReadError> {
197        self.marker
198            .take()
199            .map_or_else(|| rmp::decode::read_marker(&mut self.rd), Ok)
200    }
201
202    #[inline]
203    fn peek_or_read_marker(&mut self) -> Result<Marker, MarkerReadError> {
204        if let Some(m) = self.marker {
205            Ok(m)
206        } else {
207            let m = rmp::decode::read_marker(&mut self.rd)?;
208            Ok(self.marker.insert(m).to_owned())
209        }
210    }
211}
212
213impl<R: Read> Deserializer<ReadReader<R>, DefaultConfig> {
214    /// Constructs a new `Deserializer` by consuming the given reader.
215    #[inline]
216    pub fn new(rd: R) -> Self {
217        Self {
218            rd: ReadReader::new(rd),
219            _config: PhantomData,
220            is_human_readable: DefaultConfig.is_human_readable(),
221            // Cached marker in case of deserializing optional values.
222            marker: None,
223            depth: 1024,
224        }
225    }
226}
227
228impl<R: Read, C> Deserializer<ReadReader<R>, C> {
229    /// Gets a reference to the underlying reader in this decoder.
230    #[inline(always)]
231    pub fn get_ref(&self) -> &R {
232        &self.rd.rd
233    }
234
235    /// Gets a mutable reference to the underlying reader in this decoder.
236    #[inline(always)]
237    pub fn get_mut(&mut self) -> &mut R {
238        &mut self.rd.rd
239    }
240
241    /// Consumes this deserializer returning the underlying reader.
242    #[inline]
243    pub fn into_inner(self) -> R {
244        self.rd.rd
245    }
246}
247
248impl<R: Read, C: SerializerConfig> Deserializer<R, C> {
249    /// Consumes this deserializer and returns a new one, which will deserialize types with
250    /// human-readable representations (`Deserializer::is_human_readable` will return `true`).
251    ///
252    /// This is primarily useful if you need to interoperate with serializations produced by older
253    /// versions of `rmp-serde`.
254    #[inline]
255    pub fn with_human_readable(self) -> Deserializer<R, HumanReadableConfig<C>> {
256        let Self {
257            rd,
258            _config: _,
259            is_human_readable: _,
260            marker,
261            depth,
262        } = self;
263        Deserializer {
264            rd,
265            is_human_readable: true,
266            _config: PhantomData,
267            marker,
268            depth,
269        }
270    }
271
272    /// Consumes this deserializer and returns a new one, which will deserialize types with
273    /// binary representations (`Deserializer::is_human_readable` will return `false`).
274    ///
275    /// This is the default MessagePack deserialization mechanism, consuming the most compact
276    /// representation.
277    #[inline]
278    pub fn with_binary(self) -> Deserializer<R, BinaryConfig<C>> {
279        let Self {
280            rd,
281            _config: _,
282            is_human_readable: _,
283            marker,
284            depth,
285        } = self;
286        Deserializer {
287            rd,
288            is_human_readable: false,
289            _config: PhantomData,
290            marker,
291            depth,
292        }
293    }
294}
295
296impl<R: AsRef<[u8]>> Deserializer<ReadReader<Cursor<R>>> {
297    /// Returns the current position of this deserializer, i.e. how many bytes were read.
298    #[inline(always)]
299    pub fn position(&self) -> u64 {
300        self.rd.rd.position()
301    }
302}
303
304impl<'de, R> Deserializer<ReadRefReader<'de, R>>
305where
306    R: AsRef<[u8]> + ?Sized,
307{
308    /// Constructs a new `Deserializer` from the given byte slice.
309    #[inline(always)]
310    pub fn from_read_ref(rd: &'de R) -> Self {
311        Deserializer {
312            rd: ReadRefReader::new(rd),
313            is_human_readable: DefaultConfig.is_human_readable(),
314            _config: PhantomData,
315            marker: None,
316            depth: 1024,
317        }
318    }
319
320    /// Gets a reference to the underlying reader in this decoder.
321    #[inline(always)]
322    #[must_use]
323    pub fn get_ref(&self) -> &R {
324        self.rd.whole_slice
325    }
326}
327
328impl<'de, R: ReadSlice<'de>, C: SerializerConfig> Deserializer<R, C> {
329    /// Changes the maximum nesting depth that is allowed
330    #[inline(always)]
331    pub fn set_max_depth(&mut self, depth: usize) {
332        self.depth = depth.min(u16::MAX as _) as u16;
333    }
334}
335
336#[inline(never)]
337fn read_i128_marker<'de, R: ReadSlice<'de>>(marker: Marker, rd: &mut R) -> Result<i128, Error> {
338    Ok(match marker {
339        Marker::FixPos(val) => val.into(),
340        Marker::FixNeg(val) => val.into(),
341        Marker::U8 => rd.read_data_u8()?.into(),
342        Marker::U16 => rd.read_data_u16()?.into(),
343        Marker::U32 => rd.read_data_u32()?.into(),
344        Marker::U64 => rd.read_data_u64()?.into(),
345        Marker::I8 => rd.read_data_i8()?.into(),
346        Marker::I16 => rd.read_data_i16()?.into(),
347        Marker::I32 => rd.read_data_i32()?.into(),
348        Marker::I64 => rd.read_data_i64()?.into(),
349        Marker::Bin8 => {
350            let len = read_u8(&mut *rd)?;
351            read_128_buf(rd, len)?
352        }
353        Marker::FixArray(len) => read_128_buf(rd, len)?,
354        marker => {
355            consume_unexpected_value(rd, marker)?;
356            return Err(Error::TypeMismatch(marker));
357        }
358    })
359}
360
361fn read_128_buf<'de, R: ReadSlice<'de>>(rd: &mut R, len: u8) -> Result<i128, Error> {
362    if len != 16 {
363        return Err(Error::LengthMismatch(16));
364    }
365    let buf = match read_bin_data(rd, 16)? {
366        Reference::Borrowed(buf) => buf,
367        Reference::Copied(buf) => buf,
368    };
369    Ok(i128::from_be_bytes(
370        buf.try_into().map_err(|_| Error::LengthMismatch(16))?,
371    ))
372}
373
374fn read_str_data<'de, V, R>(rd: &mut R, len: u32, visitor: V) -> Result<V::Value, Error>
375where
376    V: Visitor<'de>,
377    R: ReadSlice<'de>,
378{
379    match read_bin_data(rd, len)? {
380        Reference::Borrowed(buf) => {
381            match str::from_utf8(buf) {
382                Ok(s) => visitor.visit_borrowed_str(s),
383                Err(err) => {
384                    // Allow to unpack invalid UTF-8 bytes into a byte array.
385                    match visitor.visit_borrowed_bytes::<Error>(buf) {
386                        Ok(buf) => Ok(buf),
387                        Err(..) => Err(Error::Utf8Error(err)),
388                    }
389                }
390            }
391        }
392        Reference::Copied(buf) => {
393            match str::from_utf8(buf) {
394                Ok(s) => visitor.visit_str(s),
395                Err(err) => {
396                    // Allow to unpack invalid UTF-8 bytes into a byte array.
397                    match visitor.visit_bytes::<Error>(buf) {
398                        Ok(buf) => Ok(buf),
399                        Err(..) => Err(Error::Utf8Error(err)),
400                    }
401                }
402            }
403        }
404    }
405}
406
407fn read_bin_data<'a, 'de, R: ReadSlice<'de>>(
408    rd: &'a mut R,
409    len: u32,
410) -> Result<Reference<'de, 'a, [u8]>, Error> {
411    rd.read_slice(len as usize).map_err(Error::InvalidDataRead)
412}
413
414fn read_u8<R: Read>(rd: &mut R) -> Result<u8, Error> {
415    byteorder::ReadBytesExt::read_u8(rd).map_err(Error::InvalidDataRead)
416}
417
418fn read_u16<R: Read>(rd: &mut R) -> Result<u16, Error> {
419    rd.read_u16::<byteorder::BigEndian>()
420        .map_err(Error::InvalidDataRead)
421}
422
423fn read_u32<R: Read>(rd: &mut R) -> Result<u32, Error> {
424    rd.read_u32::<byteorder::BigEndian>()
425        .map_err(Error::InvalidDataRead)
426}
427
428fn ext_len<'de, R: Read + ReadSlice<'de>>(rd: &mut R, marker: Marker) -> Result<u32, Error> {
429    Ok(match marker {
430        Marker::FixExt1 => 1,
431        Marker::FixExt2 => 2,
432        Marker::FixExt4 => 4,
433        Marker::FixExt8 => 8,
434        Marker::FixExt16 => 16,
435        Marker::Ext8 => u32::from(read_u8(rd)?),
436        Marker::Ext16 => u32::from(read_u16(rd)?),
437        Marker::Ext32 => read_u32(rd)?,
438        _ => {
439            consume_unexpected_value(rd, marker)?;
440            return Err(Error::TypeMismatch(marker));
441        }
442    })
443}
444
445#[derive(Debug)]
446enum ExtDeserializerState {
447    New,
448    ReadTag,
449    ReadBinary,
450}
451
452#[derive(Debug)]
453struct ExtDeserializer<'a, R, C> {
454    rd: &'a mut R,
455    _config: PhantomData<C>,
456    len: u32,
457    state: ExtDeserializerState,
458}
459
460impl<'de, 'a, R: ReadSlice<'de> + 'a, C: SerializerConfig> ExtDeserializer<'a, R, C> {
461    const fn new(d: &'a mut Deserializer<R, C>, len: u32) -> Self {
462        ExtDeserializer {
463            rd: &mut d.rd,
464            _config: d._config,
465            len,
466            state: ExtDeserializerState::New,
467        }
468    }
469}
470
471impl<'de, 'a, R: ReadSlice<'de> + 'a, C: SerializerConfig> de::Deserializer<'de>
472    for ExtDeserializer<'a, R, C>
473{
474    type Error = Error;
475
476    #[inline(always)]
477    fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Self::Error>
478    where
479        V: Visitor<'de>,
480    {
481        visitor.visit_seq(self)
482    }
483
484    forward_to_deserialize_any! {
485        bool u8 u16 u32 u64 i8 i16 i32 i64 f32 f64 char str string unit option
486        seq bytes byte_buf map unit_struct newtype_struct
487        struct identifier tuple enum ignored_any tuple_struct
488    }
489}
490
491impl<'de, 'a, R: ReadSlice<'de> + 'a, C: SerializerConfig> de::SeqAccess<'de>
492    for ExtDeserializer<'a, R, C>
493{
494    type Error = Error;
495
496    #[inline]
497    fn next_element_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>, Error>
498    where
499        T: DeserializeSeed<'de>,
500    {
501        match self.state {
502            ExtDeserializerState::New | ExtDeserializerState::ReadTag => {
503                Ok(Some(seed.deserialize(self)?))
504            }
505            ExtDeserializerState::ReadBinary => Ok(None),
506        }
507    }
508}
509
510/// Deserializer for Ext `SeqAccess`
511impl<'de, 'a, R: ReadSlice<'de> + 'a, C: SerializerConfig> de::Deserializer<'de>
512    for &mut ExtDeserializer<'a, R, C>
513{
514    type Error = Error;
515
516    fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Self::Error>
517    where
518        V: Visitor<'de>,
519    {
520        match self.state {
521            ExtDeserializerState::New => {
522                let tag = self.rd.read_data_i8()?;
523                self.state = ExtDeserializerState::ReadTag;
524                visitor.visit_i8(tag)
525            }
526            ExtDeserializerState::ReadTag => {
527                let data = self
528                    .rd
529                    .read_slice(self.len as usize)
530                    .map_err(Error::InvalidDataRead)?;
531                self.state = ExtDeserializerState::ReadBinary;
532                match data {
533                    Reference::Borrowed(bytes) => visitor.visit_borrowed_bytes(bytes),
534                    Reference::Copied(bytes) => visitor.visit_bytes(bytes),
535                }
536            }
537            ExtDeserializerState::ReadBinary => {
538                debug_assert!(false);
539                Err(Error::TypeMismatch(Marker::Reserved))
540            }
541        }
542    }
543
544    forward_to_deserialize_any! {
545        bool u8 u16 u32 u64 i8 i16 i32 i64 f32 f64 char str string unit option
546        seq bytes byte_buf map unit_struct newtype_struct
547        tuple_struct struct identifier tuple enum ignored_any
548    }
549}
550
551#[inline(never)]
552fn any_num<'de, R: ReadSlice<'de>, V: Visitor<'de>>(
553    rd: &mut R,
554    visitor: V,
555    marker: Marker,
556) -> Result<V::Value, Error> {
557    match marker {
558        Marker::Null => visitor.visit_unit(),
559        Marker::True | Marker::False => visitor.visit_bool(marker == Marker::True),
560        Marker::FixPos(val) => visitor.visit_u8(val),
561        Marker::FixNeg(val) => visitor.visit_i8(val),
562        Marker::U8 => visitor.visit_u8(rd.read_data_u8()?),
563        Marker::U16 => visitor.visit_u16(rd.read_data_u16()?),
564        Marker::U32 => visitor.visit_u32(rd.read_data_u32()?),
565        Marker::U64 => visitor.visit_u64(rd.read_data_u64()?),
566        Marker::I8 => visitor.visit_i8(rd.read_data_i8()?),
567        Marker::I16 => visitor.visit_i16(rd.read_data_i16()?),
568        Marker::I32 => visitor.visit_i32(rd.read_data_i32()?),
569        Marker::I64 => visitor.visit_i64(rd.read_data_i64()?),
570        Marker::F32 => visitor.visit_f32(rd.read_data_f32()?),
571        Marker::F64 => visitor.visit_f64(rd.read_data_f64()?),
572        other_marker => {
573            consume_unexpected_value(rd, marker)?;
574            Err(Error::TypeMismatch(other_marker))
575        }
576    }
577}
578
579fn consume_unexpected_values<'de, R: ReadSlice<'de>>(
580    rd: &mut R,
581    count: usize,
582) -> Result<(), Error> {
583    for _ in 0..count {
584        let marker = rmp::decode::read_marker(rd)?;
585        consume_unexpected_value(rd, marker)?;
586    }
587    Ok(())
588}
589
590fn consume_unexpected_value<'de, R: ReadSlice<'de>>(
591    rd: &mut R,
592    marker: Marker,
593) -> Result<(), Error> {
594    // This function is for when we read a marker that indicates a type we don't expect to see.
595    // but in order for future reads to be correct, we need to consume the data indicated by the marker.
596    // note that the only errors we expect to arise from here are invalid data reads,
597    // which the decoder is generally unable to recover from
598    match marker {
599        Marker::Null => (),
600        Marker::True | Marker::False => (),
601        Marker::FixPos(_) | Marker::FixNeg(_) => (),
602        Marker::U8 => {
603            rd.read_data_u8()?;
604        }
605        Marker::U16 => {
606            rd.read_data_u16()?;
607        }
608        Marker::U32 => {
609            rd.read_data_u32()?;
610        }
611        Marker::U64 => {
612            rd.read_data_u64()?;
613        }
614        Marker::I8 => {
615            rd.read_data_i8()?;
616        }
617        Marker::I16 => {
618            rd.read_data_i16()?;
619        }
620        Marker::I32 => {
621            rd.read_data_i32()?;
622        }
623        Marker::I64 => {
624            rd.read_data_i64()?;
625        }
626        Marker::F32 => {
627            rd.read_data_f32()?;
628        }
629        Marker::F64 => {
630            rd.read_data_f64()?;
631        }
632        Marker::FixStr(len) => {
633            rd.read_slice(len as usize)
634                .map_err(Error::InvalidDataRead)?;
635        }
636        Marker::Str8 | Marker::Bin8 => {
637            let len = rd.read_data_u8()?;
638            rd.read_slice(len as usize)
639                .map_err(Error::InvalidDataRead)?;
640        }
641        Marker::Str16 | Marker::Bin16 => {
642            let len = rd.read_data_u16()?;
643            rd.read_slice(len as usize)
644                .map_err(Error::InvalidDataRead)?;
645        }
646        Marker::Str32 | Marker::Bin32 => {
647            let len = rd.read_data_u32()?;
648            rd.read_slice(len as usize)
649                .map_err(Error::InvalidDataRead)?;
650        }
651        Marker::FixArray(len) => consume_unexpected_values(rd, len as usize)?,
652        Marker::Array16 => {
653            let len = rd.read_data_u16()?;
654            consume_unexpected_values(rd, len as usize)?
655        }
656        Marker::Array32 => {
657            let len = rd.read_data_u32()?;
658            consume_unexpected_values(rd, len as usize)?
659        }
660        Marker::FixMap(len) => consume_unexpected_values(rd, len as usize * 2)?,
661        Marker::Map16 => {
662            let len = rd.read_data_u16()?;
663            consume_unexpected_values(rd, len as usize * 2)?
664        }
665        Marker::Map32 => {
666            let len = rd.read_data_u32()?;
667            consume_unexpected_values(rd, len as usize * 2)?
668        }
669        Marker::FixExt1
670        | Marker::FixExt2
671        | Marker::FixExt4
672        | Marker::FixExt8
673        | Marker::FixExt16
674        | Marker::Ext8
675        | Marker::Ext16
676        | Marker::Ext32 => {
677            let len = ext_len(rd, marker)?;
678            rd.read_slice(len as usize + 1)
679                .map_err(Error::InvalidDataRead)?;
680        }
681        Marker::Reserved => (),
682    };
683    Ok(())
684}
685
686impl<'de, R: ReadSlice<'de>, C: SerializerConfig> Deserializer<R, C> {
687    fn any_inner<V: Visitor<'de>>(
688        &mut self,
689        visitor: V,
690        allow_bytes: bool,
691    ) -> Result<V::Value, Error> {
692        let marker = self.take_or_read_marker()?;
693        match marker {
694            Marker::Null
695            | Marker::True
696            | Marker::False
697            | Marker::FixPos(_)
698            | Marker::FixNeg(_)
699            | Marker::U8
700            | Marker::U16
701            | Marker::U32
702            | Marker::U64
703            | Marker::I8
704            | Marker::I16
705            | Marker::I32
706            | Marker::I64
707            | Marker::F32
708            | Marker::F64 => any_num(&mut self.rd, visitor, marker),
709            Marker::FixStr(_) | Marker::Str8 | Marker::Str16 | Marker::Str32 => {
710                let len = match marker {
711                    Marker::FixStr(len) => Ok(len.into()),
712                    Marker::Str8 => read_u8(&mut self.rd).map(u32::from),
713                    Marker::Str16 => read_u16(&mut self.rd).map(u32::from),
714                    Marker::Str32 => read_u32(&mut self.rd),
715                    _ => return Err(Error::TypeMismatch(Marker::Reserved)),
716                }?;
717                read_str_data(&mut self.rd, len, visitor)
718            }
719            Marker::FixArray(_) | Marker::Array16 | Marker::Array32 => {
720                let len = match marker {
721                    Marker::FixArray(len) => len.into(),
722                    Marker::Array16 => read_u16(&mut self.rd)?.into(),
723                    Marker::Array32 => read_u32(&mut self.rd)?,
724                    _ => return Err(Error::TypeMismatch(Marker::Reserved)),
725                };
726
727                depth_count!(self.depth, {
728                    let mut seq = SeqAccess::new(self, len);
729                    fn exhaust_seq_access<'a, R: ReadSlice<'a>, C: SerializerConfig>(
730                        seq: &mut SeqAccess<R, C>,
731                    ) {
732                        // we need to exhaust the sequence to keep the reader in a consistent state
733                        while let Ok(Some(_)) = seq.next_element::<IgnoredAny>() {}
734                    }
735                    let res = visitor.visit_seq(&mut seq).inspect_err(|_| {
736                        exhaust_seq_access(&mut seq);
737                    })?;
738                    match seq.left {
739                        0 => Ok(res),
740                        excess => {
741                            exhaust_seq_access(&mut seq);
742                            Err(Error::LengthMismatch(len - excess))
743                        }
744                    }
745                })
746            }
747            Marker::FixMap(_) | Marker::Map16 | Marker::Map32 => {
748                let len = match marker {
749                    Marker::FixMap(len) => len.into(),
750                    Marker::Map16 => read_u16(&mut self.rd)?.into(),
751                    Marker::Map32 => read_u32(&mut self.rd)?,
752                    _ => return Err(Error::TypeMismatch(Marker::Reserved)),
753                };
754
755                depth_count!(self.depth, {
756                    let mut seq = MapAccess::new(self, len);
757                    fn exhaust_map_access<'a, R: ReadSlice<'a>, C: SerializerConfig>(
758                        seq: &mut MapAccess<R, C>,
759                    ) {
760                        // we need to exhaust the map to keep the reader in a consistent state
761                        while let Ok(Some(_)) = seq.next_entry::<IgnoredAny, IgnoredAny>() {}
762                    }
763                    let res = visitor.visit_map(&mut seq).inspect_err(|_| {
764                        exhaust_map_access(&mut seq);
765                    })?;
766                    match seq.left {
767                        0 => Ok(res),
768                        excess => {
769                            exhaust_map_access(&mut seq);
770                            Err(Error::LengthMismatch(len - excess))
771                        }
772                    }
773                })
774            }
775            Marker::Bin8 | Marker::Bin16 | Marker::Bin32 => {
776                let len = match marker {
777                    Marker::Bin8 => read_u8(&mut self.rd).map(u32::from),
778                    Marker::Bin16 => read_u16(&mut self.rd).map(u32::from),
779                    Marker::Bin32 => read_u32(&mut self.rd),
780                    _ => return Err(Error::TypeMismatch(Marker::Reserved)),
781                }?;
782                match read_bin_data(&mut self.rd, len)? {
783                    Reference::Borrowed(buf) if allow_bytes => visitor.visit_borrowed_bytes(buf),
784                    Reference::Copied(buf) if allow_bytes => visitor.visit_bytes(buf),
785                    Reference::Borrowed(buf) | Reference::Copied(buf) => {
786                        visitor.visit_seq(SeqDeserializer::new(buf.iter().copied()))
787                    }
788                }
789            }
790            Marker::FixExt1
791            | Marker::FixExt2
792            | Marker::FixExt4
793            | Marker::FixExt8
794            | Marker::FixExt16
795            | Marker::Ext8
796            | Marker::Ext16
797            | Marker::Ext32 => {
798                let len = ext_len(&mut self.rd, marker)?;
799                depth_count!(
800                    self.depth,
801                    visitor.visit_newtype_struct(ExtDeserializer::new(self, len))
802                )
803            }
804            Marker::Reserved => Err(Error::TypeMismatch(Marker::Reserved)),
805        }
806    }
807}
808
809impl<'de, R: ReadSlice<'de>, C: SerializerConfig> serde::Deserializer<'de>
810    for &mut Deserializer<R, C>
811{
812    type Error = Error;
813
814    #[inline(always)]
815    fn is_human_readable(&self) -> bool {
816        self.is_human_readable
817    }
818
819    #[inline(always)]
820    fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Self::Error>
821    where
822        V: Visitor<'de>,
823    {
824        self.any_inner(visitor, true)
825    }
826
827    fn deserialize_option<V>(self, visitor: V) -> Result<V::Value, Self::Error>
828    where
829        V: Visitor<'de>,
830    {
831        // # Important
832        //
833        // If a nested Option `o ∈ { Option<Opion<t>>, Option<Option<Option<t>>>, ..., Option<Option<...Option<t>...> }`
834        // is visited for the first time, the marker (read from the underlying Reader) will determine
835        // `o`'s innermost type `t`.
836        // For subsequent visits of `o` the marker will not be re-read again but kept until type `t`
837        // is visited.
838        //
839        // # Note
840        //
841        // Round trips of Options where `Option<t> = None` such as `Some(None)` will fail because
842        // they are just seriialized as `nil`. The serialization format has probably to be changed
843        // to solve this. But as serde_json behaves the same, I think it's not worth doing this.
844        let marker = self.take_or_read_marker()?;
845
846        if marker == Marker::Null {
847            visitor.visit_none()
848        } else {
849            // Keep the marker until `o`'s innermost type `t` is visited.
850            self.marker = Some(marker);
851            visitor.visit_some(self)
852        }
853    }
854
855    fn deserialize_enum<V>(
856        self,
857        _name: &str,
858        _variants: &[&str],
859        visitor: V,
860    ) -> Result<V::Value, Error>
861    where
862        V: Visitor<'de>,
863    {
864        let marker = self.peek_or_read_marker()?;
865        match rmp::decode::marker_to_len(&mut self.rd, marker) {
866            Ok(len) => match len {
867                // Enums are either encoded as maps with a single K/V pair
868                // where the K = the variant & V = associated data
869                // or as just the variant
870                1 => {
871                    self.marker = None;
872                    visitor.visit_enum(VariantAccess::new(self))
873                }
874                n => Err(Error::LengthMismatch(n)),
875            },
876            // TODO: Check this is a string
877            Err(_) => visitor.visit_enum(UnitVariantAccess::new(self)),
878        }
879    }
880
881    fn deserialize_newtype_struct<V>(
882        self,
883        name: &'static str,
884        visitor: V,
885    ) -> Result<V::Value, Error>
886    where
887        V: Visitor<'de>,
888    {
889        if name == MSGPACK_EXT_STRUCT_NAME {
890            let marker = self.take_or_read_marker()?;
891
892            let len = ext_len(&mut self.rd, marker)?;
893            let ext_de = ExtDeserializer::new(self, len);
894            return visitor.visit_newtype_struct(ext_de);
895        }
896
897        visitor.visit_newtype_struct(self)
898    }
899
900    fn deserialize_unit_struct<V>(
901        self,
902        _name: &'static str,
903        visitor: V,
904    ) -> Result<V::Value, Self::Error>
905    where
906        V: Visitor<'de>,
907    {
908        // We need to special case this so that [] is treated as a unit struct when asked for,
909        // but as a sequence otherwise. This is because we serialize unit structs as [] rather
910        // than as 'nil'.
911        match self.take_or_read_marker()? {
912            Marker::Null | Marker::FixArray(0) => visitor.visit_unit(),
913            marker => {
914                self.marker = Some(marker);
915                self.deserialize_any(visitor)
916            }
917        }
918    }
919
920    #[inline]
921    fn deserialize_i128<V>(self, visitor: V) -> Result<V::Value, Self::Error>
922    where
923        V: Visitor<'de>,
924    {
925        visitor.visit_i128(read_i128_marker(self.take_or_read_marker()?, &mut self.rd)?)
926    }
927
928    #[inline]
929    fn deserialize_u128<V>(self, visitor: V) -> Result<V::Value, Self::Error>
930    where
931        V: Visitor<'de>,
932    {
933        visitor.visit_u128(read_i128_marker(self.take_or_read_marker()?, &mut self.rd)? as u128)
934    }
935
936    #[inline]
937    fn deserialize_seq<V>(self, visitor: V) -> Result<V::Value, Self::Error>
938    where
939        V: Visitor<'de>,
940    {
941        self.any_inner(visitor, false)
942    }
943
944    #[inline]
945    fn deserialize_tuple<V>(self, _len: usize, visitor: V) -> Result<V::Value, Self::Error>
946    where
947        V: Visitor<'de>,
948    {
949        self.any_inner(visitor, false)
950    }
951
952    #[inline]
953    fn deserialize_struct<V>(
954        self,
955        _: &'static str,
956        _: &'static [&'static str],
957        visitor: V,
958    ) -> Result<V::Value, Self::Error>
959    where
960        V: Visitor<'de>,
961    {
962        self.any_inner(visitor, false)
963    }
964
965    #[inline]
966    fn deserialize_tuple_struct<V>(
967        self,
968        _: &'static str,
969        _: usize,
970        visitor: V,
971    ) -> Result<V::Value, Self::Error>
972    where
973        V: Visitor<'de>,
974    {
975        self.any_inner(visitor, false)
976    }
977
978    forward_to_deserialize_any! {
979        bytes byte_buf unit
980        map identifier str string char
981        ignored_any
982    }
983
984    fn deserialize_bool<V>(self, visitor: V) -> Result<V::Value, Self::Error>
985    where
986        V: Visitor<'de>,
987    {
988        let marker = self.take_or_read_marker()?;
989        any_num(&mut self.rd, visitor, marker)
990    }
991
992    fn deserialize_u8<V>(self, visitor: V) -> Result<V::Value, Self::Error>
993    where
994        V: Visitor<'de>,
995    {
996        let marker = self.take_or_read_marker()?;
997        any_num(&mut self.rd, visitor, marker)
998    }
999
1000    fn deserialize_i8<V>(self, visitor: V) -> Result<V::Value, Self::Error>
1001    where
1002        V: Visitor<'de>,
1003    {
1004        let marker = self.take_or_read_marker()?;
1005        any_num(&mut self.rd, visitor, marker)
1006    }
1007
1008    fn deserialize_i16<V>(self, visitor: V) -> Result<V::Value, Self::Error>
1009    where
1010        V: Visitor<'de>,
1011    {
1012        let marker = self.take_or_read_marker()?;
1013        any_num(&mut self.rd, visitor, marker)
1014    }
1015
1016    fn deserialize_u16<V>(self, visitor: V) -> Result<V::Value, Self::Error>
1017    where
1018        V: Visitor<'de>,
1019    {
1020        let marker = self.take_or_read_marker()?;
1021        any_num(&mut self.rd, visitor, marker)
1022    }
1023
1024    fn deserialize_i32<V>(self, visitor: V) -> Result<V::Value, Self::Error>
1025    where
1026        V: Visitor<'de>,
1027    {
1028        let marker = self.take_or_read_marker()?;
1029        any_num(&mut self.rd, visitor, marker)
1030    }
1031
1032    fn deserialize_u32<V>(self, visitor: V) -> Result<V::Value, Self::Error>
1033    where
1034        V: Visitor<'de>,
1035    {
1036        let marker = self.take_or_read_marker()?;
1037        any_num(&mut self.rd, visitor, marker)
1038    }
1039
1040    fn deserialize_i64<V>(self, visitor: V) -> Result<V::Value, Self::Error>
1041    where
1042        V: Visitor<'de>,
1043    {
1044        let marker = self.take_or_read_marker()?;
1045        any_num(&mut self.rd, visitor, marker)
1046    }
1047
1048    fn deserialize_u64<V>(self, visitor: V) -> Result<V::Value, Self::Error>
1049    where
1050        V: Visitor<'de>,
1051    {
1052        let marker = self.take_or_read_marker()?;
1053        any_num(&mut self.rd, visitor, marker)
1054    }
1055
1056    fn deserialize_f32<V>(self, visitor: V) -> Result<V::Value, Self::Error>
1057    where
1058        V: Visitor<'de>,
1059    {
1060        let marker = self.take_or_read_marker()?;
1061        any_num(&mut self.rd, visitor, marker)
1062    }
1063
1064    fn deserialize_f64<V>(self, visitor: V) -> Result<V::Value, Self::Error>
1065    where
1066        V: Visitor<'de>,
1067    {
1068        let marker = self.take_or_read_marker()?;
1069        any_num(&mut self.rd, visitor, marker)
1070    }
1071}
1072
1073struct SeqAccess<'a, R, C> {
1074    de: &'a mut Deserializer<R, C>,
1075    left: u32,
1076}
1077
1078impl<'a, R: 'a, C> SeqAccess<'a, R, C> {
1079    #[inline]
1080    const fn new(de: &'a mut Deserializer<R, C>, len: u32) -> Self {
1081        SeqAccess { de, left: len }
1082    }
1083}
1084
1085impl<'de, 'a, R: ReadSlice<'de> + 'a, C: SerializerConfig> de::SeqAccess<'de>
1086    for SeqAccess<'a, R, C>
1087{
1088    type Error = Error;
1089
1090    #[inline]
1091    fn next_element_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>, Self::Error>
1092    where
1093        T: DeserializeSeed<'de>,
1094    {
1095        if self.left > 0 {
1096            self.left -= 1;
1097            Ok(Some(seed.deserialize(&mut *self.de)?))
1098        } else {
1099            Ok(None)
1100        }
1101    }
1102
1103    #[inline(always)]
1104    fn size_hint(&self) -> Option<usize> {
1105        self.left.try_into().ok()
1106    }
1107}
1108
1109struct MapAccess<'a, R, C> {
1110    de: &'a mut Deserializer<R, C>,
1111    left: u32,
1112}
1113
1114impl<'a, R: 'a, C> MapAccess<'a, R, C> {
1115    #[inline]
1116    const fn new(de: &'a mut Deserializer<R, C>, len: u32) -> Self {
1117        MapAccess { de, left: len }
1118    }
1119}
1120
1121impl<'de, 'a, R: ReadSlice<'de> + 'a, C: SerializerConfig> de::MapAccess<'de>
1122    for MapAccess<'a, R, C>
1123{
1124    type Error = Error;
1125
1126    #[inline]
1127    fn next_key_seed<K>(&mut self, seed: K) -> Result<Option<K::Value>, Self::Error>
1128    where
1129        K: DeserializeSeed<'de>,
1130    {
1131        if self.left > 0 {
1132            self.left -= 1;
1133            seed.deserialize(&mut *self.de).map(Some)
1134        } else {
1135            Ok(None)
1136        }
1137    }
1138
1139    #[inline]
1140    fn next_value_seed<V>(&mut self, seed: V) -> Result<V::Value, Self::Error>
1141    where
1142        V: DeserializeSeed<'de>,
1143    {
1144        seed.deserialize(&mut *self.de)
1145    }
1146
1147    #[inline(always)]
1148    fn size_hint(&self) -> Option<usize> {
1149        self.left.try_into().ok()
1150    }
1151}
1152
1153struct UnitVariantAccess<'a, R: 'a, C> {
1154    de: &'a mut Deserializer<R, C>,
1155}
1156
1157impl<'a, R: 'a, C> UnitVariantAccess<'a, R, C> {
1158    pub const fn new(de: &'a mut Deserializer<R, C>) -> Self {
1159        UnitVariantAccess { de }
1160    }
1161}
1162
1163impl<'de, R: ReadSlice<'de>, C: SerializerConfig> de::EnumAccess<'de>
1164    for UnitVariantAccess<'_, R, C>
1165{
1166    type Error = Error;
1167    type Variant = Self;
1168
1169    #[inline]
1170    fn variant_seed<V>(self, seed: V) -> Result<(V::Value, Self), Error>
1171    where
1172        V: de::DeserializeSeed<'de>,
1173    {
1174        let variant = seed.deserialize(&mut *self.de)?;
1175        Ok((variant, self))
1176    }
1177}
1178
1179impl<'de, 'a, R: ReadSlice<'de> + 'a, C: SerializerConfig> de::VariantAccess<'de>
1180    for UnitVariantAccess<'a, R, C>
1181{
1182    type Error = Error;
1183
1184    fn unit_variant(self) -> Result<(), Error> {
1185        Ok(())
1186    }
1187
1188    fn newtype_variant_seed<T>(self, _seed: T) -> Result<T::Value, Error>
1189    where
1190        T: de::DeserializeSeed<'de>,
1191    {
1192        Err(de::Error::invalid_type(
1193            Unexpected::UnitVariant,
1194            &"newtype variant",
1195        ))
1196    }
1197
1198    fn tuple_variant<V>(self, _len: usize, _visitor: V) -> Result<V::Value, Error>
1199    where
1200        V: de::Visitor<'de>,
1201    {
1202        Err(de::Error::invalid_type(
1203            Unexpected::UnitVariant,
1204            &"tuple variant",
1205        ))
1206    }
1207
1208    fn struct_variant<V>(
1209        self,
1210        _fields: &'static [&'static str],
1211        _visitor: V,
1212    ) -> Result<V::Value, Error>
1213    where
1214        V: de::Visitor<'de>,
1215    {
1216        Err(de::Error::invalid_type(
1217            Unexpected::UnitVariant,
1218            &"struct variant",
1219        ))
1220    }
1221}
1222
1223struct VariantAccess<'a, R, C> {
1224    de: &'a mut Deserializer<R, C>,
1225}
1226
1227impl<'a, R: 'a, C> VariantAccess<'a, R, C> {
1228    pub const fn new(de: &'a mut Deserializer<R, C>) -> Self {
1229        VariantAccess { de }
1230    }
1231}
1232
1233impl<'de, R: ReadSlice<'de>, C: SerializerConfig> de::EnumAccess<'de> for VariantAccess<'_, R, C> {
1234    type Error = Error;
1235    type Variant = Self;
1236
1237    #[inline]
1238    fn variant_seed<V>(self, seed: V) -> Result<(V::Value, Self), Error>
1239    where
1240        V: de::DeserializeSeed<'de>,
1241    {
1242        Ok((seed.deserialize(&mut *self.de)?, self))
1243    }
1244}
1245
1246impl<'de, R: ReadSlice<'de>, C: SerializerConfig> de::VariantAccess<'de>
1247    for VariantAccess<'_, R, C>
1248{
1249    type Error = Error;
1250
1251    #[inline]
1252    fn unit_variant(self) -> Result<(), Error> {
1253        decode::read_nil(&mut self.de.rd)?;
1254        Ok(())
1255    }
1256
1257    #[inline]
1258    fn newtype_variant_seed<T>(self, seed: T) -> Result<T::Value, Self::Error>
1259    where
1260        T: DeserializeSeed<'de>,
1261    {
1262        seed.deserialize(self.de)
1263    }
1264
1265    #[inline]
1266    fn tuple_variant<V>(self, len: usize, visitor: V) -> Result<V::Value, Error>
1267    where
1268        V: Visitor<'de>,
1269    {
1270        de::Deserializer::deserialize_tuple(self.de, len, visitor)
1271    }
1272
1273    #[inline]
1274    fn struct_variant<V>(
1275        self,
1276        fields: &'static [&'static str],
1277        visitor: V,
1278    ) -> Result<V::Value, Error>
1279    where
1280        V: Visitor<'de>,
1281    {
1282        de::Deserializer::deserialize_tuple(self.de, fields.len(), visitor)
1283    }
1284}
1285
1286/// Unification of both borrowed and non-borrowed reference types.
1287#[derive(Clone, Copy, Debug, PartialEq)]
1288pub enum Reference<'b, 'c, T: ?Sized + 'static> {
1289    /// The reference is pointed at data that was borrowed.
1290    Borrowed(&'b T),
1291    /// The reference is pointed at data that was copied.
1292    Copied(&'c T),
1293}
1294
1295/// Extends the `Read` trait by allowing to read slices directly by borrowing bytes.
1296///
1297/// Used to allow zero-copy reading.
1298pub trait ReadSlice<'de>: Read {
1299    /// Reads the exact number of bytes from the underlying byte-array.
1300    fn read_slice<'a>(&'a mut self, len: usize) -> Result<Reference<'de, 'a, [u8]>, io::Error>;
1301}
1302
1303/// Owned reader wrapper.
1304#[derive(Debug)]
1305pub struct ReadReader<R: Read> {
1306    rd: R,
1307    buf: Vec<u8>,
1308}
1309
1310impl<R: Read> ReadReader<R> {
1311    #[inline]
1312    fn new(rd: R) -> Self {
1313        Self {
1314            rd,
1315            buf: Vec::with_capacity(128),
1316        }
1317    }
1318}
1319
1320impl<'de, R: Read> ReadSlice<'de> for ReadReader<R> {
1321    #[inline]
1322    fn read_slice<'a>(&'a mut self, len: usize) -> Result<Reference<'de, 'a, [u8]>, io::Error> {
1323        self.buf.clear();
1324        let read = self
1325            .rd
1326            .by_ref()
1327            .take(len as u64)
1328            .read_to_end(&mut self.buf)?;
1329        if read != len {
1330            return Err(io::ErrorKind::UnexpectedEof.into());
1331        }
1332
1333        Ok(Reference::Copied(&self.buf[..]))
1334    }
1335}
1336
1337impl<R: Read> Read for ReadReader<R> {
1338    #[inline]
1339    fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
1340        self.rd.read(buf)
1341    }
1342
1343    #[inline]
1344    fn read_exact(&mut self, buf: &mut [u8]) -> io::Result<()> {
1345        self.rd.read_exact(buf)
1346    }
1347}
1348
1349/// Borrowed reader wrapper.
1350#[derive(Debug)]
1351pub struct ReadRefReader<'a, R: ?Sized> {
1352    whole_slice: &'a R,
1353    buf: &'a [u8],
1354}
1355
1356impl<'a, T> ReadRefReader<'a, T> {
1357    /// Returns the part that hasn't been consumed yet
1358    #[must_use]
1359    pub const fn remaining_slice(&self) -> &'a [u8] {
1360        self.buf
1361    }
1362}
1363
1364impl<'a, T: AsRef<[u8]> + ?Sized> ReadRefReader<'a, T> {
1365    #[inline]
1366    fn new(rd: &'a T) -> Self {
1367        Self {
1368            whole_slice: rd,
1369            buf: rd.as_ref(),
1370        }
1371    }
1372}
1373
1374impl<T: AsRef<[u8]> + ?Sized> Read for ReadRefReader<'_, T> {
1375    #[inline]
1376    fn read(&mut self, buf: &mut [u8]) -> Result<usize, io::Error> {
1377        self.buf.read(buf)
1378    }
1379
1380    #[inline]
1381    fn read_exact(&mut self, buf: &mut [u8]) -> Result<(), io::Error> {
1382        self.buf.read_exact(buf)
1383    }
1384}
1385
1386impl<'de, T: AsRef<[u8]> + ?Sized> ReadSlice<'de> for ReadRefReader<'de, T> {
1387    #[inline]
1388    fn read_slice<'a>(&'a mut self, len: usize) -> Result<Reference<'de, 'a, [u8]>, io::Error> {
1389        if len > self.buf.len() {
1390            return Err(ErrorKind::UnexpectedEof.into());
1391        }
1392        let (a, b) = self.buf.split_at(len);
1393        self.buf = b;
1394        Ok(Reference::Borrowed(a))
1395    }
1396}
1397
1398#[test]
1399fn test_as_ref_reader() {
1400    let buf = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
1401    let mut rd = ReadRefReader::new(&buf);
1402
1403    assert_eq!(rd.read_slice(1).unwrap(), Reference::Borrowed(&[0][..]));
1404    assert_eq!(
1405        rd.read_slice(6).unwrap(),
1406        Reference::Borrowed(&[1, 2, 3, 4, 5, 6][..])
1407    );
1408    assert!(rd.read_slice(5).is_err());
1409    assert_eq!(
1410        rd.read_slice(4).unwrap(),
1411        Reference::Borrowed(&[7, 8, 9, 10][..])
1412    );
1413}
1414
1415/// Deserialize an instance of type `T` from an I/O stream of MessagePack.
1416///
1417/// # Errors
1418///
1419/// This conversion can fail if the structure of the Value does not match the structure expected
1420/// by `T`. It can also fail if the structure is correct but `T`'s implementation of `Deserialize`
1421/// decides that something is wrong with the data, for example required struct fields are missing.
1422#[inline]
1423pub fn from_read<R, T>(rd: R) -> Result<T, Error>
1424where
1425    R: Read,
1426    T: DeserializeOwned,
1427{
1428    Deserialize::deserialize(&mut Deserializer::new(rd))
1429}
1430
1431/// Deserialize a temporary scope-bound instance of type `T` from a slice, with zero-copy if possible.
1432///
1433/// Deserialization will be performed in zero-copy manner whenever it is possible, borrowing the
1434/// data from the slice itself. For example, strings and byte-arrays won't copied.
1435///
1436/// # Errors
1437///
1438/// This conversion can fail if the structure of the Value does not match the structure expected
1439/// by `T`. It can also fail if the structure is correct but `T`'s implementation of `Deserialize`
1440/// decides that something is wrong with the data, for example required struct fields are missing.
1441///
1442/// # Examples
1443///
1444/// ```
1445/// use serde::Deserialize;
1446///
1447/// // Encoded `["Bobby", 8]`.
1448/// let buf = [0x92, 0xa5, 0x42, 0x6f, 0x62, 0x62, 0x79, 0x8];
1449///
1450/// #[derive(Debug, Deserialize, PartialEq)]
1451/// struct Dog<'a> {
1452///    name: &'a str,
1453///    age: u8,
1454/// }
1455///
1456/// assert_eq!(Dog { name: "Bobby", age: 8 }, messpack_serde::from_slice(&buf).unwrap());
1457/// ```
1458#[inline(always)]
1459#[allow(deprecated)]
1460pub fn from_slice<'a, T>(input: &'a [u8]) -> Result<T, Error>
1461where
1462    T: Deserialize<'a>,
1463{
1464    from_read_ref(input)
1465}
1466
1467#[inline]
1468#[doc(hidden)]
1469#[deprecated(note = "use from_slice")]
1470pub fn from_read_ref<'a, R, T>(rd: &'a R) -> Result<T, Error>
1471where
1472    R: AsRef<[u8]> + ?Sized,
1473    T: Deserialize<'a>,
1474{
1475    let mut de = Deserializer::from_read_ref(rd);
1476    Deserialize::deserialize(&mut de)
1477}
messpack_serde/decode.rs

messpack_serde/
decode.rs
