Struct RcuStack

pub struct RcuStack<T, F = RcuDefaultFlavor> { /* private fields */ }

Defines a RCU wait-free stack.

This stack supports multiple concurrents readers and writers. It is guaranteed to never block on a call.

Limitations

Mutable References

Because there might always be readers borrowing a node’s data, it is impossible to get a mutable references to the data inside the stack. You should design the type stored in the stack with interior mutabillity that can be shared between threads.

List Length

Because a writer might concurrently modify the stack, the amount of node might change at any moment. To prevent user error (e.g. allocate an array for each node), there is no .len() method.

Safety

It is safe to send an Arc<RcuStack<T>> to a non-registered RCU thread. A non-registered thread may drop an RcuStack<T> without calling any RCU primitives since lifetime rules prevent any other thread from accessing a RCU reference.

Implementations

impl<T, F> RcuStack<T, F>

where F: RcuFlavor,

pub fn new() -> Arc<Self>

Creates a new RCU stack.

pub fn push(&self, data: T)

Adds an element to the top of the stack.

pub fn pop<G>(&self, guard: &G) -> Option<Ref<T, F>>

where T: Send, G: RcuGuard<Flavor = F>,

Removes an element from the top of the stack.

pub fn pop_all<G>(&self, _guard: &G) -> IterRef<T, F>

where T: Send, G: RcuGuard<Flavor = F>,

Removes all elements from the stack.

pub fn peek<'me, 'guard, G>(&'me self, _guard: &'guard G) -> Option<&'guard T>

where G: RcuGuard<Flavor = F>, 'me: 'guard,

Returns a reference to the element on top of the stack.

pub fn iter<'me, 'guard, G>(&'me self, guard: &'guard G) -> Iter<'guard, T, G>

where G: RcuGuard<Flavor = F>, 'me: 'guard,

Returns an iterator over the stack.

The iterator yields all items from top to bottom.

pub fn is_empty(&self) -> bool

Returns true if there is no node in the stack.

Trait Implementations

impl<T, F> Drop for RcuStack<T, F>

fn drop(&mut self)

Executes the destructor for this type.

impl<T, F> Send for RcuStack<T, F>

where T: Send, F: RcuFlavor,

Safety

An RcuStack can be used to send T to another thread.

impl<T, F> Sync for RcuStack<T, F>

where T: Sync, F: RcuFlavor,

Safety

An RcuStack can be used to share T between threads.