Struct serde_with::Map

pub struct Map<K, V>(_);

This serializes a list of tuples into a map

Normally, you want to use a HashMap or a BTreeMap when deserializing a map. However, sometimes this is not possible due to type constraints, e.g., if the type implements neither Hash nor Ord. Another use case is deserializing a map with duplicate keys.

The implementation is generic using the FromIterator and IntoIterator traits. Therefore, all of Vec, VecDeque, and LinkedList and anything which implements those are supported.

Examples

Wrapper does not implement Hash nor Ord, thus prohibiting the use HashMap or BTreeMap. The JSON also contains a duplicate key.

#[serde_as]
#[derive(Debug, Deserialize, Serialize, Default)]
struct S {
    #[serde_as(as = "Map<_, _>")]
    s: Vec<(Wrapper<i32>, String)>,
}

#[derive(Clone, Debug, Serialize, Deserialize)]
#[serde(transparent)]
struct Wrapper<T>(T);

let data = S {
    s: vec![
        (Wrapper(1), "a".to_string()),
        (Wrapper(2), "b".to_string()),
        (Wrapper(3), "c".to_string()),
        (Wrapper(2), "d".to_string()),
    ],
};

let json = r#"{
  "s": {
    "1": "a",
    "2": "b",
    "3": "c",
    "2": "d"
  }
}"#;
assert_eq!(json, serde_json::to_string_pretty(&data).unwrap());

Trait Implementations

impl<'de, K, KAs, V, VAs, const N: usize> DeserializeAs<'de, [(K, V); N]> for Map<KAs, VAs>where
    KAs: DeserializeAs<'de, K>,
    VAs: DeserializeAs<'de, V>,

fn deserialize_as<D>(deserializer: D) -> Result<[(K, V); N], D::Error>where
    D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<'de, K, KAs, V, VAs> DeserializeAs<'de, BTreeSet<(K, V), Global>> for Map<KAs, VAs>where
    KAs: DeserializeAs<'de, K>,
    VAs: DeserializeAs<'de, V>,
    K: Ord,
    V: Ord,

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

Deserialize this value from the given Serde deserializer.

impl<'de, K, KAs, V, VAs> DeserializeAs<'de, BinaryHeap<(K, V)>> for Map<KAs, VAs>where
    KAs: DeserializeAs<'de, K>,
    VAs: DeserializeAs<'de, V>,
    K: Ord,
    V: Ord,

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

Deserialize this value from the given Serde deserializer.

impl<'de, K, KAs, V, VAs> DeserializeAs<'de, HashSet<(K, V), RandomState>> for Map<KAs, VAs>where
    KAs: DeserializeAs<'de, K>,
    VAs: DeserializeAs<'de, V>,
    K: Eq + Hash,
    V: Eq + Hash,

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

Deserialize this value from the given Serde deserializer.

impl<'de, K, KAs, V, VAs> DeserializeAs<'de, IndexSet<(K, V), RandomState>> for Map<KAs, VAs>where
    KAs: DeserializeAs<'de, K>,
    VAs: DeserializeAs<'de, V>,
    K: Eq + Hash,
    V: Eq + Hash,

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

Deserialize this value from the given Serde deserializer.

impl<'de, K, KAs, V, VAs> DeserializeAs<'de, LinkedList<(K, V)>> for Map<KAs, VAs>where
    KAs: DeserializeAs<'de, K>,
    VAs: DeserializeAs<'de, V>,

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

Deserialize this value from the given Serde deserializer.

impl<'de, K, KAs, V, VAs> DeserializeAs<'de, Vec<(K, V), Global>> for Map<KAs, VAs>where
    KAs: DeserializeAs<'de, K>,
    VAs: DeserializeAs<'de, V>,

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

Deserialize this value from the given Serde deserializer.

impl<'de, K, KAs, V, VAs> DeserializeAs<'de, VecDeque<(K, V), Global>> for Map<KAs, VAs>where
    KAs: DeserializeAs<'de, K>,
    VAs: DeserializeAs<'de, V>,

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

Deserialize this value from the given Serde deserializer.

impl<K, KAs, V, VAs, const N: usize> SerializeAs<[(K, V); N]> for Map<KAs, VAs>where
    KAs: SerializeAs<K>,
    VAs: SerializeAs<V>,

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

Serialize this value into the given Serde serializer.

impl<K, KAs, V, VAs> SerializeAs<BTreeSet<(K, V), Global>> for Map<KAs, VAs>where
    KAs: SerializeAs<K>,
    VAs: SerializeAs<V>,

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

Serialize this value into the given Serde serializer.

impl<K, KAs, V, VAs> SerializeAs<BinaryHeap<(K, V)>> for Map<KAs, VAs>where
    KAs: SerializeAs<K>,
    VAs: SerializeAs<V>,

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

Serialize this value into the given Serde serializer.

impl<K, KAs, V, VAs> SerializeAs<HashSet<(K, V), RandomState>> for Map<KAs, VAs>where
    KAs: SerializeAs<K>,
    VAs: SerializeAs<V>,

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

Serialize this value into the given Serde serializer.

impl<K, KAs, V, VAs> SerializeAs<IndexSet<(K, V), RandomState>> for Map<KAs, VAs>where
    KAs: SerializeAs<K>,
    VAs: SerializeAs<V>,

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

Serialize this value into the given Serde serializer.

impl<K, KAs, V, VAs> SerializeAs<LinkedList<(K, V)>> for Map<KAs, VAs>where
    KAs: SerializeAs<K>,
    VAs: SerializeAs<V>,

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

Serialize this value into the given Serde serializer.

impl<K, KAs, V, VAs> SerializeAs<Option<(K, V)>> for Map<KAs, VAs>where
    KAs: SerializeAs<K>,
    VAs: SerializeAs<V>,

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

Serialize this value into the given Serde serializer.

impl<K, KAs, V, VAs> SerializeAs<Vec<(K, V), Global>> for Map<KAs, VAs>where
    KAs: SerializeAs<K>,
    VAs: SerializeAs<V>,

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

Serialize this value into the given Serde serializer.

impl<K, KAs, V, VAs> SerializeAs<VecDeque<(K, V), Global>> for Map<KAs, VAs>where
    KAs: SerializeAs<K>,
    VAs: SerializeAs<V>,

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

Serialize this value into the given Serde serializer.