Struct atomic_option::AtomicOption

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

An atomic version of Option<Box<T>>, useful for moving owned objects between threads in a wait-free manner.

Methods

impl<T> AtomicOption<T>

fn new(data: Box<T>) -> AtomicOption<T>

Create a new AtomicOption storing the specified data.

let opt = AtomicOption::new(Box::new(7));
let value = opt.take(Ordering::SeqCst).unwrap();
assert_eq!(value, Box::new(7));

unsafe fn from_raw(ptr: *mut T) -> AtomicOption<T>

Create a new AtomicOption from a raw pointer.

fn empty() -> AtomicOption<T>

Create a new AtomicOption storing None.

let opt: AtomicOption<()> = AtomicOption::empty();
let value = opt.take(Ordering::SeqCst);
assert!(value.is_none());

fn take(&self, ordering: Ordering) -> Option<Box<T>>

Take the value out of the AtomicOption, if there is one.

let opt = AtomicOption::new(Box::new(178));
let first_take = opt.take(Ordering::SeqCst);
let second_take = opt.take(Ordering::SeqCst);

assert_eq!(first_take, Some(Box::new(178)));
assert!(second_take.is_none());

fn swap(&self, new: Box<T>, ordering: Ordering) -> Option<Box<T>>

Swap the value in the AtomicOption with a new one, returning the old value if there was one.

let opt = AtomicOption::new(Box::new(1236));
let old = opt.swap(Box::new(542), Ordering::SeqCst).unwrap();
assert_eq!(old, Box::new(1236));

let new = opt.take(Ordering::SeqCst).unwrap();
assert_eq!(new, Box::new(542));

fn replace(&self, new: Option<Box<T>>, ordering: Ordering) -> Option<Box<T>>

Replace the Option in the AtomicOption with a new one, returning the old option.

let opt = AtomicOption::empty();
let old = opt.replace(Some(Box::new("hello")), Ordering::SeqCst);
assert!(old.is_none());

let new = opt.take(Ordering::SeqCst).unwrap();
assert_eq!(new, Box::new("hello"));

fn try_store(&self, new: Box<T>, ordering: Ordering) -> Option<Box<T>>

Store the new value in the AtomicOption iff it currently contains a None.

None is returned if the store succeeded, or Some is returned with the rejected data if the store fails.

This operation is implemented as a single atomic compare_and_swap.

let opt = AtomicOption::empty();
let stored = opt.try_store(Box::new("some data"), Ordering::SeqCst);
assert!(stored.is_none());

let stored2 = opt.try_store(Box::new("some more data"), Ordering::SeqCst);
assert_eq!(stored2, Some(Box::new("some more data")));

let value = opt.take(Ordering::SeqCst).unwrap();
assert_eq!(value, Box::new("some data"));

fn spinlock(&self, ordering: Ordering) -> Box<T>

Execute a compare_and_swap loop until there is a value in the AtomicOption, then return it.

// We'll use an AtomicOption as a lightweight channel transferring data via a spinlock.
let tx = Arc::new(AtomicOption::empty());
let rx = tx.clone();

thread::spawn(move || {
    assert_eq!(*rx.spinlock(Ordering::Acquire), 7);
});

tx.swap(Box::new(7), Ordering::Release);

fn load_raw(&self, ordering: Ordering) -> *const T

Get the raw value stored in the AtomicOption.

Safety

It is almost never safe to read from this pointer.

Trait Implementations

impl<T> Sync for AtomicOption<T>

impl<T> From<Option<Box<T>>> for AtomicOption<T>

fn from(opt: Option<Box<T>>) -> AtomicOption<T>

Performs the conversion.

impl<T> Drop for AtomicOption<T>

fn drop(&mut self)

A method called when the value goes out of scope.