[][src]Struct vec_map::VecMap

pub struct VecMap<V> { /* fields omitted */ }

A map optimized for small integer keys.

Examples

use vec_map::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>[src]

pub fn new() -> Self[src]

Creates an empty VecMap.

Examples

use vec_map::VecMap;
let mut map: VecMap<&str> = VecMap::new();

pub fn with_capacity(capacity: usize) -> Self[src]

Creates an empty VecMap with space for at least capacity elements before resizing.

Examples

use vec_map::VecMap;
let mut map: VecMap<&str> = VecMap::with_capacity(10);

pub fn capacity(&self) -> usize[src]

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

Examples

use vec_map::VecMap;
let map: VecMap<String> = VecMap::with_capacity(10);
assert!(map.capacity() >= 10);

pub fn reserve_len(&mut self, len: usize)[src]

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 vec_map::VecMap;
let mut map: VecMap<&str> = VecMap::new();
map.reserve_len(10);
assert!(map.capacity() >= 10);

pub fn reserve_len_exact(&mut self, len: usize)[src]

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 vec_map::VecMap;
let mut map: VecMap<&str> = VecMap::new();
map.reserve_len_exact(10);
assert!(map.capacity() >= 10);

pub fn shrink_to_fit(&mut self)[src]

Trims the VecMap of any excess capacity.

The collection may reserve more space to avoid frequent reallocations.

Examples

use vec_map::VecMap;
let mut map: VecMap<&str> = VecMap::with_capacity(10);
map.shrink_to_fit();
assert_eq!(map.capacity(), 0);

Important traits for Keys<'a, V>
pub fn keys(&self) -> Keys<V>[src]

Returns an iterator visiting all keys in ascending order of the keys. The iterator's element type is usize.

Important traits for Values<'a, V>
pub fn values(&self) -> Values<V>[src]

Returns an iterator visiting all values in ascending order of the keys. The iterator's element type is &'r V.

Important traits for ValuesMut<'a, V>
pub fn values_mut(&mut self) -> ValuesMut<V>[src]

Returns an iterator visiting all values in ascending order of the keys. The iterator's element type is &'r mut V.

Important traits for Iter<'a, V>
pub fn iter(&self) -> Iter<V>[src]

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 vec_map::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);
}

Important traits for IterMut<'a, V>
pub fn iter_mut(&mut self) -> IterMut<V>[src]

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 vec_map::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");
}

pub fn append(&mut self, other: &mut Self)[src]

Moves all elements from other into the map while overwriting existing keys.

Examples

use vec_map::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");

pub fn split_off(&mut self, at: usize) -> Self[src]

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 vec_map::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");

Important traits for Drain<'a, V>
pub fn drain(&mut self) -> Drain<V>[src]

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

use vec_map::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")]);

pub fn len(&self) -> usize[src]

Returns the number of elements in the map.

Examples

use vec_map::VecMap;

let mut a = VecMap::new();
assert_eq!(a.len(), 0);
a.insert(1, "a");
assert_eq!(a.len(), 1);

pub fn is_empty(&self) -> bool[src]

Returns true if the map contains no elements.

Examples

use vec_map::VecMap;

let mut a = VecMap::new();
assert!(a.is_empty());
a.insert(1, "a");
assert!(!a.is_empty());

pub fn clear(&mut self)[src]

Clears the map, removing all key-value pairs.

Examples

use vec_map::VecMap;

let mut a = VecMap::new();
a.insert(1, "a");
a.clear();
assert!(a.is_empty());

pub fn get(&self, key: usize) -> Option<&V>[src]

Returns a reference to the value corresponding to the key.

Examples

use vec_map::VecMap;

let mut map = VecMap::new();
map.insert(1, "a");
assert_eq!(map.get(1), Some(&"a"));
assert_eq!(map.get(2), None);

pub fn contains_key(&self, key: usize) -> bool[src]

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

Examples

use vec_map::VecMap;

let mut map = VecMap::new();
map.insert(1, "a");
assert_eq!(map.contains_key(1), true);
assert_eq!(map.contains_key(2), false);

pub fn get_mut(&mut self, key: usize) -> Option<&mut V>[src]

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

Examples

use vec_map::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");

pub fn insert(&mut self, key: usize, value: V) -> Option<V>[src]

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 vec_map::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");

pub fn remove(&mut self, key: usize) -> Option<V>[src]

Removes a key from the map, returning the value at the key if the key was previously in the map.

Examples

use vec_map::VecMap;

let mut map = VecMap::new();
map.insert(1, "a");
assert_eq!(map.remove(1), Some("a"));
assert_eq!(map.remove(1), None);

pub fn entry(&mut self, key: usize) -> Entry<V>[src]

Gets the given key's corresponding entry in the map for in-place manipulation.

Examples

use vec_map::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);

pub fn retain<F>(&mut self, f: F) where
    F: FnMut(usize, &mut V) -> bool
[src]

Retains only the elements specified by the predicate.

In other words, remove all pairs (k, v) such that f(&k, &mut v) returns false.

Examples

use vec_map::VecMap;

let mut map: VecMap<usize> = (0..8).map(|x|(x, x*10)).collect();
map.retain(|k, _| k % 2 == 0);
assert_eq!(map.len(), 4);

Trait Implementations

impl<V: Clone> Clone for VecMap<V>[src]

impl<V: Debug> Debug for VecMap<V>[src]

impl<V> Default for VecMap<V>[src]

impl<V: Eq> Eq for VecMap<V>[src]

impl<'a, V: Copy> Extend<(usize, &'a V)> for VecMap<V>[src]

impl<V> Extend<(usize, V)> for VecMap<V>[src]

impl<V> FromIterator<(usize, V)> for VecMap<V>[src]

impl<V: Hash> Hash for VecMap<V>[src]

impl<'a, V> Index<&'a usize> for VecMap<V>[src]

type Output = V

The returned type after indexing.

impl<V> Index<usize> for VecMap<V>[src]

type Output = V

The returned type after indexing.

impl<'a, V> IndexMut<&'a usize> for VecMap<V>[src]

impl<V> IndexMut<usize> for VecMap<V>[src]

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?

Important traits for IntoIter<V>
fn into_iter(self) -> IntoIter<T>[src]

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 vec_map::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?

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?

impl<V: Ord> Ord for VecMap<V>[src]

impl<V: PartialEq> PartialEq<VecMap<V>> for VecMap<V>[src]

impl<V: PartialOrd> PartialOrd<VecMap<V>> for VecMap<V>[src]

Auto Trait Implementations

impl<V> RefUnwindSafe for VecMap<V> where
    V: RefUnwindSafe

impl<V> Send for VecMap<V> where
    V: Send

impl<V> Sync for VecMap<V> where
    V: Sync

impl<V> Unpin for VecMap<V> where
    V: Unpin

impl<V> UnwindSafe for VecMap<V> where
    V: UnwindSafe

Blanket Implementations

impl<T> Any for T where
    T: 'static + ?Sized
[src]

impl<T> Borrow<T> for T where
    T: ?Sized
[src]

impl<T> BorrowMut<T> for T where
    T: ?Sized
[src]

impl<T> From<T> for T[src]

impl<T, U> Into<U> for T where
    U: From<T>, 
[src]

impl<I> IntoIterator for I where
    I: Iterator
[src]

type Item = <I as Iterator>::Item

The type of the elements being iterated over.

type IntoIter = I

Which kind of iterator are we turning this into?

impl<T> ToOwned for T where
    T: Clone
[src]

type Owned = T

The resulting type after obtaining ownership.

impl<T, U> TryFrom<U> for T where
    U: Into<T>, 
[src]

type Error = Infallible

The type returned in the event of a conversion error.

impl<T, U> TryInto<U> for T where
    U: TryFrom<T>, 
[src]

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.