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::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.

Layout

Note: Most layout information is completely unstable and may even differ between compilations. The only exception is types with certain repr(...) attributes. Please see the Rust Reference's “Type Layout” chapter for details on type layout guarantees.

Size: 0 bytes