Struct vector_array::vec::VecArray

pub struct VecArray<T, const CAP: usize> { /* private fields */ }

A Vec but entirely on the stack.

Example:

use vector_array::vec::VecArray;

let mut vec: VecArray<_, 10> = VecArray::new();
vec.push(9).unwrap();
assert_eq!(vec[0], 9);

Implementations

impl<T, const CAP: usize> VecArray<T, CAP>where T: Default,

pub fn new_default() -> Self

Initializes all elements with defaults (does not increment length, so is pretty useless)

Example:

use vector_array::vec::VecArray;

let mut vec: VecArray<_, 10> = VecArray::new_default();
vec.push(9).unwrap();
assert_eq!(vec[0], 9);

impl<T, const CAP: usize> VecArray<T, CAP>

pub fn new() -> Self

Creates a new VecArray.

Example:

use vector_array::vec::VecArray;

let mut vec: VecArray<_, 10> = VecArray::new();
vec.push(9).unwrap();
assert_eq!(vec[0], 9);

Safety:

There may be problems if you try to index in to parts of the array which are no yet initialized but this is nearly impossible.

pub fn new_arr(arr: [T; CAP], len: usize) -> Self

pub fn push(&mut self, value: T) -> Result<(), ArrTooSmall>

Pushes an element.

Example:

use vector_array::vec::VecArray;

let mut vec: VecArray<_, 10> = VecArray::new();
vec.push(9).unwrap();
assert_eq!(vec[0], 9);

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

Removes the last element

Example:

use vector_array::vec::VecArray;

let mut vec: VecArray<_, 10> = VecArray::new();
vec.push(9).unwrap();
assert_eq!(vec.pop(), Some(9));

Safety:

Returns memory which will realistically wont be used anymore

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

Removes an element.

Panics:

If index is greater than or equal to length

Example:

use vector_array::vec::VecArray;
let mut vec: VecArray<_, 10> = VecArray::new();
vec.push(9).unwrap();
vec.remove(0);
assert!(vec.is_empty());

Safety:

Copied from Vec source code

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

pub fn set(&mut self, index: usize, value: T) -> Result<(), ArrTooSmall>

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

pub fn iter(&self) -> Iter<'_, T>

pub fn iter_mut(&mut self) -> IterMut<'_, T>

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

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

pub fn get_arr(self) -> [T; CAP]

pub fn len(&self) -> usize

pub fn is_empty(&self) -> bool

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

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

pub fn clear(&mut self)

pub fn capacity(&self) -> usize

Trait Implementations

impl<T: Clone, const CAP: usize> Clone for VecArray<T, CAP>

fn clone(&self) -> VecArray<T, CAP>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T, const CAP: usize> Debug for VecArray<T, CAP>where T: Debug,

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

Formats the value using the given formatter.

impl<T, const CAP: usize> Default for VecArray<T, CAP>

Does the same as ::new

fn default() -> Self

Returns the “default value” for a type.

impl<T, const CAP: usize> From<Vec<T, Global>> for VecArray<T, CAP>

fn from(value: Vec<T>) -> Self

Panics:

If inputs length is greater than CAP

impl<T, const CAP: usize> From<VecArray<T, CAP>> for Vec<T>

fn from(val: VecArray<T, CAP>) -> Self

Converts to this type from the input type.

impl<T, const CAP: usize> Index<usize> for VecArray<T, CAP>

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

Panics:

If index is greater than or equal to length

Use .get instead

type Output = T

The returned type after indexing.

impl<T, const CAP: usize> IndexMut<usize> for VecArray<T, CAP>

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

Panics:

If index is greater than or equal to length

Use .set instead

impl<T, const CAP: usize> IntoIterator for VecArray<T, CAP>

type Item = T

The type of the elements being iterated over.

type IntoIter = IntoIter<<VecArray<T, CAP> as IntoIterator>::Item, CAP>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<T, const CAP: usize> PartialEq<VecArray<T, CAP>> for VecArray<T, CAP>where T: PartialEq,

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

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

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.