Struct std::collections::VecMap
[−]
[src]
pub struct VecMap<V> { // some fields omitted }
A map optimized for small integer keys.
Examples
#![feature(collections)] 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.iter() { println!("month {} is {}", key, value); } months.clear(); assert!(months.is_empty()); }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.iter() { println!("month {} is {}", key, value); } months.clear(); assert!(months.is_empty());
Methods
impl<V> VecMap<V>
fn new() -> VecMap<V>
Creates an empty VecMap
`VecMap`.
Examples
#![feature(collections)] fn main() { use std::collections::VecMap; let mut map: VecMap<&str> = VecMap::new(); }use std::collections::VecMap; let mut map: VecMap<&str> = VecMap::new();
fn with_capacity(capacity: usize) -> VecMap<V>
Creates an empty VecMap
`VecMapwith space for at least
` with space for at least capacity
`capacity`
elements before resizing.
Examples
#![feature(collections)] fn main() { use std::collections::VecMap; let mut map: VecMap<&str> = VecMap::with_capacity(10); }use std::collections::VecMap; let mut map: VecMap<&str> = VecMap::with_capacity(10);
fn capacity(&self) -> usize
Returns the number of elements the VecMap
`VecMap` can hold without
reallocating.
Examples
#![feature(collections)] fn main() { use std::collections::VecMap; let map: VecMap<String> = VecMap::with_capacity(10); assert!(map.capacity() >= 10); }use std::collections::VecMap; let map: VecMap<String> = VecMap::with_capacity(10); assert!(map.capacity() >= 10);
fn reserve_len(&mut self, len: usize)
Reserves capacity for the given VecMap
`VecMapto contain
` to contain len
`lendistinct keys. In the case of
` distinct keys.
In the case of VecMap
`VecMapthis means reallocations will not occur as long as all inserted keys are less than
` this means reallocations will not occur as long
as all inserted keys are less than len
`len`.
The collection may reserve more space to avoid frequent reallocations.
Examples
#![feature(collections)] fn main() { use std::collections::VecMap; let mut map: VecMap<&str> = VecMap::new(); map.reserve_len(10); assert!(map.capacity() >= 10); }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)
Reserves the minimum capacity for the given VecMap
`VecMapto contain
` to contain len
`lendistinct keys. In the case of
` distinct keys.
In the case of VecMap
`VecMapthis means reallocations will not occur as long as all inserted keys are less than
` this means reallocations will not occur as long as all inserted
keys are less than len
`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
`reserve_len` if future insertions are expected.
Examples
#![feature(collections)] fn main() { use std::collections::VecMap; let mut map: VecMap<&str> = VecMap::new(); map.reserve_len_exact(10); assert!(map.capacity() >= 10); }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>
Returns an iterator visiting all keys in ascending order of the keys.
The iterator's element type is usize
`usize`.
fn values(&'r self) -> Values<'r, V>
Returns an iterator visiting all values in ascending order of the keys.
The iterator's element type is &'r V
`&'r V`.
fn iter(&'r self) -> Iter<'r, V>
Returns an iterator visiting all key-value pairs in ascending order of the keys.
The iterator's element type is (usize, &'r V)
`(usize, &'r V)`.
Examples
#![feature(collections)] 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); } }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>
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)
`(usize, &'r mut V)`.
Examples
#![feature(collections)] 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.iter() { assert_eq!(value, &"x"); } }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.iter() { assert_eq!(value, &"x"); }
fn append(&mut self, other: &mut VecMap<V>)
: recently added as part of collections reform 2
Moves all elements from other
`other` into the map while overwriting existing keys.
Examples
#![feature(collections)] 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"); }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>
: recently added as part of collections reform 2
Splits the collection into two at the given key.
Returns a newly allocated Self
`Self.
`. self
`selfcontains elements
` contains elements [0, at)
`[0, at), and the returned
`,
and the returned Self
`Selfcontains elements
` contains elements [at, max_key)
`[at, max_key)`.
Note that the capacity of self
`self` does not change.
Examples
#![feature(collections)] 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"); }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>
: matches collection reform specification, waiting for dust to settle
Returns an iterator visiting all key-value pairs in ascending order of
the keys, emptying (but not consuming) the original VecMap
`VecMap. The iterator's element type is
`.
The iterator's element type is (usize, &'r V)
`(usize, &'r V)`. Keeps the allocated memory for reuse.
Examples
#![feature(collections)] 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")]); }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
Returns the number of elements in the map.
Examples
#![feature(collections)] 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); }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
Returns true if the map contains no elements.
Examples
#![feature(collections)] fn main() { use std::collections::VecMap; let mut a = VecMap::new(); assert!(a.is_empty()); a.insert(1, "a"); assert!(!a.is_empty()); }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)
Clears the map, removing all key-value pairs.
Examples
#![feature(collections)] fn main() { use std::collections::VecMap; let mut a = VecMap::new(); a.insert(1, "a"); a.clear(); assert!(a.is_empty()); }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>
Returns a reference to the value corresponding to the key.
Examples
#![feature(collections)] 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); }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
Returns true if the map contains a value for the specified key.
Examples
#![feature(collections)] 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); }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>
Returns a mutable reference to the value corresponding to the key.
Examples
#![feature(collections)] 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"); }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>
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
`None` is returned.
Examples
#![feature(collections)] 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"); }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>
Removes a key from the map, returning the value at the key if the key was previously in the map.
Examples
#![feature(collections)] 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); }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>
Gets the given key's corresponding entry in the map for in-place manipulation.
Examples
#![feature(collections)] 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); }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);