Struct serde_with::Seq

pub struct Seq<V>(_);

De/Serialize a Map into a list of tuples or custom type

Some formats, like JSON, have limitations on the types of keys for maps. In case of JSON, keys are restricted to strings. Rust features more powerful keys, for example tuples, which can not be serialized to JSON.

This helper serializes the Map into a list of tuples, which do not have the same type restrictions. Other types can be used to, if they implement SerializeAs<(K, V)>.

Examples

#[serde_as]
#[derive(Deserialize, Serialize)]
struct A {
    #[serde_as(as = "Seq<(_, _)>")]
    s: BTreeMap<(String, u32), u32>,
}

// This converts the Rust type
let data = A {
    s: BTreeMap::from([
        (("Hello".to_string(), 123), 0),
        (("World".to_string(), 456), 1),
    ]),
};

// into this JSON
let value = json!({
    "s": [
        [["Hello", 123], 0],
        [["World", 456], 1]
    ]
});

assert_eq!(value, serde_json::to_value(&data).unwrap());
assert_eq!(data, serde_json::from_value(value).unwrap());

Use a custom representation

use serde_with::{de::DeserializeAsWrap, ser::SerializeAsWrap, DeserializeAs, SerializeAs};

#[derive(Serialize, Deserialize)]
struct Custom<K, V> {
    custom_key: K,
    v: V,
}

impl<K, KAs, V, VAs> SerializeAs<(K, V)> for Custom<KAs, VAs>
where
    KAs: SerializeAs<K>,
    VAs: SerializeAs<V>,
{
    fn serialize_as<S>((k, v): &(K, V), serializer: S) -> Result<S::Ok, S::Error>
    where
        S: serde::Serializer,
    {
        (Custom {
            custom_key: SerializeAsWrap::<K, KAs>::new(k),
            v: SerializeAsWrap::<V, VAs>::new(v),
        })
        .serialize(serializer)
    }
}

impl<'de, K, KAs, V, VAs> DeserializeAs<'de, (K, V)> for Custom<KAs, VAs>
where
    KAs: DeserializeAs<'de, K>,
    VAs: DeserializeAs<'de, V>,
{
    fn deserialize_as<D>(deserializer: D) -> Result<(K, V), D::Error>
    where
        D: serde::Deserializer<'de>,
    {
        let c = <Custom<DeserializeAsWrap<K, KAs>, DeserializeAsWrap<V, VAs>>>::deserialize(
            deserializer,
        )?;
        Ok((c.custom_key.into_inner(), c.v.into_inner()))
    }
}

#[serde_as]
#[derive(Serialize, Deserialize)]
struct SM(#[serde_as(as = "Seq<Custom<_, _>>")] BTreeMap<u32, IpAddr>);

// This converts the Rust type
let ip = "1.2.3.4".parse().unwrap();
let ip2 = "255.255.255.255".parse().unwrap();
let data = SM(vec![(1, ip), (10, ip), (200, ip2)].into_iter().collect());

// into this JSON
let value = serde_json::json!(
    [
        {
            "custom_key": 1,
            "v": "1.2.3.4"
        },
        {
            "custom_key": 10,
            "v": "1.2.3.4"
        },
        {
            "custom_key": 200,
            "v": "255.255.255.255"
        }
    ]
);

assert_eq!(value, serde_json::to_value(&data).unwrap());
assert_eq!(data, serde_json::from_value(value).unwrap());

Trait Implementations

impl<'de, K, V, TAs> DeserializeAs<'de, BTreeMap<K, V, Global>> for Seq<TAs>where TAs: DeserializeAs<'de, (K, V)>, K: Ord,

fn deserialize_as<D>(deserializer: D) -> Result<BTreeMap<K, V>, D::Error>where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<'de, K, V, TAs> DeserializeAs<'de, HashMap<K, V, RandomState>> for Seq<TAs>where TAs: DeserializeAs<'de, (K, V)>, K: Eq + Hash,

fn deserialize_as<D>(deserializer: D) -> Result<HashMap<K, V>, D::Error>where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<'de, K, V, TAs> DeserializeAs<'de, IndexMap<K, V, RandomState>> for Seq<TAs>where TAs: DeserializeAs<'de, (K, V)>, K: Eq + Hash,

fn deserialize_as<D>(deserializer: D) -> Result<IndexMap<K, V>, D::Error>where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<K, V, TAs> SerializeAs<BTreeMap<K, V, Global>> for Seq<TAs>where for<'a> TAs: SerializeAs<(&'a K, &'a V)>,

fn serialize_as<S>( source: &BTreeMap<K, V>, serializer: S ) -> Result<S::Ok, S::Error>where S: Serializer,

Serialize this value into the given Serde serializer.

impl<K, V, TAs, H> SerializeAs<HashMap<K, V, H>> for Seq<TAs>where for<'a> TAs: SerializeAs<(&'a K, &'a V)>, H: ?Sized + Sized,

fn serialize_as<S>( source: &HashMap<K, V, H>, serializer: S ) -> Result<S::Ok, S::Error>where S: Serializer,

Serialize this value into the given Serde serializer.

impl<K, V, TAs, H> SerializeAs<IndexMap<K, V, H>> for Seq<TAs>where for<'a> TAs: SerializeAs<(&'a K, &'a V)>, H: ?Sized + Sized,

fn serialize_as<S>( source: &IndexMap<K, V, H>, serializer: S ) -> Result<S::Ok, S::Error>where S: Serializer,

Serialize this value into the given Serde serializer.