Struct serde_with::StringWithSeparator

pub struct StringWithSeparator<Sep, T>(_);

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::Err: Display,

fn deserialize_as<D>(deserializer: D) -> Result<I, D::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,
    for<'x> &'x I: IntoIterator<Item = &'x T>,
    T: Display,

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

Serialize this value into the given Serde serializer.