Struct micromap::Map

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

A faster alternative of std::collections::HashMap.

For example, this is how you make a map, which is allocated on stack and is capable of storing up to eight key-values pairs:

let mut m : micromap::Map<u64, &str, 8> = micromap::Map::new();
m.insert(1, "Jeff Lebowski");
m.insert(2, "Walter Sobchak");
assert_eq!(2, m.len());

It is faster because it doesn’t use a hash function at all. It simply keeps all pairs in an array and when it’s necessary to find a value, it goes through all pairs comparing the needle with each pair available. Also it is faster because it doesn’t use heap. When a Map is being created, it allocates the necessary space on stack. That’s why the maximum size of the map must be provided in compile time.

It is also faster because it doesn’t grow in size. When a Map is created, its size is fixed on stack. If an attempt is made to insert too many keys into it, it simply panics. Moreover, in the “release” mode it doesn’t panic, but its behaviour is undefined. In the “release” mode all boundary checks are disabled, for the sake of higher performance.

Implementations

impl<K: PartialEq, V, const N: usize> Map<K, V, N>

pub const fn new() -> Self

Make it.

The size of the map is defined by the generic argument. For example, this is how you make a map of four key-values pairs:

impl<K: PartialEq, V, const N: usize> Map<K, V, N>

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

Make an iterator over all pairs.

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

An iterator with mutable references to the values but

impl<K: PartialEq, V, const N: usize> Map<K, V, N>

pub fn keys(&self) -> Keys<'_, K, V>

An iterator visiting all keys in arbitrary order.

pub fn into_keys(self) -> IntoKeys<K, V, N>

Consuming iterator visiting all keys in arbitrary order.

impl<K: PartialEq, V, const N: usize> Map<K, V, N>

pub const fn capacity(&self) -> usize

Get its total capacity.

pub const fn is_empty(&self) -> bool

Is it empty?

pub const fn len(&self) -> usize

Return the total number of pairs inside.

pub fn contains_key<Q: PartialEq + ?Sized>(&self, k: &Q) -> bool

where K: Borrow<Q>,

Does the map contain this key?

pub fn remove<Q: PartialEq + ?Sized>(&mut self, k: &Q)

where K: Borrow<Q>,

Remove by key.

pub fn insert(&mut self, k: K, v: V)

Insert a single pair into the map.

Panics

It may panic if there are too many pairs in the map already. Pay attention, it panics only in the “debug” mode. In the “release” mode, you are going to get undefined behavior. This is done for the sake of performance, in order to avoid a repetitive check for the boundary condition on every insert().

pub fn get<Q: PartialEq + ?Sized>(&self, k: &Q) -> Option<&V>

where K: Borrow<Q>,

Get a reference to a single value.

pub fn get_mut<Q: PartialEq + ?Sized>(&mut self, k: &Q) -> Option<&mut V>

where K: Borrow<Q>,

Get a mutable reference to a single value.

Panics

If can’t turn it into a mutable state.

pub fn clear(&mut self)

Remove all pairs from it, but keep the space intact for future use.

pub fn retain<F: Fn(&K, &V) -> bool>(&mut self, f: F)

Retains only the elements specified by the predicate.

pub fn get_key_value<Q: PartialEq + ?Sized>(&self, k: &Q) -> Option<(&K, &V)>

where K: Borrow<Q>,

Returns the key-value pair corresponding to the supplied key.

pub fn remove_entry<Q: PartialEq + ?Sized>(&mut self, k: &Q) -> Option<(K, V)>

where K: Borrow<Q>,

Removes a key from the map, returning the stored key and value if the key was previously in the map.

impl<K: PartialEq, V, const N: usize> Map<K, V, N>

pub fn values(&self) -> Values<'_, K, V>

An iterator visiting all values in arbitrary order.

pub fn values_mut(&mut self) -> ValuesMut<'_, K, V>

An iterator visiting all values mutably in arbitrary order.

pub fn into_values(self) -> IntoValues<K, V, N>

Consuming iterator visiting all the values in arbitrary order.

Trait Implementations

impl<K: Clone + PartialEq, V: Clone, const N: usize> Clone for Map<K, V, N>

fn clone(&self) -> Self

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<K: PartialEq + Debug, V: Debug, const N: usize> Debug for Map<K, V, N>

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

Formats the value using the given formatter.

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

fn default() -> Self

Make a default empty Map.

impl<K: PartialEq + Display, V: Display, const N: usize> Display for Map<K, V, N>

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

Formats the value using the given formatter.

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

fn drop(&mut self)

Executes the destructor for this type.

impl<K: PartialEq, V, const N: usize> From<[(K, V); N]> for Map<K, V, N>

fn from(arr: [(K, V); N]) -> Self

Converts to this type from the input type.

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

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

Creates a value from an iterator.

impl<K: PartialEq + Borrow<Q>, Q: PartialEq + ?Sized, V, const N: usize> Index<&Q> for Map<K, V, N>

type Output = V

The returned type after indexing.

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

Performs the indexing (container[index]) operation.

impl<K: PartialEq + Borrow<Q>, Q: PartialEq + ?Sized, V, const N: usize> IndexMut<&Q> for Map<K, V, N>

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

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

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

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<'a, K: PartialEq, V, const N: usize> IntoIterator for &'a mut Map<K, V, N>

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

The type of the elements being iterated over.

type IntoIter = IterMut<'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: PartialEq, V, const N: usize> IntoIterator for Map<K, V, N>

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?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

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

fn eq(&self, other: &Self) -> bool

Two maps can be compared.

For example:

let mut m1: micromap::Map<u8, i32, 10> = micromap::Map::new();
let mut m2: micromap::Map<u8, i32, 10> = micromap::Map::new();
m1.insert(1, 42);
m2.insert(1, 42);
assert_eq!(m1, m2);
// two maps with different order of key-value pairs are still equal:
m1.insert(2, 1);
m1.insert(3, 16);
m2.insert(3, 16);
m2.insert(2, 1);
assert_eq!(m1, m2);

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.

impl<K: Eq, V: Eq, const N: usize> Eq for Map<K, V, N>