Struct more_collections::vec_map::VecMap

pub struct VecMap<K, V> { /* private fields */ }

A Vec-backed map.

It has faster random access performance and slower iteration speed compared to other maps. Makes most sense for relatively dense maps or if iteration is needed significantly less than random access. In case of doubt, benchmark it for your usecase.

Performance

VecMap outperforms HashMap, IndexMap, and BTreeMap for random access (such as get()) and random modifications (such as insert()). For modifications this is only true iff VecMap does not need to do any resizing. Therefore, if performance is essential, it is strongly recommended to initialize VecMap with with_capacity().

Iteration order follows the natural ordering of IndexKey::as_index().

Implementations

impl<K: IndexKey, V: Clone> VecMap<K, V>

pub fn with_capacity(n: usize) -> Self

Initializes VecMap with capacity to hold exactly n elements in the index range of 0..n.

pub fn from_elem(elem: V, n: usize) -> Self

Initializes VecMap with n occurences of elem.

pub fn clear(&mut self)

Clears all data from the VecMap without changing the capacity.

pub fn reserve(&mut self, additional: usize)

Reserve capacity for additional key-value pairs.

impl<K: IndexKey, V> VecMap<K, V>

pub const fn new() -> Self

Initializes an empty VecMap.

For performance reasons it’s almost always better to avoid dynamic resizing by using Self::with_capacity() instead.

pub fn capacity(&self) -> usize

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

The index range of items that the map can hold without reallocating is 0..capacity.

pub fn insert(&mut self, key: K, value: V) -> Option<V>

Inserts a key-value pair into the map.

If the key is present in the map, the value is updated and the old value is returned. Otherwise, None is returned.

pub fn remove(&mut self, key: K) -> Option<V>

Removes the key-value pair indicated by key.

If the key was present, it is returned. Otherwise None is returned.

pub fn pop(&mut self) -> Option<(K, V)>

Removes the last key-value pair.

Worst case performance is O(n) in case the value is at the first index, where n = the capacity.

pub fn retain<F>(&mut self, keep: F)

where F: FnMut(K, &mut V) -> bool,

Iterates over each key-value pair in the map and keep those where the closure keep returns true.

The elements are visited in order.

pub fn entry(&mut self, key: K) -> Entry<'_, K, V>

Get the given key’s entry in the map for insertion and/or in-place manipulation.

pub fn get(&self, key: K) -> Option<&V>

Returns a reference to the value associated with key if it exists, otherwise returns None.

pub fn get_mut(&mut self, key: K) -> Option<&mut V>

Returns a mutable reference to the value associated with key if it exists, otherwise returns None.

pub const fn len(&self) -> usize

Return the number of key-value pairs in the map.

pub const fn is_empty(&self) -> bool

Returns true if the map contains no elements.

pub fn contains_key(&self, key: K) -> bool

Returns true if the map contains an item with the specified key.

pub fn iter(&self) -> Iter<'_, K, V>

Returns an iterator over the key-value pairs of the map, following the natural order of the keys.

pub fn iter_mut(&mut self) -> IterMut<'_, K, V>

Returns an iterator over the key-value pairs of the map, with the values being mutable, following the natural order of the keys.

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

Returns an iterator over the keys of the map following the natural order of the keys.

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

Returns an iterator over the values of the map following the natural order of the keys.

Trait Implementations

impl<K: Clone, V: Clone> Clone for VecMap<K, V>

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

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<K: IndexKey + Debug, V: Debug> Debug for VecMap<K, V>

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

Formats the value using the given formatter.

impl<K: IndexKey, V> Default for VecMap<K, V>

fn default() -> Self

Returns the “default value” for a type.

impl<K: IndexKey, V: Clone> Extend<(K, V)> for VecMap<K, V>

fn extend<T: IntoIterator<Item = (K, V)>>(&mut self, iter: T)

Extends a collection with the contents of an iterator.

fn extend_one(&mut self, item: A)

🔬This is a nightly-only experimental API. (extend_one)

Extends a collection with exactly one element.

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.

impl<K: IndexKey, V: Clone> FromIterator<(K, V)> for VecMap<K, V>

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

Creates a value from an iterator.

impl<K: IndexKey, V> Index<K> for VecMap<K, V>

type Output = V

The returned type after indexing.

fn index(&self, key: K) -> &Self::Output

Performs the indexing (container[index]) operation.

impl<K: IndexKey, V> IndexMut<K> for VecMap<K, V>

fn index_mut(&mut self, key: K) -> &mut Self::Output

Performs the mutable indexing (container[index]) operation.

impl<'a, K: IndexKey, V> IntoIterator for &'a VecMap<K, V>

type Item = (K, &'a V)

The type of the elements being iterated over.

type IntoIter = Iter<'a, K, V>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<'a, K: IndexKey, V> IntoIterator for &'a mut VecMap<K, V>

type Item = (K, &'a mut V)

The type of the elements being iterated over.

type IntoIter = IterMut<'a, K, V>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<K: IndexKey, V> IntoIterator for VecMap<K, V>

type Item = (K, V)

The type of the elements being iterated over.

type IntoIter = IntoIter<K, V>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<K, V: PartialEq> PartialEq for VecMap<K, V>

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

This method tests for self and other values to be equal, and is used by ==.

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.

impl<K, V: Eq> Eq for VecMap<K, V>