Struct SparseSequence 

pub struct SparseSequence<T> { /* private fields */ }

Mutable sparse indexed storage with stable holes and bounded allocation.

Logical length is stored separately from values. Writing a distant index allocates only its fixed-size chunk; intervening indices remain holes. max_len is an explicit work limit applied to every operation that can grow the logical sequence.

Implementations

impl<T> SparseSequence<T>

pub fn new(max_len: usize) -> Self

Construct an empty store whose logical length may not exceed max_len.

pub fn len(&self) -> usize

Return the logical length, including holes.

pub fn is_empty(&self) -> bool

Return whether the logical sequence is empty.

pub fn max_len(&self) -> usize

Return the configured logical-length limit.

pub fn occupied_len(&self) -> usize

Return the number of occupied positions.

pub fn revision(&self) -> u64

Return the mutation revision.

It advances for every successful operation that changes length or an occupied position, using wrapping arithmetic so mutation never fails merely because the diagnostic counter reached its integer limit.

pub fn get(&self, index: usize) -> Option<&T>

Return the value at index, or None for a hole or out-of-range index.

pub fn contains_index(&self, index: usize) -> bool

Return whether index is an occupied in-range position.

pub fn set( &mut self, index: usize, value: T, ) -> Result<Option<T>, SparseSequenceError>

Set index, growing the logical length with holes when necessary.

Returns the previously stored value, if the position was occupied.

pub fn remove(&mut self, index: usize) -> Option<T>

Remove and return the value at index, leaving a stable hole.

pub fn set_len(&mut self, new_len: usize) -> Result<(), SparseSequenceError>

Set the logical length, creating holes on growth and dropping values on truncation.

pub fn occupied_in<R>(&self, range: R) -> impl Iterator<Item = (usize, &T)>

where R: RangeBounds<usize>,

Traverse occupied (index, value) pairs within a bounded index range.

The range is intersected with the logical sequence, and holes do not produce iterator items or work proportional to the logical length.

Trait Implementations

impl<T: Clone> Clone for SparseSequence<T>

fn clone(&self) -> SparseSequence<T>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T: Debug> Debug for SparseSequence<T>

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

Formats the value using the given formatter.

impl<T: Eq> Eq for SparseSequence<T>

impl<T: PartialEq> PartialEq for SparseSequence<T>

fn eq(&self, other: &Self) -> bool

Equality operator ==.

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

Inequality operator !=.