Struct rafx_base::atomic_once_cell_stack::AtomicOnceCellStack

pub struct AtomicOnceCellStack<T> { /* fields omitted */ }

A fixed-size stack with capacity determined at run-time. The elements of the stack are uninitialized. Elements may be initialized with push and then retrieved as a reference with get. push returns the index of the element in the stack. The caller may reserve space for multiple elements with reserve_uninit. Reserved elements must be initialized with set. Calling push, reserve_uninit, or set is thread-safe. The stack will panic if the capacity is exceeded, or the index is out of range, or the set function is called more than once on an index when T is not zero-sized, or if the set function is called on an index that was not reserved by a prior call to reserve_uninit. The stack will only drop initialized elements.

Guarantees

• The stack will not allocate if capacity is 0 or if T is zero-sized.
• The allocated memory will not be default initialized.
• Elements initialized by push or set are immutable.
• The synchronization is lock-free.

Zero-sized Types

When T is zero-sized, the stack does not track individual indices and instead only maintains a count of how many instances of T have been set in the stack. On drop, the stack will drop that many instances of T. The stack will panic if the number of calls to set exceeds the capacity.

Implementations

impl<T> AtomicOnceCellStack<T>

pub fn with_capacity(capacity: usize) -> Self

pub fn push(&self, val: T) -> usize

pub fn reserve_uninit(&self, num_to_reserve: usize) -> usize

pub fn set(&self, index: usize, val: T)

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

pub fn capacity(&self) -> usize

pub fn len(&self) -> usize

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

Trait Implementations

impl<'a, T> IntoIterator for &'a AtomicOnceCellStack<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.