Struct Vec 

pub struct Vec<T, const N: usize> {
    len: usize,
    data: [MaybeUninit<T>; N],
    extra: Box<[MaybeUninit<T>]>,
}

This is a vector that can store up to N elements inline and will allocate on the heap if more are needed.

Fields

len: usize

data: [MaybeUninit<T>; N]

extra: Box<[MaybeUninit<T>]>

Implementations

impl<T: Clone + Copy, const N: usize> Vec<T, N>

pub const fn new() -> Self

Create a new Vec.

Returns a new Vec.

pub const fn from_array(arr: [T; N]) -> Self

pub fn reserve(&mut self, additional: usize) -> Result<(), Error>

Reserve additional space in the Vec.

additional - The additional space to reserve.

Returns Ok(()) if the space was reserved, otherwise Err(KernelError::OutOfMemory).

pub fn reserve_total_capacity( &mut self, total_capacity: usize, ) -> Result<(), Error>

Reserve a fixed amount of space in the Vec. Does nothing if enough space is present already.

total_capacity - The total space to be reserved.

Returns Ok(()) if the space was reserved, otherwise Err(KernelError::OutOfMemory).

pub fn new_init(length: usize, value: T) -> Result<Self, Error>

Create a new Vec with the given length and value.

length - The length of the Vec. value - The value to initialize the elements in the Vec with.

Returns the new Vec or Err(KernelError::OutOfMemory) if the allocation failed.

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

Push a value onto the Vec.

value - The value to push.

Returns Ok(()) if the value was pushed, otherwise Err(KernelError::OutOfMemory).

pub fn pop(&mut self) -> Option<T>

Pop a value from the Vec.

Returns the value if it was popped, otherwise None.

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

Remove the value at the given index.

index - The index to remove the value from.

Returns the value if it was removed, otherwise None.

pub fn len(&self) -> usize

Get the length of the Vec.

Returns the length of the Vec.

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

Get the value at the given index.

index - The index to get the value from.

Returns Some(&T) if the index is in-bounds, otherwise None.

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

Get a mutable reference to the value at the given index.

index - The index to get the value from.

Returns Some(&mut T) if the index is in-bounds, otherwise None.

fn at_mut_unchecked(&mut self, index: usize) -> *mut T

pub fn at2_mut( &mut self, index1: usize, index2: usize, ) -> (Option<&mut T>, Option<&mut T>)

Get disjoint mutable references to the values at the given indices.

index1 - The first index. index2 - The second index.

Returns Some(&mut T, &mut T) if the indices are in-bounds and disjoint, otherwise None.

pub fn at3_mut( &mut self, index1: usize, index2: usize, index3: usize, ) -> (Option<&mut T>, Option<&mut T>, Option<&mut T>)

Get disjoint mutable references to the values at the given indices.

index1 - The first index. index2 - The second index. index3 - The third index.

Returns Some(&mut T, &mut T, &mut T) if the indices are in-bounds and disjoint, otherwise None.

pub fn swap(&mut self, a: usize, b: usize)

Swap the values at the given indices.

a - The first index. b - The second index.

pub fn is_empty(&self) -> bool

Check if the Vec is empty.

Returns true if the Vec is empty, otherwise false.

pub fn capacity(&self) -> usize

Get total amount of space in Vec (in- and out-of-line)

Returns total amount of reserved space in the vec

Trait Implementations

impl<T, const N: usize> Clone for Vec<T, N>

where T: Clone + Copy,

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, const N: usize> Debug for Vec<T, N>

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

Formats the value using the given formatter.

impl<T, const N: usize> Drop for Vec<T, N>

fn drop(&mut self)

Executes the destructor for this type.

impl<T: Clone + Copy, const N: usize> Get<usize> for Vec<T, N>

type Output = T

fn get<Q: Borrow<usize>>(&self, index: Q) -> Option<&Self::Output>

impl<T: Clone + Copy, const N: usize> GetMut<usize> for Vec<T, N>

fn get_mut<Q: Borrow<usize>>(&mut self, index: Q) -> Option<&mut Self::Output>

fn get2_mut<Q: Borrow<usize>>( &mut self, index1: Q, index2: Q, ) -> (Option<&mut Self::Output>, Option<&mut Self::Output>)

fn get3_mut<Q: Borrow<usize>>( &mut self, index1: Q, index2: Q, index3: Q, ) -> (Option<&mut Self::Output>, Option<&mut Self::Output>, Option<&mut Self::Output>)

impl<T: Clone + Copy, const N: usize> Index<usize> for Vec<T, N>

type Output = T

The returned type after indexing.

fn index(&self, index: usize) -> &Self::Output

Performs the indexing (container[index]) operation.

impl<T: Clone + Copy, const N: usize> IndexMut<usize> for Vec<T, N>

fn index_mut(&mut self, index: usize) -> &mut Self::Output

Performs the mutable indexing (container[index]) operation.