Struct HMap 

pub struct HMap<K, V>(/* private fields */);

A hash map with a fast, non-cryptographic hasher and no iteration support.

Implementations

impl<K, V> HMap<K, V>

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

Creates an empty HMap.

The hash map is initially created with a capacity of 0, so it will not allocate until it is first inserted into.

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

Creates an empty HMap with the specified capacity.

The hash map will be able to hold at least capacity elements without reallocating. If capacity is 0, the hash map will not allocate.

pub fn len(&self) -> usize

Returns the number of elements in the map.

pub fn is_empty(&self) -> bool

Returns true if the map contains no elements.

pub fn clear(&mut self)

Clears the map, removing all key-value pairs. Keeps the allocated memory for reuse.

pub fn capacity(&self) -> usize

Returns the number of elements the map can hold without reallocating.

This number is a lower bound; the HMap might be able to hold more, but is guaranteed to be able to hold at least this many.

impl<K, V> HMap<K, V>

where K: Eq + Hash,

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

Reserves capacity for at least additional more elements to be inserted in the HMap. The collection may reserve more space to avoid frequent reallocations.

pub fn shrink_to_fit(&mut self)

Shrinks the capacity of the map as much as possible. It will drop down as much as possible while maintaining the internal rules and possibly leaving some space in accordance with the resize policy.

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

Inserts a key-value pair into the map.

If the map did not have this key present, None is returned.

If the map did have this key present, the value is updated, and the old value is returned. The key is not updated, though; this matters for types that can be == without being identical.

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

where Q: Hash + Equivalent<K> + ?Sized,

Returns a reference to the value corresponding to the key.

The key may be any borrowed form of the map’s key type, but Hash and Eq on the borrowed form must match those for the key type.

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

where Q: Hash + Equivalent<K> + ?Sized,

Returns a mutable reference to the value corresponding to the key.

The key may be any borrowed form of the map’s key type, but Hash and Eq on the borrowed form must match those for the key type.

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

where Q: Hash + Equivalent<K> + ?Sized,

Returns the key-value pair corresponding to the supplied key.

The supplied key may be any borrowed form of the map’s key type, but Hash and Eq on the borrowed form must match those for the key type.

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

where Q: Hash + Equivalent<K> + ?Sized,

Returns true if the map contains a value for the specified key.

The key may be any borrowed form of the map’s key type, but Hash and Eq on the borrowed form must match those for the key type.

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

where Q: Hash + Equivalent<K> + ?Sized,

Removes a key from the map, returning the value at the key if the key was previously in the map. Keeps the allocated memory for reuse.

The key may be any borrowed form of the map’s key type, but Hash and Eq on the borrowed form must match those for the key type.

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

where Q: Hash + Equivalent<K> + ?Sized,

Removes a key from the map, returning the stored key and value if the key was previously in the map. Keeps the allocated memory for reuse.

The key may be any borrowed form of the map’s key type, but Hash and Eq on the borrowed form must match those for the key type.

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

Gets the given key’s corresponding entry in the map for in-place manipulation.

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

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

Retains only the elements specified by the predicate. Keeps the allocated memory for reuse.

In other words, remove all pairs (k, v) such that f(&k, &mut v) returns false. The elements are visited in unsorted (and unspecified) order.

Trait Implementations

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

where K: Clone, V: Clone,

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

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

Prints only the entry count: printing contents would expose the table’s platform-dependent order.

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

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

Returns the “default value” for a type.

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

where K: Eq + Hash, V: Eq,

impl<K, V> Extend<(K, V)> for HMap<K, V>

where K: Eq + Hash,

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

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

Extends a collection with the contents of an iterator.

fn extend_one(&mut self, item: T)

🔬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> FromIterator<(K, V)> for HMap<K, V>

where K: Eq + Hash,

fn from_iter<I>(iter: I) -> HMap<K, V>

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

Creates a value from an iterator.

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

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

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

Look up the value for a key, panicking if it isn’t present.

type Output = V

The returned type after indexing.

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

where K: Eq + Hash, V: PartialEq,

fn eq(&self, other: &HMap<K, V>) -> bool

Equality operator ==.

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

Inequality operator !=.