Struct ConstVec

pub struct ConstVec<T> { /* private fields */ }

Implementations

impl<T, const N: usize> ConstVec<[T; N]>

pub const EMPTY: ConstVec<[T; N]> = _

impl<T, const N: usize> ConstVec<[T; N]>

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

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

pub const fn new(len: usize, arr: [T; N]) -> Self

pub const fn len(&self) -> usize

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

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

where [(); { _ }]:,

pub const fn append<const N2: usize>(&mut self, target: &ConstVec<[T; N2]>)

where [(); { _ }]:,

pub const fn clone(&self) -> Self

where [(); { _ }]:,

pub const fn pop_last(&mut self) -> &T

pub const fn cutoff_front_at(&self, mid: usize) -> Self

where [(); { _ }]:,

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

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

pub const unsafe fn set_with_no_drop_on_swap(&mut self, index: usize, value: &T)

where [(); { _ }]:,

pub const fn append_slice(&mut self, slice: &[T])

where [(); { _ }]:,

Trait Implementations

impl<T: Sized + Copy, const N1: usize, const N2: usize> Add<&ConstVec<[T; N2]>> for &ConstVec<[T; N1]>

where [(); { _ }]:,

type Output = ConstVec<[T; { _ }]>

The resulting type after applying the + operator.

const fn add(self, rhs: &ConstVec<[T; N2]>) -> Self::Output

Performs the + operation.

impl<T: Clone> Clone for ConstVec<T>

fn clone(&self) -> Self

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T: ConstEq, const N: usize> ConstEq for ConstVec<[T; N]>

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

impl<T: Debug, const N: usize> Debug for ConstVec<[T; N]>

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

Formats the value using the given formatter.

impl<T: PartialEq, const N: usize> PartialEq for ConstVec<[T; N]>

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> Copy for ConstVec<T>

impl<T: Eq, const N: usize> Eq for ConstVec<[T; N]>