Struct HashMap 

pub struct HashMap<K, V, S = RandomState> { /* private fields */ }

A wrapper type around [hashbrown::hash_map::HashMap] that only exposes fallible allocation.

Implementations

impl<K, V> HashMap<K, V, RandomState>

pub fn new() -> Self

Same as [hashbrown::hash_map::HashMap::new].

impl<K, V> HashMap<K, V, RandomState>

where K: Eq + Hash,

pub fn with_capacity(capacity: usize) -> Result<Self, OutOfMemory>

Same as [hashbrown::hash_map::HashMap::with_capacity] but returns an error on allocation failure.

impl<K, V, S> HashMap<K, V, S>

pub const fn with_hasher(hasher: S) -> Self

Same as [hashbrown::hash_map::HashMap::with_hasher].

pub fn hasher(&self) -> &S

Same as [hashbrown::hash_map::HashMap::hasher].

pub fn capacity(&self) -> usize

Same as [hashbrown::hash_map::HashMap::capacity].

pub fn len(&self) -> usize

Same as [hashbrown::hash_map::HashMap::len].

pub fn is_empty(&self) -> bool

Same as [hashbrown::hash_map::HashMap::is_empty].

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

Same as [hashbrown::hash_map::HashMap::drain].

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

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

Same as [hashbrown::hash_map::HashMap::retain].

pub fn extract_if<F>(&mut self, f: F) -> ExtractIf<'_, K, V, F>

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

Same as [hashbrown::hash_map::HashMap::extract_if].

pub fn clear(&mut self)

Same as [hashbrown::hash_map::HashMap::clear].

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

Same as [hashbrown::hash_map::HashMap::iter].

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

Same as [hashbrown::hash_map::HashMap::iter_mut].

impl<K, V, S> HashMap<K, V, S>

where K: Eq + Hash, S: BuildHasher,

pub fn with_capacity_and_hasher( capacity: usize, hasher: S, ) -> Result<Self, OutOfMemory>

Same as [hashbrown::hash_map::HashMap::with_capacity_and_hasher] but returns an error on allocation failure.

pub fn reserve(&mut self, additional: usize) -> Result<(), OutOfMemory>

Same as [hashbrown::hash_map::HashMap::reserve] but returns an error on allocation failure.

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

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

Same as [hashbrown::hash_map::HashMap::contains_key].

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

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

Same as [hashbrown::hash_map::HashMap::get].

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

Same as [hashbrown::hash_map::HashMap::insert] but returns an error on allocation failure.

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

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

Same as [hashbrown::hash_map::HashMap::remove].

Trait Implementations

impl<K, V, S> Debug for HashMap<K, V, S>

where K: Debug, V: Debug,

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

Formats the value using the given formatter.

impl<K, V, S> Default for HashMap<K, V, S>

where S: Default,

fn default() -> Self

Returns the “default value” for a type.

impl<'a, K, V, S> IntoIterator for &'a HashMap<K, V, S>

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, S> IntoIterator for &'a mut HashMap<K, V, S>

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, S> IntoIterator for HashMap<K, V, S>

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, S> PartialEq for HashMap<K, V, S>

where K: Eq + Hash, V: PartialEq, S: BuildHasher,

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.

impl<K, V, S> TryClone for HashMap<K, V, S>

where K: Eq + Hash + TryClone, V: TryClone, S: BuildHasher + TryClone,

fn try_clone(&self) -> Result<Self, OutOfMemory>

Attempt to clone self, returning an error if any allocation fails during cloning.

impl<K, V, S> Eq for HashMap<K, V, S>

where K: Eq + Hash, V: Eq, S: BuildHasher,