Struct MultiKeyMap

Source

pub struct MultiKeyMap<K, V>where
    K: Hash + Eq,
{ /* private fields */ }

Expand description

A wrapper over HashMap that allows for multiple keys to point to a single element, providing some additional utilities to make working with multiple keys easier.

Implementations§

Source §

impl<K, V> MultiKeyMap<K, V>
where K: Hash + Eq,

Source

pub fn new() -> Self

Creates an empty MultiKeyMap.

Source

pub fn contains_key<Q>(&self, k: &Q) -> bool
where K: Borrow<Q>, Q: Hash + Eq + ?Sized,

Source

pub fn insert(&mut self, k: K, v: V) -> Option<V>

inserts a new value at a given key, and returns the value at that key if there are no other keys to that value. otherwise returns None.

Source

pub fn alias<Q>(&mut self, k: &Q, alias: K) -> Result<&mut V, K>
where K: Borrow<Q>, Q: Hash + Eq + ?Sized,

Attempts to add a new key to the element at k. Returns the new key if k is not in the map.

use multi_key_map::MultiKeyMap;
let mut map = MultiKeyMap::from([
    (vec!["foo".to_string()], 1),
    (vec!["quux".to_string()], -2),
]);
let aliased = map.alias("foo", "bar".to_string());
assert_eq!(aliased, Ok(&mut 1));
let aliased = map.alias("baz", "xyz".to_string());
assert_eq!(aliased, Err("xyz".to_string()));

Source

pub fn alias_many<Q>( &mut self, k: &Q, aliases: Vec<K>, ) -> Result<&mut V, Vec<K>>
where K: Borrow<Q>, Q: Hash + Eq + ?Sized,

Attempts to add multiple new keys to the element at k. Returns the list of keys if k is not in the map.

use multi_key_map::MultiKeyMap;
let mut map = MultiKeyMap::from([
    (vec!["foo".to_string()], 1),
]);
let aliased = map.alias_many("foo", vec!["bar".to_string(), "quux".to_string()]);
assert_eq!(aliased, Ok(&mut 1));
let aliased = map.alias_many("baz", vec!["xyz".to_string(), "syzygy".to_string()]);
assert_eq!(aliased, Err(vec!["xyz".to_string(), "syzygy".to_string()]));

Source

pub fn keys(&self) -> impl Iterator<Item = &K>

An iterator visiting all keys in an arbitrary order. Equivalent to HashMap::keys.

Source

pub fn values(&self) -> impl Iterator<Item = &V>

An iterator visiting all elements in an arbitrary order. Equivalent to HashMap::values.

Source

pub fn values_mut(&mut self) -> impl Iterator<Item = &mut V>

An iterator visiting all elements in an arbitrary order, while allowing mutation. Equivalent to HashMap::values_mut.

Source

pub fn into_keys(self) -> impl Iterator<Item = K>

Consumes the map and provides an iterator over all keys. Equivalent to HashMap::into_keys.

Source

pub fn into_values(self) -> impl Iterator<Item = V>

Consumes the map and provides an iterator over all values. Equivalent to HashMap::into_values.

Source

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

An iterator visiting all key-value pairs. Due to the nature of MultiKeyMap, value references may be shared across multiple keys.

Source

pub fn get<Q>(&self, k: &Q) -> Option<&V>
where K: Borrow<Q>, Q: Hash + Eq + ?Sized,

Returns a shared reference to the value of the key. Equivalent to HashMap::get.

Source

pub fn get_mut<Q>(&mut self, k: &Q) -> Option<&mut V>
where K: Borrow<Q>, Q: Hash + Eq + ?Sized,

Returns a mutable reference to the value of the key. Equivalent to HashMap::get_mut.

use multi_key_map::MultiKeyMap;
let mut map = MultiKeyMap::new();
map.insert(1, "foo".to_string());
let x = map.get_mut(&1).unwrap();
*x = "bar".to_string();
assert_eq!(Some(&"bar".to_string()), map.get(&1));

Source

pub fn insert_many(&mut self, ks: Vec<K>, v: V) -> Vec<V>

inserts a new value, pairs it to a list of keys, and returns the values that existed at each key if there are no other keys to that value.

use multi_key_map::MultiKeyMap;
let mut map = MultiKeyMap::new();
map.insert_many(vec![1, 2],"foo".to_string());
assert_eq!(Some(&"foo".to_string()), map.get(&1));
assert_eq!(Some(&"foo".to_string()), map.get(&2));