Struct sc_client_api::leaves::LeafSet

pub struct LeafSet<H, N> { /* private fields */ }

list of leaf hashes ordered by number (descending). stored in memory for fast access. this allows very fast checking and modification of active leaves.

Implementations

impl<H, N> LeafSet<H, N>where
    H: Clone + PartialEq + Decode + Encode,
    N: Debug + Clone + AtLeast32Bit + Decode + Encode,

pub fn new() -> Self

Construct a new, blank leaf set.

Examples found in repository

src/in_mem.rs (line 154)

	pub fn new() -> Blockchain<Block> {
		let storage = Arc::new(RwLock::new(BlockchainStorage {
			blocks: HashMap::new(),
			hashes: HashMap::new(),
			best_hash: Default::default(),
			best_number: Zero::zero(),
			finalized_hash: Default::default(),
			finalized_number: Zero::zero(),
			genesis_hash: Default::default(),
			header_cht_roots: HashMap::new(),
			leaves: LeafSet::new(),
			aux: HashMap::new(),
		}));
		Blockchain { storage }
	}

pub fn read_from_db(
    db: &dyn Database<H256>,
    column: u32,
    prefix: &[u8]
) -> Result<Self>

Read the leaf list from the DB, using given prefix for keys.

pub fn import(&mut self, hash: H, number: N, parent_hash: H) -> ImportOutcome<H, N>

Update the leaf list on import.

Examples found in repository

src/in_mem.rs (line 176)

	pub fn insert(
		&self,
		hash: Block::Hash,
		header: <Block as BlockT>::Header,
		justifications: Option<Justifications>,
		body: Option<Vec<<Block as BlockT>::Extrinsic>>,
		new_state: NewBlockState,
	) -> sp_blockchain::Result<()> {
		let number = *header.number();
		if new_state.is_best() {
			self.apply_head(&header)?;
		}

		{
			let mut storage = self.storage.write();
			storage.leaves.import(hash, number, *header.parent_hash());
			storage.blocks.insert(hash, StoredBlock::new(header, body, justifications));

			if let NewBlockState::Final = new_state {
				storage.finalized_hash = hash;
				storage.finalized_number = number;
			}

			if number == Zero::zero() {
				storage.genesis_hash = hash;
			}
		}

		Ok(())
	}

pub fn remove(
    &mut self,
    hash: H,
    number: N,
    parent_hash: Option<H>
) -> Option<RemoveOutcome<H, N>>

Update the leaf list on removal.

Note that the leaves set structure doesn’t have the information to decide if the leaf we’re removing is the last children of the parent. Follows that this method requires the caller to check this condition and optionally pass the parent_hash if hash is its last child.

Returns None if no modifications are applied.

pub fn finalize_height(&mut self, number: N) -> FinalizationOutcome<H, N>

Note a block height finalized, displacing all leaves with number less than the finalized block’s.

Although it would be more technically correct to also prune out leaves at the same number as the finalized block, but with different hashes, the current behavior is simpler and our assumptions about how finalization works means that those leaves will be pruned soon afterwards anyway.

pub fn displaced_by_finalize_height(
    &self,
    number: N
) -> FinalizationOutcome<H, N>

The same as Self::finalize_height, but it only simulates the operation.

This means that no changes are done.

Returns the leaves that would be displaced by finalizing the given block.

Examples found in repository

src/in_mem.rs (line 438)

	fn displaced_leaves_after_finalizing(
		&self,
		block_number: NumberFor<Block>,
	) -> sp_blockchain::Result<Vec<Block::Hash>> {
		Ok(self
			.storage
			.read()
			.leaves
			.displaced_by_finalize_height(block_number)
			.leaves()
			.cloned()
			.collect::<Vec<_>>())
	}

pub fn undo(&mut self) -> Undo<'_, H, N>

Undo all pending operations.

This returns an Undo struct, where any Displaced objects that have returned by previous method calls should be passed to via the appropriate methods. Otherwise, the on-disk state may get out of sync with in-memory state.

pub fn revert(&mut self, best_hash: H, best_number: N)

Revert to the given block height by dropping all leaves in the leaf set with a block number higher than the target.

pub fn hashes(&self) -> Vec<H>

returns an iterator over all hashes in the leaf set ordered by their block number descending.

Examples found in repository

src/in_mem.rs (line 427)

	fn leaves(&self) -> sp_blockchain::Result<Vec<Block::Hash>> {
		Ok(self.storage.read().leaves.hashes())
	}

pub fn count(&self) -> usize

Number of known leaves.

Examples found in repository

src/in_mem.rs (line 359)

	fn info(&self) -> blockchain::Info<Block> {
		let storage = self.storage.read();
		blockchain::Info {
			best_hash: storage.best_hash,
			best_number: storage.best_number,
			genesis_hash: storage.genesis_hash,
			finalized_hash: storage.finalized_hash,
			finalized_number: storage.finalized_number,
			finalized_state: if storage.finalized_hash != Default::default() {
				Some((storage.finalized_hash, storage.finalized_number))
			} else {
				None
			},
			number_leaves: storage.leaves.count(),
			block_gap: None,
		}
	}

pub fn prepare_transaction(
    &mut self,
    tx: &mut Transaction<H256>,
    column: u32,
    prefix: &[u8]
)

Write the leaf list to the database transaction.

pub fn contains(&self, number: N, hash: H) -> bool

Check if given block is a leaf.

pub fn highest_leaf(&self) -> Option<(N, &[H])>

Returns the highest leaf and all hashes associated to it.

Trait Implementations

impl<H: Clone, N: Clone> Clone for LeafSet<H, N>

fn clone(&self) -> LeafSet<H, N>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<H: Debug, N: Debug> Debug for LeafSet<H, N>

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

Formats the value using the given formatter.

impl<H: PartialEq, N: PartialEq> PartialEq<LeafSet<H, N>> for LeafSet<H, N>

fn eq(&self, other: &LeafSet<H, N>) -> bool

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

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

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

impl<H: Eq, N: Eq> Eq for LeafSet<H, N>

impl<H, N> StructuralEq for LeafSet<H, N>

impl<H, N> StructuralPartialEq for LeafSet<H, N>