Struct DynStack

pub struct DynStack<T: ?Sized> { /* private fields */ }

Implementations

impl<T: ?Sized> DynStack<T>

pub fn new() -> Self

Creates a new, empty, DynStack.

Panics

Panics if T is not a trait object.

pub const unsafe fn new_unchecked() -> Self

Creates a new, empty, DynStack. This method is a const fn, so instances can be statically initialized. This comes at the cost of no runtime sanity check that the stack is properly used with trait objects, which is why it is unsafe to call.

Safety

Must only be called with the generic, T, being a trait object.

Example

// SAFETY: Storing trait objects, as required
static CORRECT: DynStack<dyn Display + Sync> = unsafe { DynStack::new_unchecked() };

// DONT do the following, Sting is not a trait object. This compiles
// but has undefined behavior.
static WRONG: DynStack<String> = unsafe { DynStack::new_unchecked() };

Storing it directly in a static, like above, does of course not make much sense, because you can’t modify it. But if you put it inside a synchronazation primitive that allows static initialization, such as parking_lot::RwLock, it can be used as a globally accessible, modifiable stack.

pub unsafe fn push(&mut self, item: *mut T)

Push a trait object onto the stack.

This method is unsafe because in lieu of moving a trait object onto push’s stack (not possible in rust as of 1.30.0) we copy it from the provided mutable pointer.

The user of this method must therefore either ensure that item has no Drop impl, or explicitly call std::mem::forget on item after pushing.

It is highly recommended to use the dyn_push macro instead of calling this directly.

pub fn remove_last(&mut self) -> bool

Remove the last trait object from the stack. Returns true if any items were removed.

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

Retrieve a trait object reference at the provided index.

pub fn get_mut<'a>(&'a mut self, index: usize) -> Option<&'a mut T>

Retrieve a mutable trait object reference at the provided index.

pub fn peek<'a>(&'a self) -> Option<&'a T>

Retrieve the trait object reference at the top of the stack.

pub fn peek_mut<'a>(&'a mut self) -> Option<&'a mut T>

Retrieve the mutable trait object reference at the top of the stack.

pub fn len(&self) -> usize

Returns the number of trait objects stored on the stack.

impl<'a, T: 'a + ?Sized> DynStack<T>

pub fn iter(&'a self) -> DynStackIter<'a, T>

Returns an iterator over trait object references

pub fn iter_mut(&'a mut self) -> DynStackIterMut<'a, T>

Returns an iterator over mutable trait object references

Trait Implementations

impl<T: ?Sized> Drop for DynStack<T>

fn drop(&mut self)

Executes the destructor for this type.

impl<T: ?Sized> Index<usize> for DynStack<T>

type Output = T

The returned type after indexing.

fn index(&self, idx: usize) -> &T

Performs the indexing (container[index]) operation.

impl<T: ?Sized> IndexMut<usize> for DynStack<T>

fn index_mut(&mut self, idx: usize) -> &mut T

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

impl<'a, T: 'a + ?Sized> IntoIterator for &'a DynStack<T>

type Item = &'a T

The type of the elements being iterated over.

type IntoIter = DynStackIter<'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 + ?Sized> IntoIterator for &'a mut DynStack<T>

type Item = &'a mut T

The type of the elements being iterated over.

type IntoIter = DynStackIterMut<'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: ?Sized + Send> Send for DynStack<T>

impl<T: ?Sized + Sync> Sync for DynStack<T>