Struct core_cbc_casper::justification::Justification

pub struct Justification<E: Estimator>(_);

This struct holds the set of the Message that justify the current message. It works like a Vec.

Example

Using the VoteCount type message type for brevity's sake.

use core_cbc_casper::justification::Justification;
use core_cbc_casper::message::Message;
use core_cbc_casper::VoteCount;

let message = VoteCount::create_vote_message(0, true);

let mut justification = Justification::empty();

justification.insert(message.clone());

assert_eq!(
    *justification.iter().next().unwrap().estimate(),
    VoteCount { yes: 1, no: 0 },
);

Methods

impl<E: Estimator> Justification<E>

pub fn empty() -> Self

Creates an empty justification.

pub fn from_messages<U: WeightUnit>(
    messages: Vec<Message<E>>,
    state: &mut State<E, U>
) -> Self

Creates and returns a new justification from a vector of Message and mutates the given validator::State with the updated state.

pub fn iter(&self) -> Iter<Message<E>>

pub fn par_iter(&self) -> Iter<Message<E>>

pub fn contains(&self, message: &Message<E>) -> bool

pub fn len(&self) -> usize

pub fn is_empty(&self) -> bool

pub fn insert(&mut self, message: Message<E>) -> bool

This function checks if the message is already contained into the underlying Vec. If it is, it does nothing and returns false. Else, it will push the message in the Vec and returns true.

pub fn make_estimate<U: WeightUnit>(
    &self,
    equivocators: &HashSet<E::ValidatorName>,
    validators_weights: &Weights<E::ValidatorName, U>
) -> Result<E, E::Error>

Runs the estimator on the justification given the set of equivocators and validators' weights.

pub fn faulty_inserts<'a, U: WeightUnit>(
    &mut self,
    messages: &HashSet<&'a Message<E>>,
    state: &mut State<E, U>
) -> HashSet<&'a Message<E>>

Inserts messages to the justification, accepting up to the threshold faults by weight. In ordering to insert as much messages as possible, the input messages are sorted ascendingly by their validators' weight. Returns a HashSet of messages that got successfully included in the justification.

pub fn faulty_insert<U: WeightUnit>(
    &mut self,
    message: &Message<E>,
    state: &mut State<E, U>
) -> bool

This function makes no assumption on how to treat the equivocator. It adds the message to the justification only if it will not cross the fault tolerance threshold.

pub fn faulty_insert_with_slash<'a, U: WeightUnit>(
    &mut self,
    message: &Message<E>,
    state: &'a mut State<E, U>
) -> Result<bool, Error<'a, HashMap<E::ValidatorName, U>>>

This function sets the weight of an equivocator to zero right away (returned in validator::State) and add his message to the state, since his weight is null and doesn't count to the state fault weight anymore.

Trait Implementations

impl<E: Clone + Estimator> Clone for Justification<E>

fn clone(&self) -> Justification<E>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<E: Estimator> Debug for Justification<E>

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

Formats the value using the given formatter.

impl<E: Eq + Estimator> Eq for Justification<E>

impl<'_, E: Estimator> From<&'_ Justification<E>> for LatestMessages<E>

fn from(justification: &Justification<E>) -> Self

Extracts the latest messages of each validator from a justification.

impl<E: Estimator> From<LatestMessagesHonest<E>> for Justification<E>

fn from(lmh: LatestMessagesHonest<E>) -> Self

Performs the conversion.

impl<E: Hash + Estimator> Hash for Justification<E>

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given [Hasher].

fn hash_slice<H>(data: &[Self], state: &mut H) where
    H: Hasher, 

Feeds a slice of this type into the given [Hasher].

impl<E: PartialEq + Estimator> PartialEq<Justification<E>> for Justification<E>

fn eq(&self, other: &Justification<E>) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Justification<E>) -> bool

This method tests for !=.

impl<E: Estimator> StructuralEq for Justification<E>

impl<E: Estimator> StructuralPartialEq for Justification<E>