Struct FlatMultimap

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

Multimap implementation where entries are stored as a flattened hash map.

Examples

use flat_multimap::FlatMultimap;

let mut map = FlatMultimap::new();
map.insert(1, 1);
map.insert(1, 2);
map.insert(2, 3);

assert_eq!(map.len(), 3);

Implementations

impl<K, V> FlatMultimap<K, V, RandomState>

pub fn new() -> Self

Creates an empty FlatMultimap with a capacity of 0, so it will not allocate until it is first inserted into.

Examples

use flat_multimap::FlatMultimap;

let mut map: FlatMultimap<&str, i32> = FlatMultimap::new();

assert_eq!(map.capacity(), 0);

pub fn with_capacity(capacity: usize) -> Self

Creates an empty FlatMultimap with at least the specified capacity.

impl<K, V, S> FlatMultimap<K, V, S>

pub const fn with_hasher(hash_builder: S) -> Self

Creates an empty FlatMultimap with default capacity which will use the given hash builder to hash keys.

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

Creates an empty FlatMultimap with at least the specified capacity, using the given hash builder to hash keys.

pub fn capacity(&self) -> usize

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

pub const fn hasher(&self) -> &S

Returns a reference to the map’s BuildHasher.

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) -> Drain<'_, K, V>

Clears the map, returning all key-value pairs as an iterator.

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

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

Retains only the elements specified by the predicate.

pub fn clear(&mut self)

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

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

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

pub fn iter_mut(&mut self) -> IterMut<'_, K, 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 keys(&self) -> Keys<'_, K, V>

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

Examples

use flat_multimap::FlatMultimap;

let mut map = FlatMultimap::new();
map.insert(1, 1);
map.insert(1, 2);
map.insert(2, 3);

let mut keys: Vec<_> = map.keys().collect();
keys.sort_unstable(); // Sort since the keys are visited in arbitrary order.

assert_eq!(keys, [&1, &1, &2]);

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

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) -> Values<'_, K, V>

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

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

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

pub fn into_values(self) -> IntoValues<K, 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.

impl<K, V, S> FlatMultimap<K, V, S>

where K: Eq + Hash, S: BuildHasher,

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

Reserves capacity for at least additional more elements to be inserted in the FlatMultimap.

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 FlatMultimap.

pub fn shrink_to_fit(&mut self)

Shrinks the capacity of the map as much as possible.

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

Shrinks the capacity of the map with a lower limit.

pub fn insert(&mut self, key: K, value: V)

Inserts a key-value pair into the map.

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

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

Removes an arbitrary value with the given key from the map, returning the removed value if there was a value at the key.

Examples

use flat_multimap::FlatMultimap;

let mut map = FlatMultimap::new();
map.insert(1, 1);
map.insert(1, 2);

assert!(map.remove(&1).is_some()); // Could be either Some(1) or Some(2).
assert!(map.remove(&1).is_some()); // Could be either Some(1) or Some(2), depending on the previous remove.
assert!(map.remove(&1).is_none());

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

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

Returns true if the map contains at least a single value for the specified key.

impl<K: Sync, V: Sync, S> FlatMultimap<K, V, S>

pub fn par_keys(&self) -> ParKeys<'_, K, V>

Visits (potentially in parallel) immutably borrowed keys in an arbitrary order.

pub fn par_values(&self) -> ParValues<'_, K, V>

Visits (potentially in parallel) immutably borrowed values in an arbitrary order.

impl<K: Send, V: Send, S> FlatMultimap<K, V, S>

pub fn par_values_mut(&mut self) -> ParValuesMut<'_, K, V>

Visits (potentially in parallel) mutably borrowed values in an arbitrary order.

pub fn par_drain(&mut self) -> ParDrain<'_, K, V>

Consumes (potentially in parallel) all values in an arbitrary order.

Trait Implementations

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

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

Returns a duplicate of the value.

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

Performs copy-assignment from source.

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

where S: Default,

fn default() -> Self

Returns the “default value” for a type.

impl<'de, K, V, S> Deserialize<'de> for FlatMultimap<K, V, S>

where K: Deserialize<'de> + Eq + Hash, V: Deserialize<'de>, S: BuildHasher + Default,

fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>

where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<'a, K, V, S> Extend<&'a (K, V)> for FlatMultimap<K, V, S>

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

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

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

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

where K: Eq + Hash, 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, const N: usize> From<[(K, V); N]> for FlatMultimap<K, V, RandomState>

where K: Eq + Hash,

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

Converts to this type from the input type.

impl<K, V, S> FromIterator<(K, V)> for FlatMultimap<K, V, S>

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

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

Creates a value from an iterator.

impl<K, V, S> FromParallelIterator<(K, V)> for FlatMultimap<K, V, S>

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

fn from_par_iter<P>(par_iter: P) -> Self

where P: IntoParallelIterator<Item = (K, V)>,

Creates an instance of the collection from the parallel iterator par_iter.

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

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

The type of the elements being iterated over.

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

Which kind of iterator are we turning this into?

fn into_iter(self) -> Iter<'a, K, V>

Creates an iterator from a value.

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

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

The type of the elements being iterated over.

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

Which kind of iterator are we turning this into?

fn into_iter(self) -> IterMut<'a, K, V>

Creates an iterator from a value.

impl<K, V, S> IntoIterator for FlatMultimap<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) -> IntoIter<K, V>

Creates an iterator from a value.

impl<'a, K: Sync, V: Sync, S> IntoParallelIterator for &'a FlatMultimap<K, V, S>

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

The type of item that the parallel iterator will produce.

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

The parallel iterator type that will be created.

fn into_par_iter(self) -> Self::Iter

Converts self into a parallel iterator.

impl<'a, K: Sync, V: Send, S> IntoParallelIterator for &'a mut FlatMultimap<K, V, S>

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

The type of item that the parallel iterator will produce.

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

The parallel iterator type that will be created.

fn into_par_iter(self) -> Self::Iter

Converts self into a parallel iterator.

impl<K: Send, V: Send, S> IntoParallelIterator for FlatMultimap<K, V, S>

type Item = (K, V)

The type of item that the parallel iterator will produce.

type Iter = IntoParIter<K, V>

The parallel iterator type that will be created.

fn into_par_iter(self) -> Self::Iter

Converts self into a parallel iterator.

impl<'a, K, V, S> ParallelExtend<(&'a K, &'a V)> for FlatMultimap<K, V, S>

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

fn par_extend<I>(&mut self, par_iter: I)

where I: IntoParallelIterator<Item = (&'a K, &'a V)>,

Extends an instance of the collection with the elements drawn from the parallel iterator par_iter.

impl<K, V, S> ParallelExtend<(K, V)> for FlatMultimap<K, V, S>

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

fn par_extend<I>(&mut self, par_iter: I)

where I: IntoParallelIterator<Item = (K, V)>,

Extends an instance of the collection with the elements drawn from the parallel iterator par_iter.

impl<K, V, H> Serialize for FlatMultimap<K, V, H>

where K: Serialize, V: Serialize,

fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>

where S: Serializer,

Serialize this value into the given Serde serializer.