From 7d4528a7e3db144aa75041b312a14c88b0445517 Mon Sep 17 00:00:00 2001 From: David Tolnay Date: Sat, 13 Aug 2022 14:35:56 -0700 Subject: [PATCH] Add serde_yaml::with::singleton_map_recursive --- src/with.rs | 1280 +++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 1280 insertions(+) diff --git a/src/with.rs b/src/with.rs index 0585f1c0..26880cfc 100644 --- a/src/with.rs +++ b/src/with.rs @@ -826,3 +826,1283 @@ pub mod singleton_map { } } } + +/// Apply [`singleton_map`] to *all* enums contained within the data structure. +/// +/// # Example +/// +/// ``` +/// # use serde_derive::{Deserialize, Serialize}; +/// use serde::{Deserialize, Serialize}; +/// +/// #[derive(Serialize, Deserialize, PartialEq, Debug)] +/// enum Enum { +/// Int(i32), +/// } +/// +/// #[derive(Serialize, Deserialize, PartialEq, Debug)] +/// struct Inner { +/// a: Enum, +/// bs: Vec, +/// } +/// +/// #[derive(Serialize, Deserialize, PartialEq, Debug)] +/// struct Outer { +/// tagged_style: Inner, +/// +/// #[serde(with = "serde_yaml::with::singleton_map_recursive")] +/// singleton_map_style: Inner, +/// } +/// +/// fn main() { +/// let object = Outer { +/// tagged_style: Inner { +/// a: Enum::Int(0), +/// bs: vec![Enum::Int(1)], +/// }, +/// singleton_map_style: Inner { +/// a: Enum::Int(2), +/// bs: vec![Enum::Int(3)], +/// }, +/// }; +/// +/// let yaml = serde_yaml::to_string(&object).unwrap(); +/// print!("{}", yaml); +/// +/// let deserialized: Outer = serde_yaml::from_str(&yaml).unwrap(); +/// assert_eq!(object, deserialized); +/// } +/// ``` +/// +/// The serialized output is: +/// +/// ```yaml +/// tagged_style: +/// a: !Int 0 +/// bs: +/// - !Int 1 +/// singleton_map_style: +/// a: +/// Int: 2 +/// bs: +/// - Int: 3 +/// ``` +/// +/// This module can also be used for the top-level serializer or deserializer +/// call, without `serde(with = …)`, as follows. +/// +/// ``` +/// # use serde_derive::{Deserialize, Serialize}; +/// # use serde::{Deserialize, Serialize}; +/// # +/// # #[derive(Serialize, Deserialize, PartialEq, Debug)] +/// # enum Enum { +/// # Int(i32), +/// # } +/// # +/// # #[derive(Serialize, Deserialize, PartialEq, Debug)] +/// # struct Inner { +/// # a: Enum, +/// # bs: Vec, +/// # } +/// # +/// use std::io::{self, Write}; +/// +/// fn main() { +/// let object = Inner { +/// a: Enum::Int(0), +/// bs: vec![Enum::Int(1)], +/// }; +/// +/// let mut buf = Vec::new(); +/// let mut serializer = serde_yaml::Serializer::new(&mut buf); +/// serde_yaml::with::singleton_map_recursive::serialize(&object, &mut serializer).unwrap(); +/// io::stdout().write_all(&buf).unwrap(); +/// +/// let deserializer = serde_yaml::Deserializer::from_slice(&buf); +/// let deserialized: Inner = serde_yaml::with::singleton_map_recursive::deserialize(deserializer).unwrap(); +/// assert_eq!(object, deserialized); +/// } +/// ``` +pub mod singleton_map_recursive { + use crate::value::{Mapping, Sequence, Value}; + use serde::de::{ + self, Deserialize, DeserializeSeed, Deserializer, EnumAccess, IgnoredAny, MapAccess, + SeqAccess, Unexpected, VariantAccess, Visitor, + }; + use serde::ser::{ + self, Serialize, SerializeMap, SerializeSeq, SerializeStruct, SerializeStructVariant, + SerializeTuple, SerializeTupleStruct, SerializeTupleVariant, Serializer, + }; + use std::fmt::{self, Display}; + + #[allow(missing_docs)] + pub fn serialize(value: &T, serializer: S) -> Result + where + T: Serialize, + S: Serializer, + { + value.serialize(SingletonMapRecursive { + delegate: serializer, + }) + } + + #[allow(missing_docs)] + pub fn deserialize<'de, T, D>(deserializer: D) -> Result + where + T: Deserialize<'de>, + D: Deserializer<'de>, + { + T::deserialize(SingletonMapRecursive { + delegate: deserializer, + }) + } + + struct SingletonMapRecursive { + delegate: D, + } + + impl Serialize for SingletonMapRecursive + where + D: Serialize, + { + fn serialize(&self, serializer: S) -> Result + where + S: Serializer, + { + self.delegate.serialize(SingletonMapRecursive { + delegate: serializer, + }) + } + } + + impl Serializer for SingletonMapRecursive + where + D: Serializer, + { + type Ok = D::Ok; + type Error = D::Error; + + type SerializeSeq = SingletonMapRecursive; + type SerializeTuple = SingletonMapRecursive; + type SerializeTupleStruct = SingletonMapRecursive; + type SerializeTupleVariant = SerializeTupleVariantAsSingletonMapRecursive; + type SerializeMap = SingletonMapRecursive; + type SerializeStruct = SingletonMapRecursive; + type SerializeStructVariant = + SerializeStructVariantAsSingletonMapRecursive; + + fn serialize_bool(self, v: bool) -> Result { + self.delegate.serialize_bool(v) + } + + fn serialize_i8(self, v: i8) -> Result { + self.delegate.serialize_i8(v) + } + + fn serialize_i16(self, v: i16) -> Result { + self.delegate.serialize_i16(v) + } + + fn serialize_i32(self, v: i32) -> Result { + self.delegate.serialize_i32(v) + } + + fn serialize_i64(self, v: i64) -> Result { + self.delegate.serialize_i64(v) + } + + fn serialize_i128(self, v: i128) -> Result { + self.delegate.serialize_i128(v) + } + + fn serialize_u8(self, v: u8) -> Result { + self.delegate.serialize_u8(v) + } + + fn serialize_u16(self, v: u16) -> Result { + self.delegate.serialize_u16(v) + } + + fn serialize_u32(self, v: u32) -> Result { + self.delegate.serialize_u32(v) + } + + fn serialize_u64(self, v: u64) -> Result { + self.delegate.serialize_u64(v) + } + + fn serialize_u128(self, v: u128) -> Result { + self.delegate.serialize_u128(v) + } + + fn serialize_f32(self, v: f32) -> Result { + self.delegate.serialize_f32(v) + } + + fn serialize_f64(self, v: f64) -> Result { + self.delegate.serialize_f64(v) + } + + fn serialize_char(self, v: char) -> Result { + self.delegate.serialize_char(v) + } + + fn serialize_str(self, v: &str) -> Result { + self.delegate.serialize_str(v) + } + + fn serialize_bytes(self, v: &[u8]) -> Result { + self.delegate.serialize_bytes(v) + } + + fn serialize_unit(self) -> Result { + self.delegate.serialize_unit() + } + + fn serialize_unit_struct(self, name: &'static str) -> Result { + self.delegate.serialize_unit_struct(name) + } + + fn serialize_unit_variant( + self, + name: &'static str, + variant_index: u32, + variant: &'static str, + ) -> Result { + self.delegate + .serialize_unit_variant(name, variant_index, variant) + } + + fn serialize_newtype_struct( + self, + name: &'static str, + value: &T, + ) -> Result + where + T: ?Sized + Serialize, + { + self.delegate + .serialize_newtype_struct(name, &SingletonMapRecursive { delegate: value }) + } + + fn serialize_newtype_variant( + self, + _name: &'static str, + _variant_index: u32, + variant: &'static str, + value: &T, + ) -> Result + where + T: ?Sized + Serialize, + { + let mut map = self.delegate.serialize_map(Some(1))?; + map.serialize_entry(variant, &SingletonMapRecursive { delegate: value })?; + map.end() + } + + fn serialize_none(self) -> Result { + self.delegate.serialize_none() + } + + fn serialize_some(self, value: &V) -> Result + where + V: ?Sized + Serialize, + { + self.delegate + .serialize_some(&SingletonMapRecursive { delegate: value }) + } + + fn serialize_seq(self, len: Option) -> Result { + Ok(SingletonMapRecursive { + delegate: self.delegate.serialize_seq(len)?, + }) + } + + fn serialize_tuple(self, len: usize) -> Result { + Ok(SingletonMapRecursive { + delegate: self.delegate.serialize_tuple(len)?, + }) + } + + fn serialize_tuple_struct( + self, + name: &'static str, + len: usize, + ) -> Result { + Ok(SingletonMapRecursive { + delegate: self.delegate.serialize_tuple_struct(name, len)?, + }) + } + + fn serialize_tuple_variant( + self, + _name: &'static str, + _variant_index: u32, + variant: &'static str, + len: usize, + ) -> Result { + let mut map = self.delegate.serialize_map(Some(1))?; + map.serialize_key(variant)?; + let sequence = Sequence::with_capacity(len); + Ok(SerializeTupleVariantAsSingletonMapRecursive { map, sequence }) + } + + fn serialize_map(self, len: Option) -> Result { + Ok(SingletonMapRecursive { + delegate: self.delegate.serialize_map(len)?, + }) + } + + fn serialize_struct( + self, + name: &'static str, + len: usize, + ) -> Result { + Ok(SingletonMapRecursive { + delegate: self.delegate.serialize_struct(name, len)?, + }) + } + + fn serialize_struct_variant( + self, + _name: &'static str, + _variant_index: u32, + variant: &'static str, + len: usize, + ) -> Result { + let mut map = self.delegate.serialize_map(Some(1))?; + map.serialize_key(variant)?; + let mapping = Mapping::with_capacity(len); + Ok(SerializeStructVariantAsSingletonMapRecursive { map, mapping }) + } + + fn collect_str(self, value: &T) -> Result + where + T: ?Sized + Display, + { + self.delegate.collect_str(value) + } + } + + impl SerializeSeq for SingletonMapRecursive + where + D: SerializeSeq, + { + type Ok = D::Ok; + type Error = D::Error; + + fn serialize_element(&mut self, elem: &T) -> Result<(), Self::Error> + where + T: ?Sized + ser::Serialize, + { + self.delegate + .serialize_element(&SingletonMapRecursive { delegate: elem }) + } + + fn end(self) -> Result { + self.delegate.end() + } + } + + impl SerializeTuple for SingletonMapRecursive + where + D: SerializeTuple, + { + type Ok = D::Ok; + type Error = D::Error; + + fn serialize_element(&mut self, elem: &T) -> Result<(), Self::Error> + where + T: ?Sized + ser::Serialize, + { + self.delegate + .serialize_element(&SingletonMapRecursive { delegate: elem }) + } + + fn end(self) -> Result { + self.delegate.end() + } + } + + impl SerializeTupleStruct for SingletonMapRecursive + where + D: SerializeTupleStruct, + { + type Ok = D::Ok; + type Error = D::Error; + + fn serialize_field(&mut self, value: &V) -> Result<(), Self::Error> + where + V: ?Sized + ser::Serialize, + { + self.delegate + .serialize_field(&SingletonMapRecursive { delegate: value }) + } + + fn end(self) -> Result { + self.delegate.end() + } + } + + struct SerializeTupleVariantAsSingletonMapRecursive { + map: M, + sequence: Sequence, + } + + impl SerializeTupleVariant for SerializeTupleVariantAsSingletonMapRecursive + where + M: SerializeMap, + { + type Ok = M::Ok; + type Error = M::Error; + + fn serialize_field(&mut self, field: &T) -> Result<(), Self::Error> + where + T: ?Sized + Serialize, + { + let value = field + .serialize(SingletonMapRecursive { + delegate: crate::value::Serializer, + }) + .map_err(ser::Error::custom)?; + self.sequence.push(value); + Ok(()) + } + + fn end(mut self) -> Result { + self.map.serialize_value(&self.sequence)?; + self.map.end() + } + } + + impl SerializeMap for SingletonMapRecursive + where + D: SerializeMap, + { + type Ok = D::Ok; + type Error = D::Error; + + fn serialize_key(&mut self, key: &T) -> Result<(), Self::Error> + where + T: ?Sized + ser::Serialize, + { + self.delegate + .serialize_key(&SingletonMapRecursive { delegate: key }) + } + + fn serialize_value(&mut self, value: &T) -> Result<(), Self::Error> + where + T: ?Sized + ser::Serialize, + { + self.delegate + .serialize_value(&SingletonMapRecursive { delegate: value }) + } + + fn serialize_entry(&mut self, key: &K, value: &V) -> Result<(), Self::Error> + where + K: ?Sized + ser::Serialize, + V: ?Sized + ser::Serialize, + { + self.delegate.serialize_entry( + &SingletonMapRecursive { delegate: key }, + &SingletonMapRecursive { delegate: value }, + ) + } + + fn end(self) -> Result { + self.delegate.end() + } + } + + impl SerializeStruct for SingletonMapRecursive + where + D: SerializeStruct, + { + type Ok = D::Ok; + type Error = D::Error; + + fn serialize_field(&mut self, key: &'static str, value: &V) -> Result<(), Self::Error> + where + V: ?Sized + ser::Serialize, + { + self.delegate + .serialize_field(key, &SingletonMapRecursive { delegate: value }) + } + + fn end(self) -> Result { + self.delegate.end() + } + } + + struct SerializeStructVariantAsSingletonMapRecursive { + map: M, + mapping: Mapping, + } + + impl SerializeStructVariant for SerializeStructVariantAsSingletonMapRecursive + where + M: SerializeMap, + { + type Ok = M::Ok; + type Error = M::Error; + + fn serialize_field(&mut self, name: &'static str, field: &T) -> Result<(), Self::Error> + where + T: ?Sized + Serialize, + { + let value = field + .serialize(SingletonMapRecursive { + delegate: crate::value::Serializer, + }) + .map_err(ser::Error::custom)?; + self.mapping.insert(Value::String(name.to_owned()), value); + Ok(()) + } + + fn end(mut self) -> Result { + self.map.serialize_value(&self.mapping)?; + self.map.end() + } + } + + impl<'de, D> Deserializer<'de> for SingletonMapRecursive + where + D: Deserializer<'de>, + { + type Error = D::Error; + + fn deserialize_any(self, visitor: V) -> Result + where + V: Visitor<'de>, + { + self.delegate + .deserialize_any(SingletonMapRecursive { delegate: visitor }) + } + + fn deserialize_bool(self, visitor: V) -> Result + where + V: Visitor<'de>, + { + self.delegate + .deserialize_bool(SingletonMapRecursive { delegate: visitor }) + } + + fn deserialize_i8(self, visitor: V) -> Result + where + V: Visitor<'de>, + { + self.delegate + .deserialize_i8(SingletonMapRecursive { delegate: visitor }) + } + + fn deserialize_i16(self, visitor: V) -> Result + where + V: Visitor<'de>, + { + self.delegate + .deserialize_i16(SingletonMapRecursive { delegate: visitor }) + } + + fn deserialize_i32(self, visitor: V) -> Result + where + V: Visitor<'de>, + { + self.delegate + .deserialize_i32(SingletonMapRecursive { delegate: visitor }) + } + + fn deserialize_i64(self, visitor: V) -> Result + where + V: Visitor<'de>, + { + self.delegate + .deserialize_i64(SingletonMapRecursive { delegate: visitor }) + } + + fn deserialize_i128(self, visitor: V) -> Result + where + V: Visitor<'de>, + { + self.delegate + .deserialize_i128(SingletonMapRecursive { delegate: visitor }) + } + + fn deserialize_u8(self, visitor: V) -> Result + where + V: Visitor<'de>, + { + self.delegate + .deserialize_u8(SingletonMapRecursive { delegate: visitor }) + } + + fn deserialize_u16(self, visitor: V) -> Result + where + V: Visitor<'de>, + { + self.delegate + .deserialize_u16(SingletonMapRecursive { delegate: visitor }) + } + + fn deserialize_u32(self, visitor: V) -> Result + where + V: Visitor<'de>, + { + self.delegate + .deserialize_u32(SingletonMapRecursive { delegate: visitor }) + } + + fn deserialize_u64(self, visitor: V) -> Result + where + V: Visitor<'de>, + { + self.delegate + .deserialize_u64(SingletonMapRecursive { delegate: visitor }) + } + + fn deserialize_u128(self, visitor: V) -> Result + where + V: Visitor<'de>, + { + self.delegate + .deserialize_u128(SingletonMapRecursive { delegate: visitor }) + } + + fn deserialize_f32(self, visitor: V) -> Result + where + V: Visitor<'de>, + { + self.delegate + .deserialize_f32(SingletonMapRecursive { delegate: visitor }) + } + + fn deserialize_f64(self, visitor: V) -> Result + where + V: Visitor<'de>, + { + self.delegate + .deserialize_f64(SingletonMapRecursive { delegate: visitor }) + } + + fn deserialize_char(self, visitor: V) -> Result + where + V: Visitor<'de>, + { + self.delegate + .deserialize_char(SingletonMapRecursive { delegate: visitor }) + } + + fn deserialize_str(self, visitor: V) -> Result + where + V: Visitor<'de>, + { + self.delegate + .deserialize_str(SingletonMapRecursive { delegate: visitor }) + } + + fn deserialize_string(self, visitor: V) -> Result + where + V: Visitor<'de>, + { + self.delegate + .deserialize_string(SingletonMapRecursive { delegate: visitor }) + } + + fn deserialize_bytes(self, visitor: V) -> Result + where + V: Visitor<'de>, + { + self.delegate + .deserialize_bytes(SingletonMapRecursive { delegate: visitor }) + } + + fn deserialize_byte_buf(self, visitor: V) -> Result + where + V: Visitor<'de>, + { + self.delegate + .deserialize_byte_buf(SingletonMapRecursive { delegate: visitor }) + } + + fn deserialize_option(self, visitor: V) -> Result + where + V: Visitor<'de>, + { + self.delegate + .deserialize_option(SingletonMapRecursiveAsEnum { + name: "", + delegate: visitor, + }) + } + + fn deserialize_unit(self, visitor: V) -> Result + where + V: Visitor<'de>, + { + self.delegate + .deserialize_unit(SingletonMapRecursive { delegate: visitor }) + } + + fn deserialize_unit_struct( + self, + name: &'static str, + visitor: V, + ) -> Result + where + V: Visitor<'de>, + { + self.delegate + .deserialize_unit_struct(name, SingletonMapRecursive { delegate: visitor }) + } + + fn deserialize_newtype_struct( + self, + name: &'static str, + visitor: V, + ) -> Result + where + V: Visitor<'de>, + { + self.delegate + .deserialize_newtype_struct(name, SingletonMapRecursive { delegate: visitor }) + } + + fn deserialize_seq(self, visitor: V) -> Result + where + V: Visitor<'de>, + { + self.delegate + .deserialize_seq(SingletonMapRecursive { delegate: visitor }) + } + + fn deserialize_tuple(self, len: usize, visitor: V) -> Result + where + V: Visitor<'de>, + { + self.delegate + .deserialize_tuple(len, SingletonMapRecursive { delegate: visitor }) + } + + fn deserialize_tuple_struct( + self, + name: &'static str, + len: usize, + visitor: V, + ) -> Result + where + V: Visitor<'de>, + { + self.delegate.deserialize_tuple_struct( + name, + len, + SingletonMapRecursive { delegate: visitor }, + ) + } + + fn deserialize_map(self, visitor: V) -> Result + where + V: Visitor<'de>, + { + self.delegate + .deserialize_map(SingletonMapRecursive { delegate: visitor }) + } + + fn deserialize_struct( + self, + name: &'static str, + fields: &'static [&'static str], + visitor: V, + ) -> Result + where + V: Visitor<'de>, + { + self.delegate.deserialize_struct( + name, + fields, + SingletonMapRecursive { delegate: visitor }, + ) + } + + fn deserialize_enum( + self, + name: &'static str, + _variants: &'static [&'static str], + visitor: V, + ) -> Result + where + V: Visitor<'de>, + { + self.delegate.deserialize_any(SingletonMapRecursiveAsEnum { + name, + delegate: visitor, + }) + } + + fn deserialize_identifier(self, visitor: V) -> Result + where + V: Visitor<'de>, + { + self.delegate + .deserialize_identifier(SingletonMapRecursive { delegate: visitor }) + } + + fn deserialize_ignored_any(self, visitor: V) -> Result + where + V: Visitor<'de>, + { + self.delegate + .deserialize_ignored_any(SingletonMapRecursive { delegate: visitor }) + } + } + + impl<'de, V> Visitor<'de> for SingletonMapRecursive + where + V: Visitor<'de>, + { + type Value = V::Value; + + fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result { + self.delegate.expecting(formatter) + } + + fn visit_bool(self, v: bool) -> Result + where + E: de::Error, + { + self.delegate.visit_bool(v) + } + + fn visit_i8(self, v: i8) -> Result + where + E: de::Error, + { + self.delegate.visit_i8(v) + } + + fn visit_i16(self, v: i16) -> Result + where + E: de::Error, + { + self.delegate.visit_i16(v) + } + + fn visit_i32(self, v: i32) -> Result + where + E: de::Error, + { + self.delegate.visit_i32(v) + } + + fn visit_i64(self, v: i64) -> Result + where + E: de::Error, + { + self.delegate.visit_i64(v) + } + + fn visit_i128(self, v: i128) -> Result + where + E: de::Error, + { + self.delegate.visit_i128(v) + } + + fn visit_u8(self, v: u8) -> Result + where + E: de::Error, + { + self.delegate.visit_u8(v) + } + + fn visit_u16(self, v: u16) -> Result + where + E: de::Error, + { + self.delegate.visit_u16(v) + } + + fn visit_u32(self, v: u32) -> Result + where + E: de::Error, + { + self.delegate.visit_u32(v) + } + + fn visit_u64(self, v: u64) -> Result + where + E: de::Error, + { + self.delegate.visit_u64(v) + } + + fn visit_u128(self, v: u128) -> Result + where + E: de::Error, + { + self.delegate.visit_u128(v) + } + + fn visit_f32(self, v: f32) -> Result + where + E: de::Error, + { + self.delegate.visit_f32(v) + } + + fn visit_f64(self, v: f64) -> Result + where + E: de::Error, + { + self.delegate.visit_f64(v) + } + + fn visit_char(self, v: char) -> Result + where + E: de::Error, + { + self.delegate.visit_char(v) + } + + fn visit_str(self, v: &str) -> Result + where + E: de::Error, + { + self.delegate.visit_str(v) + } + + fn visit_borrowed_str(self, v: &'de str) -> Result + where + E: de::Error, + { + self.delegate.visit_borrowed_str(v) + } + + fn visit_string(self, v: String) -> Result + where + E: de::Error, + { + self.delegate.visit_string(v) + } + + fn visit_bytes(self, v: &[u8]) -> Result + where + E: de::Error, + { + self.delegate.visit_bytes(v) + } + + fn visit_borrowed_bytes(self, v: &'de [u8]) -> Result + where + E: de::Error, + { + self.delegate.visit_borrowed_bytes(v) + } + + fn visit_byte_buf(self, v: Vec) -> Result + where + E: de::Error, + { + self.delegate.visit_byte_buf(v) + } + + fn visit_none(self) -> Result + where + E: de::Error, + { + self.delegate.visit_none() + } + + fn visit_some(self, deserializer: D) -> Result + where + D: Deserializer<'de>, + { + self.delegate.visit_some(SingletonMapRecursive { + delegate: deserializer, + }) + } + + fn visit_unit(self) -> Result + where + E: de::Error, + { + self.delegate.visit_unit() + } + + fn visit_newtype_struct(self, deserializer: D) -> Result + where + D: Deserializer<'de>, + { + self.delegate.visit_newtype_struct(SingletonMapRecursive { + delegate: deserializer, + }) + } + + fn visit_seq(self, seq: A) -> Result + where + A: SeqAccess<'de>, + { + self.delegate + .visit_seq(SingletonMapRecursive { delegate: seq }) + } + + fn visit_map(self, map: A) -> Result + where + A: MapAccess<'de>, + { + self.delegate + .visit_map(SingletonMapRecursive { delegate: map }) + } + } + + impl<'de, T> DeserializeSeed<'de> for SingletonMapRecursive + where + T: DeserializeSeed<'de>, + { + type Value = T::Value; + + fn deserialize(self, deserializer: D) -> Result + where + D: Deserializer<'de>, + { + self.delegate.deserialize(SingletonMapRecursive { + delegate: deserializer, + }) + } + } + + impl<'de, S> SeqAccess<'de> for SingletonMapRecursive + where + S: SeqAccess<'de>, + { + type Error = S::Error; + + fn next_element_seed(&mut self, seed: T) -> Result, Self::Error> + where + T: DeserializeSeed<'de>, + { + self.delegate + .next_element_seed(SingletonMapRecursive { delegate: seed }) + } + } + + impl<'de, M> MapAccess<'de> for SingletonMapRecursive + where + M: MapAccess<'de>, + { + type Error = M::Error; + + fn next_key_seed(&mut self, seed: K) -> Result, Self::Error> + where + K: DeserializeSeed<'de>, + { + self.delegate + .next_key_seed(SingletonMapRecursive { delegate: seed }) + } + + fn next_value_seed(&mut self, seed: V) -> Result + where + V: DeserializeSeed<'de>, + { + self.delegate + .next_value_seed(SingletonMapRecursive { delegate: seed }) + } + } + + struct SingletonMapRecursiveAsEnum { + name: &'static str, + delegate: D, + } + + impl<'de, V> Visitor<'de> for SingletonMapRecursiveAsEnum + where + V: Visitor<'de>, + { + type Value = V::Value; + + fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result { + self.delegate.expecting(formatter) + } + + fn visit_str(self, v: &str) -> Result + where + E: de::Error, + { + self.delegate.visit_enum(de::value::StrDeserializer::new(v)) + } + + fn visit_borrowed_str(self, v: &'de str) -> Result + where + E: de::Error, + { + self.delegate + .visit_enum(de::value::BorrowedStrDeserializer::new(v)) + } + + fn visit_string(self, v: String) -> Result + where + E: de::Error, + { + self.delegate + .visit_enum(de::value::StringDeserializer::new(v)) + } + + fn visit_none(self) -> Result + where + E: de::Error, + { + self.delegate.visit_none() + } + + fn visit_some(self, deserializer: D) -> Result + where + D: Deserializer<'de>, + { + self.delegate.visit_some(SingletonMapRecursive { + delegate: deserializer, + }) + } + + fn visit_unit(self) -> Result + where + E: de::Error, + { + self.delegate.visit_unit() + } + + fn visit_map(self, map: A) -> Result + where + A: MapAccess<'de>, + { + self.delegate.visit_enum(SingletonMapRecursiveAsEnum { + name: self.name, + delegate: map, + }) + } + } + + impl<'de, D> EnumAccess<'de> for SingletonMapRecursiveAsEnum + where + D: MapAccess<'de>, + { + type Error = D::Error; + type Variant = Self; + + fn variant_seed(mut self, seed: V) -> Result<(V::Value, Self::Variant), Self::Error> + where + V: DeserializeSeed<'de>, + { + match self.delegate.next_key_seed(seed)? { + Some(value) => Ok((value, self)), + None => Err(de::Error::invalid_value( + Unexpected::Map, + &"map with a single key", + )), + } + } + } + + impl<'de, D> VariantAccess<'de> for SingletonMapRecursiveAsEnum + where + D: MapAccess<'de>, + { + type Error = D::Error; + + fn unit_variant(self) -> Result<(), Self::Error> { + Err(de::Error::invalid_type(Unexpected::Map, &"unit variant")) + } + + fn newtype_variant_seed(mut self, seed: T) -> Result + where + T: DeserializeSeed<'de>, + { + let value = self + .delegate + .next_value_seed(SingletonMapRecursive { delegate: seed })?; + match self.delegate.next_key()? { + None => Ok(value), + Some(IgnoredAny) => Err(de::Error::invalid_value( + Unexpected::Map, + &"map with a single key", + )), + } + } + + fn tuple_variant(mut self, len: usize, visitor: V) -> Result + where + V: Visitor<'de>, + { + let value = self.delegate.next_value_seed(TupleVariantSeed { + len, + visitor: SingletonMapRecursive { delegate: visitor }, + })?; + match self.delegate.next_key()? { + None => Ok(value), + Some(IgnoredAny) => Err(de::Error::invalid_value( + Unexpected::Map, + &"map with a single key", + )), + } + } + + fn struct_variant( + mut self, + fields: &'static [&'static str], + visitor: V, + ) -> Result + where + V: Visitor<'de>, + { + let value = self.delegate.next_value_seed(StructVariantSeed { + name: self.name, + fields, + visitor: SingletonMapRecursive { delegate: visitor }, + })?; + match self.delegate.next_key()? { + None => Ok(value), + Some(IgnoredAny) => Err(de::Error::invalid_value( + Unexpected::Map, + &"map with a single key", + )), + } + } + } + + struct TupleVariantSeed { + len: usize, + visitor: V, + } + + impl<'de, V> DeserializeSeed<'de> for TupleVariantSeed + where + V: Visitor<'de>, + { + type Value = V::Value; + + fn deserialize(self, deserializer: D) -> Result + where + D: Deserializer<'de>, + { + deserializer.deserialize_tuple(self.len, self.visitor) + } + } + + struct StructVariantSeed { + name: &'static str, + fields: &'static [&'static str], + visitor: V, + } + + impl<'de, V> DeserializeSeed<'de> for StructVariantSeed + where + V: Visitor<'de>, + { + type Value = V::Value; + + fn deserialize(self, deserializer: D) -> Result + where + D: Deserializer<'de>, + { + deserializer.deserialize_struct(self.name, self.fields, self.visitor) + } + } +}