Struct stash::UniqueStash

pub struct UniqueStash<V> { /* fields omitted */ }

An O(1) amortized table that does not reuse keys.

Guarantee: No two calls to put on the same UniqueStash will ever return the same Key.

An example use case is a file descriptor table.

An example use case is a session table where expired session IDs should never be re-used.

Methods

impl<V> UniqueStash<V>

pub fn new() -> Self

Constructs a new, empty UniqueStash<T>.

The stash will not allocate until elements are put onto it.

Examples

use stash::UniqueStash;

let mut stash: UniqueStash<i32> = UniqueStash::new();

pub fn with_capacity(capacity: usize) -> Self

Constructs a new, empty UniqueStash<T> with the specified capacity.

The stash will be able to hold exactly capacity elements without reallocating. If capacity is 0, the stash will not allocate.

It is important to note that this function does not specify the length of the returned stash , but only the capacity. (For an explanation of the difference between length and capacity, see the main Vec<T> docs in the std::vec module, 'Capacity and reallocation'.)

Examples

use stash::UniqueStash;

let mut stash: UniqueStash<i32> = UniqueStash::with_capacity(10);

// The stash contains no items, even though it has capacity for more
assert_eq!(stash.len(), 0);

// These are all done without reallocating...
for i in 0i32..10 {
    let _ = stash.put(i);
}

// ...but this may make the stash reallocate
stash.put(11);

pub fn capacity(&self) -> usize

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

Examples

use stash::UniqueStash;

let stash: UniqueStash<i32> = UniqueStash::with_capacity(10);
assert_eq!(stash.capacity(), 10);

pub fn len(&self) -> usize

The number of items in the stash.

Examples

use stash::UniqueStash;

let mut stash = UniqueStash::new();
assert_eq!(stash.len(), 0);
stash.put("a");
assert_eq!(stash.len(), 1);

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

Reserves capacity for at least additional more elements to be put into the given UniqueStash<T>. The collection may reserve more space to avoid frequent reallocations.

Panics

Panics if the new capacity overflows usize.

Examples

use stash::UniqueStash;

let mut stash: UniqueStash<i32> = UniqueStash::new();
let t1 = stash.put(1);
stash.reserve(10);
assert!(stash.capacity() >= 11);

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

Reserves the minimum capacity for exactly additional more elements to be put into the given UniqueStash<T>. 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 puts are expected.

Panics

Panics if the new capacity overflows usize.

Examples

use stash::UniqueStash;

let mut stash: UniqueStash<i32> = UniqueStash::new();
let t1 = stash.put(1);
stash.reserve_exact(10);
assert!(stash.capacity() >= 11);

pub fn put(&mut self, value: V) -> Tag

Put a value into the stash.

Returns the index at which this value was stored.

Important traits for Extend<'a, I>

impl<'a, I> Iterator for Extend<'a, I> where
    I: Iterator,
    I::Item: 'a,  type Item = Tag;

pub fn extend<I>(&mut self, iter: I) -> Extend<I> where
    I: Iterator<Item = V>, 

Put all items in the iterator into the stash.

Returns an iterator over the indices where the items were inserted. The items are actually inserted as the Iterator is read. If the returned Iterator is dropped, the rest of the items will be inserted all at once.

Important traits for Iter<'a, V>

impl<'a, V> Iterator for Iter<'a, V> type Item = (Tag, &'a V);

pub fn iter(&self) -> Iter<V>

Iterate over the items in this UniqueStash<V>.

Returns an iterator that yields (index, &value) pairs.

Important traits for IterMut<'a, V>

impl<'a, V> Iterator for IterMut<'a, V> type Item = (Tag, &'a mut V);

pub fn iter_mut(&mut self) -> IterMut<V>

Mutably iterate over the items in this UniqueStash<V>.

Returns an iterator that yields (index, &mut value) pairs.

Important traits for Values<'a, V>

impl<'a, V> Iterator for Values<'a, V> type Item = &'a V;

pub fn values(&self) -> Values<V>

Iterate over the values in this UniqueStash<V> by reference.

Important traits for ValuesMut<'a, V>

impl<'a, V> Iterator for ValuesMut<'a, V> type Item = &'a mut V;

pub fn values_mut(&mut self) -> ValuesMut<V>

Mutably iterate over the values in this UniqueStash<V> by reference.

Important traits for IntoValues<V>

impl<V> Iterator for IntoValues<V> type Item = V;

pub fn into_values(self) -> IntoValues<V>

Iterate over the values in this UniqueStash<V> by value.

pub fn is_empty(&self) -> bool

Check if this UniqueStash<V> is empty.

Returns true if this UniqueStash<V> is empty.

pub fn take(&mut self, index: Tag) -> Option<V>

Take an item from a slot (if non empty).

pub fn get(&self, index: Tag) -> Option<&V>

Get a reference to the value at index.

pub fn get_mut(&mut self, index: Tag) -> Option<&mut V>

Get a mutable reference to the value at index.

pub fn clear(&mut self)

Clear the UniqueStash.

Note: This will not cause Tags to be reused.

Trait Implementations

impl<V> IntoIterator for UniqueStash<V>

type Item = (Tag, V)

The type of the elements being iterated over.

type IntoIter = IntoIter<V>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<'a, V> IntoIterator for &'a UniqueStash<V>

type Item = (Tag, &'a V)

The type of the elements being iterated over.

type IntoIter = Iter<'a, V>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<'a, V> IntoIterator for &'a mut UniqueStash<V>

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

The type of the elements being iterated over.

type IntoIter = IterMut<'a, V>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<V> Default for UniqueStash<V>

fn default() -> Self

Returns the "default value" for a type.

impl<V: Clone> Clone for UniqueStash<V>

fn clone(&self) -> UniqueStash<V>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<'a, V> Index<Tag> for UniqueStash<V>

type Output = V

The returned type after indexing.

fn index(&self, index: Tag) -> &V

Performs the indexing (container[index]) operation.

impl<'a, V> IndexMut<Tag> for UniqueStash<V>

fn index_mut(&mut self, index: Tag) -> &mut V

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

impl<V> Debug for UniqueStash<V> where
    V: Debug, 

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

Formats the value using the given formatter.