Struct slab::Slab

pub struct Slab<T, I: Index> { /* fields omitted */ }

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

Methods

impl<T, I: Index> Slab<T, I>

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

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

pub fn count(&self) -> usize

pub fn is_empty(&self) -> bool

pub fn remaining(&self) -> usize

pub fn has_remaining(&self) -> bool

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

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

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

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

pub fn insert_with<F>(&mut self, fun: F) -> Option<I> where
    F: FnOnce(I) -> T, 

Like insert but for objects that require newly allocated usize in their constructor.

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

Releases the given slot

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

pub fn replace_with<F>(&mut self, idx: I, fun: F) -> Result<(), ()> where
    F: FnOnce(T) -> Option<T>, 

Execute a function on the value in the slot and put the result of the function back into the slot. If function returns None, slot is left empty on exit.

Returns Err(()) if slot was empty

This method is very useful for storing state machines inside Slab

pub fn retain<F>(&mut self, fun: 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 SlabIter<'a, T, I>

impl<'a, T, I: Index> Iterator for SlabIter<'a, T, I> type Item = &'a T;

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

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

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

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

pub fn clear(&mut self)

Empty the slab, by freeing all entries

pub fn grow(&mut self, entries_num: usize)

Grow the slab, by adding entries_num

Trait Implementations

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

impl<'a, T, I: Index> IntoIterator for &'a Slab<T, I>

type Item = &'a T

The type of the elements being iterated over.

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

Which kind of iterator are we turning this into?

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

impl<'a, T, I: Index> Iterator for SlabIter<'a, T, I> type Item = &'a T;

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

Creates an iterator from a value.

impl<'a, T, I: Index> IntoIterator for &'a mut Slab<T, I>

type Item = &'a mut T

The type of the elements being iterated over.

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

Which kind of iterator are we turning this into?

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

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

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

Creates an iterator from a value.

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

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

Formats the value using the given formatter.

impl<T, I: Index> 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: Index> IndexMut<I> for Slab<T, I>

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

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