Struct Step 

pub struct Step<M, O, N, F: Fail> {
    pub output: Vec<O>,
    pub fault_log: FaultLog<N, F>,
    pub messages: Vec<TargetedMessage<M, N>>,
}

Single algorithm step outcome.

Each time input (typically in the form of user input or incoming network messages) is provided to an instance of an algorithm, a Step is produced, potentially containing output values, a fault log, and network messages.

Any Step must always be used by the client application; at the very least the resulting messages must be queued.

Handling unused Steps

In the (rare) case of a Step not being of any interest at all, instead of discarding it through let _ = ... or similar constructs, the implicit assumption should explicitly be checked instead:

assert!(alg.propose(123).expect("Could not propose value").is_empty(),
        "Algorithm will never output anything on first proposal");

If an edge case occurs and outgoing messages are generated as a result, the assert! will catch it, instead of potentially stalling the algorithm.

Fields

output: Vec<O>

The algorithm’s output, after consensus has been reached. This is guaranteed to be the same in all nodes.

fault_log: FaultLog<N, F>

A list of nodes that are not following consensus, together with information about the detected misbehavior.

messages: Vec<TargetedMessage<M, N>>

A list of messages that must be sent to other nodes. Each entry contains a message and a Target.

Implementations

impl<M, O, N, F> Step<M, O, N, F>

where F: Fail,

pub fn new( output: Vec<O>, fault_log: FaultLog<N, F>, messages: Vec<TargetedMessage<M, N>>, ) -> Self

Creates a new Step from the given collections.

pub fn with_output<T: Into<Option<O>>>(self, output: T) -> Self

Returns the same step, with the given additional output.

pub fn map<M2, O2, F2, FO, FF, FM>( self, f_out: FO, f_fail: FF, f_msg: FM, ) -> Step<M2, O2, N, F2>

where F2: Fail, FO: Fn(O) -> O2, FF: Fn(F) -> F2, FM: Fn(M) -> M2,

Converts self into a step of another type, given conversion methods for output, faults, and messages.

pub fn extend_with<M2, O2, F2, FF, FM>( &mut self, other: Step<M2, O2, N, F2>, f_fail: FF, f_msg: FM, ) -> Vec<O2>

where F2: Fail, FF: Fn(F2) -> F, FM: Fn(M2) -> M,

Extends self with others messages and fault logs, and returns other.output.

pub fn extend(&mut self, other: Self)

Adds the outputs, fault logs and messages of other to self.

pub fn join(self, other: Self) -> Self

Extends this step with other and returns the result.

pub fn is_empty(&self) -> bool

Returns true if there are no messages, faults or outputs.

impl<'i, M, O, N, F> Step<M, O, N, F>

where N: NodeIdT, M: 'i + Clone + SenderQueueableMessage, F: Fail,

pub fn defer_messages( &mut self, peer_epochs: &BTreeMap<N, M::Epoch>, max_future_epochs: u64, ) -> Vec<(N, M)>

Removes and returns any messages that are not yet accepted by remote nodes according to the mapping remote_epochs. This way the returned messages are postponed until later, and the remaining messages can be sent to remote nodes without delay.

Trait Implementations

impl<M: Debug, O: Debug, N: Debug, F: Debug + Fail> Debug for Step<M, O, N, F>

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

Formats the value using the given formatter.

impl<M, O, N, F> Default for Step<M, O, N, F>

where F: Fail,

fn default() -> Self

Returns the “default value” for a type.

impl<M, O, N, F> From<Fault<N, F>> for Step<M, O, N, F>

where F: Fail,

fn from(fault: Fault<N, F>) -> Self

Converts to this type from the input type.

impl<M, O, N, F> From<FaultLog<N, F>> for Step<M, O, N, F>

where F: Fail,

fn from(fault_log: FaultLog<N, F>) -> Self

Converts to this type from the input type.

impl<I, M, O, N, F> From<I> for Step<M, O, N, F>

where I: IntoIterator<Item = TargetedMessage<M, N>>, F: Fail,

fn from(msgs: I) -> Self

Converts to this type from the input type.

impl<M, O, N, F> From<TargetedMessage<M, N>> for Step<M, O, N, F>

where F: Fail,

fn from(msg: TargetedMessage<M, N>) -> Self

Converts to this type from the input type.