Struct slab::Slab

pub struct Slab<T, I = usize> { /* fields omitted */ }

A preallocated chunk of memory for storing objects of the same type.

Methods

impl<T, I> Slab<T, I>

pub fn with_capacity(capacity: usize) -> Slab<T, I>

Returns an empty Slab with the requested capacity

pub fn len(&self) -> usize

Returns the number of values stored by the Slab

pub fn capacity(&self) -> usize

Returns the total capacity of the Slab

pub fn is_empty(&self) -> bool

Returns true if the Slab is storing no values

pub fn available(&self) -> usize

Returns the number of available slots remaining in the Slab

pub fn has_available(&self) -> bool

Returns true if the Slab has available slots

impl<T, I: Into<usize> + From<usize>> Slab<T, I>

pub fn contains(&self, idx: I) -> bool

Returns true if the Slab contains a value for the given token

pub fn get(&self, idx: I) -> Option<&T>

Get a reference to the value associated with the given token

pub fn get_mut(&mut self, idx: I) -> Option<&mut T>

Get a mutable reference to the value associated with the given token

pub fn insert(&mut self, val: T) -> Result<I, T>

Insert a value into the slab, returning the associated token

pub fn entry(&mut self, idx: I) -> Option<Entry<T, I>>

Returns a handle to an entry.

This allows more advanced manipulation of the value stored at the given index.

pub fn vacant_entry(&mut self) -> Option<VacantEntry<T, I>>

Returns a handle to a vacant entry.

This allows optionally inserting a value that is constructed with the index.

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

Releases the given slot

pub fn retain<F>(&mut self, f: F) where     F: FnMut(&T) -> bool,

Retain only the elements specified by the predicate.

In other words, remove all elements e such that f(&e) returns false. This method operates in place and preserves the order of the retained elements.

Important traits for Iter<'a, T, I>

impl<'a, T, I> Iterator for Iter<'a, T, I> type Item = &'a T;

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

An iterator for visiting all elements stored in the Slab

Important traits for IterMut<'a, T, I>

impl<'a, T, I> Iterator for IterMut<'a, T, I> type Item = &'a mut T;

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

A mutable iterator for visiting all elements stored in the Slab

pub fn clear(&mut self)

Empty the slab, by freeing all entries

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

Reserves the minimum capacity for exactly additional more elements to be inserted in the given Slab. Does nothing if the capacity is already sufficient.

Trait Implementations

impl<T, I> Send for Slab<T, I> where     T: Send,

impl<T, I: From<usize> + Into<usize>> Index<I> for Slab<T, I>

type Output = T

The returned type after indexing.

fn index(&self, index: I) -> &T

Performs the indexing (container[index]) operation.

impl<T, I: From<usize> + Into<usize>> IndexMut<I> for Slab<T, I>

fn index_mut(&mut self, index: I) -> &mut T

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

impl<T, I> Debug for Slab<T, I> where     T: Debug,     I: Debug,

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

Formats the value using the given formatter.

impl<'a, T, I: From<usize> + Into<usize>> IntoIterator for &'a Slab<T, I>

type Item = &'a T

The type of the elements being iterated over.

type IntoIter = Iter<'a, T, I>

Which kind of iterator are we turning this into?

Important traits for Iter<'a, T, I>

impl<'a, T, I> Iterator for Iter<'a, T, I> type Item = &'a T;

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

Creates an iterator from a value.

impl<'a, T, I: From<usize> + Into<usize>> IntoIterator for &'a mut Slab<T, I>

type Item = &'a mut T

The type of the elements being iterated over.

type IntoIter = IterMut<'a, T, I>

Which kind of iterator are we turning this into?

Important traits for IterMut<'a, T, I>

impl<'a, T, I> Iterator for IterMut<'a, T, I> type Item = &'a mut T;

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

Creates an iterator from a value.