Struct Rule

pub struct Rule<D, T> { /* private fields */ }

A Rule defines how a reference or set of references can be made canonical, i.e. have a top-level refs/* entry – see Pattern.

The Rule::allowed type is generic to allow for Allowed to be used for serialization and deserialization, however, the use of Rule::validate should be used to get a valid rule.

The Rule::threshold, similarly, allows for doc::Threshold to be used, and Rule::validate should be used to get a valid rule.

Implementations

impl Rule<Allowed, usize>

pub fn validate<R>( self, resolve: &mut R, ) -> Result<Rule<ResolvedDelegates, Threshold>, ValidationError>

where R: Fn() -> Delegates,

Validate the Rule into a form that can be used for calculating canonical references.

The resolve callback is to allow the caller to specify the DIDs of the identity document, in the case that the allowed value is Allowed::Delegates.

impl Rule<ResolvedDelegates, Threshold>

pub fn default_branch( did: Did, name: &RefStr, ) -> Result<(Pattern, Rule<ResolvedDelegates, Threshold>), PatternError>

Initialize a ValidRule for the default branch, given by name. The rule will contain the single did as the allowed DID, and use a threshold of 1.

Note that the serialization of the rule will use the delegates token for the rule. E.g.

{
  "pattern": "refs/heads/main",
  "allow": ["did:key:z6MknSLrJoTcukLrE435hVNQT4JUhbvWLX4kUzqkEStBU8Vi"],
  "threshold": 1
}

Errors

If the name reference begins with refs/rad.

impl<D, T> Rule<D, T>

pub fn new(allow: D, threshold: T) -> Rule<D, T>

Construct a new Rule with the given allow and threshold.

pub fn allowed(&self) -> &D

Get the set of DIDs this Rule was created with.

pub fn threshold(&self) -> &T

Get the set of threshold this Rule was created with.

pub fn extensions(&self) -> &Map<String, Value>

Get the extensions that may have been added to this Rule.

pub fn add_extensions(&mut self, extensions: impl Into<Map<String, Value>>)

If the Rule::extensions is not set, the provided extensions will be used.

Otherwise, it expects that the JSON value is a Map and the extensions are merged. If the existing value is any other kind of JSON value, this is a no-op.

Trait Implementations

impl<D, T> Clone for Rule<D, T>

where D: Clone, T: Clone,

fn clone(&self) -> Rule<D, T>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<D, T> Debug for Rule<D, T>

where D: Debug, T: Debug,

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

Formats the value using the given formatter.

impl<'de, D, T> Deserialize<'de> for Rule<D, T>

where D: Sealed + Deserialize<'de>, T: Sealed + Deserialize<'de>,

fn deserialize<__D>( __deserializer: __D, ) -> Result<Rule<D, T>, <__D as Deserializer<'de>>::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl From<Rule<ResolvedDelegates, Threshold>> for Rule<Allowed, usize>

fn from(rule: Rule<ResolvedDelegates, Threshold>) -> Rule<Allowed, usize>

Converts to this type from the input type.

impl<D, T> PartialEq for Rule<D, T>

where D: PartialEq, T: PartialEq,

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

where D: Serialize, T: Serialize,

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<D, T> Eq for Rule<D, T>

where D: Eq, T: Eq,

impl<D, T> StructuralPartialEq for Rule<D, T>