Struct ValidatorMap

pub struct ValidatorMap<T>(/* private fields */);

A map from the set of validators to some values.

Implementations

impl<C: Context> ValidatorMap<Observation<C>>

pub fn has_correct(&self) -> bool

Returns true if there is at least one correct observation.

pub fn iter_correct<'a>( &'a self, state: &'a State<C>, ) -> impl Iterator<Item = &'a Unit<C>>

Returns an iterator over all honest validators’ latest units.

pub fn iter_correct_hashes(&self) -> impl Iterator<Item = &C::Hash>

Returns an iterator over all honest validators’ latest units’ hashes.

pub fn iter_faulty(&self) -> impl Iterator<Item = ValidatorIndex> + '_

Returns an iterator over all faulty validators’ indices.

pub fn iter_none(&self) -> impl Iterator<Item = ValidatorIndex> + '_

Returns an iterator over all faulty validators’ indices.

pub fn sees_correct(&self, state: &State<C>, hash: &C::Hash) -> bool

Returns true if self sees the creator of hash as correct, and sees that unit.

pub fn sees(&self, state: &State<C>, hash_to_be_found: &C::Hash) -> bool

Returns true if self sees the unit with the specified hash.

pub fn cutoff(&self, state: &State<C>, timestamp: Timestamp) -> Panorama<C>

Returns the panorama seeing all units seen by self with a timestamp no later than timestamp. Accusations are preserved regardless of the evidence’s timestamp.

pub fn geq(&self, state: &State<C>, other: &Panorama<C>) -> bool

Returns whether self can possibly come later in time than other, i.e. it can see every honest message and every fault seen by other.

impl<T> ValidatorMap<T>

pub fn get(&self, idx: ValidatorIndex) -> Option<&T>

Returns the value for the given validator, or None if the index is out of range.

pub fn len(&self) -> usize

Returns the number of values. This must equal the number of validators.

pub fn is_empty(&self) -> bool

Returns true if this ValidatorMap is empty.

pub fn iter(&self) -> impl Iterator<Item = &T>

Returns an iterator over all values.

pub fn iter_mut(&mut self) -> impl Iterator<Item = &mut T>

Returns an iterator over mutable references to all values.

pub fn enumerate(&self) -> impl Iterator<Item = (ValidatorIndex, &T)>

Returns an iterator over all values, by validator index.

pub fn has(&self, idx: ValidatorIndex) -> bool

Returns true if self has an entry for validator number idx.

pub fn keys(&self) -> impl Iterator<Item = ValidatorIndex>

Returns an iterator over all validator indices.

pub fn binary_search(&self, x: &T) -> Option<ValidatorIndex>

where T: Ord,

Binary searches this sorted ValidatorMap for x.

Returns the lowest index of an entry >= x, or None if x is greater than all entries.

impl<T> ValidatorMap<Option<T>>

pub fn keys_some(&self) -> impl Iterator<Item = ValidatorIndex> + '_

Returns the keys of all validators whose value is Some.

pub fn iter_some(&self) -> impl Iterator<Item = (ValidatorIndex, &T)> + '_

Returns an iterator over all values that are present, together with their index.

Trait Implementations

impl<Rhs, T: Copy + Add<Rhs, Output = T>> Add<ValidatorMap<Rhs>> for ValidatorMap<T>

type Output = ValidatorMap<T>

The resulting type after applying the + operator.

fn add(self, rhs: ValidatorMap<Rhs>) -> Self::Output

Performs the + operation.

impl<T> AsRef<Vec<T>> for ValidatorMap<T>

fn as_ref(&self) -> &Vec<T>

Converts this type into a shared reference of the (usually inferred) input type.

impl<T: Clone> Clone for ValidatorMap<T>

fn clone(&self) -> ValidatorMap<T>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T> DataSize for ValidatorMap<T>

where T: DataSize,

const IS_DYNAMIC: bool = true

If true, the type has a heap size that can vary at runtime, depending on the actual value.

const STATIC_HEAP_SIZE: usize = 0usize

The amount of space a value of the type always occupies. If IS_DYNAMIC is false, this is the total amount of heap memory occupied by the value. Otherwise this is a lower bound.

fn estimate_heap_size(&self) -> usize

Estimates the size of heap memory taken up by this value.

fn estimate_detailed_heap_size(&self) -> MemUsageNode

Create a tree of memory estimations.

impl<T: Debug> Debug for ValidatorMap<T>

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

Formats the value using the given formatter.

impl<'de, T> Deserialize<'de> for ValidatorMap<T>

where T: Deserialize<'de>,

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<T> Display for ValidatorMap<Option<T>>

where T: Display,

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

Formats the value using the given formatter.

impl<T> From<Vec<T>> for ValidatorMap<T>

fn from(original: Vec<T>) -> ValidatorMap<T>

Converts to this type from the input type.

impl<T> FromIterator<T> for ValidatorMap<T>

fn from_iter<I: IntoIterator<Item = T>>(ii: I) -> ValidatorMap<T>

Creates a value from an iterator.

impl<T: Hash> Hash for ValidatorMap<T>

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, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<T> Index<ValidatorIndex> for ValidatorMap<T>

type Output = T

The returned type after indexing.

fn index(&self, vidx: ValidatorIndex) -> &T

Performs the indexing (container[index]) operation.

impl<T> IndexMut<ValidatorIndex> for ValidatorMap<T>

fn index_mut(&mut self, vidx: ValidatorIndex) -> &mut T

Performs the mutable indexing (container[index]) operation.

impl<'a, T> IntoIterator for &'a ValidatorMap<T>

type Item = &'a T

The type of the elements being iterated over.

type IntoIter = Iter<'a, T>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<T> IntoIterator for ValidatorMap<T>

type Item = T

The type of the elements being iterated over.

type IntoIter = IntoIter<T>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<T: PartialEq> PartialEq for ValidatorMap<T>

fn eq(&self, other: &ValidatorMap<T>) -> bool

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<T> Serialize for ValidatorMap<T>

where T: Serialize,

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl<T: Eq> Eq for ValidatorMap<T>

impl<T> StructuralPartialEq for ValidatorMap<T>