Struct vec_map::VecMap
[−]
[src]
pub struct VecMap<V> { // some fields omitted }
A map optimized for small integer keys.
Examples
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>
[src]
fn new() -> VecMap<V>
Creates an empty VecMap
.
Examples
use std::collections::VecMap; let mut map: VecMap<&str> = VecMap::new();
fn with_capacity(capacity: usize) -> VecMap<V>
Creates an empty VecMap
with space for at least capacity
elements before resizing.
Examples
use std::collections::VecMap; let mut map: VecMap<&str> = VecMap::with_capacity(10);
fn capacity(&self) -> usize
Returns the number of elements the VecMap
can hold without
reallocating.
Examples
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
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
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
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
use std::collections::VecMap; let mut map: VecMap<&str> = VecMap::new(); map.reserve_len_exact(10); assert!(map.capacity() >= 10);
fn keys<'r>(&'r self) -> Keys<'r, V>
Returns an iterator visiting all keys in ascending order of the keys.
The iterator's element type is usize
.
fn values<'r>(&'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
.
fn iter<'r>(&'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)
.
Examples
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>(&'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)
.
Examples
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 split_off(&mut self, at: usize) -> Self
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
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 len(&self) -> usize
Returns the number of elements in the map.
Examples
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
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
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
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
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
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
is returned.
Examples
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
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
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);
Trait Implementations
impl<V> Default for VecMap<V>
[src]
impl<V: Clone> Clone for VecMap<V>
[src]
fn clone(&self) -> VecMap<V>
Returns a copy of the value. Read more
fn clone_from(&mut self, source: &VecMap<V>)
Performs copy-assignment from source
. Read more
impl<V: Hash> Hash for VecMap<V>
[src]
fn hash<H: Hasher>(&self, state: &mut H)
Feeds this value into the state given, updating the hasher as necessary.
fn hash_slice<H>(data: &[Self], state: &mut H) where H: Hasher
1.3.0
Feeds a slice of this type into the state provided.
impl<V: PartialEq> PartialEq for VecMap<V>
[src]
fn eq(&self, other: &VecMap<V>) -> bool
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, other: &Rhs) -> bool
1.0.0
This method tests for !=
.
impl<V: Eq> Eq for VecMap<V>
[src]
impl<V: Debug> Debug for VecMap<V>
[src]
impl<V> FromIterator<(usize, V)> for VecMap<V>
[src]
fn from_iter<I: IntoIterator<Item=(usize, V)>>(iter: I) -> VecMap<V>
Creates a value from an iterator. Read more
impl<T> IntoIterator for VecMap<T>
[src]
type Item = (usize, T)
The type of the elements being iterated over.
type IntoIter = IntoIter<T>
Which kind of iterator are we turning this into?
fn into_iter(self) -> IntoIter<T>
Returns an iterator visiting all key-value pairs in ascending order of
the keys, consuming the original VecMap
.
The iterator's element type is (usize, &'r V)
.
Examples
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.into_iter().collect(); assert_eq!(vec, [(1, "a"), (2, "b"), (3, "c")]);
impl<'a, T> IntoIterator for &'a VecMap<T>
[src]
type Item = (usize, &'a T)
The type of the elements being iterated over.
type IntoIter = Iter<'a, T>
Which kind of iterator are we turning this into?
fn into_iter(self) -> Iter<'a, T>
Creates an iterator from a value. Read more
impl<'a, T> IntoIterator for &'a mut VecMap<T>
[src]
type Item = (usize, &'a mut T)
The type of the elements being iterated over.
type IntoIter = IterMut<'a, T>
Which kind of iterator are we turning this into?
fn into_iter(self) -> IterMut<'a, T>
Creates an iterator from a value. Read more
impl<V> Extend<(usize, V)> for VecMap<V>
[src]
fn extend<I: IntoIterator<Item=(usize, V)>>(&mut self, iter: I)
Extends a collection with the contents of an iterator. Read more
impl<V> Index<usize> for VecMap<V>
[src]
type Output = V
The returned type after indexing
fn index<'a>(&'a self, i: usize) -> &'a V
The method for the indexing (Foo[Bar]
) operation
impl<'a, V> Index<&'a usize> for VecMap<V>
[src]
type Output = V
The returned type after indexing
fn index(&self, i: &usize) -> &V
The method for the indexing (Foo[Bar]
) operation