Struct serde_with::OneOrMany

pub struct OneOrMany<T, FORMAT: Format = PreferOne>(_);

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(deserialize_as = "OneOrMany<_, PreferOne>")]
    countries: Vec<String>,
    #[serde_as(deserialize_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!(data, serde_json::from_value(j).unwrap());

Trait Implementations

impl<'de, T, U, FORMAT> DeserializeAs<'de, Vec<T, Global>> for OneOrMany<U, FORMAT>where
    U: 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, Global>> 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.

impl<T, U> SerializeAs<Vec<T, Global>> 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.