Struct const_arrayvec::ArrayVec

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

A vector type backed by a fixed-length array.

Methods

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

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

Create a new, empty ArrayVec.

pub const fn len(&self) -> usize

pub const fn is_empty(&self) -> bool

pub const fn capacity(&self) -> usize

pub const fn remaining_capacity(&self) -> usize

pub const fn is_full(&self) -> bool

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

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

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

Add an item to the end of the vector.

Examples

use const_arrayvec::ArrayVec;
let mut vector: ArrayVec<u32, 5> = ArrayVec::new();

assert!(vector.is_empty());

vector.push(42);

assert_eq!(vector.len(), 1);
assert_eq!(vector[0], 42);

pub fn try_push(&mut self, item: T) -> Result<(), CapacityError<T>>

Try to add an item to the end of the vector, returning the original item if there wasn't enough room.

Examples

use const_arrayvec::{ArrayVec, CapacityError};
let mut vector: ArrayVec<u32, 2> = ArrayVec::new();

assert!(vector.try_push(1).is_ok());
assert!(vector.try_push(2).is_ok());
assert!(vector.is_full());

assert_eq!(vector.try_push(42), Err(CapacityError(42)));

pub unsafe fn push_unchecked(&mut self, item: T)

Add an item to the end of the array without checking the capacity.

Safety

It is up to the caller to ensure the vector's capacity is suitably large.

This method uses debug assertions to detect overflows in debug builds.

pub unsafe fn set_len(&mut self, new_length: usize)

Set the vector's length without dropping or moving out elements.

Safety

This method is unsafe because it changes the number of "valid" elements the vector thinks it contains, without adding or removing any elements. Use with care.

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

Remove an item from the end of the vector.

Examples

let mut vector: ArrayVec<u32, 5> = ArrayVec::new();

vector.push(12);
vector.push(34);

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

let got = vector.pop();

assert_eq!(got, Some(34));
assert_eq!(vector.len(), 1);

pub fn truncate(&mut self, new_length: usize)

Shorten the vector, keeping the first new_length elements and dropping the rest.

pub fn clear(&mut self)

Remove all items from the vector.

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

Insert an item.

Panics

The vector must have enough space for the item (see ArrayVec::remaining_capacity()).

pub fn try_insert(
    &mut self,
    index: usize,
    item: T
) -> Result<(), CapacityError<T>>

Try to insert an item into the vector.

Examples

The "happy path" works just as expected:

use const_arrayvec::ArrayVec;
let mut vector: ArrayVec<u32, 5> = ArrayVec::new();
vector.push(12);
vector.push(34);

vector.try_insert(1, 56).unwrap();

assert_eq!(vector.as_slice(), &[12, 56, 34]);

Trying to insert an item when the ArrayVec is full will fail, returning the original item.

use const_arrayvec::{ArrayVec, CapacityError};
let mut vector = ArrayVec::from([1, 2, 3]);
println!("{}, {}", vector.len(), vector.capacity());
println!("{:?}", vector);
assert!(vector.is_full());

let got = vector.try_insert(1, 7);

assert_eq!(got, Err(CapacityError(7)));

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

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

pub fn try_extend_from_slice(
    &mut self,
    other: &[T]
) -> Result<(), CapacityError<()>> where
    T: Copy, 

Important traits for Drain<'a, T, { N }>

impl<'a, T, const N: usize> Iterator for Drain<'a, T, { N }> type Item = T;

pub fn drain(&mut self, range: Range<usize>) -> Drain<T, { N }>

Trait Implementations

impl<T, const N: usize> From<[T; N]> for ArrayVec<T, { N }>

fn from(other: [T; N]) -> ArrayVec<T, { N }>

Performs the conversion.

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: PartialEq, const N: usize, const M: usize> PartialEq<ArrayVec<T, M>> for ArrayVec<T, { N }>

fn eq(&self, other: &ArrayVec<T, { M }>) -> bool

This method tests for self and other values to be equal, and is used by ==.

#[must_use] fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl<T: PartialEq, const N: usize> PartialEq<[T]> for ArrayVec<T, { N }>

fn eq(&self, other: &[T]) -> bool

This method tests for self and other values to be equal, and is used by ==.

#[must_use] fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl<T: Eq, const N: usize> Eq for ArrayVec<T, { N }>

impl<T: Ord, const N: usize> Ord for ArrayVec<T, { N }>

fn cmp(&self, other: &Self) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

🔬 This is a nightly-only experimental API. (clamp)

Restrict a value to a certain interval.

impl<T: PartialOrd, const N: usize> PartialOrd<ArrayVec<T, N>> for ArrayVec<T, { N }>

fn partial_cmp(&self, other: &Self) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

#[must_use] fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator.

#[must_use] fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

#[must_use] fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator.

#[must_use] fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl<T, const N: usize> Deref for ArrayVec<T, { N }>

type Target = [T]

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl<T, const N: usize> DerefMut for ArrayVec<T, { N }>

fn deref_mut(&mut self) -> &mut Self::Target

Mutably dereferences the value.

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

fn drop(&mut self)

Makes sure all items are cleaned up once you're done with the ArrayVec.

Examples

use core::{mem, sync::atomic::{AtomicUsize, Ordering}};
use const_arrayvec::ArrayVec;

// create a dummy type which increments a number when dropped

struct OnDropped<'a>(&'a AtomicUsize);

impl<'a> Drop for OnDropped<'a> {
  fn drop(&mut self) { self.0.fetch_add(1, Ordering::Relaxed); }
}

// create our vector
let mut vector: ArrayVec<OnDropped<'_>, 5> = ArrayVec::new();

// then set up our counter
let counter = AtomicUsize::new(0);

// and add a couple `OnDropped`'s to the vector
vector.push(OnDropped(&counter));
vector.push(OnDropped(&counter));
vector.push(OnDropped(&counter));

// the vector is still live so our counter shouldn't have changed
assert_eq!(counter.load(Ordering::Relaxed), 0);

// explicitly drop the vector
mem::drop(vector);

// and the counter should have updated
assert_eq!(counter.load(Ordering::Relaxed), 3);

impl<Ix, T, const N: usize> Index<Ix> for ArrayVec<T, { N }> where
    [T]: Index<Ix>, 

type Output = <[T] as Index<Ix>>::Output

The returned type after indexing.

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

Performs the indexing (container[index]) operation.

impl<Ix, T, const N: usize> IndexMut<Ix> for ArrayVec<T, { N }> where
    [T]: IndexMut<Ix>, 

fn index_mut(&mut self, ix: Ix) -> &mut Self::Output

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

impl<T: Hash, const N: usize> Hash for ArrayVec<T, { N }>

fn hash<H: Hasher>(&self, hasher: &mut H)

Feeds this value into the given [Hasher].

fn hash_slice<H>(data: &[Self], state: &mut H) where
    H: Hasher, 

Feeds a slice of this type into the given [Hasher].

impl<T, const N: usize> AsRef<[T]> for ArrayVec<T, { N }>

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

Performs the conversion.

impl<T, const N: usize> AsMut<[T]> for ArrayVec<T, { N }>

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

Performs the conversion.

impl<T: Clone, const N: usize> Clone for ArrayVec<T, { N }>

fn clone(&self) -> ArrayVec<T, { N }>

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

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

fn default() -> Self

Returns the "default value" for a type.