Struct Rules

pub struct Rules { /* private fields */ }

A set of valid Rules, where the set of DIDs and threshold are fully resolved and valid. Since the rules are constructed via a BTreeMap, they cannot be duplicated.

To construct the set of rules, use Rules::from_raw, which validates a set of RawRules, and their Pattern references, into a set of ValidRules.

Implementations

impl Rules

pub fn iter( &self, ) -> impl Iterator<Item = (&Pattern, &Rule<ResolvedDelegates, Threshold>)>

Returns an iterator over the Pattern and ValidRule in the set of rules.

pub fn is_empty(&self) -> bool

Returns true is the set of rules is empty.

pub fn from_raw<R>( rules: impl IntoIterator<Item = (Pattern, Rule<Allowed, usize>)>, resolve: &mut R, ) -> Result<Rules, ValidationError>

where R: Fn() -> Delegates,

Construct a set of Rules given a set of RawRules.

pub fn matches<'a>( &self, refname: &Qualified<'a>, ) -> impl Iterator<Item = (&Pattern, &Rule<ResolvedDelegates, Threshold>)> + use<'a, '_>

Return the matching rules for the given refname.

pub fn canonical<'a, 'b>( &'a self, refname: Qualified<'b>, repo: &Repository, ) -> Result<Option<Canonical<'b, 'a>>, CanonicalError>

Match given refname, take the most specific rule, and prepare evaluation as Canonical

N.b. it will find the first rule that is most specific for the given refname.

Trait Implementations

impl Clone for Rules

fn clone(&self) -> Rules

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Rules

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

Formats the value using the given formatter.

impl Default for Rules

fn default() -> Rules

Returns the “default value” for a type.

impl Extend<(Pattern, Rule<ResolvedDelegates, Threshold>)> for Rules

fn extend<T>(&mut self, iter: T)

where T: IntoIterator<Item = (Pattern, Rule<ResolvedDelegates, Threshold>)>,

Extends a collection with the contents of an iterator.

fn extend_one(&mut self, item: A)

🔬This is a nightly-only experimental API. (extend_one)

Extends a collection with exactly one element.

fn extend_reserve(&mut self, additional: usize)

🔬This is a nightly-only experimental API. (extend_one)

Reserves capacity in a collection for the given number of additional elements.

impl From<Rules> for RawRules

fn from(_: Rules) -> RawRules

Converts to this type from the input type.

impl FromIterator<(Pattern, Rule<ResolvedDelegates, Threshold>)> for Rules

fn from_iter<T>(iter: T) -> Rules

where T: IntoIterator<Item = (Pattern, Rule<ResolvedDelegates, Threshold>)>,

Creates a value from an iterator.

impl<'a> IntoIterator for &'a Rules

type Item = (&'a Pattern, &'a Rule<ResolvedDelegates, Threshold>)

The type of the elements being iterated over.

type IntoIter = Iter<'a, Pattern, Rule<ResolvedDelegates, Threshold>>

Which kind of iterator are we turning this into?

fn into_iter(self) -> <&'a Rules as IntoIterator>::IntoIter

Creates an iterator from a value.

impl IntoIterator for Rules

type Item = (Pattern, Rule<ResolvedDelegates, Threshold>)

The type of the elements being iterated over.

type IntoIter = IntoIter<Pattern, Rule<ResolvedDelegates, Threshold>>

Which kind of iterator are we turning this into?

fn into_iter(self) -> <Rules as IntoIterator>::IntoIter

Creates an iterator from a value.

impl PartialEq for Rules

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

fn serialize<__S>( &self, __serializer: __S, ) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Eq for Rules

impl StructuralPartialEq for Rules