Struct ConstVec

pub struct ConstVec<T, const MAX_SIZE: usize = DEFAULT_MAX_SIZE> { /* private fields */ }

ConstVec is a version of Vec that is usable in const contexts. It has a fixed maximum size, but it can can grow and shrink within that size limit as needed.

Example

const EMPTY: ConstVec<u8> = ConstVec::new();
// Methods that mutate the vector will return a new vector
const ONE: ConstVec<u8> = EMPTY.push(1);
const TWO: ConstVec<u8> = ONE.push(2);
const THREE: ConstVec<u8> = TWO.push(3);
const FOUR: ConstVec<u8> = THREE.push(4);
// If a value is also returned, that will be placed in a tuple in the return value
// along with the new vector
const POPPED: (ConstVec<u8>, Option<u8>) = FOUR.pop();
assert_eq!(POPPED.0, THREE);
assert_eq!(POPPED.1.unwrap(), 4);

Implementations

impl<T> ConstVec<T>

pub const fn new() -> Self

Create a new empty ConstVec

impl<T, const MAX_SIZE: usize> ConstVec<T, MAX_SIZE>

pub const fn new_with_max_size() -> Self

Create a new empty ConstVec with a custom maximum size

Example

const EMPTY: ConstVec<u8, 10> = ConstVec::new_with_max_size();

pub const fn push(self, value: T) -> Self

Push a value onto the end of the ConstVec

Example

const EMPTY: ConstVec<u8> = ConstVec::new();
const ONE: ConstVec<u8> = EMPTY.push(1);
assert_eq!(ONE.as_ref(), &[1]);

pub const fn extend(self, other: &[T]) -> Self

where T: Copy,

Extend the ConstVec with the contents of a slice

Example

const EMPTY: ConstVec<u8> = ConstVec::new();
const ONE: ConstVec<u8> = EMPTY.extend(&[1, 2, 3]);
assert_eq!(ONE.as_ref(), &[1, 2, 3]);

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

Get a reference to the value at the given index

Example

const EMPTY: ConstVec<u8> = ConstVec::new();
const ONE: ConstVec<u8> = EMPTY.push(1);
assert_eq!(ONE.get(0), Some(&1));

pub const fn len(&self) -> usize

Get the length of the ConstVec

Example

const EMPTY: ConstVec<u8> = ConstVec::new();
const ONE: ConstVec<u8> = EMPTY.push(1);
assert_eq!(ONE.len(), 1);

pub const fn is_empty(&self) -> bool

Check if the ConstVec is empty

Example

const EMPTY: ConstVec<u8> = ConstVec::new();
assert!(EMPTY.is_empty());
const ONE: ConstVec<u8> = EMPTY.push(1);
assert!(!ONE.is_empty());

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

Get a reference to the underlying slice

Example

const EMPTY: ConstVec<u8> = ConstVec::new();
const ONE: ConstVec<u8> = EMPTY.push(1);
assert_eq!(ONE.as_ref(), &[1]);

pub const fn swap(self, first: usize, second: usize) -> Self

where T: Copy,

Swap the values at the given indices

Example

const EMPTY: ConstVec<u8> = ConstVec::new();
const ONE: ConstVec<u8> = EMPTY.push(1);
const TWO: ConstVec<u8> = ONE.push(2);
const THREE: ConstVec<u8> = TWO.swap(0, 1);
assert_eq!(THREE.as_ref(), &[2, 1]);

pub const fn pop(self) -> (Self, Option<T>)

where T: Copy,

Pop a value off the end of the ConstVec

Example

const EMPTY: ConstVec<u8> = ConstVec::new();
const ONE: ConstVec<u8> = EMPTY.push(1);
const TWO: ConstVec<u8> = ONE.push(2);
const THREE: ConstVec<u8> = TWO.push(3);
const POPPED: (ConstVec<u8>, Option<u8>) = THREE.pop();
assert_eq!(POPPED.0, TWO);
assert_eq!(POPPED.1.unwrap(), 3);

pub const fn remove(self, index: usize) -> (Self, Option<T>)

where T: Copy,

Remove the value at the given index

Example

const EMPTY: ConstVec<u8> = ConstVec::new();
const ONE: ConstVec<u8> = EMPTY.push(1);
const TWO: ConstVec<u8> = ONE.push(2);
const THREE: ConstVec<u8> = TWO.push(3);
const REMOVED: (ConstVec<u8>, Option<u8>) = THREE.remove(1);
assert_eq!(REMOVED.0.as_ref(), &[1, 3]);
assert_eq!(REMOVED.1.unwrap(), 2);

pub const fn set(self, index: usize, value: T) -> Self

Set the value at the given index

Example

const EMPTY: ConstVec<u8> = ConstVec::new();
const ONE: ConstVec<u8> = EMPTY.push(1);
const TWO: ConstVec<u8> = ONE.set(0, 2);
assert_eq!(TWO.as_ref(), &[2]);

pub const fn split_at(&self, index: usize) -> (Self, Self)

where T: Copy,

Split the ConstVec into two at the given index

Example

const EMPTY: ConstVec<u8> = ConstVec::new();
const ONE: ConstVec<u8> = EMPTY.push(1);
const TWO: ConstVec<u8> = ONE.push(2);
const THREE: ConstVec<u8> = TWO.push(3);
const SPLIT: (ConstVec<u8>, ConstVec<u8>) = THREE.split_at(1);
assert_eq!(SPLIT.0.as_ref(), &[1]);
assert_eq!(SPLIT.1.as_ref(), &[2, 3]);

impl<const MAX_SIZE: usize> ConstVec<u8, MAX_SIZE>

pub const fn read(&self) -> ConstReadBuffer<'_>

Convert the ConstVec into a ConstReadBuffer

Example

const EMPTY: ConstVec<u8> = ConstVec::new();
const ONE: ConstVec<u8> = EMPTY.push(1);
const TWO: ConstVec<u8> = ONE.push(2);
const READ: ConstReadBuffer = TWO.read();

Trait Implementations

impl<T: Clone, const MAX_SIZE: usize> Clone for ConstVec<T, MAX_SIZE>

fn clone(&self) -> Self

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T: Debug, const MAX_SIZE: usize> Debug for ConstVec<T, MAX_SIZE>

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

Formats the value using the given formatter.

impl<T, const MAX_SIZE: usize> Default for ConstVec<T, MAX_SIZE>

fn default() -> Self

Returns the “default value” for a type.

impl<T: Hash, const MAX_SIZE: usize> Hash for ConstVec<T, MAX_SIZE>

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

Feeds this value into the given Hasher.

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

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<T: PartialEq, const MAX_SIZE: usize> PartialEq for ConstVec<T, MAX_SIZE>

fn eq(&self, other: &Self) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<T: Copy, const MAX_SIZE: usize> Copy for ConstVec<T, MAX_SIZE>