# Struct vec_map::VecMap [−] [src]

    pub struct VecMap<V> {
        // some 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>`

#### `fn new() -> VecMap<V>`

Creates an empty `VecMap`.

# Examples

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

#### `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 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");
    }

#### `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 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");

#### `fn len(&self) -> usize`

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

#### `fn is_empty(&self) -> bool`

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

#### `fn clear(&mut self)`

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

#### `fn get(&self, key: &usize) -> Option<&V>`

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

#### `fn contains_key(&self, key: &usize) -> bool`

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

#### `fn get_mut(&mut self, key: &usize) -> Option<&mut V>`

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

#### `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 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");

#### `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 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);

#### `fn entry(&mut self, key: usize) -> Entry<V>`

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

## Trait Implementations

### `impl<V> Default for VecMap<V>`

#### `fn default() -> VecMap<V>`

### `impl<V: Hash> Hash for VecMap<V>`

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

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

### `impl<V: Debug> Debug for VecMap<V>`

#### `fn fmt(&self, f: &mut Formatter) -> Result`

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

#### `fn from_iter<I: IntoIterator<Item=(usize, V)>>(iter: I) -> VecMap<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: IntoIterator<Item=(usize, V)>>(&mut self, iter: I)`

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

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

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

#### `type Output = V`

#### `fn index<'a>(&'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`

### Derived Implementations

### `impl<V: Clone> Clone for VecMap<V>`

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

#### 1.0.0 `fn clone_from(&mut self, source: &Self)`

# Help

## Keyboard Shortcuts

?
  Show this help dialog
S
  Focus the search field
⇤
  Move up in search results
⇥
  Move down in search results
⏎
  Go to active search result

## Search Tricks

Prefix searches with a type followed by a colon (e.g. `fn:`) to restrict the search to a given type.

Accepted types are: `fn`, `mod`, `struct`, `enum`, `trait`, `type`, `macro`, and `const`.

Search functions by type signature (e.g. `vec -> usize` or `* -> vec`)