Struct SmallOrderedMap 

pub struct SmallOrderedMap<K: Eq + Hash, V, const N: usize> { /* private fields */ }

An insertion-order-preserving map that lives on the stack for up to N entries, then spills to a heap-allocated ordermap::OrderMap.

Storage strategy

Uses a tagged union ([MapData]) with:

• Stack side: HeaplessOrderedMap<K, V, N> — heapless::LinearMap wrapper.
• Heap side: ordermap::OrderMap<K, V> — insertion-order-preserving hash map.

Generic parameters

Parameter	Meaning
K	Key type; must implement Eq + Hash
V	Value type
N	Stack capacity — max entries before spill

Design Considerations

• Insertion order: unlike SmallMap (which uses HashMap on the heap), this type uses OrderMap which preserves insertion order even after a spill.
• K: Eq + Hash on the struct: required by HeaplessOrderedMap and propagated to the outer struct to satisfy the MapData union’s bounds.
• remove rebuilds on stack: because heapless::LinearMap::remove requires K: PartialEq<Q> (stricter than Borrow<Q>), the stack-side remove is implemented by draining and rebuilding via HeaplessOrderedMap::remove.

Safety

on_stack determines which variant of MapData is active. Only the active variant may be accessed.

Implementations

impl<K, V, const N: usize> SmallOrderedMap<K, V, N>

where K: Eq + Hash,

pub const MAX_STACK_SIZE: usize

A constant parameter.

pub fn new() -> Self

Creates a new empty ordered map on the stack.

pub fn is_on_stack(&self) -> bool

Returns true if the map is currently storing data on the stack.

pub fn len(&self) -> usize

Returns the number of elements in the map.

pub fn is_empty(&self) -> bool

Returns true if the map contains no elements.

pub fn clear(&mut self)

Clears the map, removing all key-value pairs.

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

Inserts a key-value pair into the map.

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

where K: Borrow<Q>, Q: Hash + Eq + ?Sized,

Retrieves a reference to the value corresponding to the key.

pub fn get_mut<Q>(&mut self, key: &Q) -> Option<&mut V>

where K: Borrow<Q>, Q: Hash + Eq + ?Sized,

Retrieves a mutable reference to the value corresponding to the key.

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

where K: Borrow<Q>, Q: Hash + Eq + ?Sized,

Removes a key from the map, returning the value at the key if the key was previously in the map.

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

where K: Borrow<Q>, Q: Hash + Eq + ?Sized,

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

impl<K, V, const N: usize> SmallOrderedMap<K, V, N>

where K: Eq + Hash,

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

Returns an iterator over the elements.

Trait Implementations

impl<K: Eq + Hash, V, const N: usize> AnyMap<K, V> for SmallOrderedMap<K, V, N>

fn len(&self) -> usize

Returns the number of elements.

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

Inserts the given key-value pair or element.

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

where K: Borrow<Q>, Q: Hash + Eq + ?Sized,

Returns a reference to the value corresponding to the key.

fn get_mut<Q>(&mut self, key: &Q) -> Option<&mut V>

where K: Borrow<Q>, Q: Hash + Eq + ?Sized,

Returns a reference to the value corresponding to the key.

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

where K: Borrow<Q>, Q: Hash + Eq + ?Sized,

Removes the specified element or key-value pair.

fn contains_key<Q>(&self, key: &Q) -> bool

where K: Borrow<Q>, Q: Hash + Eq + ?Sized,

Returns true if the collection contains the item or key.

fn clear(&mut self)

Clears all elements from the collection.

fn is_empty(&self) -> bool

Returns true if the collection is empty.

impl<K, V, const N: usize> Clone for SmallOrderedMap<K, V, N>

where K: Eq + Hash + Clone, V: Clone,

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<K, V, const N: usize> Debug for SmallOrderedMap<K, V, N>

where K: Eq + Hash + Debug, V: Debug,

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

Formats the value using the given formatter.

impl<K, V, const N: usize> Default for SmallOrderedMap<K, V, N>

where K: Eq + Hash,

fn default() -> Self

Returns the “default value” for a type.

impl<K: Eq + Hash, V, const N: usize> Drop for SmallOrderedMap<K, V, N>

fn drop(&mut self)

Executes the destructor for this type.

impl<K, V, const N: usize> Extend<(K, V)> for SmallOrderedMap<K, V, N>

where K: Eq + Hash,

fn extend<I: IntoIterator<Item = (K, V)>>(&mut self, iter: I)

Extends a collection with the contents of an iterator.

fn extend_one(&mut self, item: A)

🔬This is a nightly-only experimental API. (extend_one)

Extends a collection with exactly one element.

fn extend_reserve(&mut self, additional: usize)

🔬This is a nightly-only experimental API. (extend_one)

Reserves capacity in a collection for the given number of additional elements.

impl<K, V, const N: usize> FromIterator<(K, V)> for SmallOrderedMap<K, V, N>

where K: Eq + Hash,

fn from_iter<T: IntoIterator<Item = (K, V)>>(iter: T) -> Self

Creates a value from an iterator.

impl<K, V, Q, const N: usize> Index<&Q> for SmallOrderedMap<K, V, N>

where K: Eq + Hash + Borrow<Q>, Q: Eq + Hash + ?Sized,

type Output = V

The returned type after indexing.

fn index(&self, key: &Q) -> &Self::Output

Performs the indexing (container[index]) operation.

impl<K, V, Q, const N: usize> IndexMut<&Q> for SmallOrderedMap<K, V, N>

where K: Eq + Hash + Borrow<Q>, Q: Eq + Hash + ?Sized,

fn index_mut(&mut self, key: &Q) -> &mut Self::Output

Performs the mutable indexing (container[index]) operation.

impl<K, V, const N: usize> IntoIterator for SmallOrderedMap<K, V, N>

where K: Eq + Hash,

type Item = (K, V)

The type of the elements being iterated over.

type IntoIter = SmallMapIntoIter<K, V, N>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<K, V, const N: usize, M> PartialEq<M> for SmallOrderedMap<K, V, N>

where K: Eq + Hash, V: PartialEq, M: AnyMap<K, V>,

fn eq(&self, other: &M) -> 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<K, V, const N: usize> Eq for SmallOrderedMap<K, V, N>

where K: Eq + Hash, V: Eq,