Struct max_size_vec::MaxSizeVec

pub struct MaxSizeVec<T, const SIZE: usize> { /* fields omitted */ }

This type of vector is called a max-sized vector, and reserves a fixed amount of space at its creation. Once created, there are no elements, but the amount of elements can increase until the buffer is full. When the buffer is full, and another element is attempted to be added, a panic happens describing the error. This vector has the vast majority of vector methods and traits that aren't allocation specfic (e.g. reserve isn't a method).

Implementations

impl<T, const SIZE: usize> MaxSizeVec<T, {SIZE}>

pub fn new() -> MaxSizeVec<T, {SIZE}>

Creates a new, empty max-size vector.

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

Pushes an element to the max-size vector.

pub fn pop(&mut self)

Pops off an element from the max-size vector.

pub fn len(&self) -> usize

Gets the length of the max-size vector.

pub fn drain<'a, R: RangeBounds<usize>>(
    &'a mut self,
    range: R
) -> Drain<'a, T, {SIZE}>

Drains elements from the vector based on a range.

pub fn append<const OTHER_SIZE: usize>(
    &mut self,
    other: &mut MaxSizeVec<T, {OTHER_SIZE}>
)

Appends a max-size vector onto this one, making the other one empty.

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

Gets a mutable pointer to the base of this vector.

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

Gets a mutable slice that can be used to edit or read the elements of this vector.

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

This gets a pointer to the base of this vector.

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

Gets an immutable slice that can be used to read the elements of this vector

pub fn capacity(&self) -> usize

The capacity of this vector, i.e. the maximum number of elements that it can hold.

pub fn clear(&mut self)

This clears the vector.

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

This inserts an element at an index in the vector,

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

This truncates a vector to a certain length.

pub fn resize_with(&mut self, size: usize, f: impl FnMut() -> T)

This resizes a vector with one condition: if the size is larger than the vectors size, a closure passed will be called to fill in the missing parts.

pub fn retain(&mut self, predicate: impl FnMut(&T) -> bool)

This removes all elements that don't fit a predicate, leaving the ones that fit it.

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

This removes an element from a vector at a certain index, while preserving order.

pub fn swap_remove(&mut self, index: usize)

This swaps an element at an index with the last element and pops the vector, which messes up order, but successfully removes an element from the vector.

pub fn is_empty(&self) -> bool

This checks to see whether or not the vector is empty.

impl<T: Clone, const SIZE: usize> MaxSizeVec<T, {SIZE}>

pub fn resize(&mut self, size: usize, value: T)

This resizes a vector with a value to fill in missing parts if the size is larger than the current size.

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

This extends a vector from a slice.

Trait Implementations

impl<T, const SIZE: usize> AsMut<[T]> for MaxSizeVec<T, {SIZE}>

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

Performs the conversion.

impl<T, const SIZE: usize> AsMut<MaxSizeVec<T, SIZE>> for MaxSizeVec<T, {SIZE}>

fn as_mut(&mut self) -> &mut Self

Performs the conversion.

impl<T, const SIZE: usize> AsRef<[T]> for MaxSizeVec<T, {SIZE}>

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

Performs the conversion.

impl<T, const SIZE: usize> AsRef<MaxSizeVec<T, SIZE>> for MaxSizeVec<T, {SIZE}>

fn as_ref(&self) -> &Self

Performs the conversion.

impl<T, const SIZE: usize> Borrow<[T]> for MaxSizeVec<T, {SIZE}>

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

Immutably borrows from an owned value.

impl<T, const SIZE: usize> BorrowMut<[T]> for MaxSizeVec<T, {SIZE}>

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

Mutably borrows from an owned value.

impl<T: Clone, const SIZE: usize> Clone for MaxSizeVec<T, {SIZE}>

fn clone(&self) -> MaxSizeVec<T, {SIZE}>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T: Debug, const SIZE: usize> Debug for MaxSizeVec<T, {SIZE}>

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

Formats the value using the given formatter.

impl<T, const SIZE: usize> Deref for MaxSizeVec<T, {SIZE}>

type Target = [T]

The resulting type after dereferencing.

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

Dereferences the value.

impl<T, const SIZE: usize> DerefMut for MaxSizeVec<T, {SIZE}>

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

Mutably dereferences the value.

impl<T, const SIZE: usize> Drop for MaxSizeVec<T, {SIZE}>

fn drop(&mut self)

Executes the destructor for this type.

impl<T: Eq, const SIZE: usize> Eq for MaxSizeVec<T, {SIZE}>

impl<'a, T: 'a + Copy, const SIZE: usize> Extend<&'a T> for MaxSizeVec<T, {SIZE}>

fn extend<I: IntoIterator<Item = &'a T>>(&mut self, iter: I)

Extends a collection with the contents of an iterator.

fn extend_one(&mut self, item: A)

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

Extends a collection with exactly one element.

fn extend_reserve(&mut self, additional: usize)

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

Reserves capacity in a collection for the given number of additional elements.

impl<T, const SIZE: usize> Extend<T> for MaxSizeVec<T, {SIZE}>

fn extend<I: IntoIterator<Item = T>>(&mut self, iter: I)

Extends a collection with the contents of an iterator.

fn extend_one(&mut self, item: A)

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

Extends a collection with exactly one element.

fn extend_reserve(&mut self, additional: usize)

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

Reserves capacity in a collection for the given number of additional elements.

impl<'a, T: Clone, const SIZE: usize> From<&'a [T]> for MaxSizeVec<T, {SIZE}>

fn from(x: &[T]) -> Self

Performs the conversion.

impl<'a, T: Clone, const SIZE: usize> From<&'a mut [T]> for MaxSizeVec<T, {SIZE}>

fn from(x: &mut [T]) -> Self

Performs the conversion.

impl<'a, const SIZE: usize> From<&'a str> for MaxSizeVec<u8, {SIZE}>

fn from(x: &str) -> Self

Performs the conversion.

impl<T, const SIZE: usize> FromIterator<T> for MaxSizeVec<T, {SIZE}>

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

Creates a value from an iterator.

impl<T, const SIZE: usize> Index<usize> for MaxSizeVec<T, {SIZE}>

type Output = T

The returned type after indexing.

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

Performs the indexing (container[index]) operation.

impl<T, const SIZE: usize> IndexMut<usize> for MaxSizeVec<T, {SIZE}>

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

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

impl<T, const SIZE: usize> IntoIterator for MaxSizeVec<T, {SIZE}>

type Item = T

The type of the elements being iterated over.

type IntoIter = MaxSizeVecIter<T, {SIZE}>

Which kind of iterator are we turning this into?

fn into_iter(self) -> MaxSizeVecIter<T, {SIZE}>

Creates an iterator from a value.

impl<'a, T, const SIZE: usize> IntoIterator for &'a MaxSizeVec<T, {SIZE}>

type Item = &'a T

The type of the elements being iterated over.

type IntoIter = Iter<'a, T>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Iter<'a, T>

Creates an iterator from a value.

impl<T: Ord, const SIZE: usize> Ord for MaxSizeVec<T, {SIZE}>

fn cmp(&self, other: &MaxSizeVec<T, {SIZE}>) -> Ordering

This method returns an Ordering between self and other.

#[must_use]fn max(self, other: Self) -> Self

Compares and returns the maximum of two values.

#[must_use]fn min(self, other: Self) -> Self

Compares and returns the minimum of two values.

#[must_use]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: PartialEq, const SIZE: usize, const OTHER: usize, '_> PartialEq<&'_ [T; OTHER]> for MaxSizeVec<T, {SIZE}>

fn eq(&self, other: &&[T; OTHER]) -> 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 SIZE: usize, '_> PartialEq<&'_ [T]> for MaxSizeVec<T, {SIZE}>

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: PartialEq, const SIZE: usize, const OTHER: usize> PartialEq<[T; OTHER]> for MaxSizeVec<T, {SIZE}>

fn eq(&self, other: &[T; OTHER]) -> 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 SIZE: usize, const OTHER: usize> PartialEq<MaxSizeVec<T, OTHER>> for MaxSizeVec<T, {SIZE}>

fn eq(&self, other: &MaxSizeVec<T, {OTHER}>) -> 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: PartialOrd, const SIZE: usize> PartialOrd<MaxSizeVec<T, SIZE>> for MaxSizeVec<T, {SIZE}>

fn partial_cmp(&self, other: &MaxSizeVec<T, {SIZE}>) -> 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.