Module maps_duplicate_key_is_error

Ensure no duplicate keys exist in a map.

By default serde has a last-value-wins implementation, if duplicate keys for a map exist. Sometimes it is desirable to know when such an event happens, as the first value is overwritten and it can indicate an error in the serialized data.

This helper returns an error if two identical keys exist in a map.

The implementation supports both the HashMap and the BTreeMap from the standard library.

Converting to serde_as

The same functionality can be more clearly expressed using the serde_as macro and MapPreventDuplicates. The _ is a placeholder which works for any type which implements Serialize/Deserialize.

#[serde_as]
#[derive(Deserialize, Serialize)]
struct A {
    #[serde_as(as = "MapPreventDuplicates<_, _>")]
    s: HashMap<usize, usize>,
}

Example

#[derive(Deserialize)]
struct Doc {
    #[serde(with = "::serde_with::rust::maps_duplicate_key_is_error")]
    map: HashMap<usize, usize>,
}

// Maps are serialized normally,
let s = r#"{"map": {"1": 1, "2": 2, "3": 3}}"#;
let mut v = Doc {
    map: HashMap::new(),
};
v.map.insert(1, 1);
v.map.insert(2, 2);
v.map.insert(3, 3);
assert_eq!(v, serde_json::from_str(s).unwrap());

// but create an error if duplicate keys, like the `1`, exist.
let s = r#"{"map": {"1": 1, "2": 2, "1": 3}}"#;
let res: Result<Doc, _> = serde_json::from_str(s);
assert!(res.is_err());

Functions

• deserialize
  Deserialize a map and return an error on duplicate keys
• serialize
  Serialize the map with the default serializer