Struct OneOrMany 

pub struct OneOrMany<T, FORMAT: Format = PreferOne>(/* private fields */);

Deserialize one or many elements

Sometimes it is desirable to have a shortcut in writing 1-element lists in a config file. Usually, this is done by either writing a list or the list element itself. This distinction is not semantically important on the Rust side, thus both forms should deserialize into the same Vec.

The OneOrMany adapter achieves exactly this use case. The serialization behavior can be tweaked to either always serialize as a list using PreferMany or to serialize as the inner element if possible using PreferOne. By default, PreferOne is assumed, which can also be omitted like OneOrMany<_>.

Examples

#[serde_as]
#[derive(Deserialize, serde::Serialize)]
struct Data {
    #[serde_as(as = "OneOrMany<_, PreferOne>")]
    countries: Vec<String>,
    #[serde_as(as = "OneOrMany<_, PreferMany>")]
    cities: Vec<String>,
}

// The adapter allows deserializing a `Vec` from either
// a single element
let j = json!({
    "countries": "Spain",
    "cities": "Berlin",
});
assert!(serde_json::from_value::<Data>(j).is_ok());

// or from a list.
let j = json!({
    "countries": ["Germany", "France"],
    "cities": ["Amsterdam"],
});
assert!(serde_json::from_value::<Data>(j).is_ok());

// For serialization you can choose how a single element should be encoded.
// Either directly, with `PreferOne` (default), or as a list with `PreferMany`.
let data = Data {
    countries: vec!["Spain".to_string()],
    cities: vec!["Berlin".to_string()],
};
let j = json!({
    "countries": "Spain",
    "cities": ["Berlin"],
});
assert_eq!(serde_json::to_value(data).unwrap(), j);

Trait Implementations

impl<'de, T, TAs, FORMAT> DeserializeAs<'de, Vec<T>> for OneOrMany<TAs, FORMAT>

where TAs: DeserializeAs<'de, T>, FORMAT: Format,

fn deserialize_as<D>(deserializer: D) -> Result<Vec<T>, D::Error>

where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<T, U> SerializeAs<Vec<T>> for OneOrMany<U, PreferOne>

where U: SerializeAs<T>,

fn serialize_as<S>(source: &Vec<T>, serializer: S) -> Result<S::Ok, S::Error>

where S: Serializer,

Serialize this value into the given Serde serializer.

impl<T, U> SerializeAs<Vec<T>> for OneOrMany<U, PreferMany>

where U: SerializeAs<T>,

fn serialize_as<S>(source: &Vec<T>, 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