| //! Deserialization. |
| |
| use core::f32; |
| use core::marker::PhantomData; |
| use core::result; |
| use core::str; |
| use half::f16; |
| use serde::de; |
| #[cfg(feature = "std")] |
| use std::io; |
| |
| use crate::error::{Error, ErrorCode, Result}; |
| #[cfg(not(feature = "unsealed_read_write"))] |
| use crate::read::EitherLifetime; |
| #[cfg(feature = "unsealed_read_write")] |
| pub use crate::read::EitherLifetime; |
| #[cfg(feature = "std")] |
| pub use crate::read::IoRead; |
| use crate::read::Offset; |
| #[cfg(any(feature = "std", feature = "alloc"))] |
| pub use crate::read::SliceRead; |
| pub use crate::read::{MutSliceRead, Read, SliceReadFixed}; |
| #[cfg(feature = "tags")] |
| use crate::tags::set_tag; |
| /// Decodes a value from CBOR data in a slice. |
| /// |
| /// # Examples |
| /// |
| /// Deserialize a `String` |
| /// |
| /// ``` |
| /// # use serde_cbor::de; |
| /// let v: Vec<u8> = vec![0x66, 0x66, 0x6f, 0x6f, 0x62, 0x61, 0x72]; |
| /// let value: String = de::from_slice(&v[..]).unwrap(); |
| /// assert_eq!(value, "foobar"); |
| /// ``` |
| /// |
| /// Deserialize a borrowed string with zero copies. |
| /// |
| /// ``` |
| /// # use serde_cbor::de; |
| /// let v: Vec<u8> = vec![0x66, 0x66, 0x6f, 0x6f, 0x62, 0x61, 0x72]; |
| /// let value: &str = de::from_slice(&v[..]).unwrap(); |
| /// assert_eq!(value, "foobar"); |
| /// ``` |
| #[cfg(any(feature = "std", feature = "alloc"))] |
| pub fn from_slice<'a, T>(slice: &'a [u8]) -> Result<T> |
| where |
| T: de::Deserialize<'a>, |
| { |
| let mut deserializer = Deserializer::from_slice(slice); |
| let value = de::Deserialize::deserialize(&mut deserializer)?; |
| deserializer.end()?; |
| Ok(value) |
| } |
| |
| // When the "std" feature is enabled there should be little to no need to ever use this function, |
| // as `from_slice` covers all use cases (at the expense of being less efficient). |
| /// Decode a value from CBOR data in a mutable slice. |
| /// |
| /// This can be used in analogy to `from_slice`. Unlike `from_slice`, this will use the slice's |
| /// mutability to rearrange data in it in order to resolve indefinite byte or text strings without |
| /// resorting to allocations. |
| pub fn from_mut_slice<'a, T>(slice: &'a mut [u8]) -> Result<T> |
| where |
| T: de::Deserialize<'a>, |
| { |
| let mut deserializer = Deserializer::from_mut_slice(slice); |
| let value = de::Deserialize::deserialize(&mut deserializer)?; |
| deserializer.end()?; |
| Ok(value) |
| } |
| |
| // When the "std" feature is enabled there should be little to no need to ever use this function, |
| // as `from_slice` covers all use cases and is much more reliable (at the expense of being less |
| // efficient). |
| /// Decode a value from CBOR data using a scratch buffer. |
| /// |
| /// Users should generally prefer to use `from_slice` or `from_mut_slice` over this function, |
| /// as decoding may fail when the scratch buffer turns out to be too small. |
| /// |
| /// A realistic use case for this method would be decoding in a `no_std` environment from an |
| /// immutable slice that is too large to copy. |
| pub fn from_slice_with_scratch<'a, 'b, T>(slice: &'a [u8], scratch: &'b mut [u8]) -> Result<T> |
| where |
| T: de::Deserialize<'a>, |
| { |
| let mut deserializer = Deserializer::from_slice_with_scratch(slice, scratch); |
| let value = de::Deserialize::deserialize(&mut deserializer)?; |
| deserializer.end()?; |
| Ok(value) |
| } |
| |
| /// Decodes a value from CBOR data in a reader. |
| /// |
| /// # Examples |
| /// |
| /// Deserialize a `String` |
| /// |
| /// ``` |
| /// # use serde_cbor::de; |
| /// let v: Vec<u8> = vec![0x66, 0x66, 0x6f, 0x6f, 0x62, 0x61, 0x72]; |
| /// let value: String = de::from_reader(&v[..]).unwrap(); |
| /// assert_eq!(value, "foobar"); |
| /// ``` |
| /// |
| /// Note that `from_reader` cannot borrow data: |
| /// |
| /// ```compile_fail |
| /// # use serde_cbor::de; |
| /// let v: Vec<u8> = vec![0x66, 0x66, 0x6f, 0x6f, 0x62, 0x61, 0x72]; |
| /// let value: &str = de::from_reader(&v[..]).unwrap(); |
| /// assert_eq!(value, "foobar"); |
| /// ``` |
| #[cfg(feature = "std")] |
| pub fn from_reader<T, R>(reader: R) -> Result<T> |
| where |
| T: de::DeserializeOwned, |
| R: io::Read, |
| { |
| let mut deserializer = Deserializer::from_reader(reader); |
| let value = de::Deserialize::deserialize(&mut deserializer)?; |
| deserializer.end()?; |
| Ok(value) |
| } |
| |
| /// A Serde `Deserialize`r of CBOR data. |
| #[derive(Debug)] |
| pub struct Deserializer<R> { |
| read: R, |
| remaining_depth: u8, |
| accept_named: bool, |
| accept_packed: bool, |
| accept_standard_enums: bool, |
| accept_legacy_enums: bool, |
| } |
| |
| #[cfg(feature = "std")] |
| impl<R> Deserializer<IoRead<R>> |
| where |
| R: io::Read, |
| { |
| /// Constructs a `Deserializer` which reads from a `Read`er. |
| pub fn from_reader(reader: R) -> Deserializer<IoRead<R>> { |
| Deserializer::new(IoRead::new(reader)) |
| } |
| } |
| |
| #[cfg(any(feature = "std", feature = "alloc"))] |
| impl<'a> Deserializer<SliceRead<'a>> { |
| /// Constructs a `Deserializer` which reads from a slice. |
| /// |
| /// Borrowed strings and byte slices will be provided when possible. |
| pub fn from_slice(bytes: &'a [u8]) -> Deserializer<SliceRead<'a>> { |
| Deserializer::new(SliceRead::new(bytes)) |
| } |
| } |
| |
| impl<'a> Deserializer<MutSliceRead<'a>> { |
| /// Constructs a `Deserializer` which reads from a mutable slice that doubles as its own |
| /// scratch buffer. |
| /// |
| /// Borrowed strings and byte slices will be provided even for indefinite strings. |
| pub fn from_mut_slice(bytes: &'a mut [u8]) -> Deserializer<MutSliceRead<'a>> { |
| Deserializer::new(MutSliceRead::new(bytes)) |
| } |
| } |
| |
| impl<'a, 'b> Deserializer<SliceReadFixed<'a, 'b>> { |
| #[doc(hidden)] |
| pub fn from_slice_with_scratch( |
| bytes: &'a [u8], |
| scratch: &'b mut [u8], |
| ) -> Deserializer<SliceReadFixed<'a, 'b>> { |
| Deserializer::new(SliceReadFixed::new(bytes, scratch)) |
| } |
| } |
| |
| impl<'de, R> Deserializer<R> |
| where |
| R: Read<'de>, |
| { |
| /// Constructs a `Deserializer` from one of the possible serde_cbor input sources. |
| /// |
| /// `from_slice` and `from_reader` should normally be used instead of this method. |
| pub fn new(read: R) -> Self { |
| Deserializer { |
| read, |
| remaining_depth: 128, |
| accept_named: true, |
| accept_packed: true, |
| accept_standard_enums: true, |
| accept_legacy_enums: true, |
| } |
| } |
| |
| /// Don't accept named variants and fields. |
| pub fn disable_named_format(mut self) -> Self { |
| self.accept_named = false; |
| self |
| } |
| |
| /// Don't accept numbered variants and fields. |
| pub fn disable_packed_format(mut self) -> Self { |
| self.accept_packed = false; |
| self |
| } |
| |
| /// Don't accept the new enum format used by `serde_cbor` versions >= v0.10. |
| pub fn disable_standard_enums(mut self) -> Self { |
| self.accept_standard_enums = false; |
| self |
| } |
| |
| /// Don't accept the old enum format used by `serde_cbor` versions <= v0.9. |
| pub fn disable_legacy_enums(mut self) -> Self { |
| self.accept_legacy_enums = false; |
| self |
| } |
| |
| /// This method should be called after a value has been deserialized to ensure there is no |
| /// trailing data in the input source. |
| pub fn end(&mut self) -> Result<()> { |
| match self.next()? { |
| Some(_) => Err(self.error(ErrorCode::TrailingData)), |
| None => Ok(()), |
| } |
| } |
| |
| /// Turn a CBOR deserializer into an iterator over values of type T. |
| #[allow(clippy::should_implement_trait)] // Trait doesn't allow unconstrained T. |
| pub fn into_iter<T>(self) -> StreamDeserializer<'de, R, T> |
| where |
| T: de::Deserialize<'de>, |
| { |
| StreamDeserializer { |
| de: self, |
| output: PhantomData, |
| lifetime: PhantomData, |
| } |
| } |
| |
| fn next(&mut self) -> Result<Option<u8>> { |
| self.read.next() |
| } |
| |
| fn peek(&mut self) -> Result<Option<u8>> { |
| self.read.peek() |
| } |
| |
| fn consume(&mut self) { |
| self.read.discard(); |
| } |
| |
| fn error(&self, reason: ErrorCode) -> Error { |
| let offset = self.read.offset(); |
| Error::syntax(reason, offset) |
| } |
| |
| fn parse_u8(&mut self) -> Result<u8> { |
| match self.next()? { |
| Some(byte) => Ok(byte), |
| None => Err(self.error(ErrorCode::EofWhileParsingValue)), |
| } |
| } |
| |
| fn parse_u16(&mut self) -> Result<u16> { |
| let mut buf = [0; 2]; |
| self.read |
| .read_into(&mut buf) |
| .map(|()| u16::from_be_bytes(buf)) |
| } |
| |
| fn parse_u32(&mut self) -> Result<u32> { |
| let mut buf = [0; 4]; |
| self.read |
| .read_into(&mut buf) |
| .map(|()| u32::from_be_bytes(buf)) |
| } |
| |
| fn parse_u64(&mut self) -> Result<u64> { |
| let mut buf = [0; 8]; |
| self.read |
| .read_into(&mut buf) |
| .map(|()| u64::from_be_bytes(buf)) |
| } |
| |
| fn parse_bytes<V>(&mut self, len: usize, visitor: V) -> Result<V::Value> |
| where |
| V: de::Visitor<'de>, |
| { |
| match self.read.read(len)? { |
| EitherLifetime::Long(buf) => visitor.visit_borrowed_bytes(buf), |
| EitherLifetime::Short(buf) => visitor.visit_bytes(buf), |
| } |
| } |
| |
| fn parse_indefinite_bytes<V>(&mut self, visitor: V) -> Result<V::Value> |
| where |
| V: de::Visitor<'de>, |
| { |
| self.read.clear_buffer(); |
| loop { |
| let byte = self.parse_u8()?; |
| let len = match byte { |
| 0x40..=0x57 => byte as usize - 0x40, |
| 0x58 => self.parse_u8()? as usize, |
| 0x59 => self.parse_u16()? as usize, |
| 0x5a => self.parse_u32()? as usize, |
| 0x5b => { |
| let len = self.parse_u64()?; |
| if len > usize::max_value() as u64 { |
| return Err(self.error(ErrorCode::LengthOutOfRange)); |
| } |
| len as usize |
| } |
| 0xff => break, |
| _ => return Err(self.error(ErrorCode::UnexpectedCode)), |
| }; |
| |
| self.read.read_to_buffer(len)?; |
| } |
| |
| match self.read.take_buffer() { |
| EitherLifetime::Long(buf) => visitor.visit_borrowed_bytes(buf), |
| EitherLifetime::Short(buf) => visitor.visit_bytes(buf), |
| } |
| } |
| |
| fn convert_str<'a>(buf: &'a [u8], buf_end_offset: u64) -> Result<&'a str> { |
| match str::from_utf8(buf) { |
| Ok(s) => Ok(s), |
| Err(e) => { |
| let shift = buf.len() - e.valid_up_to(); |
| let offset = buf_end_offset - shift as u64; |
| Err(Error::syntax(ErrorCode::InvalidUtf8, offset)) |
| } |
| } |
| } |
| |
| fn parse_str<V>(&mut self, len: usize, visitor: V) -> Result<V::Value> |
| where |
| V: de::Visitor<'de>, |
| { |
| if let Some(offset) = self.read.offset().checked_add(len as u64) { |
| match self.read.read(len)? { |
| EitherLifetime::Long(buf) => { |
| let s = Self::convert_str(buf, offset)?; |
| visitor.visit_borrowed_str(s) |
| } |
| EitherLifetime::Short(buf) => { |
| let s = Self::convert_str(buf, offset)?; |
| visitor.visit_str(s) |
| } |
| } |
| } else { |
| // An overflow would have occured. |
| Err(Error::syntax( |
| ErrorCode::LengthOutOfRange, |
| self.read.offset(), |
| )) |
| } |
| } |
| |
| fn parse_indefinite_str<V>(&mut self, visitor: V) -> Result<V::Value> |
| where |
| V: de::Visitor<'de>, |
| { |
| self.read.clear_buffer(); |
| loop { |
| let byte = self.parse_u8()?; |
| let len = match byte { |
| 0x60..=0x77 => byte as usize - 0x60, |
| 0x78 => self.parse_u8()? as usize, |
| 0x79 => self.parse_u16()? as usize, |
| 0x7a => self.parse_u32()? as usize, |
| 0x7b => { |
| let len = self.parse_u64()?; |
| if len > usize::max_value() as u64 { |
| return Err(self.error(ErrorCode::LengthOutOfRange)); |
| } |
| len as usize |
| } |
| 0xff => break, |
| _ => return Err(self.error(ErrorCode::UnexpectedCode)), |
| }; |
| |
| self.read.read_to_buffer(len)?; |
| } |
| |
| let offset = self.read.offset(); |
| match self.read.take_buffer() { |
| EitherLifetime::Long(buf) => { |
| let s = Self::convert_str(buf, offset)?; |
| visitor.visit_borrowed_str(s) |
| } |
| EitherLifetime::Short(buf) => { |
| let s = Self::convert_str(buf, offset)?; |
| visitor.visit_str(s) |
| } |
| } |
| } |
| |
| #[cfg(feature = "tags")] |
| fn handle_tagged_value<V>(&mut self, tag: u64, visitor: V) -> Result<V::Value> |
| where |
| V: de::Visitor<'de>, |
| { |
| self.recursion_checked(|d| { |
| set_tag(Some(tag)); |
| let r = visitor.visit_newtype_struct(d); |
| set_tag(None); |
| r |
| }) |
| } |
| |
| #[cfg(not(feature = "tags"))] |
| fn handle_tagged_value<V>(&mut self, _tag: u64, visitor: V) -> Result<V::Value> |
| where |
| V: de::Visitor<'de>, |
| { |
| self.recursion_checked(|de| de.parse_value(visitor)) |
| } |
| |
| fn recursion_checked<F, T>(&mut self, f: F) -> Result<T> |
| where |
| F: FnOnce(&mut Deserializer<R>) -> Result<T>, |
| { |
| self.remaining_depth -= 1; |
| if self.remaining_depth == 0 { |
| return Err(self.error(ErrorCode::RecursionLimitExceeded)); |
| } |
| let r = f(self); |
| self.remaining_depth += 1; |
| r |
| } |
| |
| fn parse_array<V>(&mut self, mut len: usize, visitor: V) -> Result<V::Value> |
| where |
| V: de::Visitor<'de>, |
| { |
| self.recursion_checked(|de| { |
| let value = visitor.visit_seq(SeqAccess { de, len: &mut len })?; |
| |
| if len != 0 { |
| Err(de.error(ErrorCode::TrailingData)) |
| } else { |
| Ok(value) |
| } |
| }) |
| } |
| |
| fn parse_indefinite_array<V>(&mut self, visitor: V) -> Result<V::Value> |
| where |
| V: de::Visitor<'de>, |
| { |
| self.recursion_checked(|de| { |
| let value = visitor.visit_seq(IndefiniteSeqAccess { de })?; |
| match de.next()? { |
| Some(0xff) => Ok(value), |
| Some(_) => Err(de.error(ErrorCode::TrailingData)), |
| None => Err(de.error(ErrorCode::EofWhileParsingArray)), |
| } |
| }) |
| } |
| |
| fn parse_map<V>(&mut self, mut len: usize, visitor: V) -> Result<V::Value> |
| where |
| V: de::Visitor<'de>, |
| { |
| let accept_packed = self.accept_packed; |
| let accept_named = self.accept_named; |
| self.recursion_checked(|de| { |
| let value = visitor.visit_map(MapAccess { |
| de, |
| len: &mut len, |
| accept_named, |
| accept_packed, |
| })?; |
| |
| if len != 0 { |
| Err(de.error(ErrorCode::TrailingData)) |
| } else { |
| Ok(value) |
| } |
| }) |
| } |
| |
| fn parse_indefinite_map<V>(&mut self, visitor: V) -> Result<V::Value> |
| where |
| V: de::Visitor<'de>, |
| { |
| let accept_named = self.accept_named; |
| let accept_packed = self.accept_packed; |
| self.recursion_checked(|de| { |
| let value = visitor.visit_map(IndefiniteMapAccess { |
| de, |
| accept_packed, |
| accept_named, |
| })?; |
| match de.next()? { |
| Some(0xff) => Ok(value), |
| Some(_) => Err(de.error(ErrorCode::TrailingData)), |
| None => Err(de.error(ErrorCode::EofWhileParsingMap)), |
| } |
| }) |
| } |
| |
| fn parse_enum<V>(&mut self, mut len: usize, visitor: V) -> Result<V::Value> |
| where |
| V: de::Visitor<'de>, |
| { |
| self.recursion_checked(|de| { |
| let value = visitor.visit_enum(VariantAccess { |
| seq: SeqAccess { de, len: &mut len }, |
| })?; |
| |
| if len != 0 { |
| Err(de.error(ErrorCode::TrailingData)) |
| } else { |
| Ok(value) |
| } |
| }) |
| } |
| |
| fn parse_enum_map<V>(&mut self, visitor: V) -> Result<V::Value> |
| where |
| V: de::Visitor<'de>, |
| { |
| let accept_named = self.accept_named; |
| let accept_packed = self.accept_packed; |
| self.recursion_checked(|de| { |
| let mut len = 1; |
| let value = visitor.visit_enum(VariantAccessMap { |
| map: MapAccess { |
| de, |
| len: &mut len, |
| accept_packed, |
| accept_named, |
| }, |
| })?; |
| |
| if len != 0 { |
| Err(de.error(ErrorCode::TrailingData)) |
| } else { |
| Ok(value) |
| } |
| }) |
| } |
| |
| fn parse_indefinite_enum<V>(&mut self, visitor: V) -> Result<V::Value> |
| where |
| V: de::Visitor<'de>, |
| { |
| self.recursion_checked(|de| { |
| let value = visitor.visit_enum(VariantAccess { |
| seq: IndefiniteSeqAccess { de }, |
| })?; |
| match de.next()? { |
| Some(0xff) => Ok(value), |
| Some(_) => Err(de.error(ErrorCode::TrailingData)), |
| None => Err(de.error(ErrorCode::EofWhileParsingArray)), |
| } |
| }) |
| } |
| |
| fn parse_f16(&mut self) -> Result<f32> { |
| Ok(f32::from(f16::from_bits(self.parse_u16()?))) |
| } |
| |
| fn parse_f32(&mut self) -> Result<f32> { |
| self.parse_u32().map(|i| f32::from_bits(i)) |
| } |
| |
| fn parse_f64(&mut self) -> Result<f64> { |
| self.parse_u64().map(|i| f64::from_bits(i)) |
| } |
| |
| // Don't warn about the `unreachable!` in case |
| // exhaustive integer pattern matching is enabled. |
| #[allow(unreachable_patterns)] |
| fn parse_value<V>(&mut self, visitor: V) -> Result<V::Value> |
| where |
| V: de::Visitor<'de>, |
| { |
| let byte = self.parse_u8()?; |
| match byte { |
| // Major type 0: an unsigned integer |
| 0x00..=0x17 => visitor.visit_u8(byte), |
| 0x18 => { |
| let value = self.parse_u8()?; |
| visitor.visit_u8(value) |
| } |
| 0x19 => { |
| let value = self.parse_u16()?; |
| visitor.visit_u16(value) |
| } |
| 0x1a => { |
| let value = self.parse_u32()?; |
| visitor.visit_u32(value) |
| } |
| 0x1b => { |
| let value = self.parse_u64()?; |
| visitor.visit_u64(value) |
| } |
| 0x1c..=0x1f => Err(self.error(ErrorCode::UnassignedCode)), |
| |
| // Major type 1: a negative integer |
| 0x20..=0x37 => visitor.visit_i8(-1 - (byte - 0x20) as i8), |
| 0x38 => { |
| let value = self.parse_u8()?; |
| visitor.visit_i16(-1 - i16::from(value)) |
| } |
| 0x39 => { |
| let value = self.parse_u16()?; |
| visitor.visit_i32(-1 - i32::from(value)) |
| } |
| 0x3a => { |
| let value = self.parse_u32()?; |
| visitor.visit_i64(-1 - i64::from(value)) |
| } |
| 0x3b => { |
| let value = self.parse_u64()?; |
| if value > i64::max_value() as u64 { |
| return visitor.visit_i128(-1 - i128::from(value)); |
| } |
| visitor.visit_i64(-1 - value as i64) |
| } |
| 0x3c..=0x3f => Err(self.error(ErrorCode::UnassignedCode)), |
| |
| // Major type 2: a byte string |
| 0x40..=0x57 => self.parse_bytes(byte as usize - 0x40, visitor), |
| 0x58 => { |
| let len = self.parse_u8()?; |
| self.parse_bytes(len as usize, visitor) |
| } |
| 0x59 => { |
| let len = self.parse_u16()?; |
| self.parse_bytes(len as usize, visitor) |
| } |
| 0x5a => { |
| let len = self.parse_u32()?; |
| self.parse_bytes(len as usize, visitor) |
| } |
| 0x5b => { |
| let len = self.parse_u64()?; |
| if len > usize::max_value() as u64 { |
| return Err(self.error(ErrorCode::LengthOutOfRange)); |
| } |
| self.parse_bytes(len as usize, visitor) |
| } |
| 0x5c..=0x5e => Err(self.error(ErrorCode::UnassignedCode)), |
| 0x5f => self.parse_indefinite_bytes(visitor), |
| |
| // Major type 3: a text string |
| 0x60..=0x77 => self.parse_str(byte as usize - 0x60, visitor), |
| 0x78 => { |
| let len = self.parse_u8()?; |
| self.parse_str(len as usize, visitor) |
| } |
| 0x79 => { |
| let len = self.parse_u16()?; |
| self.parse_str(len as usize, visitor) |
| } |
| 0x7a => { |
| let len = self.parse_u32()?; |
| self.parse_str(len as usize, visitor) |
| } |
| 0x7b => { |
| let len = self.parse_u64()?; |
| if len > usize::max_value() as u64 { |
| return Err(self.error(ErrorCode::LengthOutOfRange)); |
| } |
| self.parse_str(len as usize, visitor) |
| } |
| 0x7c..=0x7e => Err(self.error(ErrorCode::UnassignedCode)), |
| 0x7f => self.parse_indefinite_str(visitor), |
| |
| // Major type 4: an array of data items |
| 0x80..=0x97 => self.parse_array(byte as usize - 0x80, visitor), |
| 0x98 => { |
| let len = self.parse_u8()?; |
| self.parse_array(len as usize, visitor) |
| } |
| 0x99 => { |
| let len = self.parse_u16()?; |
| self.parse_array(len as usize, visitor) |
| } |
| 0x9a => { |
| let len = self.parse_u32()?; |
| self.parse_array(len as usize, visitor) |
| } |
| 0x9b => { |
| let len = self.parse_u64()?; |
| if len > usize::max_value() as u64 { |
| return Err(self.error(ErrorCode::LengthOutOfRange)); |
| } |
| self.parse_array(len as usize, visitor) |
| } |
| 0x9c..=0x9e => Err(self.error(ErrorCode::UnassignedCode)), |
| 0x9f => self.parse_indefinite_array(visitor), |
| |
| // Major type 5: a map of pairs of data items |
| 0xa0..=0xb7 => self.parse_map(byte as usize - 0xa0, visitor), |
| 0xb8 => { |
| let len = self.parse_u8()?; |
| self.parse_map(len as usize, visitor) |
| } |
| 0xb9 => { |
| let len = self.parse_u16()?; |
| self.parse_map(len as usize, visitor) |
| } |
| 0xba => { |
| let len = self.parse_u32()?; |
| self.parse_map(len as usize, visitor) |
| } |
| 0xbb => { |
| let len = self.parse_u64()?; |
| if len > usize::max_value() as u64 { |
| return Err(self.error(ErrorCode::LengthOutOfRange)); |
| } |
| self.parse_map(len as usize, visitor) |
| } |
| 0xbc..=0xbe => Err(self.error(ErrorCode::UnassignedCode)), |
| 0xbf => self.parse_indefinite_map(visitor), |
| |
| // Major type 6: optional semantic tagging of other major types |
| 0xc0..=0xd7 => { |
| let tag = u64::from(byte) - 0xc0; |
| self.handle_tagged_value(tag, visitor) |
| } |
| 0xd8 => { |
| let tag = self.parse_u8()?; |
| self.handle_tagged_value(tag.into(), visitor) |
| } |
| 0xd9 => { |
| let tag = self.parse_u16()?; |
| self.handle_tagged_value(tag.into(), visitor) |
| } |
| 0xda => { |
| let tag = self.parse_u32()?; |
| self.handle_tagged_value(tag.into(), visitor) |
| } |
| 0xdb => { |
| let tag = self.parse_u64()?; |
| self.handle_tagged_value(tag, visitor) |
| } |
| 0xdc..=0xdf => Err(self.error(ErrorCode::UnassignedCode)), |
| |
| // Major type 7: floating-point numbers and other simple data types that need no content |
| 0xe0..=0xf3 => Err(self.error(ErrorCode::UnassignedCode)), |
| 0xf4 => visitor.visit_bool(false), |
| 0xf5 => visitor.visit_bool(true), |
| 0xf6 => visitor.visit_unit(), |
| 0xf7 => visitor.visit_unit(), |
| 0xf8 => Err(self.error(ErrorCode::UnassignedCode)), |
| 0xf9 => { |
| let value = self.parse_f16()?; |
| visitor.visit_f32(value) |
| } |
| 0xfa => { |
| let value = self.parse_f32()?; |
| visitor.visit_f32(value) |
| } |
| 0xfb => { |
| let value = self.parse_f64()?; |
| visitor.visit_f64(value) |
| } |
| 0xfc..=0xfe => Err(self.error(ErrorCode::UnassignedCode)), |
| 0xff => Err(self.error(ErrorCode::UnexpectedCode)), |
| |
| _ => unreachable!(), |
| } |
| } |
| } |
| |
| impl<'de, 'a, R> de::Deserializer<'de> for &'a mut Deserializer<R> |
| where |
| R: Read<'de>, |
| { |
| type Error = Error; |
| |
| #[inline] |
| fn deserialize_any<V>(self, visitor: V) -> Result<V::Value> |
| where |
| V: de::Visitor<'de>, |
| { |
| self.parse_value(visitor) |
| } |
| |
| #[inline] |
| fn deserialize_option<V>(self, visitor: V) -> Result<V::Value> |
| where |
| V: de::Visitor<'de>, |
| { |
| match self.peek()? { |
| Some(0xf6) => { |
| self.consume(); |
| visitor.visit_none() |
| } |
| _ => visitor.visit_some(self), |
| } |
| } |
| |
| #[inline] |
| fn deserialize_newtype_struct<V>(self, _name: &str, visitor: V) -> Result<V::Value> |
| where |
| V: de::Visitor<'de>, |
| { |
| visitor.visit_newtype_struct(self) |
| } |
| |
| // Unit variants are encoded as just the variant identifier. |
| // Tuple variants are encoded as an array of the variant identifier followed by the fields. |
| // Struct variants are encoded as an array of the variant identifier followed by the struct. |
| #[inline] |
| fn deserialize_enum<V>( |
| self, |
| _name: &str, |
| _variants: &'static [&'static str], |
| visitor: V, |
| ) -> Result<V::Value> |
| where |
| V: de::Visitor<'de>, |
| { |
| match self.peek()? { |
| Some(byte @ 0x80..=0x9f) => { |
| if !self.accept_legacy_enums { |
| return Err(self.error(ErrorCode::WrongEnumFormat)); |
| } |
| self.consume(); |
| match byte { |
| 0x80..=0x97 => self.parse_enum(byte as usize - 0x80, visitor), |
| 0x98 => { |
| let len = self.parse_u8()?; |
| self.parse_enum(len as usize, visitor) |
| } |
| 0x99 => { |
| let len = self.parse_u16()?; |
| self.parse_enum(len as usize, visitor) |
| } |
| 0x9a => { |
| let len = self.parse_u32()?; |
| self.parse_enum(len as usize, visitor) |
| } |
| 0x9b => { |
| let len = self.parse_u64()?; |
| if len > usize::max_value() as u64 { |
| return Err(self.error(ErrorCode::LengthOutOfRange)); |
| } |
| self.parse_enum(len as usize, visitor) |
| } |
| 0x9c..=0x9e => Err(self.error(ErrorCode::UnassignedCode)), |
| 0x9f => self.parse_indefinite_enum(visitor), |
| |
| _ => unreachable!(), |
| } |
| } |
| Some(0xa1) => { |
| if !self.accept_standard_enums { |
| return Err(self.error(ErrorCode::WrongEnumFormat)); |
| } |
| self.consume(); |
| self.parse_enum_map(visitor) |
| } |
| None => Err(self.error(ErrorCode::EofWhileParsingValue)), |
| _ => { |
| if !self.accept_standard_enums && !self.accept_legacy_enums { |
| return Err(self.error(ErrorCode::WrongEnumFormat)); |
| } |
| visitor.visit_enum(UnitVariantAccess { de: self }) |
| } |
| } |
| } |
| |
| #[inline] |
| fn is_human_readable(&self) -> bool { |
| false |
| } |
| |
| serde::forward_to_deserialize_any! { |
| bool i8 i16 i32 i64 i128 u8 u16 u32 u64 u128 f32 f64 char str string unit |
| unit_struct seq tuple tuple_struct map struct identifier ignored_any |
| bytes byte_buf |
| } |
| } |
| |
| impl<R> Deserializer<R> |
| where |
| R: Offset, |
| { |
| /// Return the current offset in the reader |
| #[inline] |
| pub fn byte_offset(&self) -> usize { |
| self.read.byte_offset() |
| } |
| } |
| |
| trait MakeError { |
| fn error(&self, code: ErrorCode) -> Error; |
| } |
| |
| struct SeqAccess<'a, R> { |
| de: &'a mut Deserializer<R>, |
| len: &'a mut usize, |
| } |
| |
| impl<'de, 'a, R> de::SeqAccess<'de> for SeqAccess<'a, R> |
| where |
| R: Read<'de>, |
| { |
| type Error = Error; |
| |
| fn next_element_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>> |
| where |
| T: de::DeserializeSeed<'de>, |
| { |
| if *self.len == 0 { |
| return Ok(None); |
| } |
| *self.len -= 1; |
| |
| let value = seed.deserialize(&mut *self.de)?; |
| Ok(Some(value)) |
| } |
| |
| fn size_hint(&self) -> Option<usize> { |
| Some(*self.len) |
| } |
| } |
| |
| impl<'de, 'a, R> MakeError for SeqAccess<'a, R> |
| where |
| R: Read<'de>, |
| { |
| fn error(&self, code: ErrorCode) -> Error { |
| self.de.error(code) |
| } |
| } |
| |
| struct IndefiniteSeqAccess<'a, R> { |
| de: &'a mut Deserializer<R>, |
| } |
| |
| impl<'de, 'a, R> de::SeqAccess<'de> for IndefiniteSeqAccess<'a, R> |
| where |
| R: Read<'de>, |
| { |
| type Error = Error; |
| |
| fn next_element_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>> |
| where |
| T: de::DeserializeSeed<'de>, |
| { |
| match self.de.peek()? { |
| Some(0xff) => return Ok(None), |
| Some(_) => {} |
| None => return Err(self.de.error(ErrorCode::EofWhileParsingArray)), |
| } |
| |
| let value = seed.deserialize(&mut *self.de)?; |
| Ok(Some(value)) |
| } |
| } |
| |
| impl<'de, 'a, R> MakeError for IndefiniteSeqAccess<'a, R> |
| where |
| R: Read<'de>, |
| { |
| fn error(&self, code: ErrorCode) -> Error { |
| self.de.error(code) |
| } |
| } |
| |
| struct MapAccess<'a, R> { |
| de: &'a mut Deserializer<R>, |
| len: &'a mut usize, |
| accept_named: bool, |
| accept_packed: bool, |
| } |
| |
| impl<'de, 'a, R> de::MapAccess<'de> for MapAccess<'a, R> |
| where |
| R: Read<'de>, |
| { |
| type Error = Error; |
| |
| fn next_key_seed<K>(&mut self, seed: K) -> Result<Option<K::Value>> |
| where |
| K: de::DeserializeSeed<'de>, |
| { |
| if *self.len == 0 { |
| return Ok(None); |
| } |
| *self.len -= 1; |
| |
| match self.de.peek()? { |
| Some(_byte @ 0x00..=0x1b) if !self.accept_packed => { |
| return Err(self.de.error(ErrorCode::WrongStructFormat)); |
| } |
| Some(_byte @ 0x60..=0x7f) if !self.accept_named => { |
| return Err(self.de.error(ErrorCode::WrongStructFormat)); |
| } |
| _ => {} |
| }; |
| |
| let value = seed.deserialize(&mut *self.de)?; |
| Ok(Some(value)) |
| } |
| |
| fn next_value_seed<V>(&mut self, seed: V) -> Result<V::Value> |
| where |
| V: de::DeserializeSeed<'de>, |
| { |
| seed.deserialize(&mut *self.de) |
| } |
| |
| fn size_hint(&self) -> Option<usize> { |
| Some(*self.len) |
| } |
| } |
| |
| impl<'de, 'a, R> MakeError for MapAccess<'a, R> |
| where |
| R: Read<'de>, |
| { |
| fn error(&self, code: ErrorCode) -> Error { |
| self.de.error(code) |
| } |
| } |
| |
| struct IndefiniteMapAccess<'a, R> { |
| de: &'a mut Deserializer<R>, |
| accept_packed: bool, |
| accept_named: bool, |
| } |
| |
| impl<'de, 'a, R> de::MapAccess<'de> for IndefiniteMapAccess<'a, R> |
| where |
| R: Read<'de>, |
| { |
| type Error = Error; |
| |
| fn next_key_seed<K>(&mut self, seed: K) -> Result<Option<K::Value>> |
| where |
| K: de::DeserializeSeed<'de>, |
| { |
| match self.de.peek()? { |
| Some(_byte @ 0x00..=0x1b) if !self.accept_packed => { |
| return Err(self.de.error(ErrorCode::WrongStructFormat)) |
| } |
| Some(_byte @ 0x60..=0x7f) if !self.accept_named => { |
| return Err(self.de.error(ErrorCode::WrongStructFormat)) |
| } |
| Some(0xff) => return Ok(None), |
| Some(_) => {} |
| None => return Err(self.de.error(ErrorCode::EofWhileParsingMap)), |
| } |
| |
| let value = seed.deserialize(&mut *self.de)?; |
| Ok(Some(value)) |
| } |
| |
| fn next_value_seed<V>(&mut self, seed: V) -> Result<V::Value> |
| where |
| V: de::DeserializeSeed<'de>, |
| { |
| seed.deserialize(&mut *self.de) |
| } |
| } |
| |
| struct UnitVariantAccess<'a, R> { |
| de: &'a mut Deserializer<R>, |
| } |
| |
| impl<'de, 'a, R> de::EnumAccess<'de> for UnitVariantAccess<'a, R> |
| where |
| R: Read<'de>, |
| { |
| type Error = Error; |
| type Variant = UnitVariantAccess<'a, R>; |
| |
| fn variant_seed<V>(self, seed: V) -> Result<(V::Value, UnitVariantAccess<'a, R>)> |
| where |
| V: de::DeserializeSeed<'de>, |
| { |
| let variant = seed.deserialize(&mut *self.de)?; |
| Ok((variant, self)) |
| } |
| } |
| |
| impl<'de, 'a, R> de::VariantAccess<'de> for UnitVariantAccess<'a, R> |
| where |
| R: Read<'de>, |
| { |
| type Error = Error; |
| |
| fn unit_variant(self) -> Result<()> { |
| Ok(()) |
| } |
| |
| fn newtype_variant_seed<T>(self, _seed: T) -> Result<T::Value> |
| where |
| T: de::DeserializeSeed<'de>, |
| { |
| Err(de::Error::invalid_type( |
| de::Unexpected::UnitVariant, |
| &"newtype variant", |
| )) |
| } |
| |
| fn tuple_variant<V>(self, _len: usize, _visitor: V) -> Result<V::Value> |
| where |
| V: de::Visitor<'de>, |
| { |
| Err(de::Error::invalid_type( |
| de::Unexpected::UnitVariant, |
| &"tuple variant", |
| )) |
| } |
| |
| fn struct_variant<V>(self, _fields: &'static [&'static str], _visitor: V) -> Result<V::Value> |
| where |
| V: de::Visitor<'de>, |
| { |
| Err(de::Error::invalid_type( |
| de::Unexpected::UnitVariant, |
| &"struct variant", |
| )) |
| } |
| } |
| |
| struct VariantAccess<T> { |
| seq: T, |
| } |
| |
| impl<'de, T> de::EnumAccess<'de> for VariantAccess<T> |
| where |
| T: de::SeqAccess<'de, Error = Error> + MakeError, |
| { |
| type Error = Error; |
| type Variant = VariantAccess<T>; |
| |
| fn variant_seed<V>(mut self, seed: V) -> Result<(V::Value, VariantAccess<T>)> |
| where |
| V: de::DeserializeSeed<'de>, |
| { |
| let variant = match self.seq.next_element_seed(seed) { |
| Ok(Some(variant)) => variant, |
| Ok(None) => return Err(self.seq.error(ErrorCode::ArrayTooShort)), |
| Err(e) => return Err(e), |
| }; |
| Ok((variant, self)) |
| } |
| } |
| |
| impl<'de, T> de::VariantAccess<'de> for VariantAccess<T> |
| where |
| T: de::SeqAccess<'de, Error = Error> + MakeError, |
| { |
| type Error = Error; |
| |
| fn unit_variant(mut self) -> Result<()> { |
| match self.seq.next_element() { |
| Ok(Some(())) => Ok(()), |
| Ok(None) => Err(self.seq.error(ErrorCode::ArrayTooLong)), |
| Err(e) => Err(e), |
| } |
| } |
| |
| fn newtype_variant_seed<S>(mut self, seed: S) -> Result<S::Value> |
| where |
| S: de::DeserializeSeed<'de>, |
| { |
| match self.seq.next_element_seed(seed) { |
| Ok(Some(variant)) => Ok(variant), |
| Ok(None) => Err(self.seq.error(ErrorCode::ArrayTooShort)), |
| Err(e) => Err(e), |
| } |
| } |
| |
| fn tuple_variant<V>(self, _len: usize, visitor: V) -> Result<V::Value> |
| where |
| V: de::Visitor<'de>, |
| { |
| visitor.visit_seq(self.seq) |
| } |
| |
| fn struct_variant<V>(mut self, _fields: &'static [&'static str], visitor: V) -> Result<V::Value> |
| where |
| V: de::Visitor<'de>, |
| { |
| let seed = StructVariantSeed { visitor }; |
| match self.seq.next_element_seed(seed) { |
| Ok(Some(variant)) => Ok(variant), |
| Ok(None) => Err(self.seq.error(ErrorCode::ArrayTooShort)), |
| Err(e) => Err(e), |
| } |
| } |
| } |
| |
| struct StructVariantSeed<V> { |
| visitor: V, |
| } |
| |
| impl<'de, V> de::DeserializeSeed<'de> for StructVariantSeed<V> |
| where |
| V: de::Visitor<'de>, |
| { |
| type Value = V::Value; |
| |
| fn deserialize<D>(self, de: D) -> result::Result<V::Value, D::Error> |
| where |
| D: de::Deserializer<'de>, |
| { |
| de.deserialize_any(self.visitor) |
| } |
| } |
| |
| /// Iterator that deserializes a stream into multiple CBOR values. |
| /// |
| /// A stream deserializer can be created from any CBOR deserializer using the |
| /// `Deserializer::into_iter` method. |
| /// |
| /// ``` |
| /// # extern crate serde_cbor; |
| /// use serde_cbor::de::Deserializer; |
| /// use serde_cbor::value::Value; |
| /// |
| /// # fn main() { |
| /// let data: Vec<u8> = vec![ |
| /// 0x01, 0x66, 0x66, 0x6f, 0x6f, 0x62, 0x61, 0x72, |
| /// ]; |
| /// let mut it = Deserializer::from_slice(&data[..]).into_iter::<Value>(); |
| /// assert_eq!( |
| /// Value::Integer(1), |
| /// it.next().unwrap().unwrap() |
| /// ); |
| /// assert_eq!( |
| /// Value::Text("foobar".to_string()), |
| /// it.next().unwrap().unwrap() |
| /// ); |
| /// # } |
| /// ``` |
| #[derive(Debug)] |
| pub struct StreamDeserializer<'de, R, T> { |
| de: Deserializer<R>, |
| output: PhantomData<T>, |
| lifetime: PhantomData<&'de ()>, |
| } |
| |
| impl<'de, R, T> StreamDeserializer<'de, R, T> |
| where |
| R: Read<'de>, |
| T: de::Deserialize<'de>, |
| { |
| /// Create a new CBOR stream deserializer from one of the possible |
| /// serde_cbor input sources. |
| /// |
| /// Typically it is more convenient to use one of these methods instead: |
| /// |
| /// * `Deserializer::from_slice(...).into_iter()` |
| /// * `Deserializer::from_reader(...).into_iter()` |
| pub fn new(read: R) -> StreamDeserializer<'de, R, T> { |
| StreamDeserializer { |
| de: Deserializer::new(read), |
| output: PhantomData, |
| lifetime: PhantomData, |
| } |
| } |
| } |
| |
| impl<'de, R, T> StreamDeserializer<'de, R, T> |
| where |
| R: Offset, |
| T: de::Deserialize<'de>, |
| { |
| /// Return the current offset in the reader |
| #[inline] |
| pub fn byte_offset(&self) -> usize { |
| self.de.byte_offset() |
| } |
| } |
| |
| impl<'de, R, T> Iterator for StreamDeserializer<'de, R, T> |
| where |
| R: Read<'de>, |
| T: de::Deserialize<'de>, |
| { |
| type Item = Result<T>; |
| |
| fn next(&mut self) -> Option<Result<T>> { |
| match self.de.peek() { |
| Ok(Some(_)) => Some(T::deserialize(&mut self.de)), |
| Ok(None) => None, |
| Err(e) => Some(Err(e)), |
| } |
| } |
| } |
| |
| struct VariantAccessMap<T> { |
| map: T, |
| } |
| |
| impl<'de, T> de::EnumAccess<'de> for VariantAccessMap<T> |
| where |
| T: de::MapAccess<'de, Error = Error> + MakeError, |
| { |
| type Error = Error; |
| type Variant = VariantAccessMap<T>; |
| |
| fn variant_seed<V>(mut self, seed: V) -> Result<(V::Value, VariantAccessMap<T>)> |
| where |
| V: de::DeserializeSeed<'de>, |
| { |
| let variant = match self.map.next_key_seed(seed) { |
| Ok(Some(variant)) => variant, |
| Ok(None) => return Err(self.map.error(ErrorCode::ArrayTooShort)), |
| Err(e) => return Err(e), |
| }; |
| Ok((variant, self)) |
| } |
| } |
| |
| impl<'de, T> de::VariantAccess<'de> for VariantAccessMap<T> |
| where |
| T: de::MapAccess<'de, Error = Error> + MakeError, |
| { |
| type Error = Error; |
| |
| fn unit_variant(mut self) -> Result<()> { |
| match self.map.next_value() { |
| Ok(()) => Ok(()), |
| Err(e) => Err(e), |
| } |
| } |
| |
| fn newtype_variant_seed<S>(mut self, seed: S) -> Result<S::Value> |
| where |
| S: de::DeserializeSeed<'de>, |
| { |
| self.map.next_value_seed(seed) |
| } |
| |
| fn tuple_variant<V>(mut self, _len: usize, visitor: V) -> Result<V::Value> |
| where |
| V: de::Visitor<'de>, |
| { |
| let seed = StructVariantSeed { visitor }; |
| self.map.next_value_seed(seed) |
| } |
| |
| fn struct_variant<V>(mut self, _fields: &'static [&'static str], visitor: V) -> Result<V::Value> |
| where |
| V: de::Visitor<'de>, |
| { |
| let seed = StructVariantSeed { visitor }; |
| self.map.next_value_seed(seed) |
| } |
| } |
