Enum Policy 

pub enum Policy<S: Scope> {
    Scope(S),
    OneOf(Vec<Policy<S>>),
    AllOf(Vec<Policy<S>>),
    Not(Box<Policy<S>>),
    AllowAll,
    DenyAll,
}

A policy to verify a set of scopes

Policies can be combined using the &, | and ! operators :

let policy_a = MyScope::Foo.into_policy() & MyScope::Bar.into_policy();
 
let policy_b = (MyScope::Baz.into_policy() | MyScope::Bar.into_policy()) & !policy_a;

You can also use a PolicyBuilder<S> to build complex policies.

Variants

Scope(S)

Requires a scope to be present

OneOf(Vec<Policy<S>>)

Requires one of the policies to be verified

AllOf(Vec<Policy<S>>)

Requires all of the policies to be verified

Not(Box<Policy<S>>)

Requires a policy not to be verified

AllowAll

Policy that always accept everything

DenyAll

Policy that accepts nothing

Implementations

impl<S: Scope> Policy<S>

pub fn builder() -> PolicyBuilder<S>

Create a new PolicyBuilder<S>

Equivalent to calling PolicyBuilder<S>::new

impl<S> Policy<S>

where S: Scope,

pub fn verify<Iterator>(&self, scopes: Iterator) -> bool

where Iterator: IntoIterator + Clone, Iterator::Item: AsScopeRef<S>,

Check if a set of scopes is authorized by a policy

Trait Implementations

impl<S, I> BitAnd<I> for Policy<S>

where S: Scope, I: IntoPolicy<S>,

type Output = Policy<S>

The resulting type after applying the & operator.

fn bitand(self, rhs: I) -> Self::Output

Performs the & operation.

impl<S, I> BitOr<I> for Policy<S>

where S: Scope, I: IntoPolicy<S>,

type Output = Policy<S>

The resulting type after applying the | operator.

fn bitor(self, rhs: I) -> Self::Output

Performs the | operation.

impl<S> Clone for Policy<S>

where S: Scope + Clone,

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<S: Debug + Scope> Debug for Policy<S>

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

Formats the value using the given formatter.

impl<S> Default for Policy<S>

where S: Scope,

fn default() -> Self

Returns the “default value” for a type.

impl<S> From<&S> for Policy<S>

where S: Scope + Clone,

fn from(value: &S) -> Self

Converts to this type from the input type.

impl<S> From<S> for Policy<S>

where S: Scope,

fn from(value: S) -> Self

Converts to this type from the input type.

impl<S> Not for Policy<S>

where S: Scope,

type Output = Policy<S>

The resulting type after applying the ! operator.

fn not(self) -> Self::Output

Performs the unary ! operation.

impl<S: PartialEq + Scope> PartialEq for Policy<S>

fn eq(&self, other: &Policy<S>) -> bool

Tests for self and other values to be equal, and is used by ==.

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

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

impl<S: Scope> StructuralPartialEq for Policy<S>