Struct heapless::LinearMap [−][src]
pub struct LinearMap<K, V, N> where
N: ArrayLength<(K, V)>,
K: Eq, { /* fields omitted */ }
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)
Methods
impl<K, V, N> LinearMap<K, V, N> where
N: ArrayLength<(K, V)>,
K: Eq,
[src]
impl<K, V, N> LinearMap<K, V, N> where
N: ArrayLength<(K, V)>,
K: Eq,
pub const fn new() -> Self
[src]
pub const fn new() -> Self
Creates an empty LinearMap
Examples
use heapless::LinearMap; use heapless::consts::*; let mut map: LinearMap<&str, isize, U8> = LinearMap::new();
pub fn capacity(&mut self) -> usize
[src]
pub fn capacity(&mut self) -> usize
Returns the number of elements that the map can hold
Computes in O(1) time
Examples
use heapless::LinearMap; use heapless::consts::*; let mut map: LinearMap<&str, isize, U8> = LinearMap::new(); assert_eq!(map.capacity(), 8);
pub fn clear(&mut self)
[src]
pub fn clear(&mut self)
Clears the map, removing all key-value pairs
Computes in O(1) time
Examples
use heapless::LinearMap; use heapless::consts::*; let mut map: LinearMap<_, _, U8> = LinearMap::new(); map.insert(1, "a").unwrap(); map.clear(); assert!(map.is_empty());
pub fn contains_key(&self, key: &K) -> bool
[src]
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; use heapless::consts::*; let mut map: LinearMap<_, _, U8> = 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: ?Sized>(&self, key: &Q) -> Option<&V> where
K: Borrow<Q>,
Q: Eq,
[src]
pub fn get<Q: ?Sized>(&self, key: &Q) -> Option<&V> where
K: Borrow<Q>,
Q: Eq,
Returns a reference to the value corresponding to the key
Computes in O(N) time
Examples
use heapless::LinearMap; use heapless::consts::*; let mut map: LinearMap<_, _, U8> = 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: ?Sized>(&mut self, key: &Q) -> Option<&mut V> where
K: Borrow<Q>,
Q: Eq,
[src]
pub fn get_mut<Q: ?Sized>(&mut self, key: &Q) -> Option<&mut V> where
K: Borrow<Q>,
Q: Eq,
Returns a mutable reference to the value corresponding to the key
Computes in O(N) time
Examples
use heapless::LinearMap; use heapless::consts::*; let mut map: LinearMap<_, _, U8> = 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
[src]
pub fn len(&self) -> usize
Returns the number of elements in this map
Computes in O(1) time
Examples
use heapless::LinearMap; use heapless::consts::*; let mut a: LinearMap<_, _, U8> = 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)>
[src]
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; use heapless::consts::*; let mut map: LinearMap<_, _, U8> = 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
[src]
pub fn is_empty(&self) -> bool
Returns true if the map contains no elements
Computes in O(1) time
Examples
use heapless::LinearMap; use heapless::consts::*; let mut a: LinearMap<_, _, U8> = LinearMap::new(); assert!(a.is_empty()); a.insert(1, "a").unwrap(); assert!(!a.is_empty());
pub fn iter(&self) -> Iter<K, V>
[src]
pub fn iter(&self) -> Iter<K, V>
An iterator visiting all key-value pairs in arbitrary order.
Examples
use heapless::LinearMap; use heapless::consts::*; let mut map: LinearMap<_, _, U8> = 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>
[src]
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; use heapless::consts::*; let mut map: LinearMap<_, _, U8> = 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>
[src]
pub fn keys(
&self
) -> impl Iterator<Item = &K>
An iterator visiting all keys in arbitrary order
Examples
use heapless::LinearMap; use heapless::consts::*; let mut map: LinearMap<_, _, U8> = 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: ?Sized>(&mut self, key: &Q) -> Option<V> where
K: Borrow<Q>,
Q: Eq,
[src]
pub fn remove<Q: ?Sized>(&mut self, key: &Q) -> Option<V> where
K: Borrow<Q>,
Q: Eq,
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; use heapless::consts::*; let mut map: LinearMap<_, _, U8> = 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>
[src]
pub fn values(
&self
) -> impl Iterator<Item = &V>
An iterator visiting all values in arbitrary order
Examples
use heapless::LinearMap; use heapless::consts::*; let mut map: LinearMap<_, _, U8> = 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>
[src]
pub fn values_mut(
&mut self
) -> impl Iterator<Item = &mut V>
An iterator visiting all values mutably in arbitrary order
Examples
use heapless::LinearMap; use heapless::consts::*; let mut map: LinearMap<_, _, U8> = 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<'a, K, V, N, Q: ?Sized> Index<&'a Q> for LinearMap<K, V, N> where
N: ArrayLength<(K, V)>,
K: Borrow<Q> + Eq,
Q: Eq,
V: 'a,
[src]
impl<'a, K, V, N, Q: ?Sized> Index<&'a Q> for LinearMap<K, V, N> where
N: ArrayLength<(K, V)>,
K: Borrow<Q> + Eq,
Q: Eq,
V: 'a,
type Output = V
The returned type after indexing.
fn index(&self, key: &Q) -> &V
[src]
fn index(&self, key: &Q) -> &V
Performs the indexing (container[index]
) operation.
impl<'a, K, V, N, Q: ?Sized> IndexMut<&'a Q> for LinearMap<K, V, N> where
N: ArrayLength<(K, V)>,
K: Borrow<Q> + Eq,
Q: Eq,
V: 'a,
[src]
impl<'a, K, V, N, Q: ?Sized> IndexMut<&'a Q> for LinearMap<K, V, N> where
N: ArrayLength<(K, V)>,
K: Borrow<Q> + Eq,
Q: Eq,
V: 'a,
fn index_mut(&mut self, key: &Q) -> &mut V
[src]
fn index_mut(&mut self, key: &Q) -> &mut V
Performs the mutable indexing (container[index]
) operation.
impl<'a, K, V, N> IntoIterator for &'a LinearMap<K, V, N> where
N: ArrayLength<(K, V)>,
K: Eq,
[src]
impl<'a, K, V, N> IntoIterator for &'a LinearMap<K, V, N> where
N: ArrayLength<(K, V)>,
K: Eq,