Struct stack_dst::stack::Stack

pub struct Stack<T: ?Sized, D: DataBuf> { /* private fields */ }

A fixed-capacity stack that can contain dynamically-sized types

Uses an array of usize as a backing store for a First-In, Last-Out stack of items that can unsize to T.

Note: Each item in the stack takes at least one slot in the buffer (to store the metadata)

Implementations

impl<T: ?Sized, D: DataBuf> Stack<T, D>

pub fn new() -> Selfwhere D: Default,

Construct a new (empty) stack

pub fn with_buffer(data: D) -> Self

Construct a new (empty) stack using the provided buffer

pub fn is_empty(&self) -> bool

Tests if the stack is empty

pub fn push<U: Unsize<T>>(&mut self, v: U) -> Result<(), U>where (U, D::Inner): AlignmentValid,

Push a value at the top of the stack

let mut stack = Stack::<[u8], ::stack_dst::buffers::U64_8>::new();
stack.push([1, 2, 3]);

pub fn push_stable<U, F: FnOnce(&U) -> &T>( &mut self, v: U, f: F ) -> Result<(), U>where (U, D::Inner): AlignmentValid,

Push a value at the top of the stack (without using Unsize)

let mut stack = Stack::<[u8], ::stack_dst::buffers::U64_8>::new();
stack.push_stable([1, 2,3], |v| v);

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

Returns a pointer to the top item on the stack

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

Returns a pointer to the top item on the stack (unique/mutable)

pub fn pop(&mut self)

Pop the top item off the stack

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

Obtain an immutable iterator (yields references to items, in the order they would be popped)

let mut list = ::stack_dst::Stack::<str, ::stack_dst::buffers::Ptr8>::new();
list.push_str("Hello");
list.push_str("world");
let mut it = list.iter();
assert_eq!(it.next(), Some("world"));
assert_eq!(it.next(), Some("Hello"));
assert_eq!(it.next(), None);

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

Obtain unique/mutable iterator

let mut list = ::stack_dst::Stack::<[u8], ::stack_dst::buffers::Ptr8>::new();
list.push_copied(&[1,2,3]);
list.push_copied(&[9]);
for v in list.iter_mut() {
    v[0] -= 1;
}
let mut it = list.iter();
assert_eq!(it.next(), Some(&[8][..]));
assert_eq!(it.next(), Some(&[0,2,3][..]));
assert_eq!(it.next(), None);

impl<D: DataBuf> Stack<str, D>

pub fn push_str(&mut self, v: &str) -> Result<(), ()>

Push the contents of a string slice as an item onto the stack

let mut stack = Stack::<str, ::stack_dst::buffers::U8_32>::new();
stack.push_str("Hello!");

impl<D: DataBuf, T: Clone> Stack<[T], D>where (T, D::Inner): AlignmentValid,

pub fn push_cloned(&mut self, v: &[T]) -> Result<(), ()>

Pushes a set of items (cloning out of the input slice)

let mut stack = Stack::<[u8], ::stack_dst::buffers::U64_8>::new();
stack.push_cloned(&[1, 2, 3]);

pub fn push_copied(&mut self, v: &[T]) -> Result<(), ()>where T: Copy,

Pushes a set of items (copying out of the input slice)

let mut stack = Stack::<[u8], ::stack_dst::buffers::U64_8>::new();
stack.push_copied(&[1, 2, 3]);

impl<D: DataBuf, T> Stack<[T], D>where (T, D::Inner): AlignmentValid,

pub fn push_from_iter( &mut self, iter: impl ExactSizeIterator<Item = T> ) -> Result<(), ()>

Push an item, populated from an exact-sized iterator

let mut stack = Stack::<[u8], stack_dst::buffers::Ptr8>::new();
stack.push_from_iter(0..10);
assert_eq!(stack.top().unwrap(), &[0,1,2,3,4,5,6,7,8,9]);

Trait Implementations

impl<D: DataBuf, T> Debug for Stack<T, D>where T: Debug + ?Sized,

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

Formats the value using the given formatter.

impl<T: ?Sized, D: DataBuf + Default> Default for Stack<T, D>

fn default() -> Self

Returns the “default value” for a type.

impl<T: ?Sized, D: DataBuf> Drop for Stack<T, D>

fn drop(&mut self)

Executes the destructor for this type.