Struct FlatMultiset

pub struct FlatMultiset<T, S = RandomState> { /* private fields */ }

Multiset implementation where items are stored as a flattened hash set.

Examples

use flat_multimap::FlatMultiset;

let mut set = FlatMultiset::new();
set.insert(1);
set.insert(1);
set.insert(2);

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

Implementations

impl<T> FlatMultiset<T, RandomState>

pub fn new() -> Self

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

Examples

use flat_multimap::FlatMultiset;

let mut set: FlatMultiset<i32> = FlatMultiset::new();

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

pub fn with_capacity(capacity: usize) -> Self

Creates an empty FlatMultiset with at least the specified capacity.

impl<T, S> FlatMultiset<T, S>

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

Creates an empty FlatMultiset 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 FlatMultiset 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 set’s BuildHasher.

pub fn len(&self) -> usize

Returns the number of elements in the set.

pub fn is_empty(&self) -> bool

Returns true if the set contains no elements.

pub fn drain(&mut self) -> Drain<'_, T>

Clears the set, returning all elements as an iterator.

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

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

Retains only the elements specified by the predicate.

pub fn clear(&mut self)

Clears the set, removing all values.

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

An iterator visiting all elements in arbitrary order. The iterator element type is &'a T.

impl<T, S> FlatMultiset<T, S>

where T: Eq + Hash, S: BuildHasher,

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

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

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

pub fn shrink_to_fit(&mut self)

Shrinks the capacity of the set as much as possible.

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

Shrinks the capacity of the set with a lower limit.

pub fn insert(&mut self, value: T)

Adds a value to the set.

pub fn remove<Q>(&mut self, value: &Q) -> bool

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

Removes a value from the set. Returns whether the value was present in the set.

Examples

use flat_multimap::FlatMultiset;

let mut set = FlatMultiset::new();
set.insert(1);
set.insert(1);

assert!(set.remove(&1));
assert!(set.remove(&1));
assert!(!set.remove(&1));

pub fn contains<Q>(&mut self, value: &Q) -> bool

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

Returns true if the set contains the value.

impl<T, S> FlatMultiset<T, S>

where T: Eq + Hash + Send,

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

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

Trait Implementations

impl<T: Clone, S: Clone> Clone for FlatMultiset<T, S>

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

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T, S> Debug for FlatMultiset<T, S>

where T: Debug,

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

Formats the value using the given formatter.

impl<T, S> Default for FlatMultiset<T, S>

where S: Default,

fn default() -> Self

Returns the “default value” for a type.

impl<'de, T, S> Deserialize<'de> for FlatMultiset<T, S>

where T: Deserialize<'de> + Eq + Hash, 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, T, S> Extend<&'a T> for FlatMultiset<T, S>

where T: 'a + Eq + Hash + Copy, S: BuildHasher,

fn extend<I: IntoIterator<Item = &'a T>>(&mut self, iter: I)

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<T, S> Extend<T> for FlatMultiset<T, S>

where T: Eq + Hash, S: BuildHasher,

fn extend<I: IntoIterator<Item = T>>(&mut self, iter: I)

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<T, const N: usize> From<[T; N]> for FlatMultiset<T, RandomState>

where T: Eq + Hash,

fn from(arr: [T; N]) -> Self

Converts to this type from the input type.

impl<T, S> FromIterator<T> for FlatMultiset<T, S>

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

fn from_iter<I: IntoIterator<Item = T>>(iter: I) -> Self

Creates a value from an iterator.

impl<T, S> FromParallelIterator<T> for FlatMultiset<T, S>

where T: Eq + Hash + Send, S: BuildHasher + Default,

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

where P: IntoParallelIterator<Item = T>,

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

impl<'a, T, S> IntoIterator for &'a FlatMultiset<T, S>

type Item = &'a T

The type of the elements being iterated over.

type IntoIter = Iter<'a, T>

Which kind of iterator are we turning this into?

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

Creates an iterator from a value.

impl<T, S> IntoIterator for FlatMultiset<T, S>

type Item = T

The type of the elements being iterated over.

type IntoIter = IntoIter<T>

Which kind of iterator are we turning this into?

fn into_iter(self) -> IntoIter<T>

Creates an iterator from a value.

impl<'a, T: Sync, S> IntoParallelIterator for &'a FlatMultiset<T, S>

type Item = &'a T

The type of item that the parallel iterator will produce.

type Iter = ParIter<'a, T>

The parallel iterator type that will be created.

fn into_par_iter(self) -> Self::Iter

Converts self into a parallel iterator.

impl<T: Send, S> IntoParallelIterator for FlatMultiset<T, S>

type Item = T

The type of item that the parallel iterator will produce.

type Iter = IntoParIter<T>

The parallel iterator type that will be created.

fn into_par_iter(self) -> Self::Iter

Converts self into a parallel iterator.

impl<'a, T, S> ParallelExtend<&'a T> for FlatMultiset<T, S>

where T: 'a + Copy + Eq + Hash + Sync, S: BuildHasher,

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

where I: IntoParallelIterator<Item = &'a T>,

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

impl<T, S> ParallelExtend<T> for FlatMultiset<T, S>

where T: Eq + Hash + Send, S: BuildHasher,

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

where I: IntoParallelIterator<Item = T>,

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

impl<T, H> Serialize for FlatMultiset<T, H>

where T: Serialize,

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

where S: Serializer,

Serialize this value into the given Serde serializer.