Struct BlockHolder 

pub struct BlockHolder<T: BlockMetadata> { /* private fields */ }

RAII container for holding blocks during sessions. RAII block holder - tier-agnostic, just holds blocks.

Type Parameter

T is the tier metadata type (e.g., G2, G3). It must implement BlockMetadata which is Clone + Send + Sync + 'static.

RAII Semantics

When BlockHolder is dropped, all held blocks are released. This ensures blocks don’t leak even if session handling panics.

Example

// Create holder with searched blocks
let mut holder = BlockHolder::new(g2_blocks);

// Check what we have
println!("Holding {} blocks", holder.count());

// Release some blocks (e.g., after RDMA pull)
holder.release(&pulled_hashes);

// Holder drops here, releasing any remaining blocks

Implementations

impl<T: BlockMetadata> BlockHolder<T>

pub fn new(blocks: Vec<ImmutableBlock<T>>) -> Self

Create a new BlockHolder with the given blocks.

pub fn empty() -> Self

Create an empty BlockHolder.

pub fn blocks(&self) -> &[ImmutableBlock<T>]

Get a reference to the held blocks.

pub fn count(&self) -> usize

Get the number of held blocks.

pub fn is_empty(&self) -> bool

Check if the holder is empty.

pub fn extend(&mut self, blocks: impl IntoIterator<Item = ImmutableBlock<T>>)

Add blocks to this holder.

pub fn release(&mut self, hashes: &[SequenceHash])

Release blocks matching the given sequence hashes.

Removes blocks from the holder whose sequence hash is in hashes. The blocks are dropped, releasing their references.

pub fn retain(&mut self, hashes: &[SequenceHash])

Retain only blocks matching the given sequence hashes.

Removes blocks from the holder whose sequence hash is NOT in hashes. The removed blocks are dropped, releasing their references.

pub fn take_all(&mut self) -> Vec<ImmutableBlock<T>>

Take all blocks out of this holder.

The holder becomes empty. Useful for transferring blocks to another location or for processing before dropping.

pub fn sequence_hashes(&self) -> Vec<SequenceHash>

Get sequence hashes of all held blocks.

pub fn find(&self, hash: &SequenceHash) -> Option<&ImmutableBlock<T>>

Find a block by sequence hash.

pub fn contains(&self, hash: &SequenceHash) -> bool

Check if a block with the given hash is held.

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

Iterate over held blocks.

Trait Implementations

impl<T: Debug + BlockMetadata> Debug for BlockHolder<T>

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

Formats the value using the given formatter.

impl<T: BlockMetadata> Default for BlockHolder<T>

fn default() -> Self

Returns the “default value” for a type.

impl<T: BlockMetadata> FromIterator<ImmutableBlock<T>> for BlockHolder<T>

fn from_iter<I: IntoIterator<Item = ImmutableBlock<T>>>(iter: I) -> Self

Creates a value from an iterator.

impl<T: BlockMetadata> IntoIterator for BlockHolder<T>

type Item = ImmutableBlock<T>

The type of the elements being iterated over.

type IntoIter = IntoIter<ImmutableBlock<T>>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<'a, T: BlockMetadata> IntoIterator for &'a BlockHolder<T>

type Item = &'a ImmutableBlock<T>

The type of the elements being iterated over.

type IntoIter = Iter<'a, ImmutableBlock<T>>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.