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 pop(&mut self) -> Option<T>

Removes the last element from a vector and returns it, or None if it is empty.

This method is identical to the Vec::pop method in liballoc.

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 retain<F>(&mut self, f: F)

where F: FnMut(&T) -> bool,

Retains only the elements specified by the predicate.

In other words, remove all elements e for which f(&e) returns false. This method operates in place, visiting each element exactly once in the original order, and preserves the order of the retained elements.

This method is identical to the Vec::retain method in liballoc.

pub fn retain_mut<F>(&mut self, f: F)

where F: FnMut(&mut T) -> bool,

Retains only the elements specified by the predicate, passing a mutable reference to it.

In other words, remove all elements e such that f(&mut e) returns false. This method operates in place, visiting each element exactly once in the original order, and preserves the order of the retained elements.

This method is identical to the Vec::retain_mut method in liballoc.

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

This method is identical to the Vec::clear method in liballoc.

pub fn is_full(&self) -> bool

Is the FixedVec full?

pub fn is_empty(&self) -> bool

Returns true if this FixedVec is empty (its len is 0).

pub fn len(&self) -> usize

Returns the length of the FixedVec.

pub fn capacity(&self) -> usize

Returns the total capacity in this FixedVec.

This method is identical to the Vec::capacity method in liballoc.

Trait Implementations

impl<T> AsMut<[T]> for FixedVec<T>

fn as_mut(&mut self) -> &mut [T]

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

impl<T> AsRef<[T]> for FixedVec<T>

fn as_ref(&self) -> &[T]

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

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

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