Struct HeaplessOrderedMap 

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

A stack-allocated, insertion-order-preserving map backed by heapless::LinearMap.

Architecture & Pseudocode

This map stores elements linearly in the exact sequence they were added. It relies on a simple contiguous array layout under the hood, yielding O(N) operations.

• map: A heapless::LinearMap<K, V, N>.

Insert Algorithm

1. If map is physically full (`len == N`) AND the key is not already inside:
   a. Return `Err((key, value))` (triggers heap spill in `SmallOrderedMap`).
2. Else (capacity available or updating existing key):
   a. Let `old_val = map.insert(key, value)`.
   b. Return `Ok(old_val)`.

Remove Algorithm (Order-Preserving)

1. Initialize a temporary empty `LinearMap`.
2. Move the elements from the current map into `old_map` using `core::mem::replace`.
3. Iterate through `old_map` elements:
   a. If `element.key == target_key` (and we haven't removed it yet):
      i. Save `element.value` as the return value.
   b. Else:
      i. Insert `element` into the temporary map.
4. Replace `self.map` with the temporary map.
5. Return the saved `old_val`.

Implementations

impl<K: Eq + Hash, V, const N: usize> HeaplessOrderedMap<K, V, N>

pub fn new() -> Self

Automatically generated documentation for this item.

pub fn len(&self) -> usize

Returns the number of entries currently stored.

pub fn is_empty(&self) -> bool

Returns true if the map contains no entries.

pub fn is_full(&self) -> bool

Returns true if the map has reached its compile-time capacity N.

When is_full() returns true, inserting a new key will return Err.

pub fn clear(&mut self)

Removes all entries, dropping keys and values in place.

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

Inserts or updates a key-value pair.

Returns

Variant	Meaning
Ok(Some(old))	Key already existed; old value returned, new value stored in place.
Ok(None)	Key was new; entry appended (insertion order preserved).
Err((key, value))	Map is full and key is new; caller must spill to heap.

Complexity

O(N) — linear scan to check for the existing key before delegating to LinearMap.

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

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

Returns a shared reference to the value associated with key, or None.

Accepts any type Q where K: Borrow<Q> and Q: Hash + Eq. Complexity: O(N) linear scan.

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

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

Returns an exclusive reference to the value associated with key, or None.

Accepts any type Q where K: Borrow<Q> and Q: Hash + Eq. Complexity: O(N) linear scan.

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

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

Removes and returns the value for key, preserving insertion order for remaining entries.

Accepts any type Q where K: Borrow<Q> and Q: Hash + Eq.

Implementation note

heapless::LinearMap::remove requires K: PartialEq<Q>, which is more restrictive than K: Borrow<Q>. To stay generic we drain the map into a temporary buffer, skipping the matching entry, then write the buffer back. This preserves insertion order and is allocation-free, at the cost of O(N) time.

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

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

Returns true if the map contains an entry for key.

Accepts any type Q where K: Borrow<Q> and Q: Hash + Eq. Complexity: O(N).

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

Returns an iterator over (&K, &V) pairs in insertion order.

pub fn into_inner(self) -> LinearMap<K, V, N>

Consumes self and returns the underlying heapless::LinearMap.

Useful when the caller needs direct access to the inner map, e.g. during spill-to-heap.

Trait Implementations

impl<K: Eq + Hash, V, const N: usize> AnyMap<K, V> for HeaplessOrderedMap<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: Clone + Eq + Hash, V: Clone, const N: usize> Clone for HeaplessOrderedMap<K, V, N>

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

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<K: Debug + Eq + Hash, V: Debug, const N: usize> Debug for HeaplessOrderedMap<K, V, N>

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

Formats the value using the given formatter.

impl<K: Eq + Hash, V, const N: usize> Default for HeaplessOrderedMap<K, V, N>

fn default() -> Self

Creates an empty map. Equivalent to HeaplessOrderedMap::new.

impl<K: Eq + Hash, V, const N: usize> IntoIterator for HeaplessOrderedMap<K, V, N>

fn into_iter(self) -> Self::IntoIter

Consumes self and returns an iterator over (K, V) pairs in insertion order.

type Item = (K, V)

The type of the elements being iterated over.

type IntoIter = IntoIter<K, V, N>

Which kind of iterator are we turning this into?

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

where K: Eq + Hash, V: PartialEq,

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<K, V, const N: usize> Eq for HeaplessOrderedMap<K, V, N>

where K: Eq + Hash, V: Eq,