Struct SparseList 

pub struct SparseList<T, const N: u64> { /* private fields */ }

A list with a maximum length of N that exposes its tree structure for sparse fill-in: materialized indices, cached subtree roots, or implicit zero-hashes for never-written regions.

Hash is byte-identical to a fully-materialised List<T, N> with the same effective contents.

Implementations

impl<T, const N: u64> SparseList<T, N>

pub fn new() -> Self

Build an empty sparse list.

pub fn len(&self) -> u64

Logical length.

pub fn is_empty(&self) -> bool

true iff no entries are present and len == 0.

pub fn iter(&self) -> impl Iterator<Item = (u64, &MissingOr<T>)>

Iterator over (index, MissingOr<T>) for materialized entries only.

pub fn iter_mut(&mut self) -> impl Iterator<Item = (u64, &mut MissingOr<T>)>

Mutable iterator over (index, &mut MissingOr<T>) for materialized entries only. Used by callers that need to rewrite entry values in place (e.g., resolving Ref targets to Hash after settle).

pub fn get(&self, idx: u64) -> Option<&MissingOr<T>>

Look up a single entry by leaf index. O(log n).

pub fn insert( &mut self, idx: u64, value: MissingOr<T>, ) -> Result<(), DecodeError>

Insert a materialized entry. Updates len to max(len, idx + 1). O(n) — sorted shift on insert. If idx is already present, the existing value is overwritten (matching BTreeMap::insert semantics).

pub fn remove(&mut self, idx: u64) -> Option<MissingOr<T>>

Remove the entry at idx, returning its previous value if any. Does not decrement len — the logical length is independent of which indices are materialized.

pub fn set_len(&mut self, len: u64) -> Result<(), DecodeError>

Set the logical length explicitly (does not affect entries).

pub fn cache_subtree_root(&mut self, depth: usize, idx: u64, root: [u8; 32])

Cache a precomputed subtree root at tree position (depth, idx). depth == 0 corresponds to the root; deeper means closer to leaves. O(n) — sorted insert into cached_subtree_roots.

pub fn cached_subtree_roots_count(&self) -> usize

Number of cached subtree roots. Used by fmt::Debug.

pub fn cached_subtree_roots(&self) -> impl Iterator<Item = (u64, &[u8; 32])>

Iterator over cached subtree roots in sorted-by-key order.

Trait Implementations

impl<T, const N: u64> Archive for SparseList<T, N>

where T: Archive + Clone, MissingOr<T>: Archive,

type Archived = <SparseListRepr<T> as Archive>::Archived

The archived representation of this type.

type Resolver = <SparseListRepr<T> as Archive>::Resolver

The resolver for this type. It must contain all the additional information from serializing needed to make the archived type from the normal type.

fn resolve(&self, resolver: Self::Resolver, out: Place<Self::Archived>)

Creates the archived version of this value at the given position and writes it to the given output.

const COPY_OPTIMIZATION: CopyOptimization<Self> = _

An optimization flag that allows the bytes of this type to be copied directly to a writer instead of calling serialize.

impl<T: Clone, const N: u64> Clone for SparseList<T, N>

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T: Debug, const N: u64> Debug for SparseList<T, N>

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

Formats the value using the given formatter.

impl<T: Decode, const N: u64> Decode for SparseList<T, N>

fn is_ssz_fixed_len() -> bool

true iff this type is fixed-length.

fn ssz_fixed_len() -> usize

Number of bytes this type occupies in the fixed-length portion of a container encoding. Variable-length types return BYTES_PER_LENGTH_OFFSET.

fn from_ssz_bytes(bytes: &[u8]) -> Result<Self, DecodeError>

Decode a full instance from bytes, rejecting trailing input.

impl<T, const N: u64> Default for SparseList<T, N>

fn default() -> Self

Returns the “default value” for a type.

impl<T, D, const N: u64> Deserialize<SparseList<T, N>, D> for <SparseListRepr<T> as Archive>::Archived

where T: Archive + Clone, MissingOr<T>: Archive, <SparseListRepr<T> as Archive>::Archived: Deserialize<SparseListRepr<T>, D>, D: Fallible + ?Sized,

fn deserialize( &self, deserializer: &mut D, ) -> Result<SparseList<T, N>, <D as Fallible>::Error>

Deserializes using the given deserializer

impl<T: Encode, const N: u64> Encode for SparseList<T, N>

fn is_ssz_fixed_len() -> bool

true iff this type is fixed-length (no variable-length fields).

fn ssz_fixed_len() -> usize

Number of bytes this type occupies in the fixed-length portion of a container encoding. For variable-length types this returns BYTES_PER_LENGTH_OFFSET (i.e. the size of the offset slot).

fn ssz_bytes_len(&self) -> usize

Total size of self when serialized.

fn ssz_append(&self, buf: &mut Vec<u8>)

Append the encoding of self to buf.

fn is_basic_type() -> bool

true for “basic” SSZ types (uintN, bool), which pack adjacent elements into shared 32-byte chunks for merkleization. Composite types (containers, lists, structs) return false (the default).

fn as_ssz_bytes(&self) -> Vec<u8>

Serialize into a fresh Vec<u8> allocated through the global allocator.

impl<T: HashTreeRoot + Encode, const N: u64> HashTreeRoot for SparseList<T, N>

fn hash_tree_root<D: Digest<OutputSize = U32>>(&self) -> [u8; 32]

Compute the hash tree root using D as the underlying hash.

impl<T: PartialEq, const N: u64> PartialEq for SparseList<T, N>

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

Tests for self and other values to be equal, and is used by ==.

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

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

impl<T, S, const N: u64> Serialize<S> for SparseList<T, N>

where T: Archive + Clone, MissingOr<T>: Archive, SparseListRepr<T>: Serialize<S>, S: Fallible + ?Sized,

fn serialize( &self, serializer: &mut S, ) -> Result<Self::Resolver, <S as Fallible>::Error>

Writes the dependencies for the object and returns a resolver that can create the archived type.

impl<T: Eq, const N: u64> Eq for SparseList<T, N>