Enum rocket_cors::AllOrSome

pub enum AllOrSome<T> {
    All,
    Some(T),
}

An enum signifying that some of type T is allowed, or All (everything is allowed).

Default is implemented for this enum and is All.

This enum is serialized and deserialized “Externally tagged”

Variants

All

Everything is allowed. Usually equivalent to the “*” value.

Some(T)

Only some of T is allowed

Implementations

impl<T> AllOrSome<T>

pub fn is_all(&self) -> bool

Returns whether this is an All variant

pub fn is_some(&self) -> bool

Returns whether this is a Some variant

pub fn unwrap(self) -> T

Unwrap a Some variant and get its inner value

Panics

Panics if the variant is All

impl AllOrSome<Origins>

pub fn some<'a, 'b, S1: AsRef<str>, S2: AsRef<str>>( exact: &'a [S1], regex: &'b [S2] ) -> Self

Allows some origins, with a mix of exact matches or regex matches

Validation is not performed at this stage, but at a later stage.

Exact matches are matched exactly with the ASCII Serialization of the origin.

Regular expressions are tested for matches against the ASCII Serialization of the origin.

Opaque Origins

The specification defines an Opaque Origin as one that cannot be recreated. You can refer to the source code for the url::Url::origin method to see how an Opaque Origin is determined. Examples of Opaque origins might include schemes like file:// or Browser specific schemes like "moz-extension:// or chrome-extension://.

Opaque Origins cannot be matched exactly. You must use Regex to match Opaque Origins. If you attempt to create Cors from CorsOptions, you will get an error.

Warning about Regex expressions

By default, regex expressions are unanchored.

This means that if the regex does not start with ^ or \A, or end with $ or \z, then it is permitted to match anywhere in the text. You are encouraged to use the anchors when crafting your Regex expressions.

pub fn some_exact<S: AsRef<str>>(exact: &[S]) -> Self

Allows some exact origins

Validation is not performed at this stage, but at a later stage.

Exact matches are matched exactly with the ASCII Serialization of the origin.

Opaque Origins

The specification defines an Opaque Origin as one that cannot be recreated. You can refer to the source code for the url::Url::origin method to see how an Opaque Origin is determined. Examples of Opaque origins might include schemes like file:// or Browser specific schemes like "moz-extension:// or chrome-extension://.

pub fn some_regex<S: AsRef<str>>(regex: &[S]) -> Self

Allow some regular expression origins

Validation is not performed at this stage, but at a later stage.

Regular expressions are tested for matches against the ASCII Serialization of the origin.

Warning about Regex expressions

By default, regex expressions are unanchored.

This means that if the regex does not start with ^ or \A, or end with $ or \z, then it is permitted to match anywhere in the text. You are encouraged to use the anchors when crafting your Regex expressions.

pub fn some_null() -> Self

Allow some null origins

pub fn all() -> Self

Allows all origins

impl AllOrSome<HashSet<HeaderFieldName>>

pub fn some(headers: &[&str]) -> Self

Allow some headers

pub fn all() -> Self

Allows all headers

Trait Implementations

impl<T: Clone> Clone for AllOrSome<T>

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

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T: Debug> Debug for AllOrSome<T>

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

Formats the value using the given formatter.

impl<T> Default for AllOrSome<T>

fn default() -> AllOrSome<T>

Returns the “default value” for a type.

impl<'de, T> Deserialize<'de> for AllOrSome<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 for AllOrSome<T>

fn eq(&self, other: &AllOrSome<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 AllOrSome<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 AllOrSome<T>

impl<T> StructuralEq for AllOrSome<T>

impl<T> StructuralPartialEq for AllOrSome<T>