Struct std::collections::vec_map::VecMap [] [src]

pub struct VecMap<V> {
    // some fields omitted
}
Deprecated since 1.3.0

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

Deprecated since 1.3.0

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

Deprecated since 1.3.0

: 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

Deprecated since 1.3.0

: 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)

Deprecated since 1.3.0

: 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)

Deprecated since 1.3.0

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

Deprecated since 1.3.0

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

Deprecated since 1.3.0

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

Deprecated since 1.3.0

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

Deprecated since 1.3.0

: 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>)

Deprecated since 1.3.0

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

Deprecated since 1.3.0

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

Deprecated since 1.3.0

: 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

Deprecated since 1.3.0

: 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

Deprecated since 1.3.0

: 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)

Deprecated since 1.3.0

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

Deprecated since 1.3.0

: 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

Deprecated since 1.3.0

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

Deprecated since 1.3.0

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

Deprecated since 1.3.0

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

Deprecated since 1.3.0

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

Deprecated since 1.3.0

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

Trait Implementations

impl<V> Default for VecMap<V>

fn default() -> VecMap<V>

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

fn clone(&self) -> VecMap<V>

fn clone_from(&mut self, source: &VecMap<V>)

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

fn hash<H>(&self, state: &mut H) where H: Hasher

fn hash_slice<H>(data: &[Self], state: &mut H) where H: Hasher

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

fn eq(&self, other: &VecMap<V>) -> bool

fn ne(&self, other: &Rhs) -> bool

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

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

fn partial_cmp(&self, other: &VecMap<V>) -> Option<Ordering>

fn lt(&self, other: &Rhs) -> bool

fn le(&self, other: &Rhs) -> bool

fn gt(&self, other: &Rhs) -> bool

fn ge(&self, other: &Rhs) -> bool

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

fn cmp(&self, other: &VecMap<V>) -> Ordering

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

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<V> FromIterator<(usize, V)> for VecMap<V>

fn from_iter<I>(iter: I) -> VecMap<V> where I: IntoIterator<Item=(usize, V)>

impl<T> IntoIterator for VecMap<T>

type Item = (usize, T)

type IntoIter = IntoIter<T>

fn into_iter(self) -> IntoIter<T>

impl<'a, T> IntoIterator for &'a VecMap<T>

type Item = (usize, &'a T)

type IntoIter = Iter<'a, T>

fn into_iter(self) -> Iter<'a, T>

impl<'a, T> IntoIterator for &'a mut VecMap<T>

type Item = (usize, &'a mut T)

type IntoIter = IterMut<'a, T>

fn into_iter(self) -> IterMut<'a, T>

impl<V> Extend<(usize, V)> for VecMap<V>

fn extend<I>(&mut self, iter: I) where I: IntoIterator<Item=(usize, V)>

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

fn extend<I>(&mut self, iter: I) where I: IntoIterator<Item=(usize, &'a V)>

impl<V> Index<usize> for VecMap<V>

type Output = V

fn index(&'a self, i: usize) -> &'a V

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

type Output = V

fn index(&self, i: &usize) -> &V

impl<V> IndexMut<usize> for VecMap<V>

fn index_mut(&mut self, i: usize) -> &mut V

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

fn index_mut(&mut self, i: &usize) -> &mut V