Struct heapless::Vec

pub struct Vec<T, A> where
    A: Unsize<[T]>,  { /* fields omitted */ }

A Vec, vector, backed by a fixed size array

Methods

impl<T, A> Vec<T, A> where
    A: Unsize<[T]>, 

pub const fn new() -> Self

Constructs a new, empty Vec<T> backed by the array A

pub fn capacity(&self) -> usize

Returns the maximum number of elements the vector can hold

pub fn clear(&mut self)

Clears the vector, removing all values.

pub fn extend_from_slice(&mut self, other: &[T]) -> Result<(), BufferFullError> where
    T: Clone, 

Clones and appends all elements in a slice to the Vec.

Iterates over the slice other, clones each element, and then appends it to this Vec. The other vector is traversed in-order.

Examples

use heapless::Vec;

let mut vec = Vec::<u8, [u8; 8]>::new();
vec.push(1).unwrap();
vec.extend_from_slice(&[2, 3, 4]).unwrap();
assert_eq!(*vec, [1, 2, 3, 4]);

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

Removes the last element from a vector and return it, or None if it's empty

pub fn push(&mut self, item: T) -> Result<(), BufferFullError>

Appends an element to the back of the collection

Returns BufferFullError if the vector is full

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

Shortens the vector, keeping the first len elements and dropping the rest.

pub fn resize(
    &mut self,
    new_len: usize,
    value: T
) -> Result<(), BufferFullError> where
    T: Clone, 

Resizes the Vec in-place so that len is equal to new_len.

If new_len is greater than len, the Vec is extended by the difference, with each additional slot filled with value. If new_len is less than len, the Vec is simply truncated.

See also [resize_default].

pub fn resize_default(&mut self, new_len: usize) -> Result<(), BufferFullError> where
    T: Clone + Default, 

Resizes the Vec in-place so that len is equal to new_len.

If new_len is greater than len, the Vec is extended by the difference, with each additional slot filled with Default::default(). If new_len is less than len, the Vec is simply truncated.

See also [resize].

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

Removes an element from the vector and returns it.

The removed element is replaced by the last element of the vector.

This does not preserve ordering, but is O(1).

Panics

Panics if index is out of bounds.

Examples

use heapless::Vec;

let mut v: Vec<_, [_; 8]> = Vec::new();
v.push("foo").unwrap();
v.push("bar").unwrap();
v.push("baz").unwrap();
v.push("qux").unwrap();

assert_eq!(v.swap_remove(1), "bar");
assert_eq!(&*v, ["foo", "qux", "baz"]);

assert_eq!(v.swap_remove(0), "foo");
assert_eq!(&*v, ["baz", "qux"]);

Trait Implementations

impl<T, A> Debug for Vec<T, A> where
    A: Unsize<[T]>,
    T: Debug, 

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

Formats the value using the given formatter.

impl<T, A> Drop for Vec<T, A> where
    A: Unsize<[T]>, 

fn drop(&mut self)

Executes the destructor for this type.

impl<'a, T, A> IntoIterator for &'a Vec<T, A> where
    A: Unsize<[T]>, 

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) -> Self::IntoIter

Creates an iterator from a value.

impl<'a, T, A> IntoIterator for &'a mut Vec<T, A> where
    A: Unsize<[T]>, 

type Item = &'a mut T

The type of the elements being iterated over.

type IntoIter = IterMut<'a, T>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<T, A, B> PartialEq<Vec<T, B>> for Vec<T, A> where
    A: Unsize<[T]>,
    B: Unsize<[T]>,
    T: PartialEq, 

fn eq(&self, rhs: &Vec<T, B>) -> 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 !=.

impl<T, A> Eq for Vec<T, A> where
    A: Unsize<[T]>,
    T: Eq, 

impl<T, A> Deref for Vec<T, A> where
    A: Unsize<[T]>, 

type Target = [T]

The resulting type after dereferencing.

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

Dereferences the value.

impl<T, A> DerefMut for Vec<T, A> where
    A: Unsize<[T]>, 

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

Mutably dereferences the value.

impl<T, A> AsRef<Vec<T, A>> for Vec<T, A> where
    A: Unsize<[T]>, 

fn as_ref(&self) -> &Vec<T, A>

Performs the conversion.

impl<T, A> AsMut<Vec<T, A>> for Vec<T, A> where
    A: Unsize<[T]>, 

fn as_mut(&mut self) -> &mut Vec<T, A>

Performs the conversion.

impl<T, A> AsRef<[T]> for Vec<T, A> where
    A: Unsize<[T]>, 

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

Performs the conversion.

impl<T, A> AsMut<[T]> for Vec<T, A> where
    A: Unsize<[T]>, 

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

Performs the conversion.