Struct staticvec::StaticVec

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

A Vec-like struct (mostly directly API-compatible where it can be) 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 new_from_slice(values: &[T]) -> Self where
    T: Copy, 

Returns a new StaticVec instance filled with the contents, if any, of a slice. If the slice has a length greater than the StaticVec's capacity, any contents after that point are ignored. Locally requires that T implements Copy to avoid soundness issues.

pub fn filled_with(initializer: fn() -> T) -> Self

Returns a new StaticVec instance filled with the return value of an initializer function. The length field of the newly created StaticVec will be equal to its capacity.

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. except in the case that it has been set directly with the unsafe set_len function.

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 remove_item(&mut self, item: &T) -> Option<T> where
    T: PartialEq, 

Removes the first instance of item from the StaticVec if the item exists.

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 stable in-place sort of the StaticVec's inhabited area. Locally requires that T implements Ord to make the sorting possible.

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

Performs an unstable in-place sort of the StaticVec's inhabited area. Locally requires that T implements Ord to make the sorting possible.

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, stable-sorted StaticVec of the contents of the StaticVec's inhabited area without modifying the original data. Locally requires that T implements Copy to avoid soundness issues, and Ord to make the sorting possible.

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

Returns a separate, unstable-sorted StaticVec of the contents of the StaticVec's inhabited area without modifying the original data. Locally requires that T implements Copy to avoid soundness issues, and Ord to make the sorting possible.

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. Locally requires that T implements Copy to avoid soundness issues.

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

Copies and appends all elements, if any, in a slice to the StaticVec. Unlike the implementation of this function for Vec, no iterator is used, just a single pointer-copy call. Locally requires that T implements Copy to avoid soundness issues.

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.

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

Returns a StaticVecIterConst over the StaticVec's inhabited area.

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

Returns a StaticVecIterMut over the StaticVec's inhabited area.

Trait Implementations

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<'a, T: 'a, const N: usize> IntoIterator for &'a StaticVec<T, { N }>

type IntoIter = StaticVecIterConst<'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 StaticVecIterConst over the StaticVec's inhabited area.

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

type IntoIter = StaticVecIterMut<'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 StaticVecIterMut over the StaticVec's inhabited area.

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

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

Creates a new StaticVec instance from the elements, if any, of iter. If it has a size greater than the StaticVec's capacity, any items after that point are ignored.

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

fn default() -> Self

Calls new.