Struct heapless::LinearMap

pub struct LinearMap<K, V, const N: usize> { /* private fields */ }

A fixed capacity map / dictionary that performs lookups via linear search

Note that as this map doesn’t use hashing so most operations are O(N) instead of O(1)

Implementations

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

pub const fn new() -> Self

Creates an empty LinearMap

Examples

use heapless::LinearMap;

// allocate the map on the stack
let mut map: LinearMap<&str, isize, 8> = LinearMap::new();

// allocate the map in a static variable
static mut MAP: LinearMap<&str, isize, 8> = LinearMap::new();

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

where K: Eq,

pub fn capacity(&self) -> usize

Returns the number of elements that the map can hold

Computes in O(1) time

Examples

use heapless::LinearMap;

let map: LinearMap<&str, isize, 8> = LinearMap::new();
assert_eq!(map.capacity(), 8);

pub fn clear(&mut self)

Clears the map, removing all key-value pairs

Computes in O(1) time

Examples

use heapless::LinearMap;

let mut map: LinearMap<_, _, 8> = LinearMap::new();
map.insert(1, "a").unwrap();
map.clear();
assert!(map.is_empty());

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

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

Computes in O(N) time

Examples

use heapless::LinearMap;

let mut map: LinearMap<_, _, 8> = LinearMap::new();
map.insert(1, "a").unwrap();
assert_eq!(map.contains_key(&1), true);
assert_eq!(map.contains_key(&2), false);

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

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

Returns a reference to the value corresponding to the key

Computes in O(N) time

Examples

use heapless::LinearMap;

let mut map: LinearMap<_, _, 8> = LinearMap::new();
map.insert(1, "a").unwrap();
assert_eq!(map.get(&1), Some(&"a"));
assert_eq!(map.get(&2), None);

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

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

Returns a mutable reference to the value corresponding to the key

Computes in O(N) time

Examples

use heapless::LinearMap;

let mut map: LinearMap<_, _, 8> = LinearMap::new();
map.insert(1, "a").unwrap();
if let Some(x) = map.get_mut(&1) {
    *x = "b";
}
assert_eq!(map[&1], "b");

pub fn len(&self) -> usize

Returns the number of elements in this map

Computes in O(1) time

Examples

use heapless::LinearMap;

let mut a: LinearMap<_, _, 8> = LinearMap::new();
assert_eq!(a.len(), 0);
a.insert(1, "a").unwrap();
assert_eq!(a.len(), 1);

pub fn insert(&mut self, key: K, value: V) -> Result<Option<V>, (K, 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.

Computes in O(N) time

Examples

use heapless::LinearMap;

let mut map: LinearMap<_, _, 8> = LinearMap::new();
assert_eq!(map.insert(37, "a").unwrap(), None);
assert_eq!(map.is_empty(), false);

map.insert(37, "b").unwrap();
assert_eq!(map.insert(37, "c").unwrap(), Some("b"));
assert_eq!(map[&37], "c");

pub fn is_empty(&self) -> bool

Returns true if the map contains no elements

Computes in O(1) time

Examples

use heapless::LinearMap;

let mut a: LinearMap<_, _, 8> = LinearMap::new();
assert!(a.is_empty());
a.insert(1, "a").unwrap();
assert!(!a.is_empty());

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

An iterator visiting all key-value pairs in arbitrary order.

Examples

use heapless::LinearMap;

let mut map: LinearMap<_, _, 8> = LinearMap::new();
map.insert("a", 1).unwrap();
map.insert("b", 2).unwrap();
map.insert("c", 3).unwrap();

for (key, val) in map.iter() {
    println!("key: {} val: {}", key, val);
}

pub fn iter_mut(&mut self) -> IterMut<'_, K, V>

An iterator visiting all key-value pairs in arbitrary order, with mutable references to the values

Examples

use heapless::LinearMap;

let mut map: LinearMap<_, _, 8> = LinearMap::new();
map.insert("a", 1).unwrap();
map.insert("b", 2).unwrap();
map.insert("c", 3).unwrap();

// Update all values
for (_, val) in map.iter_mut() {
    *val = 2;
}

for (key, val) in &map {
    println!("key: {} val: {}", key, val);
}

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

An iterator visiting all keys in arbitrary order

Examples

use heapless::LinearMap;

let mut map: LinearMap<_, _, 8> = LinearMap::new();
map.insert("a", 1).unwrap();
map.insert("b", 2).unwrap();
map.insert("c", 3).unwrap();

for key in map.keys() {
    println!("{}", key);
}

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

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

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

Computes in O(N) time

Examples

use heapless::LinearMap;

let mut map: LinearMap<_, _, 8> = LinearMap::new();
map.insert(1, "a").unwrap();
assert_eq!(map.remove(&1), Some("a"));
assert_eq!(map.remove(&1), None);

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

An iterator visiting all values in arbitrary order

Examples

use heapless::LinearMap;

let mut map: LinearMap<_, _, 8> = LinearMap::new();
map.insert("a", 1).unwrap();
map.insert("b", 2).unwrap();
map.insert("c", 3).unwrap();

for val in map.values() {
    println!("{}", val);
}

pub fn values_mut(&mut self) -> impl Iterator<Item = &mut V>

An iterator visiting all values mutably in arbitrary order

Examples

use heapless::LinearMap;

let mut map: LinearMap<_, _, 8> = LinearMap::new();
map.insert("a", 1).unwrap();
map.insert("b", 2).unwrap();
map.insert("c", 3).unwrap();

for val in map.values_mut() {
    *val += 10;
}

for val in map.values() {
    println!("{}", val);
}

Trait Implementations

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

where K: Eq + Clone, V: Clone,

fn clone(&self) -> Self

Returns a copy of the value.

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

Performs copy-assignment from source.

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

where K: Eq + 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 LinearMap<K, V, N>

where K: Eq,

fn default() -> Self

Returns the “default value” for a type.

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

where K: Eq,

fn from_iter<I>(iter: I) -> Self

where I: IntoIterator<Item = (K, V)>,

Creates a value from an iterator.

impl<'a, K, V, Q, const N: usize> Index<&'a Q> for LinearMap<K, V, N>

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

type Output = V

The returned type after indexing.

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

Performs the indexing (container[index]) operation.

impl<'a, K, V, Q, const N: usize> IndexMut<&'a Q> for LinearMap<K, V, N>

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

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

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

impl<'a, K, V, const N: usize> IntoIterator for &'a LinearMap<K, V, N>

where K: Eq,

type Item = (&'a K, &'a V)

The type of the elements being iterated over.

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

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, const N2: usize> PartialEq<LinearMap<K, V, N2>> for LinearMap<K, V, N>

where K: Eq, V: PartialEq,

fn eq(&self, other: &LinearMap<K, V, N2>) -> 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 LinearMap<K, V, N>

where K: Eq, V: PartialEq,