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;
extern crate serde;
#[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 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, __arg_0: &mut Formatter) -> Result

Formats the value using the given formatter.

impl Eq for StringOrUri

impl PartialEq for StringOrUri

fn eq(&self, __arg_0: &StringOrUri) -> bool

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

fn ne(&self, __arg_0: &StringOrUri) -> bool

This method tests for !=.

impl Hash for StringOrUri

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

Feeds this value into the given [Hasher].

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

Feeds a slice of this type into the given [Hasher].

impl AsRef<str> for StringOrUri

fn as_ref(&self) -> &str

Performs the conversion.

impl FromStr for StringOrUri

type Err = Error

The associated error which can be returned from parsing.

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.

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