Struct IterableMap 

pub struct IterableMap<K, V> { /* private fields */ }

A map over global state that allows iteration. Each entry at key K_n stores (K_{n}, V, K_{n-1}), where V is the value and K_{n-1} is the key hash of the previous entry.

This creates a constant spatial overhead; every entry stores a pointer to the one inserted before it.

Enables iteration without a guaranteed ordering; updating an existing key does not affect position.

Under the hood, this is a singly-linked HashMap with linear probing for collision resolution. Supports full traversal, typically in reverse-insertion order.

Implementations

impl<K, V> IterableMap<K, V>

where K: IterableMapHash, V: BorshSerialize + BorshDeserialize,

pub fn new<S: Into<String>>(prefix: S) -> Self

Creates an empty IterableMap with the given prefix.

pub fn insert(&mut self, key: K, value: V) -> Option<V>

Inserts a key-value pair into the map.

If the map did not have this key present, None is returned.

If the map did have this key present, the value is updated, and the old value is returned.

This has an amortized complexity of O(1), with a worst-case of O(n) when running into collisions.

pub fn get(&self, key: &K) -> Option<V>

Returns a value corresponding to the key.

pub fn remove(&mut self, key: &K) -> Option<V>

Removes a key from the map. Returns the associated value if the key exists.

Has a worst-case runtime of O(n).

pub fn clear(&mut self)

Clears the map, removing all key-value pairs.

pub fn contains_key(&self, key: &K) -> bool

Returns true if the map contains a value for the specified key.

pub fn keys(&self) -> impl Iterator<Item = K> + '_

Creates an iterator visiting all the values in arbitrary order.

pub fn values(&self) -> impl Iterator<Item = V> + '_

Creates an iterator visiting all the values in arbitrary order.

pub fn is_empty(&self) -> bool

pub fn iter(&self) -> IterableMapIter<'_, K, V>

Returns an iterator over the entries in the map.

Traverses entries in reverse-insertion order. Each item is a tuple of the hashed key and the value.

pub fn len(&self) -> usize

Returns the number of entries in the map.

This is an O(n) operation.

Trait Implementations

impl<K, V> BorshDeserialize for IterableMap<K, V>

fn deserialize_reader<__R: Read>(reader: &mut __R) -> Result<Self, Error>

fn deserialize(buf: &mut &[u8]) -> Result<Self, Error>

Deserializes this instance from a given slice of bytes. Updates the buffer to point at the remaining bytes.

fn try_from_slice(v: &[u8]) -> Result<Self, Error>

Deserialize this instance from a slice of bytes.

fn try_from_reader<R>(reader: &mut R) -> Result<Self, Error>

where R: Read,

impl<K, V> BorshSerialize for IterableMap<K, V>

fn serialize<__W: Write>(&self, writer: &mut __W) -> Result<(), Error>

impl<K: Clone, V: Clone> Clone for IterableMap<K, V>

fn clone(&self) -> IterableMap<K, V>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<K: Debug, V: Debug> Debug for IterableMap<K, V>

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

Formats the value using the given formatter.

impl<'a, K, V> IntoIterator for &'a IterableMap<K, V>

where K: BorshDeserialize, V: BorshDeserialize,

type Item = (K, V)

The type of the elements being iterated over.

type IntoIter = IterableMapIter<'a, K, V>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.