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;
extern crate serde;
#[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

Methods

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

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

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

fn iter<'a>(&'a self) -> Box<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, __arg_0: &mut Formatter) -> Result

Formats the value using the given formatter.

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

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

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

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

fn ne(&self, __arg_0: &SingleOrMultiple<T>) -> bool

This method tests for !=.