Struct multimap::MultiMap

pub struct MultiMap<K, V> { /* fields omitted */ }

Methods

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

fn new() -> MultiMap<K, V>

Creates an empty MultiMap

Examples

use multimap::MultiMap;

let mut map: MultiMap<&str, isize> = MultiMap::new();

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

Creates an empty multimap with the given initial capacity.

Examples

use multimap::MultiMap;

let mut map: MultiMap<&str, isize> = MultiMap::with_capacity(20);

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

Inserts a key-value pair into the multimap. If the key does exists in the map then the key is pushed to that key's vector. If the key doesn't exists in the map a new vector with the given value is inserted.

Examples

use multimap::MultiMap;

let mut map = MultiMap::new();
map.insert("key", 42);

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

Returns true if the map contains a value for the specified key.

The key may be any borrowed form of the map's key type, but Hash and Eq on the borrowed form must match those for the key type.

Examples

use multimap::MultiMap;

let mut map = MultiMap::new();
map.insert(1, 42);
assert_eq!(map.contains_key(&1), true);
assert_eq!(map.contains_key(&2), false);

fn len(&self) -> usize

Returns the number of elements in the map.

Examples

use multimap::MultiMap;

let mut map = MultiMap::new();
map.insert(1, 42);
map.insert(2, 1337);
assert_eq!(map.len(), 2);

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

Removes a key from the map, returning the vector of values at the key if the key was previously in the map.

The key may be any borrowed form of the map's key type, but Hash and Eq on the borrowed form must match those for the key type.

Examples

use multimap::MultiMap;

let mut map = MultiMap::new();
map.insert(1, 42);
map.insert(1, 1337);
assert_eq!(map.remove(&1), Some(vec![42, 1337]));
assert_eq!(map.remove(&1), None);

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

Returns a reference to the first item in the vector corresponding to the key.

The key may be any borrowed form of the map's key type, but Hash and Eq on the borrowed form must match those for the key type.

Examples

use multimap::MultiMap;

let mut map = MultiMap::new();
map.insert(1, 42);
map.insert(1, 1337);
assert_eq!(map.get(&1), Some(&42));

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

Returns a mutable reference to the first item in the vector corresponding to the key.

The key may be any borrowed form of the map's key type, but Hash and Eq on the borrowed form must match those for the key type.

Examples

use multimap::MultiMap;

let mut map = MultiMap::new();
map.insert(1, 42);
map.insert(1, 1337);
if let Some(v) = map.get_mut(&1) {
    *v = 99;
}
assert_eq!(map[&1], 99);

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

Returns a reference to the vector corresponding to the key.

The key may be any borrowed form of the map's key type, but Hash and Eq on the borrowed form must match those for the key type.

Examples

use multimap::MultiMap;

let mut map = MultiMap::new();
map.insert(1, 42);
map.insert(1, 1337);
assert_eq!(map.get_vec(&1), Some(&vec![42, 1337]));

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

Returns a mutable reference to the vector corresponding to the key.

The key may be any borrowed form of the map's key type, but Hash and Eq on the borrowed form must match those for the key type.

Examples

use multimap::MultiMap;

let mut map = MultiMap::new();
map.insert(1, 42);
map.insert(1, 1337);
if let Some(v) = map.get_vec_mut(&1) {
    (*v)[0] = 1991;
    (*v)[1] = 2332;
}
assert_eq!(map.get_vec(&1), Some(&vec![1991, 2332]));

fn capacity(&self) -> usize

Returns the number of elements the map can hold without reallocating.

Examples

use multimap::MultiMap;

let map: MultiMap<usize, usize> = MultiMap::new();
assert!(map.capacity() >= 0);

fn is_empty(&self) -> bool

Returns true if the map contains no elements.

Examples

use multimap::MultiMap;

let mut map = MultiMap::new();
assert!(map.is_empty());
map.insert(1,42);
assert!(!map.is_empty());

fn clear(&mut self)

Clears the map, removing all key-value pairs. Keeps the allocated memory for reuse.

Examples

use multimap::MultiMap;

let mut map = MultiMap::new();
map.insert(1,42);
map.clear();
assert!(map.is_empty());

fn keys<'a>(&'a self) -> Keys<'a, K, Vec<V>>

An iterator visiting all keys in arbitrary order. Iterator element type is &'a K.

Examples

use multimap::MultiMap;

let mut map = MultiMap::new();
map.insert(1,42);
map.insert(2,1337);
map.insert(4,1991);

for key in map.keys() {
    println!("{:?}", key);
}

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

An iterator visiting all key-value pairs in arbitrary order. The iterator returns a reference to the key and the first element in the corresponding key's vector. Iterator element type is (&'a K, &'a V).

Examples

use multimap::MultiMap;

let mut map = MultiMap::new();
map.insert(1,42);
map.insert(1,1337);
map.insert(3,2332);
map.insert(4,1991);

for (key, value) in map.iter() {
    println!("key: {:?}, val: {:?}", key, value);
}

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

An iterator visiting all key-value pairs in arbitrary order. The iterator returns a reference to the key and a mutable reference to the first element in the corresponding key's vector. Iterator element type is (&'a K, &'a mut V).

Examples

use multimap::MultiMap;

let mut map = MultiMap::new();
map.insert(1,42);
map.insert(1,1337);
map.insert(3,2332);
map.insert(4,1991);

for (_, value) in map.iter_mut() {
    *value *= *value;
}

for (key, value) in map.iter() {
    println!("key: {:?}, val: {:?}", key, value);
}

fn iter_all(&self) -> IterAll<K, Vec<V>>

An iterator visiting all key-value pairs in arbitrary order. The iterator returns a reference to the key and the corresponding key's vector. Iterator element type is (&'a K, &'a V).

Examples

use multimap::MultiMap;

let mut map = MultiMap::new();
map.insert(1,42);
map.insert(1,1337);
map.insert(3,2332);
map.insert(4,1991);

for (key, values) in map.iter_all() {
    println!("key: {:?}, values: {:?}", key, values);
}

fn iter_all_mut(&mut self) -> IterAllMut<K, Vec<V>>

An iterator visiting all key-value pairs in arbitrary order. The iterator returns a reference to the key and the corresponding key's vector. Iterator element type is (&'a K, &'a V).

Examples

use multimap::MultiMap;

let mut map = MultiMap::new();
map.insert(1,42);
map.insert(1,1337);
map.insert(3,2332);
map.insert(4,1991);

for (key, values) in map.iter_all_mut() {
    for value in values.iter_mut() {
        *value = 99;
    }
}

for (key, values) in map.iter_all() {
    println!("key: {:?}, values: {:?}", key, values);
}

fn entry(&mut self, k: K) -> Entry<K, V>

Gets the specified key's corresponding entry in the map for in-place manipulation. It's possible to both manipulate the vector and the 'value' (the first value in the vector).

Examples

use multimap::MultiMap;

let mut m = MultiMap::new();
m.insert(1, 42);

{
    let mut v = m.entry(1).or_insert(43);
    assert_eq!(v, &42);
    *v = 44;
}
assert_eq!(m.entry(2).or_insert(666), &666);

{
    let mut v = m.entry(1).or_insert_vec(vec![43]);
    assert_eq!(v, &vec![44]);
    v.push(50);
}
assert_eq!(m.entry(2).or_insert_vec(vec![666]), &vec![666]);

assert_eq!(m.get_vec(&1), Some(&vec![44, 50]));

Trait Implementations

impl<K, V> Serialize for MultiMap<K, V> where
    K: Serialize + Eq + Hash,
    V: Serialize, 

fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where
    S: Serializer, 

Serialize this value into the given Serde serializer.

impl<'a, K, V> Deserialize<'a> for MultiMap<K, V> where
    K: Deserialize<'a> + Eq + Hash,
    V: Deserialize<'a>, 

fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> where
    D: Deserializer<'a>, 

Deserialize this value from the given Serde deserializer.

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

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

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<'a, K, V, Q: ?Sized> Index<&'a Q> for MultiMap<K, V> where
    K: Eq + Hash + Borrow<Q>,
    Q: Eq + Hash, 

type Output = V

The returned type after indexing

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

The method for the indexing (container[index]) operation

impl<K, V> Debug for MultiMap<K, V> where
    K: Eq + Hash + Debug,
    V: Debug, 

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

Formats the value using the given formatter.

impl<K, V> PartialEq for MultiMap<K, V> where
    K: Eq + Hash,
    V: PartialEq, 

fn eq(&self, other: &MultiMap<K, 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<K, V> Eq for MultiMap<K, V> where
    K: Eq + Hash,
    V: Eq, 

impl<K, V> Default for MultiMap<K, V> where
    K: Eq + Hash, 

fn default() -> MultiMap<K, V>

Returns the "default value" for a type.

impl<K, V> FromIterator<(K, V)> for MultiMap<K, V> where
    K: Eq + Hash, 

fn from_iter<T: IntoIterator<Item = (K, V)>>(iterable: T) -> MultiMap<K, V>

Creates a value from an iterator.

impl<'a, K, V> IntoIterator for &'a MultiMap<K, V> where
    K: Eq + Hash, 

type Item = (&'a K, &'a Vec<V>)

The type of the elements being iterated over.

type IntoIter = IterAll<'a, K, Vec<V>>

Which kind of iterator are we turning this into?

fn into_iter(self) -> IterAll<'a, K, Vec<V>>

Creates an iterator from a value.

impl<'a, K, V> IntoIterator for &'a mut MultiMap<K, V> where
    K: Eq + Hash, 

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

The type of the elements being iterated over.

type IntoIter = IterAllMut<'a, K, Vec<V>>

Which kind of iterator are we turning this into?

fn into_iter(self) -> IterAllMut<'a, K, Vec<V>>

Creates an iterator from a value.

impl<K, V> IntoIterator for MultiMap<K, V> where
    K: Eq + Hash, 

type Item = (K, Vec<V>)

The type of the elements being iterated over.

type IntoIter = IntoIter<K, Vec<V>>

Which kind of iterator are we turning this into?

fn into_iter(self) -> IntoIter<K, Vec<V>>

Creates an iterator from a value.

impl<K, V> Extend<(K, V)> for MultiMap<K, V> where
    K: Eq + Hash, 

fn extend<T: IntoIterator<Item = (K, V)>>(&mut self, iter: T)

Extends a collection with the contents of an iterator.

impl<'a, K, V> Extend<(&'a K, &'a V)> for MultiMap<K, V> where
    K: Eq + Hash + Copy,
    V: Copy, 

fn extend<T: IntoIterator<Item = (&'a K, &'a V)>>(&mut self, iter: T)

Extends a collection with the contents of an iterator.

impl<K, V> Extend<(K, Vec<V>)> for MultiMap<K, V> where
    K: Eq + Hash, 

fn extend<T: IntoIterator<Item = (K, Vec<V>)>>(&mut self, iter: T)

Extends a collection with the contents of an iterator.

impl<'a, K, V> Extend<(&'a K, &'a Vec<V>)> for MultiMap<K, V> where
    K: Eq + Hash + Copy,
    V: Copy, 

fn extend<T: IntoIterator<Item = (&'a K, &'a Vec<V>)>>(&mut self, iter: T)

Extends a collection with the contents of an iterator.