Source code
Revision control
Copy as Markdown
Other Tools
use crate::{
content::{
de::{Content as DeContent, ContentDeserializer},
ser::{Content as SerContent, ContentSerializer},
},
prelude::*,
};
/// Convert `Vec` elements into key-value map entries
///
/// This maps a single struct/tuple/etc. to a map entry.
/// The map key is converted to a struct field.
/// The other values will be mapped to the map value.
///
/// The conversion supports structs, tuple structs, tuples, maps, and sequences.
/// Structs need a field that is named `$key$` to be used as the map key.
/// This can be done with the `#[serde(rename = "$key$")]` attribute.
/// Maps similarly need a map-key that is named `$key$`.
/// For tuples, tuple structs, and sequences the first element is used as the map key.
///
/// # Examples
///
/// ## Struct with String key in JSON
///
/// ```rust
/// # #[cfg(feature = "macros")] {
/// # use serde::{Deserialize, Serialize};
/// use serde_with::{serde_as, KeyValueMap};
///
/// # #[derive(Debug, Clone, PartialEq, Eq)]
/// #[derive(Serialize, Deserialize)]
/// struct SimpleStruct {
/// b: bool,
/// // The field named `$key$` will become the map key
/// #[serde(rename = "$key$")]
/// id: String,
/// i: i32,
/// }
///
/// #[serde_as]
/// # #[derive(Debug, Clone, PartialEq, Eq)]
/// #[derive(Serialize, Deserialize)]
/// struct KVMap(
/// #[serde_as(as = "KeyValueMap<_>")]
/// Vec<SimpleStruct>,
/// );
///
/// // ---
///
/// // This will serialize this list of values
/// let values = KVMap(vec![
/// SimpleStruct {
/// b: false,
/// id: "id-0000".to_string(),
/// i: 123,
/// },
/// SimpleStruct {
/// b: true,
/// id: "id-0001".to_string(),
/// i: 555,
/// },
/// SimpleStruct {
/// b: false,
/// id: "id-0002".to_string(),
/// i: 987,
/// },
/// ]);
///
/// // into this JSON map
/// let expected =
/// r#"{
/// "id-0000": {
/// "b": false,
/// "i": 123
/// },
/// "id-0001": {
/// "b": true,
/// "i": 555
/// },
/// "id-0002": {
/// "b": false,
/// "i": 987
/// }
/// }"#;
///
/// // Both serialization and deserialization work flawlessly.
/// let serialized = serde_json::to_string_pretty(&values).unwrap();
/// assert_eq!(expected, serialized);
/// let deserialized: KVMap = serde_json::from_str(&serialized).unwrap();
/// assert_eq!(values, deserialized);
/// # }
/// ```
///
/// ## Tuple struct with complex key in YAML
///
/// ```rust
/// # #[cfg(feature = "macros")] {
/// # use serde::{Deserialize, Serialize};
/// use serde_with::{serde_as, KeyValueMap};
/// use std::net::IpAddr;
/// # use std::str::FromStr;
///
/// # #[derive(Debug, Clone, PartialEq, Eq)]
/// #[derive(Serialize, Deserialize)]
/// struct TupleStruct (
/// // The first element in a tuple struct, tuple, or sequence becomes the map key
/// (IpAddr, u8),
/// bool,
/// );
///
/// #[serde_as]
/// # #[derive(Debug, Clone, PartialEq, Eq)]
/// #[derive(Serialize, Deserialize)]
/// struct KVMap(
/// #[serde_as(as = "KeyValueMap<_>")]
/// Vec<TupleStruct>,
/// );
///
/// // ---
///
/// // This will serialize this list of values
/// let values = KVMap(vec![
/// TupleStruct(
/// (IpAddr::from_str("127.0.0.1").unwrap(), 8),
/// true
/// ),
/// TupleStruct(
/// (IpAddr::from_str("::1").unwrap(), 128),
/// true
/// ),
/// TupleStruct(
/// (IpAddr::from_str("198.51.100.0").unwrap(), 24),
/// true
/// ),
/// ]);
///
/// // into this YAML
/// let expected =
/// r#"? - 127.0.0.1
/// - 8
/// : - true
/// ? - ::1
/// - 128
/// : - true
/// ? - 198.51.100.0
/// - 24
/// : - true
/// "#;
///
/// // Both serialization and deserialization work flawlessly.
/// let serialized = serde_yaml::to_string(&values).unwrap();
/// assert_eq!(expected, serialized);
/// let deserialized: KVMap = serde_yaml::from_str(&serialized).unwrap();
/// assert_eq!(values, deserialized);
/// # }
/// ```
pub struct KeyValueMap<T>(PhantomData<T>);
impl<T, TAs> SerializeAs<Vec<T>> for KeyValueMap<TAs>
where
TAs: SerializeAs<T>,
{
fn serialize_as<S>(source: &Vec<T>, serializer: S) -> Result<S::Ok, S::Error>
where
S: Serializer,
{
<Vec<TAs>>::serialize_as(source, SeqAsMapSerializer(serializer))
}
}
impl<'de, T, TAs> DeserializeAs<'de, Vec<T>> for KeyValueMap<TAs>
where
TAs: DeserializeAs<'de, T>,
{
fn deserialize_as<D>(deserializer: D) -> Result<Vec<T>, D::Error>
where
D: Deserializer<'de>,
{
struct KeyValueMapVisitor<T, TAs> {
is_human_readable: bool,
phantom: PhantomData<(T, TAs)>,
}
impl<'de, T, TAs> Visitor<'de> for KeyValueMapVisitor<T, TAs>
where
TAs: DeserializeAs<'de, T>,
{
type Value = Vec<T>;
fn expecting(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
write!(formatter, "a map")
}
fn visit_map<A: MapAccess<'de>>(self, map: A) -> Result<Self::Value, A::Error> {
<Vec<TAs>>::deserialize_as(SeqDeserializer {
delegate: map,
is_human_readable: self.is_human_readable,
})
}
}
let is_human_readable = deserializer.is_human_readable();
deserializer.deserialize_map(KeyValueMapVisitor::<T, TAs> {
is_human_readable,
phantom: PhantomData,
})
}
}
// TODO Replace this with a const generic string once adt_const_params is stable.
// This will allow something like this.
// The `"id"` part is the field name, which gets converted to/from the map key.
// #[serde_as(as = r#"KeyValueMap<"id", _>"#)]
// Vec<SimpleStruct>,
static MAP_KEY_IDENTIFIER: &str = "$key$";
/// Convert a sequence to a map during serialization.
///
/// Only `serialize_seq` is implemented and forwarded to `serialize_map` on the inner `Serializer`.
/// The elements are serialized with [`SerializeSeqElement`].
struct SeqAsMapSerializer<S>(S);
impl<S> Serializer for SeqAsMapSerializer<S>
where
S: Serializer,
{
type Ok = S::Ok;
type Error = S::Error;
type SerializeSeq = SerializeSeqElement<S::SerializeMap>;
type SerializeTuple = Impossible<S::Ok, S::Error>;
type SerializeTupleStruct = Impossible<S::Ok, S::Error>;
type SerializeTupleVariant = Impossible<S::Ok, S::Error>;
type SerializeMap = Impossible<S::Ok, S::Error>;
type SerializeStruct = Impossible<S::Ok, S::Error>;
type SerializeStructVariant = Impossible<S::Ok, S::Error>;
fn is_human_readable(&self) -> bool {
self.0.is_human_readable()
}
fn serialize_bool(self, _v: bool) -> Result<Self::Ok, Self::Error> {
Err(SerError::custom("wrong type for KeyValueMap"))
}
fn serialize_i8(self, _v: i8) -> Result<Self::Ok, Self::Error> {
Err(SerError::custom("wrong type for KeyValueMap"))
}
fn serialize_i16(self, _v: i16) -> Result<Self::Ok, Self::Error> {
Err(SerError::custom("wrong type for KeyValueMap"))
}
fn serialize_i32(self, _v: i32) -> Result<Self::Ok, Self::Error> {
Err(SerError::custom("wrong type for KeyValueMap"))
}
fn serialize_i64(self, _v: i64) -> Result<Self::Ok, Self::Error> {
Err(SerError::custom("wrong type for KeyValueMap"))
}
fn serialize_i128(self, _v: i128) -> Result<Self::Ok, Self::Error> {
Err(SerError::custom("wrong type for KeyValueMap"))
}
fn serialize_u8(self, _v: u8) -> Result<Self::Ok, Self::Error> {
Err(SerError::custom("wrong type for KeyValueMap"))
}
fn serialize_u16(self, _v: u16) -> Result<Self::Ok, Self::Error> {
Err(SerError::custom("wrong type for KeyValueMap"))
}
fn serialize_u32(self, _v: u32) -> Result<Self::Ok, Self::Error> {
Err(SerError::custom("wrong type for KeyValueMap"))
}
fn serialize_u64(self, _v: u64) -> Result<Self::Ok, Self::Error> {
Err(SerError::custom("wrong type for KeyValueMap"))
}
fn serialize_u128(self, _v: u128) -> Result<Self::Ok, Self::Error> {
Err(SerError::custom("wrong type for KeyValueMap"))
}
fn serialize_f32(self, _v: f32) -> Result<Self::Ok, Self::Error> {
Err(SerError::custom("wrong type for KeyValueMap"))
}
fn serialize_f64(self, _v: f64) -> Result<Self::Ok, Self::Error> {
Err(SerError::custom("wrong type for KeyValueMap"))
}
fn serialize_char(self, _v: char) -> Result<Self::Ok, Self::Error> {
Err(SerError::custom("wrong type for KeyValueMap"))
}
fn serialize_str(self, _v: &str) -> Result<Self::Ok, Self::Error> {
Err(SerError::custom("wrong type for KeyValueMap"))
}
fn serialize_bytes(self, _v: &[u8]) -> Result<Self::Ok, Self::Error> {
Err(SerError::custom("wrong type for KeyValueMap"))
}
fn serialize_none(self) -> Result<Self::Ok, Self::Error> {
Err(SerError::custom("wrong type for KeyValueMap"))
}
fn serialize_some<T: ?Sized>(self, _value: &T) -> Result<Self::Ok, Self::Error>
where
T: Serialize,
{
Err(SerError::custom("wrong type for KeyValueMap"))
}
fn serialize_unit(self) -> Result<Self::Ok, Self::Error> {
Err(SerError::custom("wrong type for KeyValueMap"))
}
fn serialize_unit_struct(self, _name: &'static str) -> Result<Self::Ok, Self::Error> {
Err(SerError::custom("wrong type for KeyValueMap"))
}
fn serialize_unit_variant(
self,
_name: &'static str,
_variant_index: u32,
_variant: &'static str,
) -> Result<Self::Ok, Self::Error> {
Err(SerError::custom("wrong type for KeyValueMap"))
}
fn serialize_newtype_struct<T: ?Sized>(
self,
_name: &'static str,
_value: &T,
) -> Result<Self::Ok, Self::Error>
where
T: Serialize,
{
Err(SerError::custom("wrong type for KeyValueMap"))
}
fn serialize_newtype_variant<T: ?Sized>(
self,
_name: &'static str,
_variant_index: u32,
_variant: &'static str,
_value: &T,
) -> Result<Self::Ok, Self::Error>
where
T: Serialize,
{
Err(SerError::custom("wrong type for KeyValueMap"))
}
fn serialize_seq(self, len: Option<usize>) -> Result<Self::SerializeSeq, Self::Error> {
let is_human_readable = self.0.is_human_readable();
self.0
.serialize_map(len)
.map(|delegate| SerializeSeqElement {
delegate,
is_human_readable,
})
}
fn serialize_tuple(self, _len: usize) -> Result<Self::SerializeTuple, Self::Error> {
Err(SerError::custom("wrong type for KeyValueMap"))
}
fn serialize_tuple_struct(
self,
_name: &'static str,
_len: usize,
) -> Result<Self::SerializeTupleStruct, Self::Error> {
Err(SerError::custom("wrong type for KeyValueMap"))
}
fn serialize_tuple_variant(
self,
_name: &'static str,
_variant_index: u32,
_variant: &'static str,
_len: usize,
) -> Result<Self::SerializeTupleVariant, Self::Error> {
Err(SerError::custom("wrong type for KeyValueMap"))
}
fn serialize_map(self, _len: Option<usize>) -> Result<Self::SerializeMap, Self::Error> {
Err(SerError::custom("wrong type for KeyValueMap"))
}
fn serialize_struct(
self,
_name: &'static str,
_len: usize,
) -> Result<Self::SerializeStruct, Self::Error> {
Err(SerError::custom("wrong type for KeyValueMap"))
}
fn serialize_struct_variant(
self,
_name: &'static str,
_variant_index: u32,
_variant: &'static str,
_len: usize,
) -> Result<Self::SerializeStructVariant, Self::Error> {
Err(SerError::custom("wrong type for KeyValueMap"))
}
}
/// Serialize a single element but turn the sequence into a map logic.
///
/// It uses [`ElementAsKeyValueSerializer`] for the map element serialization.
///
/// The [`Serializer`] implementation handles `serialize_struct`, `serialize_map` and `serialize_seq` functions by deferring the work to [`SerializeStruct`], [`SerializeMap`] and [`SerializeSeq`] respectively.
struct SerializeSeqElement<M> {
delegate: M,
is_human_readable: bool,
}
impl<M> SerializeSeq for SerializeSeqElement<M>
where
M: SerializeMap,
{
type Ok = M::Ok;
type Error = M::Error;
fn serialize_element<T: ?Sized>(&mut self, value: &T) -> Result<(), Self::Error>
where
T: Serialize,
{
value.serialize(ElementAsKeyValueSerializer {
delegate: &mut self.delegate,
is_human_readable: self.is_human_readable,
})?;
Ok(())
}
fn end(self) -> Result<Self::Ok, Self::Error> {
self.delegate.end()
}
}
struct ElementAsKeyValueSerializer<'a, M> {
delegate: &'a mut M,
is_human_readable: bool,
}
impl<'a, M> Serializer for ElementAsKeyValueSerializer<'a, M>
where
M: SerializeMap,
{
type Ok = ();
type Error = M::Error;
type SerializeSeq = KeyValueSeqSerializer<'a, M>;
type SerializeTuple = KeyValueTupleSerializer<'a, M>;
type SerializeTupleStruct = KeyValueTupleStructSerializer<'a, M>;
type SerializeTupleVariant = Impossible<Self::Ok, Self::Error>;
type SerializeMap = KeyValueMapSerializer<'a, M>;
type SerializeStruct = KeyValueStructSerializer<'a, M>;
type SerializeStructVariant = Impossible<Self::Ok, Self::Error>;
fn is_human_readable(&self) -> bool {
self.is_human_readable
}
fn serialize_bool(self, _v: bool) -> Result<Self::Ok, Self::Error> {
Err(SerError::custom("wrong type for KeyValueMap"))
}
fn serialize_i8(self, _v: i8) -> Result<Self::Ok, Self::Error> {
Err(SerError::custom("wrong type for KeyValueMap"))
}
fn serialize_i16(self, _v: i16) -> Result<Self::Ok, Self::Error> {
Err(SerError::custom("wrong type for KeyValueMap"))
}
fn serialize_i32(self, _v: i32) -> Result<Self::Ok, Self::Error> {
Err(SerError::custom("wrong type for KeyValueMap"))
}
fn serialize_i64(self, _v: i64) -> Result<Self::Ok, Self::Error> {
Err(SerError::custom("wrong type for KeyValueMap"))
}
fn serialize_i128(self, _v: i128) -> Result<Self::Ok, Self::Error> {
Err(SerError::custom("wrong type for KeyValueMap"))
}
fn serialize_u8(self, _v: u8) -> Result<Self::Ok, Self::Error> {
Err(SerError::custom("wrong type for KeyValueMap"))
}
fn serialize_u16(self, _v: u16) -> Result<Self::Ok, Self::Error> {
Err(SerError::custom("wrong type for KeyValueMap"))
}
fn serialize_u32(self, _v: u32) -> Result<Self::Ok, Self::Error> {
Err(SerError::custom("wrong type for KeyValueMap"))
}
fn serialize_u64(self, _v: u64) -> Result<Self::Ok, Self::Error> {
Err(SerError::custom("wrong type for KeyValueMap"))
}
fn serialize_u128(self, _v: u128) -> Result<Self::Ok, Self::Error> {
Err(SerError::custom("wrong type for KeyValueMap"))
}
fn serialize_f32(self, _v: f32) -> Result<Self::Ok, Self::Error> {
Err(SerError::custom("wrong type for KeyValueMap"))
}
fn serialize_f64(self, _v: f64) -> Result<Self::Ok, Self::Error> {
Err(SerError::custom("wrong type for KeyValueMap"))
}
fn serialize_char(self, _v: char) -> Result<Self::Ok, Self::Error> {
Err(SerError::custom("wrong type for KeyValueMap"))
}
fn serialize_str(self, _v: &str) -> Result<Self::Ok, Self::Error> {
Err(SerError::custom("wrong type for KeyValueMap"))
}
fn serialize_bytes(self, _v: &[u8]) -> Result<Self::Ok, Self::Error> {
Err(SerError::custom("wrong type for KeyValueMap"))
}
fn serialize_none(self) -> Result<Self::Ok, Self::Error> {
Err(SerError::custom("wrong type for KeyValueMap"))
}
fn serialize_some<T: ?Sized>(self, _value: &T) -> Result<Self::Ok, Self::Error>
where
T: Serialize,
{
Err(SerError::custom("wrong type for KeyValueMap"))
}
fn serialize_unit(self) -> Result<Self::Ok, Self::Error> {
Err(SerError::custom("wrong type for KeyValueMap"))
}
fn serialize_unit_struct(self, _name: &'static str) -> Result<Self::Ok, Self::Error> {
Err(SerError::custom("wrong type for KeyValueMap"))
}
fn serialize_unit_variant(
self,
_name: &'static str,
_variant_index: u32,
_variant: &'static str,
) -> Result<Self::Ok, Self::Error> {
Err(SerError::custom("wrong type for KeyValueMap"))
}
fn serialize_newtype_struct<T: ?Sized>(
self,
_name: &'static str,
_value: &T,
) -> Result<Self::Ok, Self::Error>
where
T: Serialize,
{
Err(SerError::custom("wrong type for KeyValueMap"))
}
fn serialize_newtype_variant<T: ?Sized>(
self,
_name: &'static str,
_variant_index: u32,
_variant: &'static str,
_value: &T,
) -> Result<Self::Ok, Self::Error>
where
T: Serialize,
{
Err(SerError::custom("wrong type for KeyValueMap"))
}
fn serialize_seq(self, len: Option<usize>) -> Result<Self::SerializeSeq, Self::Error> {
Ok(KeyValueSeqSerializer {
delegate: self.delegate,
is_human_readable: self.is_human_readable,
content: Vec::with_capacity(len.unwrap_or(17) - 1),
key: None,
})
}
fn serialize_tuple(self, len: usize) -> Result<Self::SerializeTuple, Self::Error> {
Ok(KeyValueTupleSerializer {
delegate: self.delegate,
is_human_readable: self.is_human_readable,
content: Vec::with_capacity(len - 1),
key: None,
})
}
fn serialize_tuple_struct(
self,
name: &'static str,
len: usize,
) -> Result<Self::SerializeTupleStruct, Self::Error> {
Ok(KeyValueTupleStructSerializer {
delegate: self.delegate,
is_human_readable: self.is_human_readable,
name,
content: Vec::with_capacity(len - 1),
key: None,
})
}
fn serialize_tuple_variant(
self,
_name: &'static str,
_variant_index: u32,
_variant: &'static str,
_len: usize,
) -> Result<Self::SerializeTupleVariant, Self::Error> {
Err(SerError::custom("wrong type for KeyValueMap"))
}
fn serialize_map(self, len: Option<usize>) -> Result<Self::SerializeMap, Self::Error> {
Ok(KeyValueMapSerializer {
delegate: self.delegate,
is_human_readable: self.is_human_readable,
content: Vec::with_capacity(len.unwrap_or(17) - 1),
next_is_magic_key: false,
key: None,
tmp: None,
})
}
fn serialize_struct(
self,
name: &'static str,
len: usize,
) -> Result<Self::SerializeStruct, Self::Error> {
Ok(KeyValueStructSerializer {
delegate: self.delegate,
is_human_readable: self.is_human_readable,
name,
content: Vec::with_capacity(len - 1),
key: None,
})
}
fn serialize_struct_variant(
self,
_name: &'static str,
_variant_index: u32,
_variant: &'static str,
_len: usize,
) -> Result<Self::SerializeStructVariant, Self::Error> {
Err(SerError::custom("wrong type for KeyValueMap"))
}
}
/// Serialize a sequence to a key and value pair of a map.
///
/// This requires that the sequence has at least one element.
struct KeyValueSeqSerializer<'a, M> {
delegate: &'a mut M,
is_human_readable: bool,
content: Vec<SerContent>,
key: Option<SerContent>,
}
impl<'a, M> SerializeSeq for KeyValueSeqSerializer<'a, M>
where
M: SerializeMap,
{
type Ok = ();
type Error = M::Error;
fn serialize_element<T: ?Sized>(&mut self, element: &T) -> Result<(), Self::Error>
where
T: Serialize,
{
let element: SerContent =
element.serialize(ContentSerializer::new(self.is_human_readable))?;
if self.key.is_none() {
self.key = Some(element);
return Ok(());
}
self.content.push(element);
Ok(())
}
fn end(self) -> Result<Self::Ok, Self::Error> {
if let Some(key) = self.key {
self.delegate
.serialize_entry(&key, &SerContent::Seq(self.content))
} else {
Err(SerError::custom("TODO, missing value for `$key$` field"))
}
}
}
/// Serialize a tuple to a key and value pair of a map.
///
/// This requires that the tuple has at least one element.
struct KeyValueTupleSerializer<'a, M> {
delegate: &'a mut M,
is_human_readable: bool,
content: Vec<SerContent>,
key: Option<SerContent>,
}
impl<'a, M> SerializeTuple for KeyValueTupleSerializer<'a, M>
where
M: SerializeMap,
{
type Ok = ();
type Error = M::Error;
fn serialize_element<T: ?Sized>(&mut self, element: &T) -> Result<(), Self::Error>
where
T: Serialize,
{
let element: SerContent =
element.serialize(ContentSerializer::new(self.is_human_readable))?;
if self.key.is_none() {
self.key = Some(element);
return Ok(());
}
self.content.push(element);
Ok(())
}
fn end(self) -> Result<Self::Ok, Self::Error> {
if let Some(key) = self.key {
self.delegate
.serialize_entry(&key, &SerContent::Tuple(self.content))
} else {
Err(SerError::custom("TODO, missing value for `$key$` field"))
}
}
}
/// Serialize a tuple struct to a key and value pair of a map.
///
/// This requires that the tuple struct has at least one element.
struct KeyValueTupleStructSerializer<'a, M> {
delegate: &'a mut M,
is_human_readable: bool,
name: &'static str,
content: Vec<SerContent>,
key: Option<SerContent>,
}
impl<'a, M> SerializeTupleStruct for KeyValueTupleStructSerializer<'a, M>
where
M: SerializeMap,
{
type Ok = ();
type Error = M::Error;
fn serialize_field<T: ?Sized>(&mut self, field: &T) -> Result<(), Self::Error>
where
T: Serialize,
{
let field: SerContent = field.serialize(ContentSerializer::new(self.is_human_readable))?;
if self.key.is_none() {
self.key = Some(field);
return Ok(());
}
self.content.push(field);
Ok(())
}
fn end(self) -> Result<Self::Ok, Self::Error> {
if let Some(key) = self.key {
self.delegate
.serialize_entry(&key, &SerContent::TupleStruct(self.name, self.content))
} else {
Err(SerError::custom("TODO, missing value for `$key$` field"))
}
}
}
/// Serialize a map to a key and value pair of a map.
///
/// This requires that the map has one element which serializes using the magic `$key$` key.
struct KeyValueMapSerializer<'a, M> {
delegate: &'a mut M,
is_human_readable: bool,
content: Vec<(SerContent, SerContent)>,
next_is_magic_key: bool,
key: Option<SerContent>,
tmp: Option<SerContent>,
}
impl<'a, M> SerializeMap for KeyValueMapSerializer<'a, M>
where
M: SerializeMap,
{
type Ok = ();
type Error = M::Error;
fn serialize_key<T: ?Sized>(&mut self, key: &T) -> Result<(), Self::Error>
where
T: Serialize,
{
let key: SerContent = key.serialize(ContentSerializer::new(self.is_human_readable))?;
if key.as_str() == Some(MAP_KEY_IDENTIFIER) {
self.next_is_magic_key = true;
return Ok(());
}
self.tmp = Some(key);
Ok(())
}
fn serialize_value<T: ?Sized>(&mut self, value: &T) -> Result<(), Self::Error>
where
T: Serialize,
{
let value: SerContent = value.serialize(ContentSerializer::new(self.is_human_readable))?;
if self.next_is_magic_key {
self.next_is_magic_key = false;
self.key = Some(value);
return Ok(());
}
self.content.push((
self.tmp
.take()
.expect("serialize_value called before serialize_key"),
value,
));
Ok(())
}
fn end(self) -> Result<Self::Ok, Self::Error> {
if let Some(key) = self.key {
self.delegate
.serialize_entry(&key, &SerContent::Map(self.content))
} else {
Err(SerError::custom("TODO, missing value for `$key$` field"))
}
}
}
/// Serialize a struct to a key and value pair of a map.
///
/// This requires that the struct has one field named `$key$`.
struct KeyValueStructSerializer<'a, M> {
delegate: &'a mut M,
is_human_readable: bool,
name: &'static str,
content: Vec<(&'static str, SerContent)>,
key: Option<SerContent>,
}
impl<'a, M> SerializeStruct for KeyValueStructSerializer<'a, M>
where
M: SerializeMap,
{
type Ok = ();
type Error = M::Error;
fn serialize_field<T: ?Sized>(
&mut self,
key: &'static str,
value: &T,
) -> Result<(), Self::Error>
where
T: Serialize,
{
// Serialize to a Content type first
let value: SerContent = value.serialize(ContentSerializer::new(self.is_human_readable))?;
if key == MAP_KEY_IDENTIFIER {
self.key = Some(value);
return Ok(());
}
self.content.push((key, value));
Ok(())
}
fn end(self) -> Result<Self::Ok, Self::Error> {
if let Some(key) = self.key {
self.delegate
.serialize_entry(&key, &SerContent::Struct(self.name, self.content))
} else {
Err(SerError::custom("TODO, missing value for `key` field"))
}
}
}
// Below is deserialization code
/// Deserialize the sequence of enum instances.
///
/// The main [`Deserializer`] implementation handles the outer sequence (e.g., `Vec`), while the [`SeqAccess`] implementation is responsible for the inner elements.
struct SeqDeserializer<M> {
delegate: M,
is_human_readable: bool,
}
impl<'de, M> Deserializer<'de> for SeqDeserializer<M>
where
M: MapAccess<'de>,
{
type Error = M::Error;
fn is_human_readable(&self) -> bool {
self.is_human_readable
}
fn deserialize_seq<V>(self, visitor: V) -> Result<V::Value, Self::Error>
where
V: Visitor<'de>,
{
visitor.visit_seq(self)
}
fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Self::Error>
where
V: Visitor<'de>,
{
self.deserialize_seq(visitor)
}
serde::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
tuple_struct map struct enum identifier ignored_any
}
}
impl<'de, M> SeqAccess<'de> for SeqDeserializer<M>
where
M: MapAccess<'de>,
{
type Error = M::Error;
fn next_element_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>, Self::Error>
where
T: DeserializeSeed<'de>,
{
let key_value: Option<DeContent<'de>> = self.delegate.next_key()?;
if let Some(key_value) = key_value {
seed.deserialize(MapKeyDeserializer {
delegate: &mut self.delegate,
is_human_readable: self.is_human_readable,
key_value,
})
.map(Some)
} else {
Ok(None)
}
}
fn size_hint(&self) -> Option<usize> {
self.delegate.size_hint()
}
}
struct MapKeyDeserializer<'de, M> {
delegate: M,
is_human_readable: bool,
key_value: DeContent<'de>,
}
impl<'de, M> Deserializer<'de> for MapKeyDeserializer<'de, M>
where
M: MapAccess<'de>,
{
type Error = M::Error;
fn is_human_readable(&self) -> bool {
self.is_human_readable
}
fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Self::Error>
where
V: Visitor<'de>,
{
self.deserialize_map(visitor)
}
fn deserialize_seq<V>(mut self, visitor: V) -> Result<V::Value, Self::Error>
where
V: Visitor<'de>,
{
self.delegate.next_value_seed(KeyValueSeqDeserialize {
delegate: visitor,
first: Some(self.key_value),
})
}
fn deserialize_tuple<V>(mut self, len: usize, visitor: V) -> Result<V::Value, Self::Error>
where
V: Visitor<'de>,
{
self.delegate.next_value_seed(KeyValueTupleDeserialize {
delegate: visitor,
len,
first: Some(self.key_value),
})
}
fn deserialize_tuple_struct<V>(
mut self,
name: &'static str,
len: usize,
visitor: V,
) -> Result<V::Value, Self::Error>
where
V: Visitor<'de>,
{
self.delegate
.next_value_seed(KeyValueTupleStructDeserialize {
delegate: visitor,
name,
len,
first: Some(self.key_value),
})
}
fn deserialize_map<V>(mut self, visitor: V) -> Result<V::Value, Self::Error>
where
V: Visitor<'de>,
{
self.delegate.next_value_seed(KeyValueMapDeserialize {
delegate: visitor,
first: Some(self.key_value),
})
}
fn deserialize_struct<V>(
mut self,
name: &'static str,
fields: &'static [&'static str],
visitor: V,
) -> Result<V::Value, Self::Error>
where
V: Visitor<'de>,
{
self.delegate.next_value_seed(KeyValueStructDeserialize {
delegate: visitor,
name,
fields,
first: Some(self.key_value),
})
}
serde::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
enum identifier ignored_any
}
}
struct KeyValueSeqDeserialize<'de, V> {
delegate: V,
first: Option<DeContent<'de>>,
}
impl<'de, V> DeserializeSeed<'de> for KeyValueSeqDeserialize<'de, V>
where
V: Visitor<'de>,
{
type Value = V::Value;
fn deserialize<D>(mut self, deserializer: D) -> Result<Self::Value, D::Error>
where
D: Deserializer<'de>,
{
let is_human_readable = deserializer.is_human_readable();
deserializer.deserialize_seq(VisitorWrapper {
delegate: self.delegate,
is_human_readable,
first: self.first.take(),
})
}
}
struct KeyValueTupleDeserialize<'de, V> {
delegate: V,
len: usize,
first: Option<DeContent<'de>>,
}
impl<'de, V> DeserializeSeed<'de> for KeyValueTupleDeserialize<'de, V>
where
V: Visitor<'de>,
{
type Value = V::Value;
fn deserialize<D>(mut self, deserializer: D) -> Result<Self::Value, D::Error>
where
D: Deserializer<'de>,
{
let is_human_readable = deserializer.is_human_readable();
deserializer.deserialize_tuple(
self.len,
VisitorWrapper {
delegate: self.delegate,
is_human_readable,
first: self.first.take(),
},
)
}
}
struct KeyValueTupleStructDeserialize<'de, V> {
delegate: V,
name: &'static str,
len: usize,
first: Option<DeContent<'de>>,
}
impl<'de, V> DeserializeSeed<'de> for KeyValueTupleStructDeserialize<'de, V>
where
V: Visitor<'de>,
{
type Value = V::Value;
fn deserialize<D>(mut self, deserializer: D) -> Result<Self::Value, D::Error>
where
D: Deserializer<'de>,
{
let is_human_readable = deserializer.is_human_readable();
deserializer.deserialize_tuple_struct(
self.name,
self.len,
VisitorWrapper {
delegate: self.delegate,
is_human_readable,
first: self.first.take(),
},
)
}
}
struct KeyValueMapDeserialize<'de, V> {
delegate: V,
first: Option<DeContent<'de>>,
}
impl<'de, V> DeserializeSeed<'de> for KeyValueMapDeserialize<'de, V>
where
V: Visitor<'de>,
{
type Value = V::Value;
fn deserialize<D>(mut self, deserializer: D) -> Result<Self::Value, D::Error>
where
D: Deserializer<'de>,
{
let is_human_readable = deserializer.is_human_readable();
deserializer.deserialize_map(VisitorWrapper {
delegate: self.delegate,
is_human_readable,
first: self.first.take(),
})
}
}
struct KeyValueStructDeserialize<'de, V> {
delegate: V,
name: &'static str,
fields: &'static [&'static str],
first: Option<DeContent<'de>>,
}
impl<'de, V> DeserializeSeed<'de> for KeyValueStructDeserialize<'de, V>
where
V: Visitor<'de>,
{
type Value = V::Value;
fn deserialize<D>(mut self, deserializer: D) -> Result<Self::Value, D::Error>
where
D: Deserializer<'de>,
{
let is_human_readable = deserializer.is_human_readable();
deserializer.deserialize_struct(
self.name,
self.fields,
VisitorWrapper {
delegate: self.delegate,
is_human_readable,
first: self.first.take(),
},
)
}
}
struct VisitorWrapper<'de, V> {
delegate: V,
is_human_readable: bool,
first: Option<DeContent<'de>>,
}
impl<'de, V> Visitor<'de> for VisitorWrapper<'de, V>
where
V: Visitor<'de>,
{
type Value = V::Value;
fn expecting(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
self.delegate.expecting(formatter)
}
fn visit_map<A>(self, map: A) -> Result<Self::Value, A::Error>
where
A: MapAccess<'de>,
{
self.delegate.visit_map(MapAccessWrapper {
delegate: map,
is_human_readable: self.is_human_readable,
first: self.first,
})
}
fn visit_seq<A>(self, seq: A) -> Result<Self::Value, A::Error>
where
A: SeqAccess<'de>,
{
self.delegate.visit_seq(SeqAccessWrapper {
delegate: seq,
is_human_readable: self.is_human_readable,
first: self.first,
})
}
}
struct MapAccessWrapper<'de, M> {
delegate: M,
is_human_readable: bool,
first: Option<DeContent<'de>>,
}
impl<'de, M> MapAccess<'de> for MapAccessWrapper<'de, M>
where
M: MapAccess<'de>,
{
type Error = M::Error;
fn next_key_seed<K>(&mut self, seed: K) -> Result<Option<K::Value>, Self::Error>
where
K: DeserializeSeed<'de>,
{
if self.first.is_some() {
seed.deserialize(serde::de::value::StringDeserializer::new(
MAP_KEY_IDENTIFIER.to_string(),
))
.map(Some)
} else {
self.delegate.next_key_seed(seed)
}
}
fn next_value_seed<V>(&mut self, seed: V) -> Result<V::Value, Self::Error>
where
V: DeserializeSeed<'de>,
{
if let Some(first) = self.first.take() {
seed.deserialize(ContentDeserializer::new(first, self.is_human_readable))
} else {
self.delegate.next_value_seed(seed)
}
}
}
struct SeqAccessWrapper<'de, M> {
delegate: M,
is_human_readable: bool,
first: Option<DeContent<'de>>,
}
impl<'de, S> SeqAccess<'de> for SeqAccessWrapper<'de, S>
where
S: SeqAccess<'de>,
{
type Error = S::Error;
fn next_element_seed<K>(&mut self, seed: K) -> Result<Option<K::Value>, Self::Error>
where
K: DeserializeSeed<'de>,
{
if let Some(first) = self.first.take() {
seed.deserialize(ContentDeserializer::new(first, self.is_human_readable))
.map(Some)
} else {
self.delegate.next_element_seed(seed)
}
}
}