Struct multimap::MultiMap
[−]
[src]
pub struct MultiMap<K, V> {
// some 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]));