Struct map_vec::map::Map

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

map_vec::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: Eq, V> Map<K, V>

pub fn new() -> Self

pub fn with_capacity(capacity: usize) -> Self

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(&mut self, f: impl 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: Clone, V: Clone> Clone for Map<K, V>

fn clone(&self) -> Map<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 Map<K, V>

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

Formats the value using the given formatter.

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

fn default() -> Self

Returns the “default value” for a type.

impl<'de, K, V> Deserialize<'de> for Map<K, V>

where K: Deserialize<'de> + Eq, V: Deserialize<'de>,

fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>

where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<'a, K: 'a + Copy + Eq, V: 'a + Copy> Extend<(&'a K, &'a V)> for Map<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<K: Eq, V> Extend<(K, V)> for Map<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: Eq, V, T: Into<Vec<(K, V)>>> From<T> for Map<K, V>

fn from(values: T) -> Self

Converts to this type from the input type.

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

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

Creates a value from an iterator.

impl<Q: Eq + ?Sized, K: Eq + Borrow<Q>, V> Index<&Q> for Map<K, V>

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) -> <Self 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) -> <Self 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) -> <Self as IntoIterator>::IntoIter

Creates an iterator from a value.

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

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

where K: Serialize + Eq, V: Serialize,

fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>

where S: Serializer,

Serialize this value into the given Serde serializer.

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

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

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