Struct multi_map::MultiMap

pub struct MultiMap<K1: Eq + Hash, K2: Eq + Hash, V> { /* fields omitted */ }

Methods

impl<K1: Eq + Hash + Clone, K2: Eq + Hash + Clone, V> MultiMap<K1, K2, V>

fn new() -> MultiMap<K1, K2, V>

Creates a new MultiMap. The primary key is of type K1 and the secondary key is of type K2. The value is of type V. This is as compared to a std::collections::HashMap which is typed on just K and V.

Internally, two HashMaps are created - a main one on <K1, (K2, V)> and a second one on <K2, K1>. The (K2, V) tuple is so that when an item is removed using the K1 key, the appropriate K2 value is available so the K2->K1 map can be removed from the second HashMap, to keep them in sync.

fn with_capacity(capacity: usize) -> MultiMap<K1, K2, V>

Creates an empty MultiMap with the specified capacity.

The multi map will be able to hold at least capacity elements without reallocating. If capacity is 0, the multi map will not allocate.

fn insert(&mut self, key_one: K1, key_two: K2, value: V)

Insert an item into the MultiMap. You must supply both keys to insert an item. The keys cannot be modified at a later date, so if you only have one key at this time, use a placeholder value for the second key (perhaps K2 is Option<...>) and remove then re-insert when the second key becomes available.

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

Obtain a reference to an item in the MultiMap using the primary key, just like a HashMap.

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

Obtain a mutable reference to an item in the MultiMap using the primary key, just like a HashMap.

fn get_alt(&self, key: &K2) -> Option<&V>

Obtain a reference to an item in the MultiMap using the secondary key. Ordinary HashMaps can't do this.

fn get_mut_alt(&mut self, key: &K2) -> Option<&mut V>

Obtain a mutable reference to an item in the MultiMap using the secondary key. Ordinary HashMaps can't do this.

fn remove<Q: ?Sized>(&mut self, key: &Q) -> Option<V> where
    K1: Borrow<Q>,
    Q: Hash + Eq, 

Remove an item from the HashMap using the primary key. The value for the given key is returned (if it exists), just like a HashMap. This removes an item from the main HashMap, and the second <K2, K1> HashMap.

fn remove_alt<Q: ?Sized>(&mut self, key: &Q) -> Option<V> where
    K2: Borrow<Q>,
    Q: Hash + Eq, 

Remove an item from the HashMap using the secondary key. The value for the given key is returned (if it exists). Ordinary HashMaps can't do this. This removes an item from both the main HashMap and the second <K2, K1> HashMap.

fn iter(&self) -> Iter<K1, (K2, V)>

Iterate through all the values in the MultiMap. Note that the values are (K2, V) tuples, not V, as you would get with a HashMap.

Trait Implementations

impl<K1: Eq + Eq + Hash, K2: Eq + Eq + Hash, V: Eq> Eq for MultiMap<K1, K2, V>

impl<K1: Eq + Hash, K2: Eq + Hash, V: Eq> PartialEq for MultiMap<K1, K2, V>

fn eq(&self, other: &MultiMap<K1, K2, V>) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl<K1: Eq + Hash + Debug, K2: Eq + Hash + Debug, V: Debug> Debug for MultiMap<K1, K2, V>

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

Formats the value using the given formatter.