Struct mnemos_alloc::containers::FixedVec

pub struct FixedVec<T> {
    inner: Vec<T>,
}

A Vec with a fixed upper size

Semantically, FixedVec works basically the same as alloc::vec::Vec, however FixedVec will NOT ever reallocate to increase size. In practice, this acts like a heap allocated version of heapless’ Vec type.

Fields

inner: Vec<T>

Implementations

impl<T> FixedVec<T>

pub fn try_new(capacity: usize) -> Option<Self>

Try to allocate a new FixedVec with storage for UP TO capacity items.

Returns None if the allocation does not succeed immediately.

Panics if the len is zero, or large enough that creating the layout would fail

pub async fn new(capacity: usize) -> Self

Try to allocate a new FixedVec with storage for UP TO capacity items.

Will not return until allocation succeeds.

Panics if the len is zero, or large enough that creating the layout would fail

pub fn try_push(&mut self, t: T) -> Result<(), T>

Attempt to push an item into the fixed vec.

Returns an error if the fixed vec is full

pub fn try_extend_from_slice(&mut self, sli: &[T]) -> Result<(), ()>where T: Clone,

Attempt to push an item into the fixed vec.

Returns an error if the slice would not fit in the capacity. If an error is returned, the contents of the FixedVec is unchanged

pub fn as_vec(&self) -> &Vec<T>

Obtain a reference to the underlying alloc::vec::Vec

pub unsafe fn as_vec_mut(&mut self) -> &mut Vec<T>

Get inner mutable vec

SAFETY:

You must not do anything that could realloc or increase the capacity. We want an exact upper limit.

This would not be memory unsafe, but would violate the invariants of FixedVec, which is supposed to have a fixed upper size.

pub fn as_slice(&self) -> &[T]

Obtain a reference to the current contents

pub fn as_slice_mut(&mut self) -> &mut [T]

Obtain a mutable reference to the current contents

pub fn clear(&mut self)

Clear the FixedVec

pub fn is_full(&self) -> bool

Is the FixedVec full?

Trait Implementations

impl<T: Send> Send for FixedVec<T>

impl<T: Sync> Sync for FixedVec<T>