Struct SmallMap 

pub struct SmallMap<K, V>(/* private fields */);

A small map used to store a small amount of values.

The SmallMap can store up to 256 values.

let mut map = SmallMap::empty();
map.set("a", 1);
map.set("b", 2);
let Some(1) = map.set("a", 5) else { unreachable!("we know there is a one there") };

let value = map.get("b").unwrap();
assert_eq!(2, *value);

let value = map.get("a").unwrap();
assert_eq!(5, *value);

Implementations

impl<K, V> SmallMap<K, V>

where K: PartialEq,

pub fn empty() -> Self

Create a en empty map

pub fn set(&mut self, key: K, value: V) -> Option<V>

Set a value in the map. If there is already a value with the same key, the old value will be returned

pub fn insert_with<F>(&mut self, key: K, f: F) -> SmallIndex

where F: FnOnce(SmallIndex) -> V,

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

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

Get a reference to a value in the map

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

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

Get a mutable reference to a value in the map

pub fn get_index<Q>(&self, key: &Q) -> Option<SmallIndex>

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

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

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

pub fn iter(&self) -> impl Iterator<Item = (&K, &V)> + '_

Iterate over the key-value pairs of the map.

pub fn iter_mut(&mut self) -> impl Iterator<Item = (&mut K, &mut V)> + '_

pub fn get_with_index(&self, idx: SmallIndex) -> Option<&V>

Get a value ref by the value index instead of the key

pub fn get_mut_with_index(&mut self, idx: SmallIndex) -> Option<&mut V>

Get a mutable value ref by the value index instead of the key

Trait Implementations

impl<K: Clone, V: Clone> Clone for SmallMap<K, V>

fn clone(&self) -> SmallMap<K, V>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<K: Debug, V: Debug> Debug for SmallMap<K, V>

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

Formats the value using the given formatter.

impl<K: PartialEq, V: PartialEq> PartialEq for SmallMap<K, V>

fn eq(&self, other: &SmallMap<K, V>) -> 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: PartialEq, V: PartialEq> StructuralPartialEq for SmallMap<K, V>