Struct stackvector::StackVec

pub struct StackVec<A: Array> {
    pub length: usize,
    pub data: ManuallyDrop<A>,
}

A Vec-like container that stores elements on the stack.

The amount of data that a StackVec can store inline depends on its backing store. The backing store can be any type that implements the Array trait; usually it is a small fixed-sized array. For example a StackVec<[u64; 8]> can hold up to eight 64-bit integers inline.

Example

use stackvector::StackVec;
let mut v = StackVec::<[u8; 4]>::new(); // initialize an empty vector

// The vector can hold up to 4 items without spilling onto the heap.
v.extend(0..4);
assert_eq!(v.len(), 4);

// Pushing another element will force the buffer to spill and panic:
v.push(4);

Fields

length: usize

data: ManuallyDrop<A>

Methods

impl<A: Array> StackVec<A>

Important traits for StackVec<A>

impl<A: Array<Item = u8>> Write for StackVec<A>

pub fn new() -> StackVec<A>

Construct an empty vector

Important traits for StackVec<A>

impl<A: Array<Item = u8>> Write for StackVec<A>

pub fn from_vec(vec: Vec<A::Item>) -> StackVec<A>

Construct a new StackVec from a Vec<A::Item>.

Elements will be copied to the inline buffer if vec.len() <= A::size().

use stackvector::StackVec;

let vec = vec![1, 2, 3, 4, 5];
let stack_vec: StackVec<[_; 5]> = StackVec::from_vec(vec);

assert_eq!(&*stack_vec, &[1, 2, 3, 4, 5]);

Important traits for StackVec<A>

impl<A: Array<Item = u8>> Write for StackVec<A>

pub unsafe fn from_vec_unchecked(vec: Vec<A::Item>) -> StackVec<A>

Construct a new StackVec from a Vec<A::Item> without bounds checking.

Important traits for StackVec<A>

impl<A: Array<Item = u8>> Write for StackVec<A>

pub fn from_buf(buf: A) -> StackVec<A>

Constructs a new StackVec on the stack from an A without copying elements.

use stackvector::StackVec;

let buf = [1, 2, 3, 4, 5];
let stack_vec: StackVec<_> = StackVec::from_buf(buf);

assert_eq!(&*stack_vec, &[1, 2, 3, 4, 5]);

Important traits for StackVec<A>

impl<A: Array<Item = u8>> Write for StackVec<A>

pub fn from_buf_and_len(buf: A, len: usize) -> StackVec<A>

Constructs a new StackVec on the stack from an A without copying elements. Also sets the length, which must be less or equal to the size of buf.

use stackvector::StackVec;

let buf = [1, 2, 3, 4, 5, 0, 0, 0];
let stack_vec: StackVec<_> = StackVec::from_buf_and_len(buf, 5);

assert_eq!(&*stack_vec, &[1, 2, 3, 4, 5]);

Important traits for StackVec<A>

impl<A: Array<Item = u8>> Write for StackVec<A>

pub unsafe fn from_buf_and_len_unchecked(buf: A, len: usize) -> StackVec<A>

Constructs a new StackVec on the stack from an A without copying elements. Also sets the length. The user is responsible for ensuring that len <= A::size().

use stackvector::StackVec;

let buf = [1, 2, 3, 4, 5, 0, 0, 0];
let stack_vec: StackVec<_> = unsafe {
    StackVec::from_buf_and_len_unchecked(buf, 5)
};

assert_eq!(&*stack_vec, &[1, 2, 3, 4, 5]);

pub unsafe fn set_len(&mut self, new_len: usize)

Sets the length of a vector.

This will explicitly set the size of the vector, without actually modifying its buffers, so it is up to the caller to ensure that the vector is actually the specified size.

pub fn len(&self) -> usize

The number of elements stored in the vector.

pub fn is_empty(&self) -> bool

If the vector is empty.

pub fn capacity(&self) -> usize

The number of items the vector can hold.

Important traits for Drain<'a, T>

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

pub fn drain(&mut self) -> Drain<A::Item>

Empty the vector and return an iterator over its former contents.

pub fn push(&mut self, value: A::Item)

Append an item to the vector.

pub fn pop(&mut self) -> Option<A::Item>

Remove an item from the end of the vector and return it, or None if empty.

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

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

If len is greater than or equal to the vector's current length, this has no effect. shrink_to_fit after truncating.

pub fn as_slice(&self) -> &[A::Item]

Extracts a slice containing the entire vector.

Equivalent to &s[..].

pub fn as_mut_slice(&mut self) -> &mut [A::Item]

Extracts a mutable slice of the entire vector.

Equivalent to &mut s[..].

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

Remove the element at position index, replacing it with the last element.

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

Panics if index is out of bounds.

pub fn clear(&mut self)

Remove all elements from the vector.

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

Remove and return the element at position index, shifting all elements after it to the left.

Panics if index is out of bounds.

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

Insert an element at position index, shifting all elements after it to the right.

Panics if index is out of bounds.

pub fn insert_many<I: IntoIterator<Item = A::Item>>(
    &mut self,
    index: usize,
    iterable: I
)

Insert multiple elements at position index, shifting all following elements toward the back.

pub fn into_vec(self) -> Vec<A::Item>

Convert a StackVec to a Vec.

pub fn into_inner(self) -> Result<A, Self>

Convert the StackVec into an A.

pub fn retain<F: FnMut(&mut A::Item) -> bool>(&mut self, f: F)

Retains only the elements specified by the predicate.

In other words, remove all elements e such that f(&e) returns false. This method operates in place and preserves the order of the retained elements.

pub fn dedup(&mut self) where
    A::Item: PartialEq<A::Item>, 

Removes consecutive duplicate elements.

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

Removes consecutive duplicate elements using the given equality relation.

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

Removes consecutive elements that map to the same key.

impl<A: Array> StackVec<A> where
    A::Item: Copy, 

pub fn from_slice(slice: &[A::Item]) -> Self

Copy the elements from a slice into a new StackVec.

For slices of Copy types, this is more efficient than StackVec::from(slice).

pub fn insert_from_slice(&mut self, index: usize, slice: &[A::Item])

Copy elements from a slice into the vector at position index, shifting any following elements toward the back.

For slices of Copy types, this is more efficient than insert.

pub fn extend_from_slice(&mut self, slice: &[A::Item])

Copy elements from a slice and append them to the vector.

For slices of Copy types, this is more efficient than extend.

impl<A: Array> StackVec<A> where
    A::Item: Clone, 

pub fn resize(&mut self, len: usize, value: A::Item)

Resizes the vector so that its length is equal to len.

If len is less than the current length, the vector simply truncated.

If len is greater than the current length, value is appended to the vector until its length equals len.

pub fn from_elem(elem: A::Item, n: usize) -> Self

Creates a StackVec with n copies of elem.

use stackvector::StackVec;

let v = StackVec::<[char; 128]>::from_elem('d', 2);
assert_eq!(v, StackVec::from_buf(['d', 'd']));

Trait Implementations

impl<A: Array> VecLike<<A as Array>::Item> for StackVec<A>

fn push(&mut self, value: A::Item)

Deprecated:

Use Extend and Deref<[T]> instead

Append an element to the vector.

fn pop(&mut self) -> Option<A::Item>

Deprecated:

Use Extend and Deref<[T]> instead

Pop an element from the end of the vector.

impl<A: Array> ExtendFromSlice<<A as Array>::Item> for StackVec<A> where
    A::Item: Copy, 

fn extend_from_slice(&mut self, other: &[A::Item])

Extends a collection from a slice of its element type

impl<A: Array> Clone for StackVec<A> where
    A::Item: Clone, 

Important traits for StackVec<A>

impl<A: Array<Item = u8>> Write for StackVec<A>

fn clone(&self) -> StackVec<A>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<A: Array> Default for StackVec<A>

Important traits for StackVec<A>

impl<A: Array<Item = u8>> Write for StackVec<A>

fn default() -> StackVec<A>

Returns the "default value" for a type.

impl<A: Array> Drop for StackVec<A>

fn drop(&mut self)

Executes the destructor for this type.

impl<A: Array> Ord for StackVec<A> where
    A::Item: Ord, 

fn cmp(&self, other: &StackVec<A>) -> 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<A: Array> Extend<<A as Array>::Item> for StackVec<A>

fn extend<I: IntoIterator<Item = A::Item>>(&mut self, iterable: I)

Extends a collection with the contents of an iterator.

impl<A: Array> PartialOrd<StackVec<A>> for StackVec<A> where
    A::Item: PartialOrd, 

fn partial_cmp(&self, other: &StackVec<A>) -> 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<A: Array> Send for StackVec<A> where
    A::Item: Send, 

impl<'a, A: Array> From<&'a [<A as Array>::Item]> for StackVec<A> where
    A::Item: Clone, 

Important traits for StackVec<A>

impl<A: Array<Item = u8>> Write for StackVec<A>

fn from(slice: &'a [A::Item]) -> StackVec<A>

Performs the conversion.

impl<A: Array> From<Vec<<A as Array>::Item>> for StackVec<A>

Important traits for StackVec<A>

impl<A: Array<Item = u8>> Write for StackVec<A>

fn from(vec: Vec<A::Item>) -> StackVec<A>

Performs the conversion.

impl<A: Array> From<A> for StackVec<A>

Important traits for StackVec<A>

impl<A: Array<Item = u8>> Write for StackVec<A>

fn from(array: A) -> StackVec<A>

Performs the conversion.

impl<A: Array> AsRef<[<A as Array>::Item]> for StackVec<A>

fn as_ref(&self) -> &[A::Item]

Performs the conversion.

impl<A: Array> AsMut<[<A as Array>::Item]> for StackVec<A>

fn as_mut(&mut self) -> &mut [A::Item]

Performs the conversion.

impl<A: Array> IntoIterator for StackVec<A>

type IntoIter = IntoIter<A>

Which kind of iterator are we turning this into?

type Item = A::Item

The type of the elements being iterated over.

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<'a, A: Array> IntoIterator for &'a StackVec<A>

type IntoIter = Iter<'a, A::Item>

Which kind of iterator are we turning this into?

type Item = &'a A::Item

The type of the elements being iterated over.

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<'a, A: Array> IntoIterator for &'a mut StackVec<A>

type IntoIter = IterMut<'a, A::Item>

Which kind of iterator are we turning this into?

type Item = &'a mut A::Item

The type of the elements being iterated over.

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<A: Array> Eq for StackVec<A> where
    A::Item: Eq, 

impl<A: Array, B: Array> PartialEq<StackVec<B>> for StackVec<A> where
    A::Item: PartialEq<B::Item>, 

fn eq(&self, other: &StackVec<B>) -> bool

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

fn ne(&self, other: &StackVec<B>) -> bool

This method tests for !=.

impl<A: Array> Deref for StackVec<A>

type Target = [A::Item]

The resulting type after dereferencing.

fn deref(&self) -> &[A::Item]

Dereferences the value.

impl<A: Array> DerefMut for StackVec<A>

fn deref_mut(&mut self) -> &mut [A::Item]

Mutably dereferences the value.

impl<A: Array> Hash for StackVec<A> where
    A::Item: Hash, 

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<A: Array> Index<usize> for StackVec<A>

type Output = A::Item

The returned type after indexing.

fn index(&self, index: usize) -> &A::Item

Performs the indexing (container[index]) operation.

impl<A: Array> Index<Range<usize>> for StackVec<A>

type Output = [A::Item]

The returned type after indexing.

fn index(&self, index: Range<usize>) -> &[A::Item]

Performs the indexing (container[index]) operation.

impl<A: Array> Index<RangeFrom<usize>> for StackVec<A>

type Output = [A::Item]

The returned type after indexing.

fn index(&self, index: RangeFrom<usize>) -> &[A::Item]

Performs the indexing (container[index]) operation.

impl<A: Array> Index<RangeFull> for StackVec<A>

type Output = [A::Item]

The returned type after indexing.

fn index(&self, index: RangeFull) -> &[A::Item]

Performs the indexing (container[index]) operation.

impl<A: Array> Index<RangeTo<usize>> for StackVec<A>

type Output = [A::Item]

The returned type after indexing.

fn index(&self, index: RangeTo<usize>) -> &[A::Item]

Performs the indexing (container[index]) operation.

impl<A: Array> Index<RangeInclusive<usize>> for StackVec<A>

type Output = [A::Item]

The returned type after indexing.

fn index(&self, index: RangeInclusive<usize>) -> &[A::Item]

Performs the indexing (container[index]) operation.

impl<A: Array> Index<RangeToInclusive<usize>> for StackVec<A>

type Output = [A::Item]

The returned type after indexing.

fn index(&self, index: RangeToInclusive<usize>) -> &[A::Item]

Performs the indexing (container[index]) operation.

impl<A: Array> IndexMut<usize> for StackVec<A>

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

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

impl<A: Array> IndexMut<Range<usize>> for StackVec<A>

fn index_mut(&mut self, index: Range<usize>) -> &mut [A::Item]

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

impl<A: Array> IndexMut<RangeFrom<usize>> for StackVec<A>

fn index_mut(&mut self, index: RangeFrom<usize>) -> &mut [A::Item]

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

impl<A: Array> IndexMut<RangeFull> for StackVec<A>

fn index_mut(&mut self, index: RangeFull) -> &mut [A::Item]

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

impl<A: Array> IndexMut<RangeTo<usize>> for StackVec<A>

fn index_mut(&mut self, index: RangeTo<usize>) -> &mut [A::Item]

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

impl<A: Array> IndexMut<RangeInclusive<usize>> for StackVec<A>

fn index_mut(&mut self, index: RangeInclusive<usize>) -> &mut [A::Item]

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

impl<A: Array> IndexMut<RangeToInclusive<usize>> for StackVec<A>

fn index_mut(&mut self, index: RangeToInclusive<usize>) -> &mut [A::Item]

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

impl<A: Array> Debug for StackVec<A> where
    A::Item: Debug, 

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

Formats the value using the given formatter.

impl<A: Array> FromIterator<<A as Array>::Item> for StackVec<A>

Important traits for StackVec<A>

impl<A: Array<Item = u8>> Write for StackVec<A>

fn from_iter<I: IntoIterator<Item = A::Item>>(iterable: I) -> StackVec<A>

Creates a value from an iterator.

impl<A: Array> Borrow<[<A as Array>::Item]> for StackVec<A>

fn borrow(&self) -> &[A::Item]

Immutably borrows from an owned value.

impl<A: Array> BorrowMut<[<A as Array>::Item]> for StackVec<A>

fn borrow_mut(&mut self) -> &mut [A::Item]

Mutably borrows from an owned value.

impl<A: Array<Item = u8>> Write for StackVec<A>

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

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

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_vectored(&mut self, bufs: &[IoSlice]) -> Result<usize, Error>

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

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.