Struct scc::Stack

pub struct Stack<T: 'static> { /* private fields */ }

Stack is a lock-free concurrent last-in-first-out container.

Implementations

impl<T: 'static> Stack<T>

pub fn push(&self, val: T) -> Arc<Entry<T>>

Pushes an instance of T.

Returns an Arc holding a strong reference to the newly pushed entry.

Examples

use scc::Stack;

let stack: Stack<usize> = Stack::default();

assert_eq!(**stack.push(11), 11);

pub fn push_if<F: FnMut(Option<&Entry<T>>) -> bool>( &self, val: T, cond: F ) -> Result<Arc<Entry<T>>, T>

Pushes an instance of T if the newest entry satisfies the given condition.

Errors

Returns an error along with the supplied instance if the condition is not met.

Examples

use scc::Stack;

let stack: Stack<usize> = Stack::default();

stack.push(11);

assert!(stack.push_if(17, |e| e.map_or(false, |x| **x == 11)).is_ok());
assert!(stack.push_if(29, |e| e.map_or(false, |x| **x == 11)).is_err());

pub fn pop(&self) -> Option<Arc<Entry<T>>>

Pops the newest entry.

Returns None if the Stack is empty.

Examples

use scc::Stack;

let stack: Stack<usize> = Stack::default();

stack.push(37);
stack.push(3);
stack.push(1);

assert_eq!(stack.pop().map(|e| **e), Some(1));
assert_eq!(stack.pop().map(|e| **e), Some(3));
assert_eq!(stack.pop().map(|e| **e), Some(37));
assert!(stack.pop().is_none());

pub fn pop_if<F: FnMut(&Entry<T>) -> bool>( &self, cond: F ) -> Result<Option<Arc<Entry<T>>>, Arc<Entry<T>>>

Pops the newest entry if the entry satisfies the given condition.

Returns None if the Stack is empty.

Errors

Returns an error along with the newest entry if the given condition is not met.

Examples

use scc::Stack;

let stack: Stack<usize> = Stack::default();

stack.push(3);
stack.push(1);

assert!(stack.pop_if(|v| **v == 3).is_err());
assert_eq!(stack.pop().map(|e| **e), Some(1));
assert_eq!(stack.pop_if(|v| **v == 3).ok().and_then(|e| e).map(|e| **e), Some(3));

assert!(stack.is_empty());

pub fn peek<R, F: FnOnce(&Entry<T>) -> R>(&self, reader: F) -> Option<R>

Peeks the newest entry.

Returns None if the Stack is empty.

Examples

use scc::Stack;

let stack: Stack<usize> = Stack::default();

assert!(stack.peek(|v| **v).is_none());

stack.push(37);
stack.push(3);

assert_eq!(stack.peek(|v| **v), Some(3));

pub fn peek_with<'b, R, F: FnOnce(&'b Entry<T>) -> R>( &self, reader: F, barrier: &'b Barrier ) -> Option<R>

Peeks the newest entry with the supplied Barrier.

Returns None if the Stack is empty.

Examples

use scc::ebr::Barrier;
use scc::Stack;

let stack: Stack<usize> = Stack::default();

assert!(stack.peek_with(|v| **v, &Barrier::new()).is_none());

stack.push(37);
stack.push(3);

assert_eq!(stack.peek_with(|v| **v, &Barrier::new()), Some(3));

pub fn is_empty(&self) -> bool

Returns true if the Stack is empty.

Examples

use scc::Stack;

let stack: Stack<usize> = Stack::default();
assert!(stack.is_empty());

stack.push(7);
assert!(!stack.is_empty());

Trait Implementations

impl<T: 'static + Clone> Clone for Stack<T>

fn clone(&self) -> Self

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T: 'static + Debug> Debug for Stack<T>

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

Formats the value using the given formatter.

impl<T: 'static> Default for Stack<T>

fn default() -> Self

Returns the “default value” for a type.