Struct MultiStash 

pub struct MultiStash<T> { /* private fields */ }

A vector-like data structure that is able to reuse slots for new elements.

Specifically allows for (armortized) O(1) instructions for:

• MultiStash::put
• MultiStash::take_one
• MultiStash::take_all
• MultiStash::get
• MultiStash::get_mut

Implementations

impl<T> MultiStash<T>

pub fn new() -> Self

Construct a new, empty MultiStash.

The MultiStash will not allocate until items are put into it.

pub fn with_capacity(capacity: usize) -> Self

Constructs a new, empty MultiStash with at least the specified capacity.

The MultiStash will be able to hold at least capacity elements without reallocating. This method is allowed to allocate for more elements than capacity. If capacity is 0, the MultiStash will not allocate.

It is important to note that although the returned MultiStash has the minimum capacity specified, the MultiStash will have a zero length. For an explanation of the difference between length and capacity, see Capacity and reallocation.

If it is important to know the exact allocated capacity of a MultiStash, always use the capacity method after construction.

Panics

Panics if the new capacity exceeds isize::MAX bytes.

pub fn capacity(&self) -> usize

Returns the total number of elements the MultiStash can hold without reallocating.

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

Reserves capacity for at least additional more elements to be inserted in the given MultiStash. The collection may reserve more space to speculatively avoid frequent reallocations. After calling reserve, capacity will be greater than or equal to self.len() + additional. Does nothing if capacity is already sufficient.

Panics

Panics if the new capacity exceeds isize::MAX bytes.

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

Reserves the minimum capacity for at least additional more elements to be inserted in the given MultiStash. Unlike reserve, this will not deliberately over-allocate to speculatively avoid frequent allocations. After calling reserve_exact, capacity will be greater than or equal to self.len() + additional. Does nothing if the capacity is already sufficient.

Note that the allocator may give the collection more space than it requests. Therefore, capacity can not be relied upon to be precisely minimal. Prefer reserve if future insertions are expected.

Panics

Panics if the new capacity exceeds isize::MAX bytes.

pub fn len_items(&self) -> usize

Returns the number of items in the MultiStash.

Note

A single element might store multiple items.

pub fn len(&self) -> usize

Returns the number of elements in the MultiStash.

Note

A single element might store multiple items.

pub fn is_empty(&self) -> bool

Returns true if the MultiStash contains no elements.

pub fn get(&self, key: Key) -> Option<(usize, &T)>

Returns a reference to an element at the key if any.

pub fn get_mut(&mut self, key: Key) -> Option<(usize, &mut T)>

Returns a mutable reference to an element at the key if any.

pub fn put(&mut self, amount: NonZeroUsize, item: T) -> Key

Puts an amount of item into the MultiStash.

Panics

Panics if the new capacity exceeds isize::MAX bytes.

pub fn clear(&mut self)

Clears the MultiStash, removing all elements.

Note that this method has no effect on the allocated capacity of the vector.

pub fn take_all(&mut self, key: Key) -> Option<(usize, T)>

Removes and returns the element at key and its amount of remaining items.

Returns None if key refers to a vacant entry or is out of bounds.

pub fn bump(&mut self, key: Key, amount: usize) -> Option<usize>

Bumps the amount of items of the element at key if any.

Returns None if not element is found at the key.

Panics

Panics if amount of the element at key overflows.

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

Returns an iterator over the elements of the MultiStash.

The iterator yields all elements, their keys and remaining items from start to end.

pub fn iter_mut(&mut self) -> IterMut<'_, T>

Returns an iterator over the elements of the MultiStash.

The iterator yields mutable references to all elements, their keys and remaining items from start to end.

impl<T: Clone> MultiStash<T>

pub fn take_one(&mut self, key: Key) -> Option<(usize, T)>

Returns a single item of the element at key and the amount of remaining items after this operation.

Remove the element if no items are left after this operation. Returns None if key refers to a vacant entry or is out of bounds.

Trait Implementations

impl<T: Clone> Clone for MultiStash<T>

fn clone(&self) -> MultiStash<T>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T: Debug> Debug for MultiStash<T>

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

Formats the value using the given formatter.

impl<T> Default for MultiStash<T>

fn default() -> Self

Returns the “default value” for a type.

impl<T> Extend<(NonZero<usize>, T)> for MultiStash<T>

fn extend<I: IntoIterator<Item = (NonZeroUsize, 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> FromIterator<(NonZero<usize>, T)> for MultiStash<T>

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

Creates a value from an iterator.

impl<T: Hash> Hash for MultiStash<T>

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<T> Index<Key> for MultiStash<T>

type Output = T

The returned type after indexing.

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

Performs the indexing (container[index]) operation.

impl<T> IndexMut<Key> for MultiStash<T>

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

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

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

type Item = (Key, usize, &'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) -> Self::IntoIter

Creates an iterator from a value.

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

type Item = (Key, usize, &'a mut T)

The type of the elements being iterated over.

type IntoIter = IterMut<'a, 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 MultiStash<T>

type Item = (Key, usize, 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) -> Self::IntoIter

Creates an iterator from a value.

impl<T: Ord> Ord for MultiStash<T>

fn cmp(&self, other: &MultiStash<T>) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

impl<T: PartialEq> PartialEq for MultiStash<T>

fn eq(&self, other: &MultiStash<T>) -> 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: PartialOrd> PartialOrd for MultiStash<T>

fn partial_cmp(&self, other: &MultiStash<T>) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

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

Tests less than (for self and other) and is used by the < operator.

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

Tests less than or equal to (for self and other) and is used by the <= operator.

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

Tests greater than (for self and other) and is used by the > operator.

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

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl<T: Eq> Eq for MultiStash<T>

impl<T> StructuralPartialEq for MultiStash<T>