Struct ReadsContract 

#[non_exhaustive]
pub struct ReadsContract {
    pub required: &'static [&'static str],
    pub exactly_one_of: &'static [&'static [&'static str]],
    pub optional: &'static [&'static str],
    pub with_field_requires: &'static [(&'static str, &'static str)],
    pub lists: &'static [ListInput],
}

What an action requires of its step’s reads: map.

See ActionType::reads_contract.

Fields (Non-exhaustive)

Non-exhaustive structs could have additional fields added in future. Therefore, non-exhaustive structs cannot be constructed in external crates using the traditional Struct { .. } syntax; cannot be matched against without a wildcard ..; and struct update syntax will not work.

required: &'static [&'static str]

Inputs every step of this action must name.

exactly_one_of: &'static [&'static [&'static str]]

Groups from which exactly one input must be named. Each group holds the alternatives in the order they should be listed to the author.

optional: &'static [&'static str]

Inputs a step may name and the action reads when it does.

Listed so that a key the action would never look at is refused rather than dropped: a reads: entry that nothing reads is a step running without what its author gave it.

with_field_requires: &'static [(&'static str, &'static str)]

with: fields that mean nothing unless the step also names a given input, as (field, input) pairs.

Where an action offers two paths over one operation, a parameter can belong to only one of them. On the other path it would be parsed and never read, so the step would run without whatever the parameter asked for. This says which parameter needs which input.

lists: &'static [ListInput]

Inputs that hold a list of references rather than one, each with the fewest entries a step may give.

For an action that takes a set whose size the ceremony chooses, such as the shares of a split. Every other input named in this contract holds one reference, and the resolver reports a list where one is expected as it reports one where a list is.

Implementations

impl ReadsContract

pub const NONE: Self

The contract of an action that constrains its inputs in neither way.

pub const fn required(fields: &'static [&'static str]) -> Self

The contract of an action that requires these inputs and offers no alternatives between them.

pub fn is_list(&self, key: &str) -> bool

Whether the input named key holds a list under this contract.

pub fn is_empty(&self) -> bool

Whether this contract constrains the reads: map at all.

with_field_requires is a rule over with:, so it is not counted here.

pub fn accepts(&self, key: &str) -> bool

Whether a step of this action may name this input.

Trait Implementations

impl Clone for ReadsContract

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for ReadsContract

impl Debug for ReadsContract

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

Formats the value using the given formatter.

impl Eq for ReadsContract

impl PartialEq for ReadsContract

fn eq(&self, other: &Self) -> bool

Equality operator ==.

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

Inequality operator !=.

impl StructuralPartialEq for ReadsContract