Struct collecting_hashmap::CollectingHashMap

pub struct CollectingHashMap<K, V, S = RandomState>where
    K: Hash + Eq,
    S: BuildHasher,{ /* private fields */ }

A hashmap that stores a vec of values for each key

Implementations

impl<K, V> CollectingHashMap<K, V, RandomState>where
    K: Hash + Eq,

pub fn new() -> CollectingHashMap<K, V, RandomState>

Creates a new CollectingHashMap with the default Hasher

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

Creates a new CollectingHashMap with the given capacity

impl<K, V, S> CollectingHashMap<K, V, S>where
    K: Hash + Eq,
    S: BuildHasher,

pub fn with_hashmap(h: HashMap<K, Vec<V>, S>) -> CollectingHashMap<K, V, S>

Creates a new CollectingHashMap using the given HashMap for it’s backing storage

pub fn insert(&mut self, k: K, v: V)

Inserts a value for the given key

If the key is already present, this will append the value to the key’s Vec<V>

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

Retrieves a reference to a value for the given key

If there is at least one value for the given key, this will return &V using the first element of Ks Vec<V>

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

Retrieves a mutable reference to a value for the given key

If there is at least one value for the given key, this will return &mut V using the first element of Ks Vec<V>

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

Retrieves a reference to all values stored for the given key

If there is at least one value present for the given key, this will return a reference to the Vec<V> for the key

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

Retrieves a mutable reference to all values stored for the given key

If there is at least one value present for the given key, this will return a mutable reference to the Vec<V> for the key

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

Removes a set of values for the given key

If there is a value present for the given key, this will remove all values from the underlying HashMap but will ONLY return the first element. To return the entire Vec<V> for the key, use remove_all

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

Removes a set of values for the given key

If there is a value present for the given key, this will remove all values from the underlying HashMap, and return the Vec<V>

pub fn hasher(&self) -> &S

The same as HashMap::hasher

pub fn capacity(&self) -> usize

The same as HashMap::capacity

pub fn is_empty(&self) -> bool

The same as HashMap::is_empty

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

The same as HashMap::reserve

pub fn shrink_to_fit(&mut self)

The same as HashMap::shrink_to_fit

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

The same as HashMap::keys

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

The same as HashMap::values

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

The same as HashMap::values_mut

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

The same as HashMap::iter

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

The same as HashMap::iter_mut

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

The same as HashMap::entry

pub fn len(&self) -> usize

The same as HashMap::len

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

The same as HashMap::drain

pub fn clear(&mut self)

The same as HashMap::clear

pub fn contains_key<Q>(&self, k: &Q) -> boolwhere
    K: Borrow<Q>,
    Q: Hash + Eq + ?Sized,

The same as HashMap::contains_key

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

The same as HashMap::remove_entry

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

The same as HashMap::retain

Trait Implementations

impl<K, V, S> Default for CollectingHashMap<K, V, S>where
    K: Hash + Eq,
    S: BuildHasher + Default,

fn default() -> CollectingHashMap<K, V, S>

Returns the “default value” for a type.

impl<K, V, S> Extend<(K, V)> for CollectingHashMap<K, V, S>where
    K: Hash + Eq,
    S: BuildHasher,

fn extend<T: IntoIterator<Item = (K, 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> FromIterator<(K, V)> for CollectingHashMap<K, V, S>where
    K: Hash + Eq,
    S: BuildHasher + Default,

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

Creates a value from an iterator.