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 an 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 reference, which can be either &mut or & as if it is &mut it will implicitly coerce to &. If the slice has a length greater than the StaticVec's declared capacity, any contents after that point are ignored. Locally requires that T implements Copy to avoid soundness issues.

pub fn new_from_array<const N2: usize>(values: [T; N2]) -> Self

Returns a new StaticVec instance filled with the contents, if any, of an array. If the array has a length greater than the StaticVec's declared capacity, any contents after that point are ignored. The N2 parameter does not need to be provided explicitly, and can be inferred from the array itself. This function does not leak memory, as any ignored extra elements in the source array are explicitly dropped with drop_in_place before forget is called on it.

pub fn filled_with<F>(initializer: F) -> Self where
    F: FnMut() -> T, 

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.

Example usage:

let mut i = 0;
let v = StaticVec::<i32, 64>::filled_with(|| { i += 1; i });
assert_eq!(v.len(), 64);
assert_eq!(v[0], 1);
assert_eq!(v[1], 2);
assert_eq!(v[2], 3);
assert_eq!(v[3], 4);

pub fn filled_with_by_index<F>(initializer: F) -> Self where
    F: FnMut(usize) -> T, 

Returns a new StaticVec instance filled with the return value of an initializer function. Unlike for filled_with, the initializer function in this case must take a single usize variable as an input parameter, which will be called with the current index of the 0..N loop that filled_with_by_index is implemented with internally. The length field of the newly created StaticVec will be equal to its capacity.

Example usage:

let v = StaticVec::<usize, 64>::filled_with_by_index(|i| { i + 1 });
assert_eq!(v.len(), 64);
assert_eq!(v[0], 1);
assert_eq!(v[1], 2);
assert_eq!(v[2], 3);
assert_eq!(v[3], 4);

pub const 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, etc. 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 backing array.

pub const fn cap() -> usize

Does the same thing as capacity, but as an associated function rather than a method.

pub const CAPACITY: usize

Serves the same purpose as capacity, but as an associated constant rather than a method.

pub const fn remaining_capacity(&self) -> usize

Returns the remaining capacity of the StaticVec.

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 const fn is_empty(&self) -> bool

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

pub const fn is_not_empty(&self) -> bool

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

pub const fn is_full(&self) -> bool

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

pub const 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 unsafe fn get_unchecked(&self, index: usize) -> &T

Returns a constant reference to the element of the StaticVec at index, if index is within the range 0..length. No checks are performed to ensure that is the case, so this function is marked unsafe and should be used with caution only when performance is absolutely paramount.

Note that, unlike slice::get_unchecked, this method only supports accessing individual elements via usize; it cannot also produce subslices. To unsafely get a subslice without a bounds check, use vec.as_slice().get_unchecked(a..b).

Safety

It is up to the caller to ensure that index is within the appropriate bounds.

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

Returns a mutable reference to the element of the StaticVec at index, if index is within the range 0..length. No checks are performed to ensure that is the case, so this function is marked unsafe and should be used with caution only when performance is absolutely paramount.

The same differences between this method and the slice method of the same name apply as do for get_unchecked.

Safety

It is up to the caller to ensure that index is within the appropriate bounds.

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 try_push(&mut self, value: T) -> Result<(), &'static str>

Pushes value to the StaticVec if its current length is less than its capacity, or returns an error indicating there's no remaining capacity otherwise.

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

Push a value to the end of this StaticVec. Panics if the collection is full; that is, if self.len() == self.capacity().

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 fn first(&self) -> Option<&T>

Returns a constant reference to the first element of the StaticVec in Some if the StaticVec is not empty, or None otherwise.

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

Returns a mutable reference to the first element of the StaticVec in Some if the StaticVec is not empty, or None otherwise.

pub fn last(&self) -> Option<&T>

Returns a constant reference to the last element of the StaticVec in Some if the StaticVec is not empty, or None otherwise.

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

Returns a mutable reference to the last element of the StaticVec in Some if the StaticVec is not empty, or None otherwise.

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 swap_pop(&mut self, index: usize) -> Option<T>

Returns None if index is greater than or equal to the current length of the StaticVec. Otherwise, removes the value at that position and returns it in Some, and then moves the last value in the StaticVec into the empty slot.

pub fn swap_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, and then moves the last value in the StaticVec into the empty slot.

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 positions after index are shifted to the right.

pub fn try_insert(&mut self, index: usize, value: T) -> Result<(), &'static str>

Inserts value at index if the current length of the StaticVec is less than N and index is less than the length, or returns a error stating one of the two is not the case otherwise. Any values that exist in positions after index are shifted to the right.

pub fn clear(&mut self)

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

Important traits for StaticVecIterConst<'a, T>

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

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

Returns a StaticVecIterConst over the StaticVec's inhabited area.

Important traits for StaticVecIterMut<'a, T>

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

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

Returns a StaticVecIterMut over the StaticVec's inhabited area.

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

This is supported on feature="std" only.

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(&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(&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, of a slice (which can also be &mut as it will coerce implicitly to &) to the StaticVec. If the slice has a length greater than the StaticVec's remaining capacity, any contents after that point are ignored. Locally requires that T implements Copy to avoid soundness issues.

pub fn try_extend_from_slice(&mut self, other: &[T]) -> Result<(), &'static str> where
    T: Copy, 

Copies and appends all elements, if any, of a slice to the StaticVec if the StaticVec's remaining capacity is greater than the length of the slice, or returns an error indicating that's not the case otherwise.

pub fn into_vec(&mut self) -> Vec<T>

This is supported on feature="std" only.

Returns a Vec containing the contents of the StaticVec instance. The returned Vec will initially have the same value for len and capacity as the source StaticVec. Note that while using this function does not consume the source StaticVec in the sense of rendering it completely inaccessible / unusable, it does empty it (that is, it will have no contents and a length of 0 afterwards.)

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 drain_filter<F>(&mut self, filter: F) -> Self where
    F: FnMut(&mut T) -> bool, 

Removes all elements in the StaticVec for which filter returns true and returns them in a new one.

pub fn retain<F>(&mut self, filter: F) where
    F: FnMut(&T) -> bool, 

Removes all elements in the StaticVec for which filter returns false.

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

Shortens the StaticVec, keeping the first length elements and dropping the rest. Does nothing if length is greater than or equal to the current length of the StaticVec.

pub fn split_off(&mut self, at: usize) -> Self

Splits the StaticVec into two at the given index. The original StaticVec will contain elements 0..at, and the new one will contain elements at..length.

pub fn dedup_by<F>(&mut self, same_bucket: F) where
    F: FnMut(&mut T, &mut T) -> bool, 

Removes all but the first of consecutive elements in the StaticVec satisfying a given equality relation.

pub fn dedup(&mut self) where
    T: PartialEq, 

Removes consecutive repeated elements in the StaticVec according to the locally required PartialEq trait implementation for T.

pub fn dedup_by_key<F, K>(&mut self, key: F) where
    F: FnMut(&mut T) -> K,
    K: PartialEq<K>, 

Removes all but the first of consecutive elements in the StaticVec that resolve to the same key.

Trait Implementations

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

type Target = [T]

The resulting type after dereferencing.

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

Dereferences the value.

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

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

Mutably dereferences the value.

impl<'_, T: Copy, const N: usize> From<&'_ [T]> for StaticVec<T, { N }>

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

Creates a new StaticVec instance from the contents of values, using new_from_slice internally.

impl<'_, T: Copy, const N: usize> From<&'_ mut [T]> for StaticVec<T, { N }>

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

Creates a new StaticVec instance from the contents of values, using new_from_slice internally.

impl<T, const N1: usize, const N2: usize> From<[T; N1]> for StaticVec<T, { N2 }>

fn from(values: [T; N1]) -> Self

Creates a new StaticVec instance from the contents of values, using new_from_array internally.

impl<'_, T: Copy, const N1: usize, const N2: usize> From<&'_ [T; N1]> for StaticVec<T, { N2 }>

fn from(values: &[T; N1]) -> Self

Creates a new StaticVec instance from the contents of values, using new_from_slice internally.

impl<'_, T: Copy, const N1: usize, const N2: usize> From<&'_ mut [T; N1]> for StaticVec<T, { N2 }>

fn from(values: &mut [T; N1]) -> Self

Creates a new StaticVec instance from the contents of values, using new_from_slice internally.

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

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

Formats the value using the given formatter.

impl<T1, T2: PartialEq<T1>, const N1: usize, const N2: usize> PartialEq<StaticVec<T1, N1>> for StaticVec<T2, { N2 }>

fn eq(&self, other: &StaticVec<T1, { N1 }>) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &StaticVec<T1, { N1 }>) -> bool

This method tests for !=.

impl<'_, T1, T2: PartialEq<T1>, const N1: usize, const N2: usize> PartialEq<StaticVec<T1, N1>> for &'_ StaticVec<T2, { N2 }>

fn eq(&self, other: &StaticVec<T1, { N1 }>) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &StaticVec<T1, { N1 }>) -> bool

This method tests for !=.

impl<'_, T1, T2: PartialEq<T1>, const N1: usize, const N2: usize> PartialEq<StaticVec<T1, N1>> for &'_ mut StaticVec<T2, { N2 }>

fn eq(&self, other: &StaticVec<T1, { N1 }>) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &StaticVec<T1, { N1 }>) -> bool

This method tests for !=.

impl<'_, T1, T2: PartialEq<T1>, const N1: usize, const N2: usize> PartialEq<&'_ StaticVec<T1, N1>> for StaticVec<T2, { N2 }>

fn eq(&self, other: &&StaticVec<T1, { N1 }>) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &&StaticVec<T1, { N1 }>) -> bool

This method tests for !=.

impl<'_, T1, T2: PartialEq<T1>, const N1: usize, const N2: usize> PartialEq<&'_ mut StaticVec<T1, N1>> for StaticVec<T2, { N2 }>

fn eq(&self, other: &&mut StaticVec<T1, { N1 }>) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &&mut StaticVec<T1, { N1 }>) -> bool

This method tests for !=.

impl<T1, T2: PartialEq<T1>, const N1: usize, const N2: usize> PartialEq<[T1; N1]> for StaticVec<T2, { N2 }>

fn eq(&self, other: &[T1; N1]) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &[T1; N1]) -> bool

This method tests for !=.

impl<'_, T1, T2: PartialEq<T1>, const N1: usize, const N2: usize> PartialEq<[T1; N1]> for &'_ StaticVec<T2, { N2 }>

fn eq(&self, other: &[T1; N1]) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &[T1; N1]) -> bool

This method tests for !=.

impl<'_, T1, T2: PartialEq<T1>, const N1: usize, const N2: usize> PartialEq<[T1; N1]> for &'_ mut StaticVec<T2, { N2 }>

fn eq(&self, other: &[T1; N1]) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &[T1; N1]) -> bool

This method tests for !=.

impl<'_, T1, T2: PartialEq<T1>, const N1: usize, const N2: usize> PartialEq<&'_ [T1; N1]> for StaticVec<T2, { N2 }>

fn eq(&self, other: &&[T1; N1]) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &&[T1; N1]) -> bool

This method tests for !=.

impl<'_, T1, T2: PartialEq<T1>, const N1: usize, const N2: usize> PartialEq<&'_ mut [T1; N1]> for StaticVec<T2, { N2 }>

fn eq(&self, other: &&mut [T1; N1]) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &&mut [T1; N1]) -> bool

This method tests for !=.

impl<T1, T2: PartialEq<T1>, const N: usize> PartialEq<[T1]> for StaticVec<T2, { N }>

fn eq(&self, other: &[T1]) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &[T1]) -> bool

This method tests for !=.

impl<'_, T1, T2: PartialEq<T1>, const N: usize> PartialEq<[T1]> for &'_ StaticVec<T2, { N }>

fn eq(&self, other: &[T1]) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &[T1]) -> bool

This method tests for !=.

impl<'_, T1, T2: PartialEq<T1>, const N: usize> PartialEq<[T1]> for &'_ mut StaticVec<T2, { N }>

fn eq(&self, other: &[T1]) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &[T1]) -> bool

This method tests for !=.

impl<'_, T1, T2: PartialEq<T1>, const N: usize> PartialEq<&'_ [T1]> for StaticVec<T2, { N }>

fn eq(&self, other: &&[T1]) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &&[T1]) -> bool

This method tests for !=.

impl<'_, T1, T2: PartialEq<T1>, const N: usize> PartialEq<&'_ mut [T1]> for StaticVec<T2, { N }>

fn eq(&self, other: &&mut [T1]) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &&mut [T1]) -> bool

This method tests for !=.

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

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

fn cmp(&self, other: &Self) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

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

Restrict a value to a certain interval.

impl<T1, T2: PartialOrd<T1>, const N1: usize, const N2: usize> PartialOrd<StaticVec<T1, N1>> for StaticVec<T2, { N2 }>

fn partial_cmp(&self, other: &StaticVec<T1, { N1 }>) -> 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.

impl<'_, T1, T2: PartialOrd<T1>, const N1: usize, const N2: usize> PartialOrd<StaticVec<T1, N1>> for &'_ StaticVec<T2, { N2 }>

fn partial_cmp(&self, other: &StaticVec<T1, { N1 }>) -> 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.

impl<'_, T1, T2: PartialOrd<T1>, const N1: usize, const N2: usize> PartialOrd<StaticVec<T1, N1>> for &'_ mut StaticVec<T2, { N2 }>

fn partial_cmp(&self, other: &StaticVec<T1, { N1 }>) -> 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.

impl<'_, T1, T2: PartialOrd<T1>, const N1: usize, const N2: usize> PartialOrd<&'_ StaticVec<T1, N1>> for StaticVec<T2, { N2 }>

fn partial_cmp(&self, other: &&StaticVec<T1, { N1 }>) -> 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.

impl<'_, T1, T2: PartialOrd<T1>, const N1: usize, const N2: usize> PartialOrd<&'_ mut StaticVec<T1, N1>> for StaticVec<T2, { N2 }>

fn partial_cmp(&self, other: &&mut StaticVec<T1, { N1 }>) -> 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.

impl<T1, T2: PartialOrd<T1>, const N1: usize, const N2: usize> PartialOrd<[T1; N1]> for StaticVec<T2, { N2 }>

fn partial_cmp(&self, other: &[T1; N1]) -> 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.

impl<'_, T1, T2: PartialOrd<T1>, const N1: usize, const N2: usize> PartialOrd<[T1; N1]> for &'_ StaticVec<T2, { N2 }>

fn partial_cmp(&self, other: &[T1; N1]) -> 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.

impl<'_, T1, T2: PartialOrd<T1>, const N1: usize, const N2: usize> PartialOrd<[T1; N1]> for &'_ mut StaticVec<T2, { N2 }>

fn partial_cmp(&self, other: &[T1; N1]) -> 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.

impl<'_, T1, T2: PartialOrd<T1>, const N1: usize, const N2: usize> PartialOrd<&'_ [T1; N1]> for StaticVec<T2, { N2 }>

fn partial_cmp(&self, other: &&[T1; N1]) -> 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.

impl<'_, T1, T2: PartialOrd<T1>, const N1: usize, const N2: usize> PartialOrd<&'_ mut [T1; N1]> for StaticVec<T2, { N2 }>

fn partial_cmp(&self, other: &&mut [T1; N1]) -> 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.

impl<T1, T2: PartialOrd<T1>, const N: usize> PartialOrd<[T1]> for StaticVec<T2, { N }>

fn partial_cmp(&self, other: &[T1]) -> 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.

impl<'_, T1, T2: PartialOrd<T1>, const N: usize> PartialOrd<[T1]> for &'_ StaticVec<T2, { N }>

fn partial_cmp(&self, other: &[T1]) -> 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.

impl<'_, T1, T2: PartialOrd<T1>, const N: usize> PartialOrd<[T1]> for &'_ mut StaticVec<T2, { N }>

fn partial_cmp(&self, other: &[T1]) -> 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.

impl<'_, T1, T2: PartialOrd<T1>, const N: usize> PartialOrd<&'_ [T1]> for StaticVec<T2, { N }>

fn partial_cmp(&self, other: &&[T1]) -> 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.

impl<'_, T1, T2: PartialOrd<T1>, const N: usize> PartialOrd<&'_ mut [T1]> for StaticVec<T2, { N }>

fn partial_cmp(&self, other: &&mut [T1]) -> 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.

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

fn drop(&mut self)

Executes the destructor for this type.

impl<T, I: SliceIndex<[T]>, const N: usize> Index<I> for StaticVec<T, { N }>

type Output = I::Output

The returned type after indexing.

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

Performs the indexing (container[index]) operation.

impl<T, I: SliceIndex<[T]>, const N: usize> IndexMut<I> for StaticVec<T, { N }>

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

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

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

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, 

Feeds a slice of this type into the given [Hasher].

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 iter has a size greater than the StaticVec's capacity, any items after that point are ignored.

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

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

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

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 = &'a T

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 = &'a mut T

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> Extend<T> for StaticVec<T, { N }>

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

Appends all elements, if any, from iter to the StaticVec. If iter has a size greater than the StaticVec's capacity, any items after that point are ignored.

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

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

Appends all elements, if any, from iter to the StaticVec. If iter has a size greater than the StaticVec's capacity, any items after that point are ignored.

impl<T, const N: usize> AsRef<[T]> for StaticVec<T, { N }>

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

Performs the conversion.

impl<T, const N: usize> AsMut<[T]> for StaticVec<T, { N }>

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

Performs the conversion.

impl<'_, T, const N: usize> Into<Vec<T>> for &'_ mut StaticVec<T, { N }>

fn into(self) -> Vec<T>

Functionally equivalent to into_vec.

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

default fn clone(&self) -> Self

Returns a copy of the value.

default fn clone_from(&mut self, rhs: &Self)

Performs copy-assignment from source.

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

fn clone(&self) -> Self

Returns a copy of the value.

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

Performs copy-assignment from source.

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

fn default() -> Self

Calls new.

impl<const N: usize> Read for StaticVec<u8, { N }>

Read from a StaticVec. This implementation reads from the StaticVec by copying bytes into the destination buffers, then shifting the remaining bytes over. This might be inefficient for your needs; consider using Cursor or [T] as Read for more efficient ways to read out of a StaticVec without mutating it.

unsafe fn initializer(&self) -> Initializer

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

Determines if this Reader can work with buffers of uninitialized memory.

fn read(&mut self, buf: &mut [u8]) -> Result<usize>

Pull some bytes from this source into the specified buffer, returning how many bytes were read.

fn read_to_end(&mut self, buf: &mut Vec<u8>) -> Result<usize>

Read all bytes until EOF in this source, placing them into buf.

fn read_to_string(&mut self, buf: &mut String) -> Result<usize>

Read all bytes until EOF in this source, appending them to buf.

fn read_exact(&mut self, buf: &mut [u8]) -> Result<()>

Read the exact number of bytes required to fill buf.

fn read_vectored(&mut self, bufs: &mut [IoSliceMut]) -> Result<usize>

Like read, except that it reads into a slice of buffers.

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

Creates a "by reference" adaptor for this instance of Read.

fn bytes(self) -> Bytes<Self>

Transforms this Read instance to an [Iterator] over its bytes.

fn chain<R>(self, next: R) -> Chain<Self, R> where
    R: Read, 

Creates an adaptor which will chain this stream with another.

fn take(self, limit: u64) -> Take<Self>

Creates an adaptor which will read at most limit bytes from it.

impl<const N: usize> Write for StaticVec<u8, { N }>

fn write(&mut self, buf: &[u8]) -> Result<usize>

Write a buffer into this writer, returning how many bytes were written.

fn write_vectored(&mut self, bufs: &[IoSlice]) -> Result<usize>

Like write, except that it writes from a slice of buffers.

fn write_all(&mut self, buf: &[u8]) -> Result<()>

Attempts to write an entire buffer into this writer.

fn flush(&mut self) -> Result<()>

Flush this output stream, ensuring that all intermediately buffered contents reach their destination.

fn write_fmt(&mut self, fmt: Arguments) -> Result<(), Error>

Writes a formatted string into this writer, returning any error encountered.

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

Creates a "by reference" adaptor for this instance of Write.