Struct weak_table::WeakWeakHashMap

pub struct WeakWeakHashMap<K, V, S = RandomState> { /* fields omitted */ }

A hash map with weak keys and weak values, hashed on key value.

When a weak pointer expires, its mapping is lazily removed.

Implementations

impl<K: WeakKey, V: WeakElement> WeakWeakHashMap<K, V, RandomState>

pub fn new() -> Self

Creates an empty WeakWeakHashMap.

O(1) time

pub fn with_capacity(capacity: usize) -> Self

Creates an empty WeakWeakHashMap with the given capacity.

O(n) time

impl<K: WeakKey, V: WeakElement, S: BuildHasher> WeakWeakHashMap<K, V, S>

pub fn with_hasher(hash_builder: S) -> Self

Creates an empty WeakWeakHashMap with the given capacity and hasher.

O(n) time

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

Creates an empty WeakWeakHashMap with the given capacity and hasher.

O(n) time

pub fn hasher(&self) -> &S

Returns a reference to the map’s BuildHasher.

O(1) time

pub fn capacity(&self) -> usize

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

O(1) time

pub fn remove_expired(&mut self)

Removes all mappings whose keys have expired.

O(n) time

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

Reserves room for additional elements.

O(n) time

pub fn shrink_to_fit(&mut self)

Shrinks the capacity to the minimum allowed to hold the current number of elements.

O(n) time

pub fn len(&self) -> usize

Returns an over-approximation of the number of elements.

O(1) time

pub fn is_empty(&self) -> bool

Is the map empty?

Note that this may return false even if all keys in the map have expired, if they haven’t been collected yet.

O(1) time

pub fn load_factor(&self) -> f32

The proportion of buckets that are used.

This is an over-approximation because of expired keys.

O(1) time

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

Gets the requested entry.

expected O(n) time; worst-case O(nq) time (where n is self.capacity() and q is the length of the probe sequences in other)

pub fn clear(&mut self)

Removes all associations from the map.

O(n) time

pub fn get<Q>(&self, key: &Q) -> Option<V::Strong> where
    Q: ?Sized + Hash + Eq,
    K::Key: Borrow<Q>, 

Returns a reference to the value corresponding to the key.

expected O(1) time; worst-case O(p) time

pub fn get_key<Q>(&self, key: &Q) -> Option<K::Strong> where
    Q: ?Sized + Hash + Eq,
    K::Key: Borrow<Q>, 

Returns the strong reference to the key, if present.

expected O(1) time; worst-case O(p) time

pub fn get_both<Q>(&self, key: &Q) -> Option<(K::Strong, V::Strong)> where
    Q: ?Sized + Hash + Eq,
    K::Key: Borrow<Q>, 

Returns strong references to both the key and the value, if present.

expected O(1) time; worst-case O(p) time

pub fn contains_key<Q>(&self, key: &Q) -> bool where
    Q: ?Sized + Hash + Eq,
    K::Key: Borrow<Q>, 

Returns true if the map contains the specified key.

expected O(1) time; worst-case O(p) time

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

Unconditionally inserts the value, returning the old value if already present.

Unlike std::collections::HashMap, this replaces the key even if occupied.

expected O(1) time; worst-case O(p) time

pub fn remove<Q>(&mut self, key: &Q) -> Option<V::Strong> where
    Q: ?Sized + Hash + Eq,
    K::Key: Borrow<Q>, 

Removes the entry with the given key, if it exists, and returns the value.

expected O(1) time; worst-case O(p) time

pub fn retain<F>(&mut self, f: F) where
    F: FnMut(K::Strong, V::Strong) -> bool, 

Removes all mappings not satisfying the given predicate.

Also removes any expired mappings.

O(n) time

pub fn is_submap_with<F, S1, V1>(
    &self,
    other: &WeakWeakHashMap<K, V1, S1>,
    value_equal: F
) -> bool where
    V1: WeakElement,
    F: FnMut(V::Strong, V1::Strong) -> bool,
    S1: BuildHasher, 

Is this map a submap of the other, using the given value comparison.

In particular, all the keys of self must be in other and the values must compare true with value_equal.

expected O(n) time; worst-case O(nq) time (where n is self.capacity() and q is the length of the probe sequences in other)

pub fn is_submap<V1, S1>(&self, other: &WeakWeakHashMap<K, V1, S1>) -> bool where
    V1: WeakElement,
    V::Strong: PartialEq<V1::Strong>,
    S1: BuildHasher, 

Is self a submap of other?

expected O(n) time; worst-case O(nq) time (where n is self.capacity() and q is the length of the probe sequences in other)

pub fn domain_is_subset<V1, S1>(
    &self,
    other: &WeakWeakHashMap<K, V1, S1>
) -> bool where
    V1: WeakElement,
    S1: BuildHasher, 

Are the keys of self a subset of the keys of other?

expected O(n) time; worst-case O(nq) time (where n is self.capacity() and q is the length of the probe sequences in other)

impl<K: WeakElement, V: WeakElement, S> WeakWeakHashMap<K, V, S>

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

Gets an iterator over the keys and values.

O(1) time

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

Gets an iterator over the keys.

O(1) time

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

Gets an iterator over the values.

O(1) time

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

Gets a draining iterator, which removes all the values but retains the storage.

O(1) time (and O(n) time to dispose of the result)

Trait Implementations

impl<K: Clone, V: Clone, S: Clone> Clone for WeakWeakHashMap<K, V, S>

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

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<K: WeakElement, V: WeakElement, S> Debug for WeakWeakHashMap<K, V, S> where
    K::Strong: Debug,
    V::Strong: Debug, 

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

Formats the value using the given formatter.

impl<K: WeakKey, V: WeakElement, S: BuildHasher + Default> Default for WeakWeakHashMap<K, V, S>

fn default() -> Self

Returns the “default value” for a type.

impl<K, V, S> Extend<(<K as WeakElement>::Strong, <V as WeakElement>::Strong)> for WeakWeakHashMap<K, V, S> where
    K: WeakKey,
    V: WeakElement,
    S: BuildHasher, 

fn extend<T: IntoIterator<Item = (K::Strong, V::Strong)>>(&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, V, S> FromIterator<(<K as WeakElement>::Strong, <V as WeakElement>::Strong)> for WeakWeakHashMap<K, V, S> where
    K: WeakKey,
    V: WeakElement,
    S: BuildHasher + Default, 

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

Creates a value from an iterator.

impl<K: WeakElement, V: WeakElement, S> IntoIterator for WeakWeakHashMap<K, V, S>

fn into_iter(self) -> Self::IntoIter

Creates an owning iterator from self.

O(1) time (and O(n) time to dispose of the result)

type Item = (K::Strong, V::Strong)

The type of the elements being iterated over.

type IntoIter = IntoIter<K, V>

Which kind of iterator are we turning this into?

impl<'a, K: WeakElement, V: WeakElement, S> IntoIterator for &'a WeakWeakHashMap<K, V, S>

fn into_iter(self) -> Self::IntoIter

Creates a borrowing iterator from self.

O(1) time

type Item = (K::Strong, V::Strong)

The type of the elements being iterated over.

type IntoIter = Iter<'a, K, V>

Which kind of iterator are we turning this into?

impl<K, V, V1, S, S1> PartialEq<WeakWeakHashMap<K, V1, S1>> for WeakWeakHashMap<K, V, S> where
    K: WeakKey,
    V: WeakElement,
    V1: WeakElement,
    V::Strong: PartialEq<V1::Strong>,
    S: BuildHasher,
    S1: BuildHasher, 

fn eq(&self, other: &WeakWeakHashMap<K, V1, S1>) -> 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 !=.

impl<K: WeakKey, V: WeakElement, S: BuildHasher> Eq for WeakWeakHashMap<K, V, S> where
    V::Strong: Eq,