Enum hbbft::sender_queue::Message

pub enum Message<M: SenderQueueableMessage> {
    EpochStarted(M::Epoch),
    Algo(M),
}

A SenderQueue message.

Variants

EpochStarted(M::Epoch)

The announcement that this node has reached the given epoch.

Algo(M)

A message of the wrapped algorithm.

Trait Implementations

impl<M: SenderQueueableMessage> From<M> for Message<M>

fn from(message: M) -> Self

Performs the conversion.

impl<M: Clone + SenderQueueableMessage> Clone for Message<M> where
    M::Epoch: Clone, 

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

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<M: Debug + SenderQueueableMessage> Debug for Message<M> where
    M::Epoch: Debug, 

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

Formats the value using the given formatter.

impl<M: SenderQueueableMessage> Serialize for Message<M> where
    M: Serialize,
    M::Epoch: Serialize, 

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

Serialize this value into the given Serde serializer.

impl<'de, M: SenderQueueableMessage> Deserialize<'de> for Message<M> where
    M: Deserialize<'de>,
    M::Epoch: Deserialize<'de>, 

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error> where
    __D: Deserializer<'de>, 

Deserialize this value from the given Serde deserializer.

impl<M: SenderQueueableMessage> Distribution<Message<M>> for Standard where
    Standard: Distribution<M> + Distribution<M::Epoch>, 

fn sample<R: Rng + ?Sized>(&self, rng: &mut R) -> Message<M>

Generate a random value of T, using rng as the source of randomness.

fn sample_iter<R>(&'a self, rng: &'a mut R) -> DistIter<'a, Self, R, T> where
    R: Rng, 

Create an iterator that generates random values of T, using rng as the source of randomness.