Struct LogicalBlockAssignments 

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

Manages the physical block guards (RAII types) through three ordered collections, mirroring the block lifecycle state machine: MutableBlock<T> → CompleteBlock<T> → ImmutableBlock<T>.

Provides the same ordered-collection semantics as ExternalBlockAssignments but at the guard level rather than the identity level.

Implementations

impl<T: BlockMetadata> LogicalBlockAssignments<T>

pub fn new() -> Self

Creates an empty LogicalBlockAssignments.

pub fn assigned_count(&self) -> usize

Returns the number of assigned (registered/immutable) blocks.

pub fn staged_count(&self) -> usize

Returns the number of staged (complete) blocks.

pub fn unassigned_count(&self) -> usize

Returns the number of unassigned (mutable) blocks.

pub fn is_empty(&self) -> bool

Returns true if all three collections are empty.

pub fn contains(&self, block_id: &BlockId) -> bool

Checks whether a BlockId is present in any of the three collections.

pub fn get_assigned( &self, index: usize, ) -> Option<(&BlockId, &ImmutableBlock<T>)>

Returns the assigned block at the given index (insertion order).

pub fn get_staged(&self, index: usize) -> Option<(&BlockId, &CompleteBlock<T>)>

Returns the staged block at the given index (staging order).

pub fn get_unassigned( &self, index: usize, ) -> Option<(&BlockId, &MutableBlock<T>)>

Returns the unassigned block at the given index (FIFO order).

pub fn assigned_iter( &self, ) -> impl Iterator<Item = (&BlockId, &ImmutableBlock<T>)>

Iterates over assigned blocks in positional order.

pub fn staged_iter(&self) -> impl Iterator<Item = (&BlockId, &CompleteBlock<T>)>

Iterates over staged blocks in staging order.

pub fn unassigned_iter( &self, ) -> impl Iterator<Item = (&BlockId, &MutableBlock<T>)>

Iterates over unassigned blocks in FIFO order.

pub fn all_block_ids(&self) -> impl Iterator<Item = &BlockId>

Iterates over all block IDs across all three collections in lifecycle order: assigned → staged → unassigned.

pub fn extend_blocks( &mut self, blocks: impl IntoIterator<Item = MutableBlock<T>>, ) -> Result<usize, LogicalBlockAssignmentError<T>>

Adds mutable blocks to the unassigned queue.

Two-phase atomic: collects all blocks, validates no duplicate BlockIds across all three collections, then commits to unassigned. On error, all blocks are returned in the error variant (no leaks).

pub fn extend_assigned( &mut self, blocks: impl IntoIterator<Item = ImmutableBlock<T>>, ) -> Result<usize, LogicalBlockAssignmentError<T>>

Inserts pre-matched immutable blocks directly into the assigned collection.

This is the entry point for blocks retrieved via BlockManager::match_blocks — blocks that already exist in the manager’s pools and can skip the unassigned → staged → assigned pipeline.

Two-phase atomic: collects all blocks, validates no duplicate BlockIds across all three collections, then commits to assigned. On error, all blocks are returned in the error variant (no leaks).

pub fn stage( &mut self, sequence_blocks: &[TokenBlock], ) -> Result<usize, BlockError<MutableBlock<T>>>

FIFO drain from unassigned, completing each block with the corresponding token block.

Stages min(sequence_blocks.len(), unassigned.len()) blocks. On BlockError, already-staged blocks remain in staged; the failed block is returned in the error.

pub fn register(&mut self, manager: &BlockManager<T>) -> usize

Takes all staged blocks (FIFO order), registering each with the block manager and moving them to assigned.

Returns the number of blocks registered.

pub fn pop_last_unassigned(&mut self) -> Option<(BlockId, MutableBlock<T>)>

LIFO-removes the last unassigned block.

pub fn clear(&mut self)

Drops all guards across all three collections (RAII returns blocks to pools).

pub fn take_assigned(&mut self) -> Vec<(BlockId, ImmutableBlock<T>)>

Takes all assigned blocks, returning them as a Vec.

pub fn take_staged(&mut self) -> Vec<(BlockId, CompleteBlock<T>)>

Takes all staged blocks, returning them as a Vec.

pub fn take_unassigned(&mut self) -> Vec<(BlockId, MutableBlock<T>)>

Takes all unassigned blocks, returning them as a Vec.

Trait Implementations

impl<T: BlockMetadata> Debug for LogicalBlockAssignments<T>

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

Formats the value using the given formatter.

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

fn default() -> Self

Returns the “default value” for a type.