Struct ArrayVec 

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

A fixed-size array, which has vector-like operations.

ArrayVec provides a vector-like interface with a compile-time fixed capacity N. Elements are stored in a stack-allocated array, making it suitable for no_std environments and situations where heap allocation is not available or desirable.

Type Parameters

• T: The type of elements stored in the vector
• N: The maximum number of elements (capacity)

Examples

use planck_noalloc::vec::ArrayVec;

// Create a vector with capacity 4
let mut vec = ArrayVec::<String, 4>::new();
vec.push(String::from("hello"));
vec.push(String::from("world"));

assert_eq!(vec.len(), 2);

Implementations

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

pub const fn new() -> Self

Creates a new ArrayVec with no elements.

Examples

use planck_noalloc::vec::ArrayVec;

let mut vec = ArrayVec::<u8, 4>::new();
assert_eq!(vec.len(), 0);
assert!(vec.is_empty());

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

Tries to push a value into the ArrayVec.

Errors

Returns an error if the ArrayVec is full.

Examples

use planck_noalloc::vec::ArrayVec;

let mut vec = ArrayVec::<u8, 1>::new();
assert!(vec.try_push(1).is_ok());
assert_eq!(vec.len(), 1);
assert!(vec.try_push(2).is_err());

pub fn push(&mut self, value: T)

Pushes a value into the ArrayVec.

Panics

Panics if the ArrayVec is full.

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

Removes and returns the last element, or None if empty.

pub fn clear(&mut self)

Removes all elements.

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

Removes the element at index by swapping it with the last element.

Panics

Panics if index >= len.

pub fn len(&self) -> usize

Returns the number of elements in the ArrayVec.

Examples

use planck_noalloc::vec::ArrayVec;

let mut vec = ArrayVec::<u8, 4>::new();
assert_eq!(vec.len(), 0);
vec.push(1);
assert_eq!(vec.len(), 1);
vec.push(2);
assert_eq!(vec.len(), 2);

pub fn is_empty(&self) -> bool

Returns true if the ArrayVec is empty.

Examples

use planck_noalloc::vec::ArrayVec;

let mut vec = ArrayVec::<u8, 4>::new();
assert!(vec.is_empty());
vec.push(1);
assert!(!vec.is_empty());

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

Returns a slice of all the elements in the ArrayVec.

Examples

use planck_noalloc::vec::ArrayVec;

let mut vec = ArrayVec::<u8, 4>::new();
vec.push(1);
vec.push(2);
vec.push(3);
vec.push(4);

assert_eq!(vec.as_slice(), &[1, 2, 3, 4]);

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

Returns a mutable slice of all the elements in the ArrayVec.

Examples

use planck_noalloc::vec::ArrayVec;

let mut vec = ArrayVec::<u8, 4>::new();
vec.push(1);
vec.push(2);
vec.push(3);
vec.push(4);

assert_eq!(vec.as_mut_slice(), &mut [1, 2, 3, 4]);

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

Returns an iterator over the elements of the ArrayVec.

Examples

use planck_noalloc::vec::ArrayVec;

let mut vec = ArrayVec::<u8, 4>::new();
vec.push(1);
vec.push(2);
vec.push(3);
vec.push(4);

for i in vec.iter() {
    assert!(*i == 1 || *i == 2 || *i == 3 || *i == 4);
    // do something
}

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

Returns a mutable iterator over the elements of the ArrayVec.

Examples

use planck_noalloc::vec::ArrayVec;

let mut vec = ArrayVec::<u8, 4>::new();
vec.push(1);
vec.push(2);
vec.push(3);
vec.push(4);

for i in vec.iter_mut() {
    *i += 1;
    // do something
}

pub fn reverse(&mut self)

Reverses the order of the elements in the ArrayVec.

Examples

use planck_noalloc::vec::ArrayVec;

let mut vec = ArrayVec::<u8, 4>::new();
vec.push(1);
vec.push(2);
vec.push(3);
vec.push(4);

vec.reverse();

assert_eq!(vec.as_slice(), &[4, 3, 2, 1]);

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

Inserts value at index, shifting all elements after it to the right.

Panics

Panics if index > len or if the ArrayVec is full.

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

Removes and returns the element at index, shifting all elements after it to the left. Preserves ordering.

Panics

Panics if index >= len.

pub fn last(&self) -> Option<&T>

Returns the last element, or None if empty.

pub fn is_full(&self) -> bool

Returns true if the ArrayVec is at capacity.

pub fn as_ptr(&self) -> *const T

Returns a pointer to the underlying data.

pub fn as_mut_ptr(&mut self) -> *mut T

Returns a mutable pointer to the underlying data.

impl<T, const U: usize> ArrayVec<T, U>

where T: Copy + PartialEq,

pub fn contains(&self, value: &T) -> bool

Returns true if the ArrayVec contains the given value.

Examples

use planck_noalloc::vec::ArrayVec;

let mut vec = ArrayVec::<u8, 4>::new();
vec.push(1);
vec.push(2);
vec.push(3);
vec.push(4);

assert!(vec.contains(&1));
assert!(!vec.contains(&5));

impl<T, const U: usize> ArrayVec<T, U>

where T: Copy + Ord,

pub fn sort_unstable(&mut self)

Sorts the ArrayVec in place. The sort is not stable, meaning that the relative order of elements that are equal is not preserved.

Examples

use planck_noalloc::vec::ArrayVec;

let mut vec = ArrayVec::<u8, 4>::new();
vec.push(1);
vec.push(2);
vec.push(3);
vec.push(4);

vec.sort_unstable();

assert_eq!(vec.as_slice(), &[1, 2, 3, 4]);

Trait Implementations

impl<T: Debug, const N: usize> Debug for ArrayVec<T, N>

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

Formats the value using the given formatter.

impl<T, const N: usize> Default for ArrayVec<T, N>

fn default() -> Self

Returns the “default value” for a type.

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

fn drop(&mut self)

Executes the destructor for this type.

impl<T, const N: usize> Index<usize> for ArrayVec<T, N>

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

Returns a reference to the element at the given index.

Panics

Panics if the index is out of bounds.

Examples

use planck_noalloc::vec::ArrayVec;

let mut vec = ArrayVec::<u8, 4>::new();
vec.push(1);
vec.push(2);
vec.push(3);
vec.push(4);

assert_eq!(vec[0], 1);
assert_eq!(vec[1], 2);
assert_eq!(vec[2], 3);
assert_eq!(vec[3], 4);

type Output = T

The returned type after indexing.

impl<T, const N: usize> IndexMut<usize> for ArrayVec<T, N>

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

Returns a mutable reference to the element at the given index.

Panics

Panics if the index is out of bounds.

Examples

use planck_noalloc::vec::ArrayVec;

let mut vec = ArrayVec::<u8, 4>::new();
vec.push(1);
vec.push(2);
vec.push(3);
vec.push(4);

assert_eq!(vec[0], 1);
assert_eq!(vec[1], 2);
assert_eq!(vec[2], 3);
assert_eq!(vec[3], 4);

vec[0] = 5;
assert_eq!(vec[0], 5);

impl<'a, T, const N: usize> IntoIterator for &'a ArrayVec<T, N>

type Item = &'a T

The type of the elements being iterated over.

type IntoIter = Iter<'a, T>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<'a, T, const N: usize> IntoIterator for &'a mut ArrayVec<T, N>

type Item = &'a mut T

The type of the elements being iterated over.

type IntoIter = IterMut<'a, T>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.