Struct heapless::LinearMap

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

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§

source§

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

source

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();
source§

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

source

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);
source

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());
source

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);
source

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);
source

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");
source

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);
source

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");
source

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());
source

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);
}
source

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);
}
source

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);
}
source

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);
source

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);
}
source

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§

source§

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

source§

fn clone(&self) -> Self

Returns a copy of the value. Read more
1.0.0§

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

Performs copy-assignment from source. Read more
source§

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

source§

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

Formats the value using the given formatter. Read more
source§

impl<K, V, const N: usize> Default for LinearMap<K, V, N>
where K: Eq,

source§

fn default() -> Self

Returns the “default value” for a type. Read more
source§

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

source§

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

Creates a value from an iterator. Read more
source§

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.
source§

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

Performs the indexing (container[index]) operation. Read more
source§

impl<'a, K, V, Q, const N: usize> IndexMut<&'a Q> for LinearMap<K, V, N>
where K: Borrow<Q> + Eq, Q: Eq + ?Sized,

source§

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

Performs the mutable indexing (container[index]) operation. Read more
source§

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?
source§

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value. Read more
source§

impl<K, V, const N: usize, const N2: usize> PartialEq<LinearMap<K, V, N2>> for LinearMap<K, V, N>
where K: Eq, V: PartialEq,

source§

fn eq(&self, other: &LinearMap<K, V, N2>) -> bool

This method tests for self and other values to be equal, and is used by ==.
1.0.0§

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.
source§

impl<K, V, const N: usize> Eq for LinearMap<K, V, N>
where K: Eq, V: PartialEq,

Auto Trait Implementations§

§

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

§

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

§

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

§

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

§

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

§

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

Blanket Implementations§

§

impl<T> Any for T
where T: 'static + ?Sized,

§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
§

impl<T> Borrow<T> for T
where T: ?Sized,

§

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
§

impl<T> BorrowMut<T> for T
where T: ?Sized,

§

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more
§

impl<T> CloneToUninit for T
where T: Clone,

§

default unsafe fn clone_to_uninit(&self, dst: *mut T)

🔬This is a nightly-only experimental API. (clone_to_uninit)
Performs copy-assignment from self to dst. Read more
§

impl<T> From<T> for T

§

fn from(t: T) -> T

Returns the argument unchanged.

§

impl<T, U> Into<U> for T
where U: From<T>,

§

fn into(self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of [From]<T> for U chooses to do.

§

impl<T, U> TryFrom<U> for T
where U: Into<T>,

§

type Error = Infallible

The type returned in the event of a conversion error.
§

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.
§

impl<T, U> TryInto<U> for T
where U: TryFrom<T>,

§

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.
§

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.