# Struct vec_map::VecMap

``pub struct VecMap<V> { /* private fields */ }``
Expand description

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

## Implementations§

source§

### impl<V> VecMap<V>

source

#### pub fn new() -> Self

Creates an empty `VecMap`.

##### §Examples
``````use vec_map::VecMap;
let mut map: VecMap<&str> = VecMap::new();``````
source

#### pub fn with_capacity(capacity: usize) -> Self

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

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

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

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

#### pub fn shrink_to_fit(&mut self)

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

#### pub fn keys(&self) -> Keys<'_, V> ⓘ

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

source

#### pub fn values(&self) -> Values<'_, V> ⓘ

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

source

#### pub fn values_mut(&mut self) -> ValuesMut<'_, V> ⓘ

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

source

#### pub fn iter(&self) -> Iter<'_, 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);
}``````
source

#### pub fn iter_mut(&mut self) -> IterMut<'_, 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");
}``````
source

#### pub fn append(&mut self, other: &mut Self)

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

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

#### pub fn drain(&mut self) -> Drain<'_, V> ⓘ

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

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

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

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

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

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

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

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

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

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

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

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§

source§

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

source§

#### fn clone(&self) -> Self

Returns a copy of the value. Read more
source§

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

Performs copy-assignment from `source`. Read more
source§

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

source§

#### fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter. Read more
source§

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

source§

#### fn default() -> Self

Returns the “default value” for a type. Read more
source§

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

source§

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

Extends a collection with the contents of an iterator. Read more
source§

#### fn extend_one(&mut self, item: A)

🔬This is a nightly-only experimental API. (`extend_one`)
Extends a collection with exactly one element.
source§

#### fn extend_reserve(&mut self, additional: usize)

🔬This is a nightly-only experimental API. (`extend_one`)
Reserves capacity in a collection for the given number of additional elements. Read more
source§

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

source§

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

Extends a collection with the contents of an iterator. Read more
source§

#### fn extend_one(&mut self, item: A)

🔬This is a nightly-only experimental API. (`extend_one`)
Extends a collection with exactly one element.
source§

#### fn extend_reserve(&mut self, additional: usize)

🔬This is a nightly-only experimental API. (`extend_one`)
Reserves capacity in a collection for the given number of additional elements. Read more
source§

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

source§

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

Creates a value from an iterator. Read more
source§

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

source§

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

Feeds this value into the given `Hasher`. Read more
1.3.0 · source§

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

Feeds a slice of this type into the given `Hasher`. Read more
source§

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

§

#### type Output = V

The returned type after indexing.
source§

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

Performs the indexing (`container[index]`) operation. Read more
source§

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

§

#### type Output = V

The returned type after indexing.
source§

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

Performs the indexing (`container[index]`) operation. Read more
source§

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

source§

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

Performs the mutable indexing (`container[index]`) operation. Read more
source§

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

source§

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

Performs the mutable indexing (`container[index]`) operation. Read more
source§

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

§

#### 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?
source§

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

Creates an iterator from a value. Read more
source§

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

§

#### 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?
source§

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

Creates an iterator from a value. Read more
source§

### impl<T> IntoIterator for VecMap<T>

source§

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

#### 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?
source§

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

source§

#### fn cmp(&self, other: &Self) -> Ordering

This method returns an `Ordering` between `self` and `other`. Read more
1.21.0 · source§

#### fn max(self, other: Self) -> Selfwhere Self: Sized,

Compares and returns the maximum of two values. Read more
1.21.0 · source§

#### fn min(self, other: Self) -> Selfwhere Self: Sized,

Compares and returns the minimum of two values. Read more
1.50.0 · source§

#### fn clamp(self, min: Self, max: Self) -> Selfwhere Self: Sized + PartialOrd,

Restrict a value to a certain interval. Read more
source§

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

source§

#### fn eq(&self, other: &Self) -> bool

This method tests for `self` and `other` values to be equal, and is used by `==`.
1.0.0 · source§

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

This method tests for `!=`. The default implementation is almost always sufficient, and should not be overridden without very good reason.
source§

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

source§

#### fn partial_cmp(&self, other: &Self) -> Option<Ordering>

This method returns an ordering between `self` and `other` values if one exists. Read more
1.0.0 · source§

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

This method tests less than (for `self` and `other`) and is used by the `<` operator. Read more
1.0.0 · source§

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

This method tests less than or equal to (for `self` and `other`) and is used by the `<=` operator. Read more
1.0.0 · source§

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

This method tests greater than (for `self` and `other`) and is used by the `>` operator. Read more
1.0.0 · source§

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

This method tests greater than or equal to (for `self` and `other`) and is used by the `>=` operator. Read more
source§

§

§

§

§

§

## Blanket Implementations§

source§

### impl<T> Any for Twhere T: 'static + ?Sized,

source§

#### fn type_id(&self) -> TypeId

Gets the `TypeId` of `self`. Read more
source§

### impl<T> Borrow<T> for Twhere T: ?Sized,

source§

#### fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
source§

### impl<T> BorrowMut<T> for Twhere T: ?Sized,

source§

#### fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more
source§

### impl<T> From<T> for T

source§

#### fn from(t: T) -> T

Returns the argument unchanged.

source§

### impl<T, U> Into<U> for Twhere U: From<T>,

source§

#### fn into(self) -> U

Calls `U::from(self)`.

That is, this conversion is whatever the implementation of `From<T> for U` chooses to do.

source§

### impl<T> ToOwned for Twhere T: Clone,

§

#### type Owned = T

The resulting type after obtaining ownership.
source§

#### fn to_owned(&self) -> T

Creates owned data from borrowed data, usually by cloning. Read more
source§

#### fn clone_into(&self, target: &mut T)

Uses borrowed data to replace owned data, usually by cloning. Read more
source§

### impl<T, U> TryFrom<U> for Twhere U: Into<T>,

§

#### type Error = Infallible

The type returned in the event of a conversion error.
source§

#### fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.
source§

### impl<T, U> TryInto<U> for Twhere U: TryFrom<T>,

§

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

The type returned in the event of a conversion error.
source§

#### fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.