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<SEP, T, TA> JsonSchemaAs<T> for StringWithSeparator<SEP, TA>

where SEP: Separator,

Available on crate feature schemars_0_8 only.

fn schema_name() -> String

The name of the generated JSON Schema.

fn schema_id() -> Cow<'static, str>

Returns a string that uniquely identifies the schema produced by this type.

fn json_schema(gen: &mut SchemaGenerator) -> Schema

Generates a JSON Schema for this type.

fn is_referenceable() -> bool

Whether JSON Schemas generated for this type should be re-used where possible using the $ref keyword.

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.