Struct std::collections::vec_map::VecMap
[−]
[src]
pub struct VecMap<V> {
// some fields omitted
}: VecMap moved to crates.io as vec_map
A map optimized for small integer keys.
Examples
#![feature(vecmap)] fn main() { use std::collections::VecMap; let mut months = VecMap::new(); months.insert(1, "Jan"); months.insert(2, "Feb"); months.insert(3, "Mar"); if !months.contains_key(&12) { println!("The end is near!"); } assert_eq!(months.get(&1), Some(&"Jan")); if let Some(value) = months.get_mut(&3) { *value = "Venus"; } assert_eq!(months.get(&3), Some(&"Venus")); // Print out all months for (key, value) in &months { println!("month {} is {}", key, value); } months.clear(); assert!(months.is_empty()); }#![feature(vecmap)] use std::collections::VecMap; let mut months = VecMap::new(); months.insert(1, "Jan"); months.insert(2, "Feb"); months.insert(3, "Mar"); if !months.contains_key(&12) { println!("The end is near!"); } assert_eq!(months.get(&1), Some(&"Jan")); if let Some(value) = months.get_mut(&3) { *value = "Venus"; } assert_eq!(months.get(&3), Some(&"Venus")); // Print out all months for (key, value) in &months { println!("month {} is {}", key, value); } months.clear(); assert!(months.is_empty());
Methods
impl<V> VecMap<V>
fn new() -> VecMap<V>
: VecMap moved to crates.io as vec_map
Creates an empty VecMap.
Examples
#![feature(vecmap)] fn main() { use std::collections::VecMap; let mut map: VecMap<&str> = VecMap::new(); }#![feature(vecmap)] use std::collections::VecMap; let mut map: VecMap<&str> = VecMap::new();
fn with_capacity(capacity: usize) -> VecMap<V>
: VecMap moved to crates.io as vec_map
Creates an empty VecMap with space for at least capacity
elements before resizing.
Examples
#![feature(vecmap)] fn main() { use std::collections::VecMap; let mut map: VecMap<&str> = VecMap::with_capacity(10); }#![feature(vecmap)] use std::collections::VecMap; let mut map: VecMap<&str> = VecMap::with_capacity(10);
fn capacity(&self) -> usize
: VecMap moved to crates.io as vec_map
Returns the number of elements the VecMap can hold without
reallocating.
Examples
#![feature(vecmap)] fn main() { use std::collections::VecMap; let map: VecMap<String> = VecMap::with_capacity(10); assert!(map.capacity() >= 10); }#![feature(vecmap)] use std::collections::VecMap; let map: VecMap<String> = VecMap::with_capacity(10); assert!(map.capacity() >= 10);
fn reserve_len(&mut self, len: usize)
: VecMap moved to crates.io as vec_map
Reserves capacity for the given VecMap to contain len distinct keys.
In the case of VecMap this means reallocations will not occur as long
as all inserted keys are less than len.
The collection may reserve more space to avoid frequent reallocations.
Examples
#![feature(vecmap)] fn main() { use std::collections::VecMap; let mut map: VecMap<&str> = VecMap::new(); map.reserve_len(10); assert!(map.capacity() >= 10); }#![feature(vecmap)] use std::collections::VecMap; let mut map: VecMap<&str> = VecMap::new(); map.reserve_len(10); assert!(map.capacity() >= 10);
fn reserve_len_exact(&mut self, len: usize)
: VecMap moved to crates.io as vec_map
Reserves the minimum capacity for the given VecMap to contain len distinct keys.
In the case of VecMap this means reallocations will not occur as long as all inserted
keys are less than len.
Note that the allocator may give the collection more space than it requests.
Therefore capacity cannot be relied upon to be precisely minimal. Prefer
reserve_len if future insertions are expected.
Examples
#![feature(vecmap)] fn main() { use std::collections::VecMap; let mut map: VecMap<&str> = VecMap::new(); map.reserve_len_exact(10); assert!(map.capacity() >= 10); }#![feature(vecmap)] use std::collections::VecMap; let mut map: VecMap<&str> = VecMap::new(); map.reserve_len_exact(10); assert!(map.capacity() >= 10);
fn keys(&'r self) -> Keys<'r, V>
: VecMap moved to crates.io as vec_map
Returns an iterator visiting all keys in ascending order of the keys.
The iterator's element type is usize.
fn values(&'r self) -> Values<'r, V>
: VecMap moved to crates.io as vec_map
Returns an iterator visiting all values in ascending order of the keys.
The iterator's element type is &'r V.
fn iter(&'r self) -> Iter<'r, V>
: VecMap moved to crates.io as vec_map
Returns an iterator visiting all key-value pairs in ascending order of the keys.
The iterator's element type is (usize, &'r V).
Examples
#![feature(vecmap)] fn main() { use std::collections::VecMap; let mut map = VecMap::new(); map.insert(1, "a"); map.insert(3, "c"); map.insert(2, "b"); // Print `1: a` then `2: b` then `3: c` for (key, value) in map.iter() { println!("{}: {}", key, value); } }#![feature(vecmap)] use std::collections::VecMap; let mut map = VecMap::new(); map.insert(1, "a"); map.insert(3, "c"); map.insert(2, "b"); // Print `1: a` then `2: b` then `3: c` for (key, value) in map.iter() { println!("{}: {}", key, value); }
fn iter_mut(&'r mut self) -> IterMut<'r, V>
: VecMap moved to crates.io as vec_map
Returns an iterator visiting all key-value pairs in ascending order of the keys,
with mutable references to the values.
The iterator's element type is (usize, &'r mut V).
Examples
#![feature(vecmap)] fn main() { use std::collections::VecMap; let mut map = VecMap::new(); map.insert(1, "a"); map.insert(2, "b"); map.insert(3, "c"); for (key, value) in map.iter_mut() { *value = "x"; } for (key, value) in &map { assert_eq!(value, &"x"); } }#![feature(vecmap)] use std::collections::VecMap; let mut map = VecMap::new(); map.insert(1, "a"); map.insert(2, "b"); map.insert(3, "c"); for (key, value) in map.iter_mut() { *value = "x"; } for (key, value) in &map { assert_eq!(value, &"x"); }
fn append(&mut self, other: &mut VecMap<V>)
: VecMap moved to crates.io as vec_map
Moves all elements from other into the map while overwriting existing keys.
Examples
#![feature(vecmap, append)] fn main() { use std::collections::VecMap; let mut a = VecMap::new(); a.insert(1, "a"); a.insert(2, "b"); let mut b = VecMap::new(); b.insert(3, "c"); b.insert(4, "d"); a.append(&mut b); assert_eq!(a.len(), 4); assert_eq!(b.len(), 0); assert_eq!(a[1], "a"); assert_eq!(a[2], "b"); assert_eq!(a[3], "c"); assert_eq!(a[4], "d"); }#![feature(vecmap, append)] use std::collections::VecMap; let mut a = VecMap::new(); a.insert(1, "a"); a.insert(2, "b"); let mut b = VecMap::new(); b.insert(3, "c"); b.insert(4, "d"); a.append(&mut b); assert_eq!(a.len(), 4); assert_eq!(b.len(), 0); assert_eq!(a[1], "a"); assert_eq!(a[2], "b"); assert_eq!(a[3], "c"); assert_eq!(a[4], "d");
fn split_off(&mut self, at: usize) -> VecMap<V>
: VecMap moved to crates.io as vec_map
Splits the collection into two at the given key.
Returns a newly allocated Self. self contains elements [0, at),
and the returned Self contains elements [at, max_key).
Note that the capacity of self does not change.
Examples
#![feature(vecmap, split_off)] fn main() { use std::collections::VecMap; let mut a = VecMap::new(); a.insert(1, "a"); a.insert(2, "b"); a.insert(3, "c"); a.insert(4, "d"); let b = a.split_off(3); assert_eq!(a[1], "a"); assert_eq!(a[2], "b"); assert_eq!(b[3], "c"); assert_eq!(b[4], "d"); }#![feature(vecmap, split_off)] use std::collections::VecMap; let mut a = VecMap::new(); a.insert(1, "a"); a.insert(2, "b"); a.insert(3, "c"); a.insert(4, "d"); let b = a.split_off(3); assert_eq!(a[1], "a"); assert_eq!(a[2], "b"); assert_eq!(b[3], "c"); assert_eq!(b[4], "d");
fn drain(&'a mut self) -> Drain<'a, V>
: VecMap moved to crates.io as vec_map
Returns an iterator visiting all key-value pairs in ascending order of
the keys, emptying (but not consuming) the original VecMap.
The iterator's element type is (usize, &'r V). Keeps the allocated memory for reuse.
Examples
#![feature(vecmap, drain)] fn main() { use std::collections::VecMap; let mut map = VecMap::new(); map.insert(1, "a"); map.insert(3, "c"); map.insert(2, "b"); let vec: Vec<(usize, &str)> = map.drain().collect(); assert_eq!(vec, [(1, "a"), (2, "b"), (3, "c")]); }#![feature(vecmap, drain)] use std::collections::VecMap; let mut map = VecMap::new(); map.insert(1, "a"); map.insert(3, "c"); map.insert(2, "b"); let vec: Vec<(usize, &str)> = map.drain().collect(); assert_eq!(vec, [(1, "a"), (2, "b"), (3, "c")]);
fn len(&self) -> usize
: VecMap moved to crates.io as vec_map
Returns the number of elements in the map.
Examples
#![feature(vecmap)] fn main() { use std::collections::VecMap; let mut a = VecMap::new(); assert_eq!(a.len(), 0); a.insert(1, "a"); assert_eq!(a.len(), 1); }#![feature(vecmap)] use std::collections::VecMap; let mut a = VecMap::new(); assert_eq!(a.len(), 0); a.insert(1, "a"); assert_eq!(a.len(), 1);
fn is_empty(&self) -> bool
: VecMap moved to crates.io as vec_map
Returns true if the map contains no elements.
Examples
#![feature(vecmap)] fn main() { use std::collections::VecMap; let mut a = VecMap::new(); assert!(a.is_empty()); a.insert(1, "a"); assert!(!a.is_empty()); }#![feature(vecmap)] use std::collections::VecMap; let mut a = VecMap::new(); assert!(a.is_empty()); a.insert(1, "a"); assert!(!a.is_empty());
fn clear(&mut self)
: VecMap moved to crates.io as vec_map
Clears the map, removing all key-value pairs.
Examples
#![feature(vecmap)] fn main() { use std::collections::VecMap; let mut a = VecMap::new(); a.insert(1, "a"); a.clear(); assert!(a.is_empty()); }#![feature(vecmap)] use std::collections::VecMap; let mut a = VecMap::new(); a.insert(1, "a"); a.clear(); assert!(a.is_empty());
fn get(&self, key: &usize) -> Option<&V>
: VecMap moved to crates.io as vec_map
Returns a reference to the value corresponding to the key.
Examples
#![feature(vecmap)] fn main() { use std::collections::VecMap; let mut map = VecMap::new(); map.insert(1, "a"); assert_eq!(map.get(&1), Some(&"a")); assert_eq!(map.get(&2), None); }#![feature(vecmap)] use std::collections::VecMap; let mut map = VecMap::new(); map.insert(1, "a"); assert_eq!(map.get(&1), Some(&"a")); assert_eq!(map.get(&2), None);
fn contains_key(&self, key: &usize) -> bool
: VecMap moved to crates.io as vec_map
Returns true if the map contains a value for the specified key.
Examples
#![feature(vecmap)] fn main() { use std::collections::VecMap; let mut map = VecMap::new(); map.insert(1, "a"); assert_eq!(map.contains_key(&1), true); assert_eq!(map.contains_key(&2), false); }#![feature(vecmap)] use std::collections::VecMap; let mut map = VecMap::new(); map.insert(1, "a"); assert_eq!(map.contains_key(&1), true); assert_eq!(map.contains_key(&2), false);
fn get_mut(&mut self, key: &usize) -> Option<&mut V>
: VecMap moved to crates.io as vec_map
Returns a mutable reference to the value corresponding to the key.
Examples
#![feature(vecmap)] fn main() { use std::collections::VecMap; let mut map = VecMap::new(); map.insert(1, "a"); if let Some(x) = map.get_mut(&1) { *x = "b"; } assert_eq!(map[1], "b"); }#![feature(vecmap)] use std::collections::VecMap; let mut map = VecMap::new(); map.insert(1, "a"); if let Some(x) = map.get_mut(&1) { *x = "b"; } assert_eq!(map[1], "b");
fn insert(&mut self, key: usize, value: V) -> Option<V>
: VecMap moved to crates.io as vec_map
Inserts a key-value pair into the map. If the key already had a value
present in the map, that value is returned. Otherwise, None is returned.
Examples
#![feature(vecmap)] fn main() { use std::collections::VecMap; let mut map = VecMap::new(); assert_eq!(map.insert(37, "a"), None); assert_eq!(map.is_empty(), false); map.insert(37, "b"); assert_eq!(map.insert(37, "c"), Some("b")); assert_eq!(map[37], "c"); }#![feature(vecmap)] use std::collections::VecMap; let mut map = VecMap::new(); assert_eq!(map.insert(37, "a"), None); assert_eq!(map.is_empty(), false); map.insert(37, "b"); assert_eq!(map.insert(37, "c"), Some("b")); assert_eq!(map[37], "c");
fn remove(&mut self, key: &usize) -> Option<V>
: VecMap moved to crates.io as vec_map
Removes a key from the map, returning the value at the key if the key was previously in the map.
Examples
#![feature(vecmap)] fn main() { use std::collections::VecMap; let mut map = VecMap::new(); map.insert(1, "a"); assert_eq!(map.remove(&1), Some("a")); assert_eq!(map.remove(&1), None); }#![feature(vecmap)] use std::collections::VecMap; let mut map = VecMap::new(); map.insert(1, "a"); assert_eq!(map.remove(&1), Some("a")); assert_eq!(map.remove(&1), None);
fn entry(&mut self, key: usize) -> Entry<V>
: VecMap moved to crates.io as vec_map
Gets the given key's corresponding entry in the map for in-place manipulation.
Examples
#![feature(vecmap, entry)] fn main() { use std::collections::VecMap; let mut count: VecMap<u32> = VecMap::new(); // count the number of occurrences of numbers in the vec for x in vec![1, 2, 1, 2, 3, 4, 1, 2, 4] { *count.entry(x).or_insert(0) += 1; } assert_eq!(count[1], 3); }#![feature(vecmap, entry)] use std::collections::VecMap; let mut count: VecMap<u32> = VecMap::new(); // count the number of occurrences of numbers in the vec for x in vec![1, 2, 1, 2, 3, 4, 1, 2, 4] { *count.entry(x).or_insert(0) += 1; } assert_eq!(count[1], 3);