Struct vector_map::VecMap

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

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, 

Contracts

Post-condition: ret . len() == 0

pub fn with_capacity(capacity: usize) -> Self where
    K: PartialEq, 

Contracts

Post-condition: ret . len() == 0

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>>(&self, key: &Q) -> bool

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

Contracts

Post-condition: ! self . contains_key(key) -> ret . is_none()

Post-condition: self . contains_key(key) -> ret . is_some()

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

Contracts

Post-condition: ! old(self . contains_key(key)) -> ret . is_none()

Post-condition: old(self . contains_key(key)) -> ret . is_some()

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

Contracts

Post-condition: ! old(self . contains_key(& key)) -> ret . is_none()

Post-condition: old(self . contains_key(& key)) -> ret . is_some()

pub fn drain<'l>(&'l mut self) -> Drain<'l, 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>>(
    &'l self,
    key: &Q
) -> Option<(&'l K, &'l V)>

Contracts

Post-condition: ! self . contains_key(key) -> ret . is_none()

Post-condition: self . contains_key(key) -> ret . is_some()

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

Contracts

Post-condition: ! old(self . contains_key(key)) -> ret . is_none()

Post-condition: old(self . contains_key(key)) -> ret . is_some()

Post-condition: self . contains_key(key) == false

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

Contracts

Post-condition: ! old(self . contains_key(key)) -> ret . is_none()

Post-condition: old(self . contains_key(key)) -> ret . is_some()

Post-condition: self . contains_key(key) == false

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

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

pub fn iter_mut<'a>(&'a mut self) -> IterMut<'a, 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. 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<'a>(&'a self) -> Keys<'a, K, V>

pub fn values<'a>(&'a self) -> Values<'a, 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: Default, V: Default> Default for VecMap<K, V>

fn default() -> VecMap<K, V>

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>, 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>, 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<VecMap<K, V>> 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 ==.

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

This method tests for !=.