Struct CpuSlab

pub struct CpuSlab<B> { /* private fields */ }

A wrapper around a GrowableSlab that provides convenience methods for working with CPU-side slabs.

Working with slabs on the CPU is much more convenient because the underlying buffer B is often a growable type, like Vec<u32>. This wrapper provides methods for appending to the end of the buffer with automatic resizing and for preallocating space for elements that will be written later.

Implementations

impl<B> CpuSlab<B>

where B: GrowableSlab,

pub fn new(slab: B) -> CpuSlab<B>

Create a new SlabBuffer with the given slab.

pub fn into_inner(self) -> B

Consume the CpuSlab, converting it into the underlying buffer.

Trait Implementations

impl<B> AsMut<B> for CpuSlab<B>

fn as_mut(&mut self) -> &mut B

Converts this type into a mutable reference of the (usually inferred) input type.

impl<B> AsRef<B> for CpuSlab<B>

fn as_ref(&self) -> &B

Converts this type into a shared reference of the (usually inferred) input type.

impl<B> GrowableSlab for CpuSlab<B>

where B: GrowableSlab,

fn capacity(&self) -> usize

Return the current capacity of the slab.

fn reserve_capacity(&mut self, capacity: usize)

Reserve enough space on the slab to fit the given capacity.

fn increment_len(&mut self, n: usize) -> usize

Increment the length of the slab by n u32s.

fn maybe_expand_to_fit<T>(&mut self, len: usize)

where T: SlabItem,

Expands the slab to fit the given number of Ts, if necessary.

fn allocate<T>(&mut self) -> Id<T>

where T: SlabItem,

Preallocate space for one T element, but don’t write anything to the buffer.

fn allocate_array<T>(&mut self, len: usize) -> Array<T>

where T: SlabItem,

Preallocate space for len T elements, but don’t write to the buffer.

fn append<T>(&mut self, t: &T) -> Id<T>

where T: SlabItem,

Append to the end of the buffer.

fn append_array<T>(&mut self, ts: &[T]) -> Array<T>

where T: SlabItem,

Append a slice to the end of the buffer, resizing if necessary and returning a slabbed array.

impl<B> Slab for CpuSlab<B>

where B: Slab,

fn len(&self) -> usize

Return the number of u32 elements in the slab.

fn read_unchecked<T>(&self, id: Id<T>) -> T

where T: SlabItem,

Read the type from the slab using the Id as the index.

fn write_indexed<T>(&mut self, t: &T, index: usize) -> usize

where T: SlabItem,

Write the type into the slab at the index.

fn write_indexed_slice<T>(&mut self, t: &[T], index: usize) -> usize

where T: SlabItem,

Write a slice of the type into the slab at the index.

fn is_empty(&self) -> bool

fn contains<T>(&self, id: Id<T>) -> bool

where T: SlabItem,

Returns true if the slab size is great enough to contain the value with the given id.

fn read<T>(&self, id: Id<T>) -> T

where T: SlabItem + Default,

Read the type from the slab using the Id as the index, or return the default if id is Id::NONE.

fn read_into_if_some<T>(&self, id: Id<T>, t: &mut T)

where T: SlabItem,

fn read_vec<T>(&self, array: Array<T>) -> Vec<T>

where T: SlabItem + Default,

fn write<T>(&mut self, id: Id<T>, t: &T)

where T: SlabItem,

Write the type into the slab at the position of the given Id.

fn write_array<T>(&mut self, array: Array<T>, data: &[T])

where T: SlabItem,

Write contiguous elements into the slab at the position of the given Array.