Struct Amalgamator 

pub struct Amalgamator<T: Amalgamate, S = RandomState>(/* private fields */);

A set/map like data structure that allows you to combine members of the set/map together based on some criteria.

Implementations

impl<T> Amalgamator<T>

where T: Amalgamate,

pub fn new() -> Self

Creates a new Amalgamator with an empty set/map.

pub fn with_capacity(capacity: usize) -> Self

Creates a new Amalgamator with the given capacity.

pub fn capacity(&self) -> usize

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

pub fn add(&mut self, item: T)

Adds an element to the Amalgamator.

If an element with the same key already exists in the Amalgamator, the two elements will be combined. This will be done by calling Amalgamate::amalgamate on the existing element with the new element as an argument.

pub fn get_by_key<Q>(&self, key: &Q) -> Option<&T>

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

Returns a reference to the element with the given key.

pub fn get_by_key_mut<Q>(&mut self, key: &Q) -> Option<&mut T>

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

Returns a mutable reference to the element with the given key.

pub fn remove_by_key<Q>(&mut self, key: &Q) -> Option<T>

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

Removes the element with the given key from the Amalgamator and returns it.

pub fn get_key_value<Q>(&self, key: &Q) -> Option<(&T::Key, &T)>

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

Returns the key-value pair corresponding to the supplied key.

pub fn remove(&mut self, item: &T) -> Option<T>

Removes the element from the Amalgamator and returns it.

pub fn len(&self) -> usize

Returns the number of elements in the Amalgamator.

pub fn is_empty(&self) -> bool

Returns true if the Amalgamator is empty.

pub fn clear(&mut self)

Removes all elements from the Amalgamator.

pub fn contains(&self, item: &T) -> bool

Returns true if the Amalgamator contains the given element.

Keep in mind that this is checking for something that has the same key, not the same value.

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

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

Returns true if the Amalgamator contains an element with the given key.

Keep in mind that this is checking for something that has the same key, not the same value.

pub fn keys(&self) -> impl Iterator<Item = &T::Key>

Returns an iterator over the keys of the Amalgamator.

pub fn values(&self) -> impl Iterator<Item = &T>

Returns an iterator over the values of the Amalgamator.

pub fn values_mut(&mut self) -> impl Iterator<Item = &mut T>

Returns an iterator over the mutable values of the Amalgamator.

pub fn into_values(self) -> impl Iterator<Item = T>

Returns an iterator over the values of the Amalgamator.

pub fn into_keys(self) -> impl Iterator<Item = T::Key>

Returns an iterator over the keys of the Amalgamator.

pub fn iter(&self) -> impl Iterator<Item = (&T::Key, &T)>

Returns an iterator over the elements of the Amalgamator.

pub fn iter_mut(&mut self) -> impl Iterator<Item = (&T::Key, &mut T)>

Returns an iterator over the mutable elements of the Amalgamator.

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

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

Retains only the elements that satisfy the predicate.

pub fn drain(&mut self) -> impl Iterator<Item = T> + '_

Removes all elements from the Amalgamator and returns them in an iterator.

impl<T, S> Amalgamator<T, S>

where T: Amalgamate, S: BuildHasher,

pub fn with_hasher(hash_builder: S) -> Self

Creates a new Amalgamator with the given hasher.

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

Creates a new Amalgamator with the given hasher and capacity.

pub fn hasher(&self) -> &S

Returns a reference to the hasher used by the Amalgamator.

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

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

pub fn shrink_to_fit(&mut self)

Shrinks the capacity of the Amalgamator as much as possible.

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

Shrinks the capacity of the Amalgamator to a minimum.

Trait Implementations

impl<T: Clone + Amalgamate, S: Clone> Clone for Amalgamator<T, S>

where T::Key: Clone,

fn clone(&self) -> Amalgamator<T, S>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T: Debug + Amalgamate, S: Debug> Debug for Amalgamator<T, S>

where T::Key: Debug,

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

Formats the value using the given formatter.

impl<T> Default for Amalgamator<T>

where T: Amalgamate,

fn default() -> Self

Returns the “default value” for a type.

impl<T> Extend<T> for Amalgamator<T>

where T: Amalgamate,

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

where I: IntoIterator<Item = 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<V, const N: usize> From<[V; N]> for Amalgamator<V>

where V: Amalgamate,

fn from(array: [V; N]) -> Self

Converts to this type from the input type.

impl<T> FromIterator<T> for Amalgamator<T>

where T: Amalgamate,

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

where I: IntoIterator<Item = T>,

Creates a value from an iterator.

impl<Q, T> Index<&Q> for Amalgamator<T>

where T: Amalgamate, T::Key: Borrow<Q>, Q: Hash + Eq + ?Sized,

type Output = T

The returned type after indexing.

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

Performs the indexing (container[index]) operation.

impl<Q, T> IndexMut<&Q> for Amalgamator<T>

where T: Amalgamate, T::Key: Borrow<Q>, Q: Hash + Eq + ?Sized,

fn index_mut(&mut self, key: &Q) -> &mut Self::Output

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

impl<'a, T> IntoIterator for &'a Amalgamator<T>

where T: Amalgamate,

type Item = (&'a <T as Amalgamate>::Key, &'a T)

The type of the elements being iterated over.

type IntoIter = Iter<'a, <T as Amalgamate>::Key, T>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<'a, T> IntoIterator for &'a mut Amalgamator<T>

where T: Amalgamate,

type Item = (&'a <T as Amalgamate>::Key, &'a mut T)

The type of the elements being iterated over.

type IntoIter = IterMut<'a, <T as Amalgamate>::Key, T>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<T> IntoIterator for Amalgamator<T>

where T: Amalgamate,

type Item = (<T as Amalgamate>::Key, T)

The type of the elements being iterated over.

type IntoIter = IntoIter<<T as Amalgamate>::Key, T>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<T> PartialEq for Amalgamator<T>

where T: Amalgamate + PartialEq,

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

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<T> Eq for Amalgamator<T>

where T: Amalgamate + Eq,