# Struct arduboy_rust::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() -> LinearMap<K, V, N>

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) -> LinearMap<K, V, N>

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<(), Error>

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() -> LinearMap<K, V, N>

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

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

source§

#### fn drop(&mut self)

Executes the destructor for this 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) -> LinearMap<K, V, N>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) -> <&'a LinearMap<K, V, N> as IntoIterator>::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<V>,

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<V>,

## Auto Trait Implementations§

§

### 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 Twhere T: 'static + ?Sized,

§

#### fn type_id(&self) -> TypeId

Gets the `TypeId` of `self`. Read more
§

### impl<T> Borrow<T> for Twhere T: ?Sized,

§

#### fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
§

### impl<T> BorrowMut<T> for Twhere T: ?Sized,

§

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

Mutably borrows from an owned value. Read more
§

### impl<T> From<T> for T

§

#### fn from(t: T) -> T

Returns the argument unchanged.

§

### impl<T, U> Into<U> for Twhere 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 Twhere 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 Twhere 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.