Struct EnsureOriginEqualOrHigherPrivilege

pub struct EnsureOriginEqualOrHigherPrivilege<Origin, PrivilegeCmp>(/* private fields */);

EnsureOrigin implementation that checks that an origin has equal or higher privilege compared to the expected Origin.

It will take the shortcut of comparing the incoming origin with the expected Origin and if both are the same the origin is accepted.

Example

#[derive(Eq, PartialEq, Debug)]
pub enum Origin {
    Root,
    SomethingBelowRoot,
    NormalUser,
}

struct OriginPrivilegeCmp;

impl PrivilegeCmp<Origin> for OriginPrivilegeCmp {
    fn cmp_privilege(left: &Origin, right: &Origin) -> Option<Ordering> {
        match (left, right) {
            (Origin::Root, Origin::Root) => Some(Ordering::Equal),
            (Origin::Root, _) => Some(Ordering::Greater),
            (Origin::SomethingBelowRoot, Origin::SomethingBelowRoot) => Some(Ordering::Equal),
            (Origin::SomethingBelowRoot, Origin::Root) => Some(Ordering::Less),
            (Origin::SomethingBelowRoot, Origin::NormalUser) => Some(Ordering::Greater),
            (Origin::NormalUser, Origin::NormalUser) => Some(Ordering::Equal),
            (Origin::NormalUser, _) => Some(Ordering::Less),
        }
    }
}

parameter_types! {
    pub const ExpectedOrigin: Origin = Origin::SomethingBelowRoot;
}

type EnsureOrigin = EnsureOriginEqualOrHigherPrivilege<ExpectedOrigin, OriginPrivilegeCmp>;

// `Root` has an higher privilege as our expected origin.
assert!(EnsureOrigin::ensure_origin(Origin::Root).is_ok());
// `SomethingBelowRoot` is exactly the expected origin.
assert!(EnsureOrigin::ensure_origin(Origin::SomethingBelowRoot).is_ok());
// The `NormalUser` origin is not allowed.
assert!(EnsureOrigin::ensure_origin(Origin::NormalUser).is_err());

Trait Implementations

impl<OuterOrigin, Origin, PrivilegeCmp> EnsureOrigin<OuterOrigin> for EnsureOriginEqualOrHigherPrivilege<Origin, PrivilegeCmp>

where Origin: Get<OuterOrigin>, OuterOrigin: Eq, PrivilegeCmp: PrivilegeCmp<OuterOrigin>,

type Success = ()

A return type.

fn try_origin(o: OuterOrigin) -> Result<Self::Success, OuterOrigin>

Perform the origin check.

fn try_successful_origin() -> Result<OuterOrigin, ()>

Attempt to get an outer origin capable of passing try_origin check. May return Err if it is impossible.

fn ensure_origin(o: OuterOrigin) -> Result<Self::Success, BadOrigin>

Perform the origin check.

fn ensure_origin_or_root( o: OuterOrigin, ) -> Result<Option<Self::Success>, BadOrigin>

where OuterOrigin: OriginTrait,

The same as ensure_origin except that Root origin will always pass. This can only be used if Success has a sensible impl of Default since that will be used in the result.

fn try_origin_or_root( o: OuterOrigin, ) -> Result<Option<Self::Success>, OuterOrigin>

where OuterOrigin: OriginTrait,

The same as try_origin except that Root origin will always pass. This can only be used if Success has a sensible impl of Default since that will be used in the result.