Struct FixedCapacityVec 

pub struct FixedCapacityVec<T> {
    elements: Box<[MaybeUninit<T>]>,
    len: usize,
}

Fields

elements: Box<[MaybeUninit<T>]>

A contiguous, non-reallocating, heap allocated vector. Behaves like a subset of alloc::vec::Vec, cleansed of any operation that reallocates. Backed by via boxed slice containing elements of type MaybeUninit<T>. The maximum size (pendant to alloc::vec::Vec::capacity) is determined at creation and remains unchanged over the lifetime of Self. Nonetheless a variable amount of T can be kept within Self, just never more than the maximum size passed to the constructor.

This can be used as a stack, in which case the first element (forming the bottom of the stack) is at index 0, and new elements grow towards Self’s end. The last element (self.stack[self.stack.len() - 1] is the topmost possible entry.

len: usize

Number of elements in Self. Also an index, pointing always to the first unused slot in Self::elements.

Implementations

impl<T> FixedCapacityVec<T>

pub fn with_capacity(capacity: usize) -> Self

Construct new Self, holding up to capacity elements of type T

pub const fn is_empty(&self) -> bool

Check if the Self is empty

pub const fn is_full(&self) -> bool

Check if the Self is full

pub const fn len(&self) -> usize

Get the Self is height.

pub const fn capacity(&self) -> usize

Get the maximum number of elements that fit into Self.

pub unsafe fn push_unchecked(&mut self, value: T)

Push a value to the end of Self

Safety

• Causes UB if Self is already full.
• Causes UB if Self has a capacity equal to usize::MAX

pub fn push(&mut self, value: T) -> Result<(), FullContainerError>

Push a value to the end of Self

pub unsafe fn pop_unchecked(&mut self) -> T

Pop a value from Self’s top/tail

Safety

Causes UB if the stack is empty.

pub fn pop(&mut self) -> Result<T, EmptyContainerError>

Pop a value from Self’s top/tail

pub unsafe fn peek_unchecked(&self) -> &T

Peek at the topmost/last value from Self

Safety

Causes UB if the stack is empty.

pub fn peek(&self) -> Result<&T, EmptyContainerError>

Peek at the topmost/last value from Self

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

Get a shared ref to the nth element in Self

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

Get a mut ref to the nth element in Self

impl<T: Clone> FixedCapacityVec<T>

pub fn push_from_slice( &mut self, values: &[T], ) -> Result<(), FullContainerError>

Push from a slice into Self, appending after the last/topmost element

pub fn pop_into_slice( &mut self, n: usize, ) -> Result<impl Deref<Target = [T]> + '_, EmptyContainerError>

Pop n elements from Self into a slice. The topmost/last element of Self will become the slice’s last element.

impl<T: Copy> FixedCapacityVec<T>

pub fn remove_in_between(&mut self, remove_count: usize, keep_count: usize)

Remove remove_count values from Self, keeping the topmost keep_count values

From the Self, remove remove_count elements, by sliding down the keep_count last/topmost values remove_count positions forward/towards the bottom.

Effects

• after the operation, Self will contain remove_count fewer elements
• keep_count topmost elements will be identical before and after the operation
• all elements below the remove_count + keep_count topmost stack entry remain

Trait Implementations

impl<T: Clone> Clone for FixedCapacityVec<T>

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T: Debug> Debug for FixedCapacityVec<T>

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

Formats the value using the given formatter.

impl<T> Drop for FixedCapacityVec<T>

fn drop(&mut self)

Executes the destructor for this type.