Struct PtrWeakKeyHashMap 

pub struct PtrWeakKeyHashMap<K, V, S = RandomState>(/* private fields */);

A hash map with weak keys, hashed on key pointer.

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

Examples

use weak_table::PtrWeakKeyHashMap;
use std::rc::{Rc, Weak};

type Table = PtrWeakKeyHashMap<Weak<str>, usize>;

let mut map = Table::new();
let a = Rc::<str>::from("hello");
let b = Rc::<str>::from("hello");

map.insert(a.clone(), 5);

assert_eq!( map.get(&a), Some(&5) );
assert_eq!( map.get(&b), None );

map.insert(b.clone(), 7);

assert_eq!( map.get(&a), Some(&5) );
assert_eq!( map.get(&b), Some(&7) );

Implementations

impl<K, V> PtrWeakKeyHashMap<K, V, RandomState>

pub fn new() -> Self

Creates an empty `PtrWeakKeyHashMap.

O(1) time

pub fn with_capacity(capacity: usize) -> Self

Creates an empty `PtrWeakKeyHashMap with the given capacity.

O(n) time

impl<K, V, S: BuildHasher> PtrWeakKeyHashMap<K, V, S>

pub fn with_hasher(hash_builder: S) -> Self

Creates an empty `PtrWeakKeyHashMap with the given hasher.

O(n) time

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

Creates an empty `PtrWeakKeyHashMap with the given capacity and hasher.

O(n) time

impl<K, V, S> PtrWeakKeyHashMap<K, V, S>

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 len(&self) -> usize

Returns an over-approximation of the number of elements.

(This is an over-approximation because it includes expired elements.)

O(1) time

pub fn is_empty(&self) -> bool

Is the map empty?

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

O(1) time

pub fn load_factor(&self) -> f32

Returns proportion of buckets that are used.

This is an over-approximation because of expired elements.

O(1) time

pub fn clear(&mut self)

Remove all elements from the map.

O(n) time

impl<K: WeakElement, V, S: BuildHasher> PtrWeakKeyHashMap<K, V, S>

where K::Strong: Deref,

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.

This method ensures that at least additional_capacity insertions may be performed without reallocating.

O(n) time

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

Tries to reserve room for additional mappings.

If this method succeeds, then at least additional_capacity insertions may be performed without reallocating further.

O(n) time

pub fn shrink_to_fit(&mut self)

Shrinks the capacity to the minimum to hold the current number of mappings.

O(n) time

pub fn shrink_to(&mut self, min_capacity: usize)

Shrinks the capacity to hold no fewer than min_capacity mappings.

May remove expired items if necessary. Does nothing if the current capacity is already at min_capacity or below.

O(n) time

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

The proportion of buckets that Gets the requested entry.

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

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

Returns a reference to the value corresponding to the key.

Returns None if no matching key is found.

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

pub fn contains_key(&self, key: &K::Strong) -> bool

Returns true if the map contains the specified key.

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

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

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

Returns None if no matching key is found.

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

pub fn get_disjoint_mut<const N: usize>( &mut self, ks: [&K::Strong; N], ) -> [Option<&mut V>; N]

Looks up mutable references to the values corresponding to several keys at a time.

(Because of borrowing rules, Rust doesn’t allow you to call get_mut() again while the result of a previous get_mut() is still live. This method exists to work around that limitation.)

Only one mutable reference can exist to any given value at a time. Therefore, all keys must refer to different values, or this method will panic.

expected O(1 N^2) time; worst-case O(p N^2) time, where N is the length of the array.

Panics

Panics if any keys refer to the same value.

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

Unconditionally inserts the value, returning the old value if already present. Does not replace the key.

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

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

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, &mut V) -> bool,

Removes all mappings not satisfying the given predicate.

Also removes any expired mappings.

O(n) time

pub fn submap_with<F, S1, V1>( &self, other: &PtrWeakKeyHashMap<K, V1, S1>, value_equal: F, ) -> bool

where F: FnMut(&V, &V1) -> 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: &PtrWeakKeyHashMap<K, V1, S1>) -> bool

where V: PartialEq<V1>, 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: &PtrWeakKeyHashMap<K, V1, S1>, ) -> bool

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

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

Gets an iterator over the keys and values.

O(1) time

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

Gets an iterator over the keys.

O(1) time

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

Gets an iterator over the values.

O(1) time

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

Gets an iterator over the keys and mutable values.

O(1) time

pub fn values_mut(&mut self) -> ValuesMut<'_, ByPtr<K>, V>

Gets an iterator over the mutable values.

O(1) time

pub fn drain(&mut self) -> Drain<'_, ByPtr<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)

pub fn into_keys(self) -> IntoKeys<ByPtr<K>, V>

Returns an iterator that owns and consumes this map, returning the keys in the map.

O(1)

pub fn into_values(self) -> IntoValues<ByPtr<K>, V>

Returns an iterator that owns and consumes this map, returning the keys in the map.

O(1)

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

where F: FnMut(K::Strong, &mut V) -> bool + 'a,

Gets an iterator that removes and returns elements matching a given predicate.

Expired elements are also removed.

If this iterator is dropped before it is completed, then no further elements are removed. (This is in contrast to the behavior of drain).

O(1) time

Trait Implementations

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

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

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<K, V: Debug, S> Debug for PtrWeakKeyHashMap<K, V, S>

where K: WeakElement, K::Strong: Debug,

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

Formats the value using the given formatter.

impl<K, V, S: BuildHasher + Default> Default for PtrWeakKeyHashMap<K, V, S>

fn default() -> Self

Returns the “default value” for a type.

impl<K: WeakElement, V: Eq, S: BuildHasher> Eq for PtrWeakKeyHashMap<K, V, S>

where K::Strong: Deref,

impl<'a, K, V, S> Extend<(&'a <K as WeakElement>::Strong, &'a V)> for PtrWeakKeyHashMap<K, V, S>

where K: 'a + WeakElement, K::Strong: Clone + Deref, V: 'a + Clone, S: BuildHasher,

fn extend<T: IntoIterator<Item = (&'a K::Strong, &'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, V, S> Extend<(<K as WeakElement>::Strong, V)> for PtrWeakKeyHashMap<K, V, S>

where K: WeakElement, K::Strong: Deref, S: BuildHasher,

fn extend<T: IntoIterator<Item = (K::Strong, 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, V, const N: usize> From<[(<K as WeakElement>::Strong, V); N]> for PtrWeakKeyHashMap<K, V, RandomState>

where K: WeakElement, K::Strong: Deref,

fn from(value: [(K::Strong, V); N]) -> Self

Converts an array of key-value pairs into a map.

If any entries in the array have equal keys, all but one of the corresponding values will be dropped.

impl<K, V, S> FromIterator<(<K as WeakElement>::Strong, V)> for PtrWeakKeyHashMap<K, V, S>

where K: WeakElement, K::Strong: Deref, S: BuildHasher + Default,

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

Creates a value from an iterator.

impl<'a, K, V, S> Index<&'a <K as WeakElement>::Strong> for PtrWeakKeyHashMap<K, V, S>

where K: WeakElement, K::Strong: Deref, S: BuildHasher,

type Output = V

The returned type after indexing.

fn index(&self, index: &'a K::Strong) -> &Self::Output

Performs the indexing (container[index]) operation.

impl<'a, K, V, S> IndexMut<&'a <K as WeakElement>::Strong> for PtrWeakKeyHashMap<K, V, S>

where K: WeakElement, K::Strong: Deref, S: BuildHasher,

fn index_mut(&mut self, index: &'a K::Strong) -> &mut Self::Output

Performs the mutable indexing (container[index]) operation.

impl<K: WeakElement, V, S> IntoIterator for PtrWeakKeyHashMap<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 as WeakElement>::Strong, V)

The type of the elements being iterated over.

type IntoIter = IntoIter<ByPtr<K>, V>

Which kind of iterator are we turning this into?

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

fn into_iter(self) -> Self::IntoIter

Creates a borrowing iterator from self.

O(1) time

type Item = (<K as WeakElement>::Strong, &'a V)

The type of the elements being iterated over.

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

Which kind of iterator are we turning this into?

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

fn into_iter(self) -> Self::IntoIter

Creates a borrowing iterator from self.

O(1) time

type Item = (<K as WeakElement>::Strong, &'a mut V)

The type of the elements being iterated over.

type IntoIter = IterMut<'a, ByPtr<K>, V>

Which kind of iterator are we turning this into?

impl<K, V, V1, S, S1> PartialEq<PtrWeakKeyHashMap<K, V1, S1>> for PtrWeakKeyHashMap<K, V, S>

where K: WeakElement, K::Strong: Deref, V: PartialEq<V1>, S: BuildHasher, S1: BuildHasher,

fn eq(&self, other: &PtrWeakKeyHashMap<K, V1, S1>) -> bool

Equality operator ==.

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

Inequality operator !=.