Struct serde_with::OneOrMany

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

Deserialize one or many elements

Sometime it is desireable 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 serialize 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<T: Clone, FORMAT: Clone + Format> Clone for OneOrMany<T, FORMAT>

fn clone(&self) -> OneOrMany<T, FORMAT>

Returns a copy of the value.

pub fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<T: Copy, FORMAT: Copy + Format> Copy for OneOrMany<T, FORMAT>

impl<T: Debug, FORMAT: Debug + Format> Debug for OneOrMany<T, FORMAT>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<T: Default, FORMAT: Default + Format> Default for OneOrMany<T, FORMAT>

fn default() -> OneOrMany<T, FORMAT>

Returns the “default value” for a type.

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