Enum biscuit::SingleOrMultiple

pub enum SingleOrMultiple<T> {
    Single(T),
    Multiple(Vec<T>),
}

Represents a choice between a single value or multiple values. This value is serialized by serde untagged.

Examples

extern crate biscuit;
#[macro_use]
extern crate serde_derive;
extern crate serde_json;

use biscuit::SingleOrMultiple;

#[derive(Debug, Eq, PartialEq, Serialize, Deserialize)]
struct SingleOrMultipleStrings {
    values: SingleOrMultiple<String>,
}

let single = SingleOrMultipleStrings {
    values: SingleOrMultiple::Single("foobar".to_string())
};
let expected_json = r#"{"values":"foobar"}"#;

let serialized = serde_json::to_string(&single).unwrap();
assert_eq!(expected_json, serialized);

let deserialized: SingleOrMultipleStrings = serde_json::from_str(&serialized).unwrap();
assert_eq!(deserialized, single);

let multiple = SingleOrMultipleStrings {
    values: SingleOrMultiple::Multiple(vec!["foo".to_string(),
                                            "bar".to_string(),
                                            "baz".to_string()]),
};

let expected_json = r#"{"values":["foo","bar","baz"]}"#;

let serialized = serde_json::to_string(&multiple).unwrap();
assert_eq!(expected_json, serialized);

let deserialized: SingleOrMultipleStrings = serde_json::from_str(&serialized).unwrap();
assert_eq!(deserialized, multiple);

Variants

Single(T)

One single value

Multiple(Vec<T>)

Multiple values

Implementations

impl<T> SingleOrMultiple<T>where
    T: Clone + Debug + Eq + PartialEq + Serialize + DeserializeOwned + Send + Sync,

pub fn contains<Q: ?Sized>(&self, value: &Q) -> boolwhere
    T: Borrow<Q>,
    Q: PartialEq,

Checks whether this enum, regardless of single or multiple value contains value.

pub fn iter<'a>(&'a self) -> Box<dyn Iterator<Item = &'a T> + 'a>

Yields an iterator for the single value or the list

Trait Implementations

impl<T: Clone> Clone for SingleOrMultiple<T>

fn clone(&self) -> SingleOrMultiple<T>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T: Debug> Debug for SingleOrMultiple<T>

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

Formats the value using the given formatter.

impl<'de, T> Deserialize<'de> for SingleOrMultiple<T>where
    T: Deserialize<'de>,

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>where
    __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<T: PartialEq> PartialEq<SingleOrMultiple<T>> for SingleOrMultiple<T>

fn eq(&self, other: &SingleOrMultiple<T>) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<T> Serialize for SingleOrMultiple<T>where
    T: Serialize,

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>where
    __S: Serializer,

Serialize this value into the given Serde serializer.

impl<T: Eq> Eq for SingleOrMultiple<T>

impl<T> StructuralEq for SingleOrMultiple<T>

impl<T> StructuralPartialEq for SingleOrMultiple<T>