Struct staticvec::StaticVec

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

A Vec-like struct (directly API-compatible where it can be at least as far as function signatures go) implemented with const generics around a static array of fixed N capacity.

Methods

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

pub fn new() -> Self

Returns a new StaticVec instance.

pub fn len(&self) -> usize

Returns the current length of the StaticVec. Just as for a normal Vec, this means the number of elements that have been added to it with push, insert, e.t.c.

pub const fn capacity(&self) -> usize

Returns the total capacity of the StaticVec. This is always equivalent to the generic N parameter it was declared with, which determines the fixed size of the static backing array.

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

Directly sets the length field of the StaticVec to new_len. Useful if you intend to write to it solely element-wise, but marked unsafe due to how it creates the potential for reading from unitialized memory later on.

pub fn is_empty(&self) -> bool

Returns true if the current length of the StaticVec is 0.

pub fn is_not_empty(&self) -> bool

Returns true if the current length of the StaticVec is greater than 0.

pub fn is_full(&self) -> bool

Returns true if the current length of the StaticVec is equal to its capacity.

pub fn is_not_full(&self) -> bool

Returns true if the current length of the StaticVec is less than its capacity.

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

Returns a constant pointer to the first element of the StaticVec's internal array.

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

Returns a mutable pointer to the first element of the StaticVec's internal array.

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

Returns a constant reference to a slice of the StaticVec's inhabited area.

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

Returns a mutable reference to a slice of the StaticVec's inhabited area.

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

Asserts that the current length of the StaticVec is less than N, and if so appends a value to the end of it.

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

Removes the value at the last position of the StaticVec and returns it in Some if the StaticVec has a current length greater than 0, and returns None otherwise.

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

Appends a value to the end of the StaticVec without asserting that its current length is less than N.

pub unsafe fn pop_unchecked(&mut self) -> T

Pops a value from the end of the StaticVec and returns it directly without asserting that the StaticVec's current length is greater than 0.

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

Asserts that index is less than the current length of the StaticVec, and if so removes the value at that position and returns it. Any values that exist in later positions are shifted to the left.

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

Asserts that the current length of the StaticVec is less than N and that index is less than the length, and if so inserts value at that position. Any values that exist in later positions are shifted to the right.

pub fn clear(&mut self)

Removes all contents from the StaticVec and sets its length back to 0.

pub fn sort(&mut self) where
    T: Ord, 

Performs an unstable in-place sort of the StaticVec's inhabited area.

pub fn reverse(&mut self)

Reverses the contents of the StaticVec's inhabited area in-place.

pub fn sorted(&mut self) -> Self where
    T: Copy + Ord, 

Returns a separate, sorted StaticVec of the contents of the StaticVec's inhabited area without modifying the original data.

pub fn reversed(&mut self) -> Self where
    T: Copy, 

Returns a separate, reversed StaticVec of the contents of the StaticVec's inhabited area without modifying the original data.

pub fn extend_from_slice(&mut self, other: &[T]) where
    T: Copy, 

Copies and appends all elements in a slice to the StaticVec. Unlike the implementation of this function for Vec, no iterator is used, just a single pointer-copy call.

pub fn drain<R>(&mut self, range: R) -> Self where
    R: RangeBounds<usize>, 

Removes the specified range of elements from the StaticVec and returns them in a new one.

Important traits for StaticVecIteratorConst<'a, T>

impl<'a, T: 'a> Iterator for StaticVecIteratorConst<'a, T> type Item = &'a T;

pub fn iter<'a>(&'a self) -> StaticVecIteratorConst<'a, T>

Returns a StaticVecIteratorConst over the StaticVec's inhabited area.

Important traits for StaticVecIteratorMut<'a, T>

impl<'a, T: 'a> Iterator for StaticVecIteratorMut<'a, T> type Item = &'a mut T;

pub fn iter_mut<'a>(&'a mut self) -> StaticVecIteratorMut<'a, T>

Returns a StaticVecIteratorMut over the StaticVec's inhabited area.

Trait Implementations

impl<'a, T: 'a, const N: usize> IntoIterator for &'a StaticVec<T, { N }>

type IntoIter = StaticVecIteratorConst<'a, T>

Which kind of iterator are we turning this into?

type Item = <Self::IntoIter as Iterator>::Item

The type of the elements being iterated over.

fn into_iter(self) -> Self::IntoIter

Returns a StaticVecIteratorConst over the StaticVec's inhabited area.

impl<'a, T: 'a, const N: usize> IntoIterator for &'a mut StaticVec<T, { N }>

type IntoIter = StaticVecIteratorMut<'a, T>

Which kind of iterator are we turning this into?

type Item = <Self::IntoIter as Iterator>::Item

The type of the elements being iterated over.

fn into_iter(self) -> Self::IntoIter

Returns a `StaticVecIteratorMut`` over the StaticVec's inhabited area.

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

fn drop(&mut self)

Calls clear through the StaticVec before dropping it.

impl<T, const N: usize> Index<usize> for StaticVec<T, { N }>

type Output = T

The returned type after indexing.

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

Asserts that index is less than the current length of the StaticVec, as if so returns the value at that position as a constant reference.

impl<T, const N: usize> IndexMut<usize> for StaticVec<T, { N }>

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

Asserts that index is less than the current length of the StaticVec, as if so returns the value at that position as a mutable reference.

impl<T, const N: usize> FromIterator<T> for StaticVec<T, { N }>

fn from_iter<I: IntoIterator<Item = T>>(iter: I) -> Self

Attempts to create a new StaticVec instance of the specified capacity from iter. If it has a size greater than N, any contents after that point are ignored.