aboutsummaryrefslogtreecommitdiff
path: root/vendor/serde/src/de/value.rs
diff options
context:
space:
mode:
Diffstat (limited to 'vendor/serde/src/de/value.rs')
-rw-r--r--vendor/serde/src/de/value.rs1720
1 files changed, 0 insertions, 1720 deletions
diff --git a/vendor/serde/src/de/value.rs b/vendor/serde/src/de/value.rs
deleted file mode 100644
index b229eba..0000000
--- a/vendor/serde/src/de/value.rs
+++ /dev/null
@@ -1,1720 +0,0 @@
-//! Building blocks for deserializing basic values using the `IntoDeserializer`
-//! trait.
-//!
-//! ```edition2021
-//! use serde::de::{value, Deserialize, IntoDeserializer};
-//! use serde_derive::Deserialize;
-//! use std::str::FromStr;
-//!
-//! #[derive(Deserialize)]
-//! enum Setting {
-//! On,
-//! Off,
-//! }
-//!
-//! impl FromStr for Setting {
-//! type Err = value::Error;
-//!
-//! fn from_str(s: &str) -> Result<Self, Self::Err> {
-//! Self::deserialize(s.into_deserializer())
-//! }
-//! }
-//! ```
-
-use crate::lib::*;
-
-use self::private::{First, Second};
-use crate::de::{self, size_hint, Deserializer, Expected, IntoDeserializer, SeqAccess, Visitor};
-use crate::ser;
-
-////////////////////////////////////////////////////////////////////////////////
-
-// For structs that contain a PhantomData. We do not want the trait
-// bound `E: Clone` inferred by derive(Clone).
-macro_rules! impl_copy_clone {
- ($ty:ident $(<$lifetime:tt>)*) => {
- impl<$($lifetime,)* E> Copy for $ty<$($lifetime,)* E> {}
-
- impl<$($lifetime,)* E> Clone for $ty<$($lifetime,)* E> {
- fn clone(&self) -> Self {
- *self
- }
- }
- };
-}
-
-////////////////////////////////////////////////////////////////////////////////
-
-/// A minimal representation of all possible errors that can occur using the
-/// `IntoDeserializer` trait.
-#[derive(Clone, PartialEq)]
-pub struct Error {
- err: ErrorImpl,
-}
-
-#[cfg(any(feature = "std", feature = "alloc"))]
-type ErrorImpl = Box<str>;
-#[cfg(not(any(feature = "std", feature = "alloc")))]
-type ErrorImpl = ();
-
-impl de::Error for Error {
- #[cfg(any(feature = "std", feature = "alloc"))]
- #[cold]
- fn custom<T>(msg: T) -> Self
- where
- T: Display,
- {
- Error {
- err: msg.to_string().into_boxed_str(),
- }
- }
-
- #[cfg(not(any(feature = "std", feature = "alloc")))]
- #[cold]
- fn custom<T>(msg: T) -> Self
- where
- T: Display,
- {
- let _ = msg;
- Error { err: () }
- }
-}
-
-impl ser::Error for Error {
- #[cold]
- fn custom<T>(msg: T) -> Self
- where
- T: Display,
- {
- de::Error::custom(msg)
- }
-}
-
-impl Display for Error {
- #[cfg(any(feature = "std", feature = "alloc"))]
- fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
- formatter.write_str(&self.err)
- }
-
- #[cfg(not(any(feature = "std", feature = "alloc")))]
- fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
- formatter.write_str("Serde deserialization error")
- }
-}
-
-impl Debug for Error {
- fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
- let mut debug = formatter.debug_tuple("Error");
- #[cfg(any(feature = "std", feature = "alloc"))]
- debug.field(&self.err);
- debug.finish()
- }
-}
-
-#[cfg(feature = "std")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "std")))]
-impl error::Error for Error {
- fn description(&self) -> &str {
- &self.err
- }
-}
-
-////////////////////////////////////////////////////////////////////////////////
-
-impl<'de, E> IntoDeserializer<'de, E> for ()
-where
- E: de::Error,
-{
- type Deserializer = UnitDeserializer<E>;
-
- fn into_deserializer(self) -> UnitDeserializer<E> {
- UnitDeserializer::new()
- }
-}
-
-/// A deserializer holding a `()`.
-pub struct UnitDeserializer<E> {
- marker: PhantomData<E>,
-}
-
-impl_copy_clone!(UnitDeserializer);
-
-impl<E> UnitDeserializer<E> {
- #[allow(missing_docs)]
- pub fn new() -> Self {
- UnitDeserializer {
- marker: PhantomData,
- }
- }
-}
-
-impl<'de, E> de::Deserializer<'de> for UnitDeserializer<E>
-where
- E: de::Error,
-{
- type Error = E;
-
- forward_to_deserialize_any! {
- bool i8 i16 i32 i64 i128 u8 u16 u32 u64 u128 f32 f64 char str string
- bytes byte_buf unit unit_struct newtype_struct seq tuple tuple_struct
- map struct enum identifier ignored_any
- }
-
- fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Self::Error>
- where
- V: de::Visitor<'de>,
- {
- visitor.visit_unit()
- }
-
- fn deserialize_option<V>(self, visitor: V) -> Result<V::Value, Self::Error>
- where
- V: de::Visitor<'de>,
- {
- visitor.visit_none()
- }
-}
-
-impl<E> Debug for UnitDeserializer<E> {
- fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
- formatter.debug_struct("UnitDeserializer").finish()
- }
-}
-
-////////////////////////////////////////////////////////////////////////////////
-
-/// A deserializer that cannot be instantiated.
-#[cfg(feature = "unstable")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "unstable")))]
-pub struct NeverDeserializer<E> {
- never: !,
- marker: PhantomData<E>,
-}
-
-#[cfg(feature = "unstable")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "unstable")))]
-impl<'de, E> IntoDeserializer<'de, E> for !
-where
- E: de::Error,
-{
- type Deserializer = NeverDeserializer<E>;
-
- fn into_deserializer(self) -> Self::Deserializer {
- self
- }
-}
-
-#[cfg(feature = "unstable")]
-impl<'de, E> de::Deserializer<'de> for NeverDeserializer<E>
-where
- E: de::Error,
-{
- type Error = E;
-
- fn deserialize_any<V>(self, _visitor: V) -> Result<V::Value, Self::Error>
- where
- V: de::Visitor<'de>,
- {
- self.never
- }
-
- forward_to_deserialize_any! {
- bool i8 i16 i32 i64 i128 u8 u16 u32 u64 u128 f32 f64 char str string
- bytes byte_buf option unit unit_struct newtype_struct seq tuple
- tuple_struct map struct enum identifier ignored_any
- }
-}
-
-////////////////////////////////////////////////////////////////////////////////
-
-macro_rules! primitive_deserializer {
- ($ty:ty, $doc:tt, $name:ident, $method:ident $($cast:tt)*) => {
- #[doc = "A deserializer holding"]
- #[doc = $doc]
- pub struct $name<E> {
- value: $ty,
- marker: PhantomData<E>
- }
-
- impl_copy_clone!($name);
-
- impl<'de, E> IntoDeserializer<'de, E> for $ty
- where
- E: de::Error,
- {
- type Deserializer = $name<E>;
-
- fn into_deserializer(self) -> $name<E> {
- $name::new(self)
- }
- }
-
- impl<E> $name<E> {
- #[allow(missing_docs)]
- pub fn new(value: $ty) -> Self {
- $name {
- value,
- marker: PhantomData,
- }
- }
- }
-
- impl<'de, E> de::Deserializer<'de> for $name<E>
- where
- E: de::Error,
- {
- type Error = E;
-
- forward_to_deserialize_any! {
- bool i8 i16 i32 i64 i128 u8 u16 u32 u64 u128 f32 f64 char str
- string bytes byte_buf option unit unit_struct newtype_struct seq
- tuple tuple_struct map struct enum identifier ignored_any
- }
-
- fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Self::Error>
- where
- V: de::Visitor<'de>,
- {
- visitor.$method(self.value $($cast)*)
- }
- }
-
- impl<E> Debug for $name<E> {
- fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
- formatter
- .debug_struct(stringify!($name))
- .field("value", &self.value)
- .finish()
- }
- }
- }
-}
-
-primitive_deserializer!(bool, "a `bool`.", BoolDeserializer, visit_bool);
-primitive_deserializer!(i8, "an `i8`.", I8Deserializer, visit_i8);
-primitive_deserializer!(i16, "an `i16`.", I16Deserializer, visit_i16);
-primitive_deserializer!(i32, "an `i32`.", I32Deserializer, visit_i32);
-primitive_deserializer!(i64, "an `i64`.", I64Deserializer, visit_i64);
-primitive_deserializer!(i128, "an `i128`.", I128Deserializer, visit_i128);
-primitive_deserializer!(isize, "an `isize`.", IsizeDeserializer, visit_i64 as i64);
-primitive_deserializer!(u8, "a `u8`.", U8Deserializer, visit_u8);
-primitive_deserializer!(u16, "a `u16`.", U16Deserializer, visit_u16);
-primitive_deserializer!(u64, "a `u64`.", U64Deserializer, visit_u64);
-primitive_deserializer!(u128, "a `u128`.", U128Deserializer, visit_u128);
-primitive_deserializer!(usize, "a `usize`.", UsizeDeserializer, visit_u64 as u64);
-primitive_deserializer!(f32, "an `f32`.", F32Deserializer, visit_f32);
-primitive_deserializer!(f64, "an `f64`.", F64Deserializer, visit_f64);
-primitive_deserializer!(char, "a `char`.", CharDeserializer, visit_char);
-
-/// A deserializer holding a `u32`.
-pub struct U32Deserializer<E> {
- value: u32,
- marker: PhantomData<E>,
-}
-
-impl_copy_clone!(U32Deserializer);
-
-impl<'de, E> IntoDeserializer<'de, E> for u32
-where
- E: de::Error,
-{
- type Deserializer = U32Deserializer<E>;
-
- fn into_deserializer(self) -> U32Deserializer<E> {
- U32Deserializer::new(self)
- }
-}
-
-impl<E> U32Deserializer<E> {
- #[allow(missing_docs)]
- pub fn new(value: u32) -> Self {
- U32Deserializer {
- value,
- marker: PhantomData,
- }
- }
-}
-
-impl<'de, E> de::Deserializer<'de> for U32Deserializer<E>
-where
- E: de::Error,
-{
- type Error = E;
-
- forward_to_deserialize_any! {
- bool i8 i16 i32 i64 i128 u8 u16 u32 u64 u128 f32 f64 char str string
- bytes byte_buf option unit unit_struct newtype_struct seq tuple
- tuple_struct map struct identifier ignored_any
- }
-
- fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Self::Error>
- where
- V: de::Visitor<'de>,
- {
- visitor.visit_u32(self.value)
- }
-
- fn deserialize_enum<V>(
- self,
- name: &str,
- variants: &'static [&'static str],
- visitor: V,
- ) -> Result<V::Value, Self::Error>
- where
- V: de::Visitor<'de>,
- {
- let _ = name;
- let _ = variants;
- visitor.visit_enum(self)
- }
-}
-
-impl<'de, E> de::EnumAccess<'de> for U32Deserializer<E>
-where
- E: de::Error,
-{
- type Error = E;
- type Variant = private::UnitOnly<E>;
-
- fn variant_seed<T>(self, seed: T) -> Result<(T::Value, Self::Variant), Self::Error>
- where
- T: de::DeserializeSeed<'de>,
- {
- seed.deserialize(self).map(private::unit_only)
- }
-}
-
-impl<E> Debug for U32Deserializer<E> {
- fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
- formatter
- .debug_struct("U32Deserializer")
- .field("value", &self.value)
- .finish()
- }
-}
-
-////////////////////////////////////////////////////////////////////////////////
-
-/// A deserializer holding a `&str`.
-pub struct StrDeserializer<'a, E> {
- value: &'a str,
- marker: PhantomData<E>,
-}
-
-impl_copy_clone!(StrDeserializer<'de>);
-
-impl<'de, 'a, E> IntoDeserializer<'de, E> for &'a str
-where
- E: de::Error,
-{
- type Deserializer = StrDeserializer<'a, E>;
-
- fn into_deserializer(self) -> StrDeserializer<'a, E> {
- StrDeserializer::new(self)
- }
-}
-
-impl<'a, E> StrDeserializer<'a, E> {
- #[allow(missing_docs)]
- pub fn new(value: &'a str) -> Self {
- StrDeserializer {
- value,
- marker: PhantomData,
- }
- }
-}
-
-impl<'de, 'a, E> de::Deserializer<'de> for StrDeserializer<'a, E>
-where
- E: de::Error,
-{
- type Error = E;
-
- fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Self::Error>
- where
- V: de::Visitor<'de>,
- {
- visitor.visit_str(self.value)
- }
-
- fn deserialize_enum<V>(
- self,
- name: &str,
- variants: &'static [&'static str],
- visitor: V,
- ) -> Result<V::Value, Self::Error>
- where
- V: de::Visitor<'de>,
- {
- let _ = name;
- let _ = variants;
- visitor.visit_enum(self)
- }
-
- forward_to_deserialize_any! {
- bool i8 i16 i32 i64 i128 u8 u16 u32 u64 u128 f32 f64 char str string
- bytes byte_buf option unit unit_struct newtype_struct seq tuple
- tuple_struct map struct identifier ignored_any
- }
-}
-
-impl<'de, 'a, E> de::EnumAccess<'de> for StrDeserializer<'a, E>
-where
- E: de::Error,
-{
- type Error = E;
- type Variant = private::UnitOnly<E>;
-
- fn variant_seed<T>(self, seed: T) -> Result<(T::Value, Self::Variant), Self::Error>
- where
- T: de::DeserializeSeed<'de>,
- {
- seed.deserialize(self).map(private::unit_only)
- }
-}
-
-impl<'a, E> Debug for StrDeserializer<'a, E> {
- fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
- formatter
- .debug_struct("StrDeserializer")
- .field("value", &self.value)
- .finish()
- }
-}
-
-////////////////////////////////////////////////////////////////////////////////
-
-/// A deserializer holding a `&str` with a lifetime tied to another
-/// deserializer.
-pub struct BorrowedStrDeserializer<'de, E> {
- value: &'de str,
- marker: PhantomData<E>,
-}
-
-impl_copy_clone!(BorrowedStrDeserializer<'de>);
-
-impl<'de, E> BorrowedStrDeserializer<'de, E> {
- /// Create a new borrowed deserializer from the given string.
- pub fn new(value: &'de str) -> BorrowedStrDeserializer<'de, E> {
- BorrowedStrDeserializer {
- value,
- marker: PhantomData,
- }
- }
-}
-
-impl<'de, E> de::Deserializer<'de> for BorrowedStrDeserializer<'de, E>
-where
- E: de::Error,
-{
- type Error = E;
-
- fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Self::Error>
- where
- V: de::Visitor<'de>,
- {
- visitor.visit_borrowed_str(self.value)
- }
-
- fn deserialize_enum<V>(
- self,
- name: &str,
- variants: &'static [&'static str],
- visitor: V,
- ) -> Result<V::Value, Self::Error>
- where
- V: de::Visitor<'de>,
- {
- let _ = name;
- let _ = variants;
- visitor.visit_enum(self)
- }
-
- forward_to_deserialize_any! {
- bool i8 i16 i32 i64 i128 u8 u16 u32 u64 u128 f32 f64 char str string
- bytes byte_buf option unit unit_struct newtype_struct seq tuple
- tuple_struct map struct identifier ignored_any
- }
-}
-
-impl<'de, E> de::EnumAccess<'de> for BorrowedStrDeserializer<'de, E>
-where
- E: de::Error,
-{
- type Error = E;
- type Variant = private::UnitOnly<E>;
-
- fn variant_seed<T>(self, seed: T) -> Result<(T::Value, Self::Variant), Self::Error>
- where
- T: de::DeserializeSeed<'de>,
- {
- seed.deserialize(self).map(private::unit_only)
- }
-}
-
-impl<'de, E> Debug for BorrowedStrDeserializer<'de, E> {
- fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
- formatter
- .debug_struct("BorrowedStrDeserializer")
- .field("value", &self.value)
- .finish()
- }
-}
-
-////////////////////////////////////////////////////////////////////////////////
-
-/// A deserializer holding a `String`.
-#[cfg(any(feature = "std", feature = "alloc"))]
-#[cfg_attr(doc_cfg, doc(cfg(any(feature = "std", feature = "alloc"))))]
-pub struct StringDeserializer<E> {
- value: String,
- marker: PhantomData<E>,
-}
-
-#[cfg(any(feature = "std", feature = "alloc"))]
-impl<E> Clone for StringDeserializer<E> {
- fn clone(&self) -> Self {
- StringDeserializer {
- value: self.value.clone(),
- marker: PhantomData,
- }
- }
-}
-
-#[cfg(any(feature = "std", feature = "alloc"))]
-#[cfg_attr(doc_cfg, doc(cfg(any(feature = "std", feature = "alloc"))))]
-impl<'de, E> IntoDeserializer<'de, E> for String
-where
- E: de::Error,
-{
- type Deserializer = StringDeserializer<E>;
-
- fn into_deserializer(self) -> StringDeserializer<E> {
- StringDeserializer::new(self)
- }
-}
-
-#[cfg(any(feature = "std", feature = "alloc"))]
-impl<E> StringDeserializer<E> {
- #[allow(missing_docs)]
- pub fn new(value: String) -> Self {
- StringDeserializer {
- value,
- marker: PhantomData,
- }
- }
-}
-
-#[cfg(any(feature = "std", feature = "alloc"))]
-impl<'de, E> de::Deserializer<'de> for StringDeserializer<E>
-where
- E: de::Error,
-{
- type Error = E;
-
- fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Self::Error>
- where
- V: de::Visitor<'de>,
- {
- visitor.visit_string(self.value)
- }
-
- fn deserialize_enum<V>(
- self,
- name: &str,
- variants: &'static [&'static str],
- visitor: V,
- ) -> Result<V::Value, Self::Error>
- where
- V: de::Visitor<'de>,
- {
- let _ = name;
- let _ = variants;
- visitor.visit_enum(self)
- }
-
- forward_to_deserialize_any! {
- bool i8 i16 i32 i64 i128 u8 u16 u32 u64 u128 f32 f64 char str string
- bytes byte_buf option unit unit_struct newtype_struct seq tuple
- tuple_struct map struct identifier ignored_any
- }
-}
-
-#[cfg(any(feature = "std", feature = "alloc"))]
-impl<'de, E> de::EnumAccess<'de> for StringDeserializer<E>
-where
- E: de::Error,
-{
- type Error = E;
- type Variant = private::UnitOnly<E>;
-
- fn variant_seed<T>(self, seed: T) -> Result<(T::Value, Self::Variant), Self::Error>
- where
- T: de::DeserializeSeed<'de>,
- {
- seed.deserialize(self).map(private::unit_only)
- }
-}
-
-#[cfg(any(feature = "std", feature = "alloc"))]
-impl<E> Debug for StringDeserializer<E> {
- fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
- formatter
- .debug_struct("StringDeserializer")
- .field("value", &self.value)
- .finish()
- }
-}
-
-////////////////////////////////////////////////////////////////////////////////
-
-/// A deserializer holding a `Cow<str>`.
-#[cfg(any(feature = "std", feature = "alloc"))]
-#[cfg_attr(doc_cfg, doc(cfg(any(feature = "std", feature = "alloc"))))]
-pub struct CowStrDeserializer<'a, E> {
- value: Cow<'a, str>,
- marker: PhantomData<E>,
-}
-
-#[cfg(any(feature = "std", feature = "alloc"))]
-impl<'a, E> Clone for CowStrDeserializer<'a, E> {
- fn clone(&self) -> Self {
- CowStrDeserializer {
- value: self.value.clone(),
- marker: PhantomData,
- }
- }
-}
-
-#[cfg(any(feature = "std", feature = "alloc"))]
-#[cfg_attr(doc_cfg, doc(cfg(any(feature = "std", feature = "alloc"))))]
-impl<'de, 'a, E> IntoDeserializer<'de, E> for Cow<'a, str>
-where
- E: de::Error,
-{
- type Deserializer = CowStrDeserializer<'a, E>;
-
- fn into_deserializer(self) -> CowStrDeserializer<'a, E> {
- CowStrDeserializer::new(self)
- }
-}
-
-#[cfg(any(feature = "std", feature = "alloc"))]
-impl<'a, E> CowStrDeserializer<'a, E> {
- #[allow(missing_docs)]
- pub fn new(value: Cow<'a, str>) -> Self {
- CowStrDeserializer {
- value,
- marker: PhantomData,
- }
- }
-}
-
-#[cfg(any(feature = "std", feature = "alloc"))]
-impl<'de, 'a, E> de::Deserializer<'de> for CowStrDeserializer<'a, E>
-where
- E: de::Error,
-{
- type Error = E;
-
- fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Self::Error>
- where
- V: de::Visitor<'de>,
- {
- match self.value {
- Cow::Borrowed(string) => visitor.visit_str(string),
- Cow::Owned(string) => visitor.visit_string(string),
- }
- }
-
- fn deserialize_enum<V>(
- self,
- name: &str,
- variants: &'static [&'static str],
- visitor: V,
- ) -> Result<V::Value, Self::Error>
- where
- V: de::Visitor<'de>,
- {
- let _ = name;
- let _ = variants;
- visitor.visit_enum(self)
- }
-
- forward_to_deserialize_any! {
- bool i8 i16 i32 i64 i128 u8 u16 u32 u64 u128 f32 f64 char str string
- bytes byte_buf option unit unit_struct newtype_struct seq tuple
- tuple_struct map struct identifier ignored_any
- }
-}
-
-#[cfg(any(feature = "std", feature = "alloc"))]
-impl<'de, 'a, E> de::EnumAccess<'de> for CowStrDeserializer<'a, E>
-where
- E: de::Error,
-{
- type Error = E;
- type Variant = private::UnitOnly<E>;
-
- fn variant_seed<T>(self, seed: T) -> Result<(T::Value, Self::Variant), Self::Error>
- where
- T: de::DeserializeSeed<'de>,
- {
- seed.deserialize(self).map(private::unit_only)
- }
-}
-
-#[cfg(any(feature = "std", feature = "alloc"))]
-impl<'a, E> Debug for CowStrDeserializer<'a, E> {
- fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
- formatter
- .debug_struct("CowStrDeserializer")
- .field("value", &self.value)
- .finish()
- }
-}
-
-////////////////////////////////////////////////////////////////////////////////
-
-/// A deserializer holding a `&[u8]`. Always calls [`Visitor::visit_bytes`].
-pub struct BytesDeserializer<'a, E> {
- value: &'a [u8],
- marker: PhantomData<E>,
-}
-
-impl<'a, E> BytesDeserializer<'a, E> {
- /// Create a new deserializer from the given bytes.
- pub fn new(value: &'a [u8]) -> Self {
- BytesDeserializer {
- value,
- marker: PhantomData,
- }
- }
-}
-
-impl_copy_clone!(BytesDeserializer<'a>);
-
-impl<'de, 'a, E> IntoDeserializer<'de, E> for &'a [u8]
-where
- E: de::Error,
-{
- type Deserializer = BytesDeserializer<'a, E>;
-
- fn into_deserializer(self) -> BytesDeserializer<'a, E> {
- BytesDeserializer::new(self)
- }
-}
-
-impl<'de, 'a, E> Deserializer<'de> for BytesDeserializer<'a, E>
-where
- E: de::Error,
-{
- type Error = E;
-
- fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Self::Error>
- where
- V: Visitor<'de>,
- {
- visitor.visit_bytes(self.value)
- }
-
- forward_to_deserialize_any! {
- bool i8 i16 i32 i64 i128 u8 u16 u32 u64 u128 f32 f64 char str string
- bytes byte_buf option unit unit_struct newtype_struct seq tuple
- tuple_struct map struct enum identifier ignored_any
- }
-}
-
-impl<'a, E> Debug for BytesDeserializer<'a, E> {
- fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
- formatter
- .debug_struct("BytesDeserializer")
- .field("value", &self.value)
- .finish()
- }
-}
-
-/// A deserializer holding a `&[u8]` with a lifetime tied to another
-/// deserializer. Always calls [`Visitor::visit_borrowed_bytes`].
-pub struct BorrowedBytesDeserializer<'de, E> {
- value: &'de [u8],
- marker: PhantomData<E>,
-}
-
-impl<'de, E> BorrowedBytesDeserializer<'de, E> {
- /// Create a new borrowed deserializer from the given borrowed bytes.
- pub fn new(value: &'de [u8]) -> Self {
- BorrowedBytesDeserializer {
- value,
- marker: PhantomData,
- }
- }
-}
-
-impl_copy_clone!(BorrowedBytesDeserializer<'de>);
-
-impl<'de, E> Deserializer<'de> for BorrowedBytesDeserializer<'de, E>
-where
- E: de::Error,
-{
- type Error = E;
-
- fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Self::Error>
- where
- V: Visitor<'de>,
- {
- visitor.visit_borrowed_bytes(self.value)
- }
-
- forward_to_deserialize_any! {
- bool i8 i16 i32 i64 i128 u8 u16 u32 u64 u128 f32 f64 char str string
- bytes byte_buf option unit unit_struct newtype_struct seq tuple
- tuple_struct map struct enum identifier ignored_any
- }
-}
-
-impl<'de, E> Debug for BorrowedBytesDeserializer<'de, E> {
- fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
- formatter
- .debug_struct("BorrowedBytesDeserializer")
- .field("value", &self.value)
- .finish()
- }
-}
-
-////////////////////////////////////////////////////////////////////////////////
-
-/// A deserializer that iterates over a sequence.
-#[derive(Clone)]
-pub struct SeqDeserializer<I, E> {
- iter: iter::Fuse<I>,
- count: usize,
- marker: PhantomData<E>,
-}
-
-impl<I, E> SeqDeserializer<I, E>
-where
- I: Iterator,
-{
- /// Construct a new `SeqDeserializer<I, E>`.
- pub fn new(iter: I) -> Self {
- SeqDeserializer {
- iter: iter.fuse(),
- count: 0,
- marker: PhantomData,
- }
- }
-}
-
-impl<I, E> SeqDeserializer<I, E>
-where
- I: Iterator,
- E: de::Error,
-{
- /// Check for remaining elements after passing a `SeqDeserializer` to
- /// `Visitor::visit_seq`.
- pub fn end(self) -> Result<(), E> {
- let remaining = self.iter.count();
- if remaining == 0 {
- Ok(())
- } else {
- // First argument is the number of elements in the data, second
- // argument is the number of elements expected by the Deserialize.
- Err(de::Error::invalid_length(
- self.count + remaining,
- &ExpectedInSeq(self.count),
- ))
- }
- }
-}
-
-impl<'de, I, T, E> de::Deserializer<'de> for SeqDeserializer<I, E>
-where
- I: Iterator<Item = T>,
- T: IntoDeserializer<'de, E>,
- E: de::Error,
-{
- type Error = E;
-
- fn deserialize_any<V>(mut self, visitor: V) -> Result<V::Value, Self::Error>
- where
- V: de::Visitor<'de>,
- {
- let v = tri!(visitor.visit_seq(&mut self));
- tri!(self.end());
- Ok(v)
- }
-
- forward_to_deserialize_any! {
- bool i8 i16 i32 i64 i128 u8 u16 u32 u64 u128 f32 f64 char str string
- bytes byte_buf option unit unit_struct newtype_struct seq tuple
- tuple_struct map struct enum identifier ignored_any
- }
-}
-
-impl<'de, I, T, E> de::SeqAccess<'de> for SeqDeserializer<I, E>
-where
- I: Iterator<Item = T>,
- T: IntoDeserializer<'de, E>,
- E: de::Error,
-{
- type Error = E;
-
- fn next_element_seed<V>(&mut self, seed: V) -> Result<Option<V::Value>, Self::Error>
- where
- V: de::DeserializeSeed<'de>,
- {
- match self.iter.next() {
- Some(value) => {
- self.count += 1;
- seed.deserialize(value.into_deserializer()).map(Some)
- }
- None => Ok(None),
- }
- }
-
- fn size_hint(&self) -> Option<usize> {
- size_hint::from_bounds(&self.iter)
- }
-}
-
-struct ExpectedInSeq(usize);
-
-impl Expected for ExpectedInSeq {
- fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
- if self.0 == 1 {
- write!(formatter, "1 element in sequence")
- } else {
- write!(formatter, "{} elements in sequence", self.0)
- }
- }
-}
-
-impl<I, E> Debug for SeqDeserializer<I, E>
-where
- I: Debug,
-{
- fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
- formatter
- .debug_struct("SeqDeserializer")
- .field("iter", &self.iter)
- .field("count", &self.count)
- .finish()
- }
-}
-
-////////////////////////////////////////////////////////////////////////////////
-
-#[cfg(any(feature = "std", feature = "alloc"))]
-#[cfg_attr(doc_cfg, doc(cfg(any(feature = "std", feature = "alloc"))))]
-impl<'de, T, E> IntoDeserializer<'de, E> for Vec<T>
-where
- T: IntoDeserializer<'de, E>,
- E: de::Error,
-{
- type Deserializer = SeqDeserializer<<Self as IntoIterator>::IntoIter, E>;
-
- fn into_deserializer(self) -> Self::Deserializer {
- SeqDeserializer::new(self.into_iter())
- }
-}
-
-#[cfg(any(feature = "std", feature = "alloc"))]
-#[cfg_attr(doc_cfg, doc(cfg(any(feature = "std", feature = "alloc"))))]
-impl<'de, T, E> IntoDeserializer<'de, E> for BTreeSet<T>
-where
- T: IntoDeserializer<'de, E> + Eq + Ord,
- E: de::Error,
-{
- type Deserializer = SeqDeserializer<<Self as IntoIterator>::IntoIter, E>;
-
- fn into_deserializer(self) -> Self::Deserializer {
- SeqDeserializer::new(self.into_iter())
- }
-}
-
-#[cfg(feature = "std")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "std")))]
-impl<'de, T, S, E> IntoDeserializer<'de, E> for HashSet<T, S>
-where
- T: IntoDeserializer<'de, E> + Eq + Hash,
- S: BuildHasher,
- E: de::Error,
-{
- type Deserializer = SeqDeserializer<<Self as IntoIterator>::IntoIter, E>;
-
- fn into_deserializer(self) -> Self::Deserializer {
- SeqDeserializer::new(self.into_iter())
- }
-}
-
-////////////////////////////////////////////////////////////////////////////////
-
-/// A deserializer holding a `SeqAccess`.
-#[derive(Clone, Debug)]
-pub struct SeqAccessDeserializer<A> {
- seq: A,
-}
-
-impl<A> SeqAccessDeserializer<A> {
- /// Construct a new `SeqAccessDeserializer<A>`.
- pub fn new(seq: A) -> Self {
- SeqAccessDeserializer { seq }
- }
-}
-
-impl<'de, A> de::Deserializer<'de> for SeqAccessDeserializer<A>
-where
- A: de::SeqAccess<'de>,
-{
- type Error = A::Error;
-
- fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Self::Error>
- where
- V: de::Visitor<'de>,
- {
- visitor.visit_seq(self.seq)
- }
-
- forward_to_deserialize_any! {
- bool i8 i16 i32 i64 i128 u8 u16 u32 u64 u128 f32 f64 char str string
- bytes byte_buf option unit unit_struct newtype_struct seq tuple
- tuple_struct map struct enum identifier ignored_any
- }
-}
-
-////////////////////////////////////////////////////////////////////////////////
-
-/// A deserializer that iterates over a map.
-pub struct MapDeserializer<'de, I, E>
-where
- I: Iterator,
- I::Item: private::Pair,
-{
- iter: iter::Fuse<I>,
- value: Option<Second<I::Item>>,
- count: usize,
- lifetime: PhantomData<&'de ()>,
- error: PhantomData<E>,
-}
-
-impl<'de, I, E> MapDeserializer<'de, I, E>
-where
- I: Iterator,
- I::Item: private::Pair,
-{
- /// Construct a new `MapDeserializer<I, E>`.
- pub fn new(iter: I) -> Self {
- MapDeserializer {
- iter: iter.fuse(),
- value: None,
- count: 0,
- lifetime: PhantomData,
- error: PhantomData,
- }
- }
-}
-
-impl<'de, I, E> MapDeserializer<'de, I, E>
-where
- I: Iterator,
- I::Item: private::Pair,
- E: de::Error,
-{
- /// Check for remaining elements after passing a `MapDeserializer` to
- /// `Visitor::visit_map`.
- pub fn end(self) -> Result<(), E> {
- let remaining = self.iter.count();
- if remaining == 0 {
- Ok(())
- } else {
- // First argument is the number of elements in the data, second
- // argument is the number of elements expected by the Deserialize.
- Err(de::Error::invalid_length(
- self.count + remaining,
- &ExpectedInMap(self.count),
- ))
- }
- }
-}
-
-impl<'de, I, E> MapDeserializer<'de, I, E>
-where
- I: Iterator,
- I::Item: private::Pair,
-{
- fn next_pair(&mut self) -> Option<(First<I::Item>, Second<I::Item>)> {
- match self.iter.next() {
- Some(kv) => {
- self.count += 1;
- Some(private::Pair::split(kv))
- }
- None => None,
- }
- }
-}
-
-impl<'de, I, E> de::Deserializer<'de> for MapDeserializer<'de, I, E>
-where
- I: Iterator,
- I::Item: private::Pair,
- First<I::Item>: IntoDeserializer<'de, E>,
- Second<I::Item>: IntoDeserializer<'de, E>,
- E: de::Error,
-{
- type Error = E;
-
- fn deserialize_any<V>(mut self, visitor: V) -> Result<V::Value, Self::Error>
- where
- V: de::Visitor<'de>,
- {
- let value = tri!(visitor.visit_map(&mut self));
- tri!(self.end());
- Ok(value)
- }
-
- fn deserialize_seq<V>(mut self, visitor: V) -> Result<V::Value, Self::Error>
- where
- V: de::Visitor<'de>,
- {
- let value = tri!(visitor.visit_seq(&mut self));
- tri!(self.end());
- Ok(value)
- }
-
- fn deserialize_tuple<V>(self, len: usize, visitor: V) -> Result<V::Value, Self::Error>
- where
- V: de::Visitor<'de>,
- {
- let _ = len;
- self.deserialize_seq(visitor)
- }
-
- forward_to_deserialize_any! {
- bool i8 i16 i32 i64 i128 u8 u16 u32 u64 u128 f32 f64 char str string
- bytes byte_buf option unit unit_struct newtype_struct tuple_struct map
- struct enum identifier ignored_any
- }
-}
-
-impl<'de, I, E> de::MapAccess<'de> for MapDeserializer<'de, I, E>
-where
- I: Iterator,
- I::Item: private::Pair,
- First<I::Item>: IntoDeserializer<'de, E>,
- Second<I::Item>: IntoDeserializer<'de, E>,
- E: de::Error,
-{
- type Error = E;
-
- fn next_key_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>, Self::Error>
- where
- T: de::DeserializeSeed<'de>,
- {
- match self.next_pair() {
- Some((key, value)) => {
- self.value = Some(value);
- seed.deserialize(key.into_deserializer()).map(Some)
- }
- None => Ok(None),
- }
- }
-
- fn next_value_seed<T>(&mut self, seed: T) -> Result<T::Value, Self::Error>
- where
- T: de::DeserializeSeed<'de>,
- {
- let value = self.value.take();
- // Panic because this indicates a bug in the program rather than an
- // expected failure.
- let value = value.expect("MapAccess::next_value called before next_key");
- seed.deserialize(value.into_deserializer())
- }
-
- fn next_entry_seed<TK, TV>(
- &mut self,
- kseed: TK,
- vseed: TV,
- ) -> Result<Option<(TK::Value, TV::Value)>, Self::Error>
- where
- TK: de::DeserializeSeed<'de>,
- TV: de::DeserializeSeed<'de>,
- {
- match self.next_pair() {
- Some((key, value)) => {
- let key = tri!(kseed.deserialize(key.into_deserializer()));
- let value = tri!(vseed.deserialize(value.into_deserializer()));
- Ok(Some((key, value)))
- }
- None => Ok(None),
- }
- }
-
- fn size_hint(&self) -> Option<usize> {
- size_hint::from_bounds(&self.iter)
- }
-}
-
-impl<'de, I, E> de::SeqAccess<'de> for MapDeserializer<'de, I, E>
-where
- I: Iterator,
- I::Item: private::Pair,
- First<I::Item>: IntoDeserializer<'de, E>,
- Second<I::Item>: IntoDeserializer<'de, E>,
- E: de::Error,
-{
- type Error = E;
-
- fn next_element_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>, Self::Error>
- where
- T: de::DeserializeSeed<'de>,
- {
- match self.next_pair() {
- Some((k, v)) => {
- let de = PairDeserializer(k, v, PhantomData);
- seed.deserialize(de).map(Some)
- }
- None => Ok(None),
- }
- }
-
- fn size_hint(&self) -> Option<usize> {
- size_hint::from_bounds(&self.iter)
- }
-}
-
-// Cannot #[derive(Clone)] because of the bound `Second<I::Item>: Clone`.
-impl<'de, I, E> Clone for MapDeserializer<'de, I, E>
-where
- I: Iterator + Clone,
- I::Item: private::Pair,
- Second<I::Item>: Clone,
-{
- fn clone(&self) -> Self {
- MapDeserializer {
- iter: self.iter.clone(),
- value: self.value.clone(),
- count: self.count,
- lifetime: self.lifetime,
- error: self.error,
- }
- }
-}
-
-impl<'de, I, E> Debug for MapDeserializer<'de, I, E>
-where
- I: Iterator + Debug,
- I::Item: private::Pair,
- Second<I::Item>: Debug,
-{
- fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
- formatter
- .debug_struct("MapDeserializer")
- .field("iter", &self.iter)
- .field("value", &self.value)
- .field("count", &self.count)
- .finish()
- }
-}
-
-// Used in the `impl SeqAccess for MapDeserializer` to visit the map as a
-// sequence of pairs.
-struct PairDeserializer<A, B, E>(A, B, PhantomData<E>);
-
-impl<'de, A, B, E> de::Deserializer<'de> for PairDeserializer<A, B, E>
-where
- A: IntoDeserializer<'de, E>,
- B: IntoDeserializer<'de, E>,
- E: de::Error,
-{
- type Error = E;
-
- forward_to_deserialize_any! {
- bool i8 i16 i32 i64 i128 u8 u16 u32 u64 u128 f32 f64 char str string
- bytes byte_buf option unit unit_struct newtype_struct tuple_struct map
- struct enum identifier ignored_any
- }
-
- fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Self::Error>
- where
- V: de::Visitor<'de>,
- {
- self.deserialize_seq(visitor)
- }
-
- fn deserialize_seq<V>(self, visitor: V) -> Result<V::Value, Self::Error>
- where
- V: de::Visitor<'de>,
- {
- let mut pair_visitor = PairVisitor(Some(self.0), Some(self.1), PhantomData);
- let pair = tri!(visitor.visit_seq(&mut pair_visitor));
- if pair_visitor.1.is_none() {
- Ok(pair)
- } else {
- let remaining = pair_visitor.size_hint().unwrap();
- // First argument is the number of elements in the data, second
- // argument is the number of elements expected by the Deserialize.
- Err(de::Error::invalid_length(2, &ExpectedInSeq(2 - remaining)))
- }
- }
-
- fn deserialize_tuple<V>(self, len: usize, visitor: V) -> Result<V::Value, Self::Error>
- where
- V: de::Visitor<'de>,
- {
- if len == 2 {
- self.deserialize_seq(visitor)
- } else {
- // First argument is the number of elements in the data, second
- // argument is the number of elements expected by the Deserialize.
- Err(de::Error::invalid_length(2, &ExpectedInSeq(len)))
- }
- }
-}
-
-struct PairVisitor<A, B, E>(Option<A>, Option<B>, PhantomData<E>);
-
-impl<'de, A, B, E> de::SeqAccess<'de> for PairVisitor<A, B, E>
-where
- A: IntoDeserializer<'de, E>,
- B: IntoDeserializer<'de, E>,
- E: de::Error,
-{
- type Error = E;
-
- fn next_element_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>, Self::Error>
- where
- T: de::DeserializeSeed<'de>,
- {
- if let Some(k) = self.0.take() {
- seed.deserialize(k.into_deserializer()).map(Some)
- } else if let Some(v) = self.1.take() {
- seed.deserialize(v.into_deserializer()).map(Some)
- } else {
- Ok(None)
- }
- }
-
- fn size_hint(&self) -> Option<usize> {
- if self.0.is_some() {
- Some(2)
- } else if self.1.is_some() {
- Some(1)
- } else {
- Some(0)
- }
- }
-}
-
-struct ExpectedInMap(usize);
-
-impl Expected for ExpectedInMap {
- fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
- if self.0 == 1 {
- write!(formatter, "1 element in map")
- } else {
- write!(formatter, "{} elements in map", self.0)
- }
- }
-}
-
-////////////////////////////////////////////////////////////////////////////////
-
-#[cfg(any(feature = "std", feature = "alloc"))]
-#[cfg_attr(doc_cfg, doc(cfg(any(feature = "std", feature = "alloc"))))]
-impl<'de, K, V, E> IntoDeserializer<'de, E> for BTreeMap<K, V>
-where
- K: IntoDeserializer<'de, E> + Eq + Ord,
- V: IntoDeserializer<'de, E>,
- E: de::Error,
-{
- type Deserializer = MapDeserializer<'de, <Self as IntoIterator>::IntoIter, E>;
-
- fn into_deserializer(self) -> Self::Deserializer {
- MapDeserializer::new(self.into_iter())
- }
-}
-
-#[cfg(feature = "std")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "std")))]
-impl<'de, K, V, S, E> IntoDeserializer<'de, E> for HashMap<K, V, S>
-where
- K: IntoDeserializer<'de, E> + Eq + Hash,
- V: IntoDeserializer<'de, E>,
- S: BuildHasher,
- E: de::Error,
-{
- type Deserializer = MapDeserializer<'de, <Self as IntoIterator>::IntoIter, E>;
-
- fn into_deserializer(self) -> Self::Deserializer {
- MapDeserializer::new(self.into_iter())
- }
-}
-
-////////////////////////////////////////////////////////////////////////////////
-
-/// A deserializer holding a `MapAccess`.
-#[derive(Clone, Debug)]
-pub struct MapAccessDeserializer<A> {
- map: A,
-}
-
-impl<A> MapAccessDeserializer<A> {
- /// Construct a new `MapAccessDeserializer<A>`.
- pub fn new(map: A) -> Self {
- MapAccessDeserializer { map }
- }
-}
-
-impl<'de, A> de::Deserializer<'de> for MapAccessDeserializer<A>
-where
- A: de::MapAccess<'de>,
-{
- type Error = A::Error;
-
- fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Self::Error>
- where
- V: de::Visitor<'de>,
- {
- visitor.visit_map(self.map)
- }
-
- fn deserialize_enum<V>(
- self,
- _name: &str,
- _variants: &'static [&'static str],
- visitor: V,
- ) -> Result<V::Value, Self::Error>
- where
- V: de::Visitor<'de>,
- {
- visitor.visit_enum(self)
- }
-
- forward_to_deserialize_any! {
- bool i8 i16 i32 i64 i128 u8 u16 u32 u64 u128 f32 f64 char str string
- bytes byte_buf option unit unit_struct newtype_struct seq tuple
- tuple_struct map struct identifier ignored_any
- }
-}
-
-impl<'de, A> de::EnumAccess<'de> for MapAccessDeserializer<A>
-where
- A: de::MapAccess<'de>,
-{
- type Error = A::Error;
- type Variant = private::MapAsEnum<A>;
-
- fn variant_seed<T>(mut self, seed: T) -> Result<(T::Value, Self::Variant), Self::Error>
- where
- T: de::DeserializeSeed<'de>,
- {
- match tri!(self.map.next_key_seed(seed)) {
- Some(key) => Ok((key, private::map_as_enum(self.map))),
- None => Err(de::Error::invalid_type(de::Unexpected::Map, &"enum")),
- }
- }
-}
-
-////////////////////////////////////////////////////////////////////////////////
-
-/// A deserializer holding an `EnumAccess`.
-#[derive(Clone, Debug)]
-pub struct EnumAccessDeserializer<A> {
- access: A,
-}
-
-impl<A> EnumAccessDeserializer<A> {
- /// Construct a new `EnumAccessDeserializer<A>`.
- pub fn new(access: A) -> Self {
- EnumAccessDeserializer { access }
- }
-}
-
-impl<'de, A> de::Deserializer<'de> for EnumAccessDeserializer<A>
-where
- A: de::EnumAccess<'de>,
-{
- type Error = A::Error;
-
- fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Self::Error>
- where
- V: de::Visitor<'de>,
- {
- visitor.visit_enum(self.access)
- }
-
- forward_to_deserialize_any! {
- bool i8 i16 i32 i64 i128 u8 u16 u32 u64 u128 f32 f64 char str string
- bytes byte_buf option unit unit_struct newtype_struct seq tuple
- tuple_struct map struct enum identifier ignored_any
- }
-}
-
-////////////////////////////////////////////////////////////////////////////////
-
-mod private {
- use crate::lib::*;
-
- use crate::de::{
- self, DeserializeSeed, Deserializer, MapAccess, Unexpected, VariantAccess, Visitor,
- };
-
- pub struct UnitOnly<E> {
- marker: PhantomData<E>,
- }
-
- pub fn unit_only<T, E>(t: T) -> (T, UnitOnly<E>) {
- (
- t,
- UnitOnly {
- marker: PhantomData,
- },
- )
- }
-
- impl<'de, E> de::VariantAccess<'de> for UnitOnly<E>
- where
- E: de::Error,
- {
- type Error = E;
-
- fn unit_variant(self) -> Result<(), Self::Error> {
- Ok(())
- }
-
- fn newtype_variant_seed<T>(self, _seed: T) -> Result<T::Value, Self::Error>
- where
- T: de::DeserializeSeed<'de>,
- {
- Err(de::Error::invalid_type(
- Unexpected::UnitVariant,
- &"newtype variant",
- ))
- }
-
- fn tuple_variant<V>(self, _len: usize, _visitor: V) -> Result<V::Value, Self::Error>
- where
- V: de::Visitor<'de>,
- {
- Err(de::Error::invalid_type(
- Unexpected::UnitVariant,
- &"tuple variant",
- ))
- }
-
- fn struct_variant<V>(
- self,
- _fields: &'static [&'static str],
- _visitor: V,
- ) -> Result<V::Value, Self::Error>
- where
- V: de::Visitor<'de>,
- {
- Err(de::Error::invalid_type(
- Unexpected::UnitVariant,
- &"struct variant",
- ))
- }
- }
-
- pub struct MapAsEnum<A> {
- map: A,
- }
-
- pub fn map_as_enum<A>(map: A) -> MapAsEnum<A> {
- MapAsEnum { map }
- }
-
- impl<'de, A> VariantAccess<'de> for MapAsEnum<A>
- where
- A: MapAccess<'de>,
- {
- type Error = A::Error;
-
- fn unit_variant(mut self) -> Result<(), Self::Error> {
- self.map.next_value()
- }
-
- fn newtype_variant_seed<T>(mut self, seed: T) -> Result<T::Value, Self::Error>
- where
- T: DeserializeSeed<'de>,
- {
- self.map.next_value_seed(seed)
- }
-
- fn tuple_variant<V>(mut self, len: usize, visitor: V) -> Result<V::Value, Self::Error>
- where
- V: Visitor<'de>,
- {
- self.map.next_value_seed(SeedTupleVariant { len, visitor })
- }
-
- fn struct_variant<V>(
- mut self,
- _fields: &'static [&'static str],
- visitor: V,
- ) -> Result<V::Value, Self::Error>
- where
- V: Visitor<'de>,
- {
- self.map.next_value_seed(SeedStructVariant { visitor })
- }
- }
-
- struct SeedTupleVariant<V> {
- len: usize,
- visitor: V,
- }
-
- impl<'de, V> DeserializeSeed<'de> for SeedTupleVariant<V>
- where
- V: Visitor<'de>,
- {
- type Value = V::Value;
-
- fn deserialize<D>(self, deserializer: D) -> Result<Self::Value, D::Error>
- where
- D: Deserializer<'de>,
- {
- deserializer.deserialize_tuple(self.len, self.visitor)
- }
- }
-
- struct SeedStructVariant<V> {
- visitor: V,
- }
-
- impl<'de, V> DeserializeSeed<'de> for SeedStructVariant<V>
- where
- V: Visitor<'de>,
- {
- type Value = V::Value;
-
- fn deserialize<D>(self, deserializer: D) -> Result<Self::Value, D::Error>
- where
- D: Deserializer<'de>,
- {
- deserializer.deserialize_map(self.visitor)
- }
- }
-
- /// Avoid having to restate the generic types on `MapDeserializer`. The
- /// `Iterator::Item` contains enough information to figure out K and V.
- pub trait Pair {
- type First;
- type Second;
- fn split(self) -> (Self::First, Self::Second);
- }
-
- impl<A, B> Pair for (A, B) {
- type First = A;
- type Second = B;
- fn split(self) -> (A, B) {
- self
- }
- }
-
- pub type First<T> = <T as Pair>::First;
- pub type Second<T> = <T as Pair>::Second;
-}
Copyright © 2024 Valentin A. Popov. All Rights Reverse Engineered.