Struct StringWithSeparator

pub struct StringWithSeparator<Sep, T>(/* private fields */);

De/Serialize a delimited collection using Display and FromStr implementation

StringWithSeparator takes a second type, which needs to implement Display+FromStr and constitutes the inner type of the collection. You can define an arbitrary separator, by specifying a type which implements Separator. Some common ones, like space and comma are already predefined and you can find them here.

An empty string deserializes as an empty collection.

Examples

use serde_with::formats::{CommaSeparator, SpaceSeparator};
use std::collections::BTreeSet;

#[serde_as]
#[derive(Deserialize, Serialize)]
struct A {
    #[serde_as(as = "StringWithSeparator::<SpaceSeparator, String>")]
    tags: Vec<String>,
    #[serde_as(as = "StringWithSeparator::<CommaSeparator, String>")]
    more_tags: BTreeSet<String>,
}

let v: A = serde_json::from_str(r##"{
    "tags": "#hello #world",
    "more_tags": "foo,bar,bar"
}"##).unwrap();
assert_eq!(vec!["#hello", "#world"], v.tags);
assert_eq!(2, v.more_tags.len());

let x = A {
    tags: vec!["1".to_string(), "2".to_string(), "3".to_string()],
    more_tags: BTreeSet::new(),
};
assert_eq!(
    r#"{"tags":"1 2 3","more_tags":""}"#,
    serde_json::to_string(&x).unwrap()
);

Trait Implementations

impl<'de, SEPARATOR, I, T> DeserializeAs<'de, I> for StringWithSeparator<SEPARATOR, T>

where SEPARATOR: Separator, I: FromIterator<T>, T: FromStr, <T as FromStr>::Err: Display,

fn deserialize_as<D>( deserializer: D, ) -> Result<I, <D as Deserializer<'de>>::Error>

where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<SEPARATOR, I, T> SerializeAs<I> for StringWithSeparator<SEPARATOR, T>

where SEPARATOR: Separator, &'x I: for<'x> IntoIterator<Item = &'x T>, T: Display,

fn serialize_as<S>( source: &I, serializer: S, ) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>

where S: Serializer,

Serialize this value into the given Serde serializer.