Struct TransientMap 

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

A hashmap wrapper which tracks used and unused entries, allowing for their efficient removal.

Implementations

impl<K, V> TransientMap<K, V, RandomState>

pub fn new() -> Self

Creates an empty TransientMap.

pub fn with_capacity(capacity: usize) -> Self

Creates an empty TransientMap with at least the specified capacity.

impl<K, V, S> TransientMap<K, V, S>

pub fn set_all_used(&mut self)

Marks all entries as used. They will not be included in the next drain_unused call. This function is O(1).

pub fn set_all_unused(&mut self)

Marks all entries as unused. They will be included in the next drain_unused call. This function is O(1).

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

Creates an empty TransientMap with at least the specified capacity, using hasher to hash the keys.

pub fn capacity(&self) -> usize

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

pub fn keys(&self) -> impl Iterator<Item = &K>

An iterator visiting all keys in arbitrary order. The iterator element type is &'a K.

pub fn keys_silent(&self) -> impl Iterator<Item = &K>

An iterator visiting all keys in arbitrary order. The iterator element type is &'a K. The iterator visits all keys silently, meaning that nothing is marked as used.

pub fn into_keys(self) -> impl Iterator<Item = K>

Creates a consuming iterator visiting all the keys in arbitrary order. The map cannot be used after calling this. The iterator element type is K.

pub fn values(&self) -> impl Iterator<Item = &V>

An iterator visiting all values in arbitrary order. The iterator element type is &'a V.

pub fn values_silent(&self) -> impl Iterator<Item = &V>

An iterator visiting all values in arbitrary order. The iterator element type is &'a V. The iterator visits all keys silently, meaning that nothing is marked as used.

pub fn values_mut(&mut self) -> impl Iterator<Item = &mut V>

An iterator visiting all values mutably in arbitrary order. The iterator element type is &'a mut V.

pub fn into_values(self) -> impl Iterator<Item = V>

Creates a consuming iterator visiting all the values in arbitrary order. The map cannot be used after calling this. The iterator element type is V.

pub fn iter(&self) -> impl '_ + Iterator<Item = (&K, &V)>

An iterator visiting all key-value pairs in arbitrary order. The iterator element type is (&'a K, &'a V).

pub fn iter_silent(&self) -> impl '_ + Iterator<Item = (&K, &V)>

An iterator visiting all key-value pairs in arbitrary order. The iterator element type is (&'a K, &'a V). The iterator visits all keys silently, meaning that nothing is marked as used.

pub fn iter_mut(&mut self) -> impl '_ + Iterator<Item = (&K, &mut V)>

An iterator visiting all key-value pairs in arbitrary order, with mutable references to the values. The iterator element type is (&'a K, &'a mut V).

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 drain(&mut self) -> impl '_ + Iterator<Item = (K, V)>

Clears the map, returning all key-value pairs as an iterator. Keeps the allocated memory for reuse.

If the returned iterator is dropped before being fully consumed, it drops the remaining key-value pairs. The returned iterator keeps a mutable borrow on the map to optimize its implementation.

pub fn clear(&mut self)

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

pub fn hasher(&self) -> &S

Returns a reference to the map’s BuildHasher.

impl<K, V, S> TransientMap<K, V, S>

where K: Eq + Hash, S: BuildHasher,

pub fn drain_unused(&mut self) -> impl '_ + Iterator<Item = (K, V)>

Removes all entries from the map that were not accessed since the last call to drain_used or drain_unused.

It takes O(unused elements) time to iterate over the results of this call. Like the standard hash_map::Drain, all elements remaining in the iterator when it is dropped are also dropped.

pub fn drain_used(&mut self) -> impl '_ + Iterator<Item = (K, V)>

Removes all entries from the map that were accessed since the last call to drain_used or drain_unused.

It takes O(used elements) time to iterate over the results of this call. Like the standard hash_map::Drain, all elements remaining in the iterator when it is dropped are also dropped.

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

Reserves capacity for at least additional more elements to be inserted in the TransientMap. The collection may reserve more space to speculatively avoid frequent reallocations. After calling reserve, capacity will be greater than or equal to self.len() + additional. Does nothing if capacity is already sufficient.

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

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

Retains only the elements specified by the predicate. Because the predicate visits all elements, all elements are marked as used.

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

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

Tries to reserve capacity for at least additional more elements to be inserted in the TransientMap. The collection may reserve more space to speculatively avoid frequent reallocations. After calling try_reserve, capacity will be greater than or equal to self.len() + additional if it returns Ok(()).

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 shrink_to(&mut self, min_capacity: usize)

Shrinks the capacity of the map with a lower limit. It will drop down no lower than the supplied limit while maintaining the internal rules and possibly leaving some space in accordance with the resize policy.

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 get<Q>(&self, k: &Q) -> Option<&V>

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

Returns a reference to the value corresponding to the key.

pub fn get_silent<Q>(&self, k: &Q) -> Option<&V>

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

Returns a reference to the value corresponding to the key. This accesses the value silently, meaning that nothing is marked as used.

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

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

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

pub fn get_key_value_silent<Q>(&self, k: &Q) -> Option<(&K, &V)>

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

Returns the key-value pair corresponding to the supplied key. This accesses the pair silently, meaning that nothing is marked as used.

pub fn contains_key_silent<Q>(&self, k: &Q) -> bool

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

Returns true if the map contains a value for the specified key. This accesses the value silently, meaning that nothing is marked as used.

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

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

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

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

Inserts a key-value pair into the map. The inserted key is automatically treated as used.

pub fn insert_unused(&mut self, k: K, v: V) -> Option<V>

Inserts a key-value pair into the map. The inserted key is initially considered unused.

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

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

Removes a key from the map, returning the value at the key if the key was previously in the map.

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

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

Removes a key from the map, returning the stored key and value if the key was previously in the map.

Trait Implementations

impl<K, V, S> Clone for TransientMap<K, V, S>

where K: Clone, V: Clone, S: Clone,

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<K, V, S> Debug for TransientMap<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 TransientMap<K, V, S>

where S: Default,

fn default() -> Self

Returns the “default value” for a type.

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

type Item = (&'a K, &'a V)

The type of the elements being iterated over.

type IntoIter = Box<dyn Iterator<Item = (&'a K, &'a V)> + 'a>

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 TransientMap<K, V, S>

type Item = (&'a K, &'a mut V)

The type of the elements being iterated over.

type IntoIter = Box<dyn Iterator<Item = (&'a K, &'a mut V)> + 'a>

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 TransientMap<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 TransientMap<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> Eq for TransientMap<K, V, S>

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

impl<K, V, S> Send for TransientMap<K, V, S>

where K: Send, V: Send, S: Send,