Struct ArrayVec 

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

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

Implementations

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

pub const fn new() -> ArrayVec<T, N>

Creates a new ArrayVec with no elements.

Examples

use no_alloc::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 no_alloc::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 len(&self) -> usize

Returns the number of elements in the ArrayVec.

Examples

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

where T: Debug,

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

Formats the value using the given formatter.

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

where T: Copy,

fn index(&self, index: usize) -> &<ArrayVec<T, N> as Index<usize>>::Output

Returns a reference to the element at the given index.

Panics

Panics if the index is out of bounds.

Examples

use no_alloc::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>

where T: Copy,

fn index_mut( &mut self, index: usize, ) -> &mut <ArrayVec<T, N> as Index<usize>>::Output

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

Panics

Panics if the index is out of bounds.

Examples

use no_alloc::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);