Struct PackedArray

pub struct PackedArray<T, const N: usize> { /* private fields */ }

Densly packed data structure for fast iteration

Implementations

impl<T, const N: usize> PackedArray<T, N>

pub fn new() -> Self

Return new PackedArray with allocated storage

pub fn len(&self) -> usize

Returns current number of elements stored

pub fn has(&self, index: usize) -> bool

Returns true if there is a valid entry under index

pub fn full(&self) -> bool

Returns true if allocated memory is exhausted True also means that no more entries can be added

pub fn get(&self, index: usize) -> &T

Returns reference to an element at index Panics if there is no valid element with such index

pub fn get_mut(&mut self, index: usize) -> &mut T

Return mutable reference to an element at index Panics if there is no valid element with such index

pub fn append(&mut self, value: T) -> usize

Adds element to the end of array. Return index of newly-added element for future access Panics if structure is full

pub fn set(&mut self, index: usize, value: T)

Sets value of passed index If there is no valid element with such index, element is added

pub fn remove(&mut self, index: usize)

Removes element by given index Panics if there is no valid element with such index

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

Returns an underlying storage as slice

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

Returns an underlying storage as mutable slice

pub fn iter(&self) -> Iter<'_, T>

Returns an iterator to underlying storage

pub fn iter_mut(&mut self) -> IterMut<'_, T>

Return a mutable iterator to underlying storage

Trait Implementations

impl<T, const N: usize> Index<usize> for PackedArray<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, const N: usize> IndexMut<usize> for PackedArray<T, N>

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

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