Struct 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() -> Self

Initializes all elements with defaults (does not increment length)

Example

use vector_array::vec::VecArray;

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

Use ::new_no_default if type doesn’t implement default

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

pub fn new_no_default() -> Self

Creates a new VecArray. Use ::new if type has default especially if type contains pointers/references (think String, Box, etc)

Example

use vector_array::vec::VecArray;

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

Safety

There may be problems with drops if your type contains references for example. There also 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

Creates a new VecArray. Use when type doesnt implement default and (drop) safety is a problem.

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

Panics

If index is greater than or equal to length or new length is greater than CAP

Example

use vector_array::{vec_arr, VecArray};

let mut vec: VecArray<_, 10> = vec_arr![1, 2, 3];
vec.insert(1, 4);
assert_eq!(vec, vec_arr![1, 4, 2, 3]);
vec.insert(2, 5);
assert_eq!(vec, vec_arr![1, 4, 5, 2, 3]);

Safety

Copied from Vec source code

pub fn swap(&mut self, index1: usize, index2: usize)

Swaps two elements in the vec.

Panics

Panics if one of the indexes are out of bounds.

Examples

use vector_array::{vec_arr, VecArray};

let mut vec: VecArray<_, 10> = vec_arr![0, 1, 2, 3];
vec.swap(2, 3);
assert_eq!(vec, vec_arr![0, 1, 3, 2]);

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

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

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 unsafe fn get_arr(self) -> [T; CAP]

Returns the entire array

Safety

Can point to uninitialized memory, causes a segfault if memory is not properly initialized

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 duplicate of the value.

const 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>

where T: Default,

Does the same as ::new

fn default() -> Self

Returns the “default value” for a type.

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

where T: Default,

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 for VecArray<T, CAP>

where T: PartialEq,

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

Tests for self and other values to be equal, and is used by ==.

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

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