Struct Map 

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

Map is a data structure with a HashMap-like API but based on a Vec.

It’s primarily useful when you care about constant factors or prefer determinism to speed. Please refer to the docs for HashMap for details and examples of the Map API.

Example

let mut map = map_vec::Map::new();
map.insert("hello".to_string(), "world".to_string());
map.entry("hello".to_string()).and_modify(|mut v| v.push_str("!"));
assert_eq!(map.get("hello").map(String::as_str), Some("world!"))

Implementations

impl<K, V> Map<K, V>

where K: Eq,

pub fn new() -> Map<K, V>

pub fn with_capacity(capacity: usize) -> Map<K, V>

pub fn capacity(&self) -> usize

pub fn clear(&mut self)

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

where K: Borrow<Q>, Q: Eq + ?Sized,

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

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

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

where K: Borrow<Q>, Q: Eq + ?Sized,

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

where K: Borrow<Q>, Q: Eq + ?Sized,

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

where K: Borrow<Q>, Q: Eq + ?Sized,

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

pub fn is_empty(&self) -> bool

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

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

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

pub fn len(&self) -> usize

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

where K: Borrow<Q>, Q: Eq + ?Sized,

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

where K: Borrow<Q>, Q: Eq + ?Sized,

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

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

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

pub fn shrink_to_fit(&mut self)

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

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

pub fn shrink_to(&mut self, min_capacity: usize)

pub fn try_reserve(&mut self, additional: usize) -> Result<(), TryReserveError>

Trait Implementations

impl<K, V> Clone for Map<K, V>

where K: Clone, V: Clone,

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

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<K, V> Debug for Map<K, V>

where K: Debug, V: Debug,

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

Formats the value using the given formatter.

impl<K, V> Default for Map<K, V>

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

Returns the “default value” for a type.

impl<'a, K, V> Extend<(&'a K, &'a V)> for Map<K, V>

where K: 'a + Copy + Eq, V: 'a + Copy,

fn extend<T>(&mut self, iter: T)

where T: IntoIterator<Item = (&'a K, &'a V)>,

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, V> Extend<(K, V)> for Map<K, V>

where K: Eq,

fn extend<T>(&mut self, iter: T)

where T: IntoIterator<Item = (K, V)>,

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, V, T> From<T> for Map<K, V>

where K: Eq, T: Into<Vec<(K, V)>>,

fn from(values: T) -> Map<K, V>

Converts to this type from the input type.

impl<K, V> FromIterator<(K, V)> for Map<K, V>

where K: Eq,

fn from_iter<T>(iter: T) -> Map<K, V>

where T: IntoIterator<Item = (K, V)>,

Creates a value from an iterator.

impl<Q, K, V> Index<&Q> for Map<K, V>

where Q: Eq + ?Sized, K: Eq + Borrow<Q>,

type Output = V

The returned type after indexing.

fn index(&self, key: &Q) -> &V

Performs the indexing (container[index]) operation.

impl<'a, K, V> IntoIterator for &'a Map<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) -> <&'a Map<K, V> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<'a, K, V> IntoIterator for &'a mut Map<K, V>

type Item = (&'a mut 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) -> <&'a mut Map<K, V> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<K, V> IntoIterator for Map<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) -> <Map<K, V> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<K, V> PartialEq for Map<K, V>

where K: PartialEq, V: PartialEq,

fn eq(&self, other: &Map<K, V>) -> 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.

impl<K, V> Eq for Map<K, V>

where K: Eq, V: Eq,

impl<K, V> StructuralPartialEq for Map<K, V>