Struct VecMap

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

A std::vec::Vec based Map, motivated by the fact that, for some key types, iterating over a vector can be faster than other methods for small maps.

Most of the operations on this map implementation work in O(n), including some of the ones that are O(1) in HashMap. However, optimizers can work magic with contiguous arrays like Vec, and so for small sets (up to 256 elements for integer keys, for example), iterating through a vector actually yields better performance than the less branch- and cache-predictable hash maps.

To keep item removal fast, this container doesn’t form guaranties on item ordering, nor on the stability of the ordering.

The good news about that is that you’re free to mutate keys if your use-case requires that, though I wouldn’t recommend it: the underlying vector can be accessed through the unsafe part of the API, in hopes to discourage you from using it.

Checking equality between maps is defined as “both maps are the same set”, and performs worst for maps that are permutations of each other.

Implementations

impl<K, V> VecMap<K, V>

pub fn new() -> Self

where K: PartialEq,

pub fn with_capacity(capacity: usize) -> Self

where K: PartialEq,

pub fn len(&self) -> usize

pub fn is_empty(&self) -> bool

pub fn capacity(&self) -> usize

pub fn clear(&mut self)

pub fn contains_key<Q: PartialEq<K> + ?Sized>(&self, key: &Q) -> bool

pub fn get<'l, Q: PartialEq<K> + ?Sized>(&'l self, key: &Q) -> Option<&'l V>

pub fn get_mut<'l, Q: PartialEq<K> + ?Sized>( &'l mut self, key: &Q, ) -> Option<&'l mut V>

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

where K: PartialEq,

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

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

pub fn shrink_to_fit(&mut self)

pub fn get_key_value<'l, Q: PartialEq<K> + ?Sized>( &'l self, key: &Q, ) -> Option<(&'l K, &'l V)>

pub fn remove<Q: PartialEq<K> + ?Sized>(&mut self, key: &Q) -> Option<V>

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

where K: PartialEq,

pub fn remove_entry<Q: PartialEq<K> + ?Sized>( &mut self, key: &Q, ) -> Option<(K, V)>

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

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

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

pub fn sort(&mut self)

where K: Ord,

pub unsafe fn identical(&self, other: &Self) -> bool

where K: PartialEq, V: PartialEq,

Much faster than self == other, but will return false if the order of the data isn’t identical.

Safety

Note that for the order of data with two VecMaps to be identical, they must either have been both sorted, or they must have undergone the insertion and removal of keys in the same order.

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

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

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: Debug, V: Debug> Debug for VecMap<K, V>

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

Formats the value using the given formatter.

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

fn default() -> Self

Returns the “default value” for a type.

impl<'a, K: PartialEq + Copy + 'a, V: Copy + 'a> Extend<(&'a K, &'a V)> for VecMap<K, V>

fn extend<T: IntoIterator<Item = (&'a K, &'a 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<'a, K: PartialEq, V> 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: PartialEq, V> FromIterator<(K, V)> for VecMap<K, V>

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

Creates a value from an iterator.

impl<'a, Q: PartialEq<K> + ?Sized, K, V> Index<&'a Q> for VecMap<K, V>

type Output = V

The returned type after indexing.

fn index(&self, key: &'a Q) -> &Self::Output

Performs the indexing (container[index]) operation.

impl<'a, Q: PartialEq<K> + ?Sized, K, V> IndexMut<&'a Q> for VecMap<K, V>

fn index_mut(&mut self, key: &'a Q) -> &mut Self::Output

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

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

type Item = (&'a 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, V> IntoIterator for &'a mut VecMap<K, V>

type Item = (&'a 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, 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: PartialEq, V: PartialEq> PartialEq for VecMap<K, V>

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

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.