Struct sc_consensus_epochs::EpochChanges

pub struct EpochChanges<Hash, Number, E: Epoch> { /* fields omitted */ }

Tree of all epoch changes across all seen forks. Data stored in tree is the hash and block number of the block signaling the epoch change, and the epoch that was signalled at that block.

The first epoch, epoch_0, is special cased by saying that it starts at slot number of the first block in the chain. When bootstrapping a chain, there can be multiple competing block #1s, so we have to ensure that the overlayed DAG doesn’t get confused.

The first block of every epoch should be producing a descriptor for the next epoch - this is checked in higher-level code. So the first block of epoch_0 contains a descriptor for epoch_1. We special-case these and bundle them together in the same DAG entry, pinned to a specific block #1.

Further epochs (epoch_2, …, epoch_n) each get their own entry.

Implementations

impl<Hash, Number, E: Epoch> EpochChanges<Hash, Number, E> where
    Hash: PartialEq + Ord + AsRef<[u8]> + AsMut<[u8]> + Copy,
    Number: Ord + One + Zero + Add<Output = Number> + Sub<Output = Number> + Copy, 

pub fn new() -> Self

Create a new epoch change.

pub fn rebalance(&mut self)

Rebalances the tree of epoch changes so that it is sorted by length of fork (longest fork first).

pub fn map<B, F>(self, f: F) -> EpochChanges<Hash, Number, B> where
    B: Epoch<Slot = E::Slot>,
    F: FnMut(&Hash, &Number, E) -> B, 

Map the epoch changes from one storing data to a different one.

pub fn prune_finalized<D: IsDescendentOfBuilder<Hash>>(
    &mut self,
    descendent_of_builder: D,
    hash: &Hash,
    number: Number,
    slot: E::Slot
) -> Result<(), Error<D::Error>>

Prune out finalized epochs, except for the ancestor of the finalized block. The given slot should be the slot number at which the finalized block was authored.

pub fn epoch(&self, id: &EpochIdentifier<Hash, Number>) -> Option<&E>

Get a reference to an epoch with given identifier.

pub fn viable_epoch<G>(
    &self,
    descriptor: &ViableEpochDescriptor<Hash, Number, E>,
    make_genesis: G
) -> Option<ViableEpoch<E, &E>> where
    G: FnOnce(E::Slot) -> E, 

Get a reference to a viable epoch with given descriptor.

pub fn epoch_mut(
    &mut self,
    id: &EpochIdentifier<Hash, Number>
) -> Option<&mut E>

Get a mutable reference to an epoch with given identifier.

pub fn viable_epoch_mut<G>(
    &mut self,
    descriptor: &ViableEpochDescriptor<Hash, Number, E>,
    make_genesis: G
) -> Option<ViableEpoch<E, &mut E>> where
    G: FnOnce(E::Slot) -> E, 

Get a mutable reference to a viable epoch with given descriptor.

pub fn epoch_data<G>(
    &self,
    descriptor: &ViableEpochDescriptor<Hash, Number, E>,
    make_genesis: G
) -> Option<E> where
    G: FnOnce(E::Slot) -> E,
    E: Clone, 

Get the epoch data from an epoch descriptor.

Note that this function ignores the fact that an genesis epoch might need to be imported. Mostly useful for testing.

pub fn epoch_data_for_child_of<D: IsDescendentOfBuilder<Hash>, G>(
    &self,
    descendent_of_builder: D,
    parent_hash: &Hash,
    parent_number: Number,
    slot: E::Slot,
    make_genesis: G
) -> Result<Option<E>, Error<D::Error>> where
    G: FnOnce(E::Slot) -> E,
    E: Clone, 

Finds the epoch data for a child of the given block. Similar to epoch_descriptor_for_child_of but returns the full data.

Note that this function ignores the fact that an genesis epoch might need to be imported. Mostly useful for testing.

pub fn epoch_descriptor_for_child_of<D: IsDescendentOfBuilder<Hash>>(
    &self,
    descendent_of_builder: D,
    parent_hash: &Hash,
    parent_number: Number,
    slot: E::Slot
) -> Result<Option<ViableEpochDescriptor<Hash, Number, E>>, Error<D::Error>>

Finds the epoch for a child of the given block, assuming the given slot number.

If the returned epoch is an UnimportedGenesis epoch, it should be imported into the tree.

pub fn import<D: IsDescendentOfBuilder<Hash>>(
    &mut self,
    descendent_of_builder: D,
    hash: Hash,
    number: Number,
    parent_hash: Hash,
    epoch: IncrementedEpoch<E>
) -> Result<(), Error<D::Error>>

Import a new epoch-change, signalled at the given block.

This assumes that the given block is prospective (i.e. has not been imported yet), but its parent has. This is why the parent hash needs to be provided.

pub fn tree(&self) -> &ForkTree<Hash, Number, PersistedEpochHeader<E>>

Return the inner fork tree.

pub fn reset(
    &mut self,
    parent_hash: Hash,
    hash: Hash,
    number: Number,
    current: E,
    next: E
)

Reset to a specified pair of epochs, as if they were announced at blocks parent_hash and hash.

Trait Implementations

impl<Hash: Clone, Number: Clone, E: Clone + Epoch> Clone for EpochChanges<Hash, Number, E>

fn clone(&self) -> EpochChanges<Hash, Number, E>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<Hash, Number, E: Epoch> Decode for EpochChanges<Hash, Number, E> where
    ForkTree<Hash, Number, PersistedEpochHeader<E>>: Decode,
    ForkTree<Hash, Number, PersistedEpochHeader<E>>: Decode,
    BTreeMap<(Hash, Number), PersistedEpoch<E>>: Decode,
    BTreeMap<(Hash, Number), PersistedEpoch<E>>: Decode, 

fn decode<__CodecInputEdqy: Input>(
    __codec_input_edqy: &mut __CodecInputEdqy
) -> Result<Self, Error>

Attempt to deserialise the value from input.

fn skip<I>(input: &mut I) -> Result<(), Error> where
    I: Input, 

Attempt to skip the encoded value from input.

fn encoded_fixed_size() -> Option<usize>

Returns the fixed encoded size of the type.

impl<Hash, Number, E: Epoch> Default for EpochChanges<Hash, Number, E> where
    Hash: PartialEq + Ord,
    Number: Ord, 

fn default() -> Self

Returns the “default value” for a type.

impl<Hash, Number, E: Epoch> Encode for EpochChanges<Hash, Number, E> where
    ForkTree<Hash, Number, PersistedEpochHeader<E>>: Encode,
    ForkTree<Hash, Number, PersistedEpochHeader<E>>: Encode,
    BTreeMap<(Hash, Number), PersistedEpoch<E>>: Encode,
    BTreeMap<(Hash, Number), PersistedEpoch<E>>: Encode, 

fn encode_to<__CodecOutputEdqy: Output + ?Sized>(
    &self,
    __codec_dest_edqy: &mut __CodecOutputEdqy
)

Convert self to a slice and append it to the destination.

fn size_hint(&self) -> usize

If possible give a hint of expected size of the encoding.

fn encode(&self) -> Vec<u8, Global>

Convert self to an owned vector.

fn using_encoded<R, F>(&self, f: F) -> R where
    F: FnOnce(&[u8]) -> R, 

Convert self to a slice and then invoke the given closure with it.

fn encoded_size(&self) -> usize

Calculates the encoded size.

impl<Hash, Number, E: Epoch> EncodeLike<EpochChanges<Hash, Number, E>> for EpochChanges<Hash, Number, E> where
    ForkTree<Hash, Number, PersistedEpochHeader<E>>: Encode,
    ForkTree<Hash, Number, PersistedEpochHeader<E>>: Encode,
    BTreeMap<(Hash, Number), PersistedEpoch<E>>: Encode,
    BTreeMap<(Hash, Number), PersistedEpoch<E>>: Encode,