Struct RadixMap 

pub struct RadixMap<V, const KEY_BYTES: usize> { /* private fields */ }

A structurally-compressed sparse binary radix merkle map (option “b”).

Keys are [u8; KEY_BYTES] (MSB-first); values are V: HashTreeRoot. The root is canonical and binding (see the module docs). Storage is the strictly-ascending sorted set of (key, MissingOr<V>) entries; the tree structure is recomputed on HashTreeRoot::hash_tree_root.

Implementations

impl<V, const KEY_BYTES: usize> RadixMap<V, KEY_BYTES>

pub const KEY_BITS: usize

Number of significant key bits (8 * KEY_BYTES).

pub fn new() -> Self

Build an empty map.

pub fn len(&self) -> usize

Number of entries (the map’s “length” is just its key count).

pub fn is_empty(&self) -> bool

true iff the map holds no entries.

pub fn get(&self, key: &[u8; KEY_BYTES]) -> Option<&MissingOr<V>>

Look up an entry by key. O(log n).

pub fn insert( &mut self, key: [u8; KEY_BYTES], value: MissingOr<V>, ) -> Option<MissingOr<V>>

Insert (or overwrite) an entry, keeping the sorted invariant. Returns the previous value at key, if any. O(n) (sorted shift).

pub fn remove(&mut self, key: &[u8; KEY_BYTES]) -> Option<MissingOr<V>>

Remove the entry at key, returning its previous value if present.

pub fn iter(&self) -> impl Iterator<Item = (&[u8; KEY_BYTES], &MissingOr<V>)>

Iterate entries in ascending key order.

pub fn iter_mut( &mut self, ) -> impl Iterator<Item = (&[u8; KEY_BYTES], &mut MissingOr<V>)>

Mutably iterate entries in ascending key order (e.g. to resolve Ref targets after settle), preserving the key set / order.

impl<V: HashTreeRoot + Clone, const KEY_BYTES: usize> RadixMap<V, KEY_BYTES>

pub fn prove<D: Digest<OutputSize = U32>>( &self, key: &[u8; KEY_BYTES], ) -> RadixProof<V, KEY_BYTES>

Produce a compact (non-)membership proof for key.

Trait Implementations

impl<V, const KEY_BYTES: usize> Archive for RadixMap<V, KEY_BYTES>

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

type Archived = <RadixMapRepr<V, KEY_BYTES> as Archive>::Archived

The archived representation of this type.

type Resolver = <RadixMapRepr<V, KEY_BYTES> 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<V: Clone, const KEY_BYTES: usize> Clone for RadixMap<V, KEY_BYTES>

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<V: Debug, const KEY_BYTES: usize> Debug for RadixMap<V, KEY_BYTES>

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

Formats the value using the given formatter.

impl<V: Decode, const KEY_BYTES: usize> Decode for RadixMap<V, KEY_BYTES>

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<V, const KEY_BYTES: usize> Default for RadixMap<V, KEY_BYTES>

fn default() -> Self

Returns the “default value” for a type.

impl<V, D, const KEY_BYTES: usize> Deserialize<RadixMap<V, KEY_BYTES>, D> for <RadixMapRepr<V, KEY_BYTES> as Archive>::Archived

where V: Archive + Clone, MissingOr<V>: Archive, <RadixMapRepr<V, KEY_BYTES> as Archive>::Archived: Deserialize<RadixMapRepr<V, KEY_BYTES>, D>, D: Fallible + ?Sized,

fn deserialize( &self, deserializer: &mut D, ) -> Result<RadixMap<V, KEY_BYTES>, <D as Fallible>::Error>

Deserializes using the given deserializer

impl<V: Encode, const KEY_BYTES: usize> Encode for RadixMap<V, KEY_BYTES>

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<V: HashTreeRoot, const KEY_BYTES: usize> HashTreeRoot for RadixMap<V, KEY_BYTES>

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

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

impl<V: PartialEq, const KEY_BYTES: usize> PartialEq for RadixMap<V, KEY_BYTES>

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<V, S, const KEY_BYTES: usize> Serialize<S> for RadixMap<V, KEY_BYTES>

where V: Archive + Clone, MissingOr<V>: Archive, RadixMapRepr<V, KEY_BYTES>: 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<V: Eq, const KEY_BYTES: usize> Eq for RadixMap<V, KEY_BYTES>