Struct serde_with::Seq
source · pub struct Seq<V>(_);
Expand description
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§
source§impl<'de, K, V, TAs> DeserializeAs<'de, BTreeMap<K, V, Global>> for Seq<TAs>where
TAs: DeserializeAs<'de, (K, V)>,
K: Ord,
impl<'de, K, V, TAs> DeserializeAs<'de, BTreeMap<K, V, Global>> for Seq<TAs>where TAs: DeserializeAs<'de, (K, V)>, K: Ord,
source§fn deserialize_as<D>(deserializer: D) -> Result<BTreeMap<K, V>, D::Error>where
D: Deserializer<'de>,
fn deserialize_as<D>(deserializer: D) -> Result<BTreeMap<K, V>, D::Error>where D: Deserializer<'de>,
Deserialize this value from the given Serde deserializer.
source§impl<'de, K, V, TAs> DeserializeAs<'de, HashMap<K, V, RandomState>> for Seq<TAs>where
TAs: DeserializeAs<'de, (K, V)>,
K: Eq + Hash,
impl<'de, K, V, TAs> DeserializeAs<'de, HashMap<K, V, RandomState>> for Seq<TAs>where TAs: DeserializeAs<'de, (K, V)>, K: Eq + Hash,
source§fn deserialize_as<D>(deserializer: D) -> Result<HashMap<K, V>, D::Error>where
D: Deserializer<'de>,
fn deserialize_as<D>(deserializer: D) -> Result<HashMap<K, V>, D::Error>where D: Deserializer<'de>,
Deserialize this value from the given Serde deserializer.
source§impl<'de, K, V, TAs> DeserializeAs<'de, IndexMap<K, V, RandomState>> for Seq<TAs>where
TAs: DeserializeAs<'de, (K, V)>,
K: Eq + Hash,
impl<'de, K, V, TAs> DeserializeAs<'de, IndexMap<K, V, RandomState>> for Seq<TAs>where TAs: DeserializeAs<'de, (K, V)>, K: Eq + Hash,
source§fn deserialize_as<D>(deserializer: D) -> Result<IndexMap<K, V>, D::Error>where
D: Deserializer<'de>,
fn deserialize_as<D>(deserializer: D) -> Result<IndexMap<K, V>, D::Error>where D: Deserializer<'de>,
Deserialize this value from the given Serde deserializer.
source§impl<K, V, TAs> SerializeAs<BTreeMap<K, V, Global>> for Seq<TAs>where
for<'a> TAs: SerializeAs<(&'a K, &'a V)>,
impl<K, V, TAs> SerializeAs<BTreeMap<K, V, Global>> for Seq<TAs>where for<'a> TAs: SerializeAs<(&'a K, &'a V)>,
source§fn serialize_as<S>(
source: &BTreeMap<K, V>,
serializer: S
) -> Result<S::Ok, S::Error>where
S: Serializer,
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.
source§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,
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,
source§fn serialize_as<S>(
source: &HashMap<K, V, H>,
serializer: S
) -> Result<S::Ok, S::Error>where
S: Serializer,
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.
source§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,
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,
source§fn serialize_as<S>(
source: &IndexMap<K, V, H>,
serializer: S
) -> Result<S::Ok, S::Error>where
S: Serializer,
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.