Enum biscuit::StringOrUri

pub enum StringOrUri {
    String(String),
    Uri(Url),
}

Represents a choice between a URI or an arbitrary string. Both variants will serialize to a string. According to RFC 7519, any string containing the “:” character will be deserialized as a URL. Any invalid URLs will be treated as a deserialization failure. The URL is parsed according to the URL Standard which supersedes RFC 3986 as required in the JWT RFC.

Examples

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

use std::str::FromStr;
use biscuit::{SingleOrMultiple, StringOrUri};

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

let multiple = SingleOrMultipleStringOrUris {
    values: SingleOrMultiple::Multiple(vec![FromStr::from_str("foo").unwrap(),
                                            FromStr::from_str("https://www.bar.com/").unwrap(),
                                            FromStr::from_str("http://baz/").unwrap()]),
};

let expected_json = r#"{"values":["foo","https://www.bar.com/","http://baz/"]}"#;

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

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

Variants

String(String)

A generic string

Uri(Url)

A parsed URI

Trait Implementations

impl AsRef<str> for StringOrUri

fn as_ref(&self) -> &str

Converts this type into a shared reference of the (usually inferred) input type.

impl Clone for StringOrUri

fn clone(&self) -> StringOrUri

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for StringOrUri

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for StringOrUri

fn deserialize<D>(deserializer: D) -> Result<StringOrUri, D::Error>where
    D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for StringOrUri

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

Formats the value using the given formatter.

impl FromStr for StringOrUri

fn from_str(input: &str) -> Result<Self, Self::Err>

Parses a &str into a StringOrUri. According to RFC 7519, any string containing the “:” character will be treated as a URL. Any invalid URLs will be treated as failure.

type Err = Error

The associated error which can be returned from parsing.

impl Hash for StringOrUri

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)where
    H: Hasher,
    Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq<StringOrUri> for StringOrUri

fn eq(&self, other: &StringOrUri) -> 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 Serialize for StringOrUri

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

Serialize this value into the given Serde serializer.

impl Eq for StringOrUri

impl StructuralEq for StringOrUri

impl StructuralPartialEq for StringOrUri