Struct RoundInput 

pub struct RoundInput<M> { /* private fields */ }

Simple implementation of RoundStore that waits for all parties to send a message

Round is considered complete when the store received a message from every party. Note that the store will ignore all the messages such as msg.sender == local_party_index.

Once round is complete, it outputs RoundMsgs.

Example

use round_based::{Incoming, MessageType};
use round_based::round::{RoundStore, RoundInput};

let mut input = RoundInput::<&'static str>::broadcast(1, 3);
input.add_message(Incoming{
    id: 0,
    sender: 0,
    msg_type: MessageType::Broadcast { reliable: false },
    msg: "first party message",
})?;
input.add_message(Incoming{
    id: 1,
    sender: 2,
    msg_type: MessageType::Broadcast { reliable: false },
    msg: "third party message",
})?;
assert!(!input.wants_more());

let output = input.output().unwrap();
assert_eq!(
    output.clone().into_vec_without_me(),
    ["first party message", "third party message"]
);
assert_eq!(
    output.into_vec_including_me("my msg"),
    ["first party message", "my msg", "third party message"]
);

Implementations

impl<M> RoundInput<M>

pub fn new(i: PartyIndex, n: u16, msg_type: MessageType) -> Self

Constructs new messages store

Takes index of local party i and amount of parties n

Panics

Panics if n is less than 2 or i is not in the range [0; n).

pub fn broadcast(i: PartyIndex, n: u16) -> Self

Construct a new store for broadcast messages

The same as RoundInput::new(i, n, MessageType::Broadcast { reliable: false })

pub fn reliable_broadcast(i: PartyIndex, n: u16) -> Self

Construct a new store for reliable broadcast messages

The same as RoundInput::new(i, n, MessageType::Broadcast { reliable: true })

pub fn p2p(i: PartyIndex, n: u16) -> Self

Construct a new store for p2p messages

The same as RoundInput::new(i, n, MessageType::P2P)

Trait Implementations

impl<M: Clone> Clone for RoundInput<M>

fn clone(&self) -> RoundInput<M>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<M: Debug> Debug for RoundInput<M>

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

Formats the value using the given formatter.

impl<M> RoundInfo for RoundInput<M>

where M: 'static,

type Msg = M

Message type

type Output = RoundMsgs<M>

Store output (e.g. Vec<_> of received messages)

type Error = RoundInputError

Store error

impl<M> RoundStore for RoundInput<M>

where M: 'static,

fn add_message(&mut self, msg: Incoming<Self::Msg>) -> Result<(), Self::Error>

Adds received message to the store

fn wants_more(&self) -> bool

Indicates if store expects more messages to receive

fn output(self) -> Result<Self::Output, Self>

Retrieves store output if enough messages are received

fn read_any_prop(&self, property: &mut dyn Any)

Interface that exposes ability to retrieve generic information about the round store