Struct ochenslab::OchenSlab

pub struct OchenSlab<T> { /* fields omitted */ }

Limited size preallocated slab storage that won't reallocate ever

Example

use ochenslab::OchenSlab;

let mut slab = OchenSlab::<usize>::with_capacity(2);

let a = slab.insert(31337);
let b = slab.insert(31338);
assert!(a.is_some());
assert!(b.is_some());

// at this point container is at its max capacity
let c = slab.insert(31339);
assert!(c.is_none());

assert_eq!(*slab.get(a.unwrap()).unwrap(), 31337);
assert_eq!(*slab.get(b.unwrap()).unwrap(), 31338);

Methods

impl<T> OchenSlab<T>

pub fn with_capacity(capacity: usize) -> OchenSlab<T>

Create slab instance with given capacity Capacity will be constant for the entire lifetime of this object and cannot increase

pub fn len(&self) -> usize

Return number of elements in this container

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

Get reference to an item by its index

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

Get mutable reference to an item by its index

pub fn insert(&mut self, t: T) -> Option<usize>

Insert a new item and return its index. Returns None if there's no space left Contrary to Rust opinion this cannot affect any other items in this container, so it is safe to hold a mutable reference to some other item while inserting another. This is because insert will not ever reallocate, so it can't invalidate existing pointers.

pub fn remove(&mut self, index: usize) -> Option<T>

Remove an item by its index. Returns the item by value if there was one