Struct DoubleMap 

pub struct DoubleMap<K1, K2, V> { /* private fields */ }

A map-like container supporting O(1) lookup by two key types.

Implementations

impl<K1, K2, V> DoubleMap<K1, K2, V>

pub fn new() -> Self

Constructs a new, empty DoubleMap.

pub fn with_capacity(capacity: usize) -> Self

Constructs a new, empty DoubleMap with at least the specified capacity for both internal maps.

pub fn capacity(&self) -> usize

Returns the minimum of the two internal capacities.

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

Returns an iterator over the keys, yielding a (&K1, &K2) tuple for each entry.

pub fn into_keys(self) -> IntoKeys<K1, K2, V>

Creates a consuming iterator yielding owned (K1, K2) key tuples in arbitrary order. The map cannot be used after calling this.

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

Returns an iterator over the values.

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

Returns an iterator yielding mutable references to each value.

pub fn into_values(self) -> IntoValues<K1, K2, V>

Creates a consuming iterator yielding owned values in arbitrary order. The map cannot be used after calling this.

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

Returns an iterator yielding every entry as (&K1, &K2, &V).

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

Returns an iterator yielding every entry as (&K1, &K2, &mut V).

Neither key is mutably accessible — mutating them would desync the two internal maps.

pub fn len(&self) -> usize

Returns the number of entries in the map.

pub fn is_empty(&self) -> bool

Returns true if the map contains no entries.

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

Clears the map, returning all entries as an iterator.

pub fn clear(&mut self)

Removes all entries.

impl<K1, K2, V> DoubleMap<K1, K2, V>

where K1: Eq + Hash, K2: Eq + Hash,

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

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

Retains only the entries for which the predicate returns true.

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

Reserves capacity for at least additional more entries in both internal maps.

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

Tries to reserve capacity for at least additional more entries in both internal maps. Returns an error on allocation failure.

pub fn shrink_to_fit(&mut self)

Shrinks the internal maps to fit the current number of entries.

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

Shrinks the internal maps toward the given lower bound.

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

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

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

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

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

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

pub fn get_by_keys<Q1, Q2>(&self, key1: &Q1, key2: &Q2) -> Option<&V>

where K1: Borrow<Q1>, K2: Borrow<Q2>, Q1: Eq + Hash + ?Sized, Q2: Eq + Hash + ?Sized,

Returns a reference to the value for the entry whose K1 key equals key1 and whose K2 key equals key2. Returns None if either key is missing, or if they refer to different entries.

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

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

Returns the stored K1 key and value for the entry identified by the given K1 key.

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

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

Returns the stored K2 key and value for the entry identified by the given K2 key.

pub fn get_keys_value<Q1, Q2>( &self, key1: &Q1, key2: &Q2, ) -> Option<(&K1, &K2, &V)>

where K1: Borrow<Q1>, K2: Borrow<Q2>, Q1: Eq + Hash + ?Sized, Q2: Eq + Hash + ?Sized,

Returns the stored (K1, K2, V) triple for the entry whose K1 key equals key1 and whose K2 key equals key2. Returns None if either key is missing, or if they refer to different entries.

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

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

Returns true if the map contains a value for the given K1 key.

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

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

Returns true if the map contains a value for the given K2 key.

pub fn contains_keys<Q1, Q2>(&self, key1: &Q1, key2: &Q2) -> bool

where K1: Borrow<Q1>, K2: Borrow<Q2>, Q1: Eq + Hash + ?Sized, Q2: Eq + Hash + ?Sized,

Returns true if the map contains an entry whose K1 key equals key1 and whose K2 key equals key2 (i.e. both keys refer to the same entry).

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

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

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

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

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

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

pub fn get_mut_by_keys<Q1, Q2>( &mut self, key1: &Q1, key2: &Q2, ) -> Option<&mut V>

where K1: Borrow<Q1>, K2: Borrow<Q2>, Q1: Eq + Hash + ?Sized, Q2: Eq + Hash + ?Sized,

Returns a mutable reference to the value for the entry whose K1 key equals key1 and whose K2 key equals key2. Returns None if either key is missing, or if they refer to different entries.

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

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

Removes an entry by its K1 key, returning the value if it was present.

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

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

Removes an entry by its K2 key, returning the value if it was present.

pub fn remove_by_keys<Q1, Q2>(&mut self, key1: &Q1, key2: &Q2) -> Option<V>

where K1: Borrow<Q1>, K2: Borrow<Q2>, Q1: Eq + Hash + ?Sized, Q2: Eq + Hash + ?Sized,

Removes an entry only if its K1 key equals key1 and its K2 key equals key2. Returns the value on success, or None if either key is missing or they refer to different entries. On mismatch, the map is unchanged.

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

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

Removes an entry by its K1 key, returning the full (K1, K2, V) triple if it was present.

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

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

Removes an entry by its K2 key, returning the full (K1, K2, V) triple if it was present.

pub fn remove_entry_by_keys<Q1, Q2>( &mut self, key1: &Q1, key2: &Q2, ) -> Option<(K1, K2, V)>

where K1: Borrow<Q1>, K2: Borrow<Q2>, Q1: Eq + Hash + ?Sized, Q2: Eq + Hash + ?Sized,

Removes an entry only if its K1 key equals key1 and its K2 key equals key2. Returns the full (K1, K2, V) triple on success, or None if either key is missing or they refer to different entries. On mismatch, the map is unchanged.

impl<K1, K2, V> DoubleMap<K1, K2, V>

where K1: Eq + Hash + Clone, K2: Eq + Hash + Clone,

pub fn entry( &mut self, key1: K1, key2: K2, ) -> Result<Entry<'_, K1, K2, V>, KeyConflictError<K1, K2>>

Gets the given (key1, key2) pair’s Entry in the map for in-place manipulation.

• Returns Ok(Entry::Occupied) if both keys refer to the same existing entry.
• Returns Ok(Entry::Vacant) if neither key is present.
• Returns Err(KeyConflictError) if the two keys clash with existing entries. In the error case the map is unchanged and the rejected (K1, K2) pair is returned.

pub fn insert( &mut self, key1: K1, key2: K2, value: V, ) -> Result<Option<V>, KeyConflictError<K1, K2, V>>

Inserts a new entry, or updates the value if both keys are already present and refer to the same entry.

• Returns Ok(None) when neither key was present and a fresh entry was inserted.
• Returns Ok(Some(old_value)) when both keys matched the same existing entry and its value was replaced.
• Returns Err(KeyConflictError) if the two keys clash with existing entries. In all error cases the map is unchanged and the rejected triple is returned.

Trait Implementations

impl<K1, K2, V> Clone for DoubleMap<K1, K2, V>

where K1: Clone, K2: Clone, V: Clone,

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<K1, K2, V> Debug for DoubleMap<K1, K2, V>

where K1: Debug, K2: Debug, V: Debug,

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

Formats the value using the given formatter.

impl<K1, K2, V> Default for DoubleMap<K1, K2, V>

fn default() -> Self

Returns the “default value” for a type.

impl<K1, K2, V> Eq for DoubleMap<K1, K2, V>

where K1: Eq + Hash, K2: Eq + Hash, V: Eq,

impl<'a, K1, K2, V> Extend<(&'a K1, &'a K2, &'a V)> for DoubleMap<K1, K2, V>

where K1: Eq + Hash + Copy, K2: Eq + Hash + Copy, V: Copy,

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

where I: IntoIterator<Item = (&'a K1, &'a K2, &'a V)>,

Extends the map with borrowed (&K1, &K2, &V) triples, copying each element into place.

Conflicting triples are silently skipped, same as the owned-triple Extend impl.

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<K1, K2, V> Extend<(K1, K2, V)> for DoubleMap<K1, K2, V>

where K1: Eq + Hash + Clone, K2: Eq + Hash + Clone,

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

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

Extends the map with (K1, K2, V) triples from any iterator.

Triples whose keys conflict with an existing entry (same K1 mapped to a different K2, or same K2 mapped to a different K1) are silently skipped and the map is left unchanged for that triple. A consistent repeat (same K1 and same K2) updates the value.

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<K1, K2, V, const N: usize> From<[(K1, K2, V); N]> for DoubleMap<K1, K2, V>

where K1: Eq + Hash + Clone, K2: Eq + Hash + Clone,

fn from(arr: [(K1, K2, V); N]) -> Self

Builds a DoubleMap from an array of (K1, K2, V) triples.

Conflicting triples are silently skipped, same as FromIterator.

impl<K1, K2, V> FromIterator<(K1, K2, V)> for DoubleMap<K1, K2, V>

where K1: Eq + Hash + Clone, K2: Eq + Hash + Clone,

fn from_iter<I>(iter: I) -> Self

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

Collects (K1, K2, V) triples into a fresh DoubleMap.

Conflicting triples are silently skipped, same as Extend.

impl<K1, K2, V, Q> Index<&Q> for DoubleMap<K1, K2, V>

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

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

Returns a reference to the value corresponding to the supplied key1.

Panics

Panics if the key is not present in the map.

type Output = V

The returned type after indexing.

impl<K1, K2, V> IntoIterator for DoubleMap<K1, K2, V>

fn into_iter(self) -> Self::IntoIter

Consumes the map, yielding owned (K1, K2, V) triples.

type Item = (K1, K2, V)

The type of the elements being iterated over.

type IntoIter = IntoIter<K1, K2, V>

Which kind of iterator are we turning this into?

impl<'a, K1, K2, V> IntoIterator for &'a DoubleMap<K1, K2, V>

fn into_iter(self) -> Self::IntoIter

Borrows the map, yielding (&K1, &K2, &V) triples.

type Item = (&'a K1, &'a K2, &'a V)

The type of the elements being iterated over.

type IntoIter = Iter<'a, K1, K2, V>

Which kind of iterator are we turning this into?

impl<'a, K1, K2, V> IntoIterator for &'a mut DoubleMap<K1, K2, V>

fn into_iter(self) -> Self::IntoIter

Mutably borrows the map, yielding (&K1, &K2, &mut V) triples. Keys are exposed immutably to preserve the invariant that both internal maps stay in sync.

type Item = (&'a K1, &'a K2, &'a mut V)

The type of the elements being iterated over.

type IntoIter = IterMut<'a, K1, K2, V>

Which kind of iterator are we turning this into?

impl<K1, K2, V> PartialEq for DoubleMap<K1, K2, V>

where K1: Eq + Hash, K2: Eq + Hash, V: PartialEq,

fn eq(&self, other: &Self) -> bool

Equality operator ==.

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

Inequality operator !=.