Struct massa_consensus_worker::state::blocks_state::BlocksState

pub struct BlocksState {
    block_statuses: PreHashMap<BlockId, BlockStatus>,
    incoming_index: PreHashSet<BlockId>,
    sequence_counter: u64,
    waiting_for_slot_index: PreHashSet<BlockId>,
    waiting_for_dependencies_index: PreHashSet<BlockId>,
    discarded_index: PreHashSet<BlockId>,
    active_index: PreHashSet<BlockId>,
}

Fields

block_statuses: PreHashMap<BlockId, BlockStatus>

Every block we know about

incoming_index: PreHashSet<BlockId>

Ids of incoming blocks/headers

sequence_counter: u64

Used to limit the number of waiting and discarded blocks

waiting_for_slot_index: PreHashSet<BlockId>

ids of waiting for slot blocks/headers

waiting_for_dependencies_index: PreHashSet<BlockId>

ids of waiting for dependencies blocks/headers

discarded_index: PreHashSet<BlockId>

ids of discarded blocks

active_index: PreHashSet<BlockId>

ids of active blocks

Implementations

impl BlocksState

pub fn new() -> Self

Initialize the BlocksState structure

pub fn get(&self, block_id: &BlockId) -> Option<&BlockStatus>

Get a reference on a BlockStatus from a BlockId

pub fn get_mut(&mut self, block_id: &BlockId) -> Option<&mut BlockStatus>

Get a mutable reference on a BlockStatus from a BlockId

pub fn sequence_counter(&self) -> u64

Get the sequence counter

pub fn incoming_blocks(&self) -> &PreHashSet<BlockId>

Get a reference on the list of all blocks stored with the status Incoming

pub fn waiting_for_slot_blocks(&self) -> &PreHashSet<BlockId>

Get a reference on the list of all blocks stored with the status WaitingForSlot

pub fn waiting_for_dependencies_blocks(&self) -> &PreHashSet<BlockId>

Get a reference on the list of all blocks stored with the status WaitingForDependencies

pub fn discarded_blocks(&self) -> &PreHashSet<BlockId>

Get a reference on the list of all blocks stored with the status Discarded

pub fn active_blocks(&self) -> &PreHashSet<BlockId>

Get a reference on the list of all blocks stored with the status Active

fn update_indexes( &mut self, block_id: &BlockId, old_block_status: Option<&BlockStatusId>, new_block_status: Option<&BlockStatusId>, )

fn promote_dep_tree(&mut self, hash: BlockId)

Promote a block id and all of its dependencies to be the first in the sequence

pub fn iter(&self) -> impl Iterator<Item = (&BlockId, &BlockStatus)> + '_

Get an iterator over all the blocks stored in the BlocksState

pub fn len(&self) -> usize

Get the number of blocks stored in the BlocksState

pub fn transition_map<F: FnOnce(Option<BlockStatus>, &mut PreHashMap<BlockId, BlockStatus>) -> Option<BlockStatus>>( &mut self, block_id: &BlockId, callback: F, )

Change the state of a block Steps are:

1. Remove the block from state
2. Call the callback function with the removed state (or None if block wasn’t in the BlocksState) as parameter and retrieve the new state (or None if we don’t want to add the block again in the BlocksState)
3. Verify that the transition is valid
4. Insert the new state in the BlocksState

Trait Implementations

impl Clone for BlocksState

fn clone(&self) -> BlocksState

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for BlocksState

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

Formats the value using the given formatter.