Module serde_with::rust::seq_display_fromstr

De/Serialize sequences using FromIterator and IntoIterator implementation for it and Display and FromStr implementation for each element

This allows to serialize and deserialize collections with elements which can be represented as strings.

Converting to serde_as

The same functionality can be more clearly expressed via DisplayFromStr and using the serde_as macro. Instead of

#[serde(with = "serde_with::rust::seq_display_fromstr")]
addresses: BTreeSet<Ipv4Addr>,

you can write:

#[serde_as(as = "BTreeSet<DisplayFromStr>")]
addresses: BTreeSet<Ipv4Addr>,

This works for any container type, so also for Vec:

#[serde_as(as = "Vec<DisplayFromStr>")]
bs: Vec<bool>,

Examples

use std::collections::BTreeSet;
use std::net::Ipv4Addr;

#[derive(Deserialize, Serialize)]
struct A {
    #[serde(with = "serde_with::rust::seq_display_fromstr")]
    addresses: BTreeSet<Ipv4Addr>,
    #[serde(with = "serde_with::rust::seq_display_fromstr")]
    bs: Vec<bool>,
}

let v: A = serde_json::from_str(r#"{
    "addresses": ["192.168.2.1", "192.168.2.2", "192.168.1.1", "192.168.2.2"],
    "bs": ["true", "false"]
}"#).unwrap();
assert_eq!(v.addresses.len(), 3);
assert!(v.addresses.contains(&Ipv4Addr::new(192, 168, 2, 1)));
assert!(v.addresses.contains(&Ipv4Addr::new(192, 168, 2, 2)));
assert!(!v.addresses.contains(&Ipv4Addr::new(192, 168, 1, 2)));
assert_eq!(v.bs.len(), 2);
assert!(v.bs[0]);
assert!(!v.bs[1]);

let x = A {
    addresses: vec![
        Ipv4Addr::new(127, 53, 0, 1),
        Ipv4Addr::new(127, 53, 1, 1),
        Ipv4Addr::new(127, 53, 0, 2)
    ].into_iter().collect(),
    bs: vec![false, true],
};
assert_eq!(
    r#"{"addresses":["127.53.0.1","127.53.0.2","127.53.1.1"],"bs":["false","true"]}"#,
    serde_json::to_string(&x).unwrap()
);

Functions

deserialize

Deserialize collection T using FromIterator and FromStr for each element

serialize

Serialize collection T using IntoIterator and Display for each element