Struct atomic_once_cell::AtomicOnceCell

source · [−]

pub struct AtomicOnceCell<T> { /* private fields */ }

Expand description

A thread-safe cell which can be written to only once.

Examples

use atomic_once_cell::AtomicOnceCell;

let cell = AtomicOnceCell::new();
assert!(cell.get().is_none());

let value: &String = cell.get_or_init(|| {
    "Hello, World!".to_string()
});
assert_eq!(value, "Hello, World!");
assert!(cell.get().is_some());

Implementations

source

impl<T> AtomicOnceCell<T>

source

pub const fn new() -> Self

Creates a new empty cell.

source

pub fn get(&self) -> Option<&T>

Gets the reference to the underlying value.

Returns None if the cell is empty.

source

pub fn get_mut(&mut self) -> Option<&mut T>

Gets the mutable reference to the underlying value.

Returns None if the cell is empty.

source

pub fn set(&self, value: T) -> Result<(), T>

Sets the contents of the cell to value.

Errors

This method returns Ok(()) if the cell was empty and Err(value) if it was full.

Examples

use atomic_once_cell::AtomicOnceCell;

let cell = AtomicOnceCell::new();
assert!(cell.get().is_none());

assert_eq!(cell.set(92), Ok(()));
assert_eq!(cell.set(62), Err(62));

assert!(cell.get().is_some());

source

pub fn get_or_init<F>(&self, f: F) -> &T where
F: FnOnce() -> T,

Gets the contents of the cell, initializing it with f if the cell was empty.

Blocking

This method might block and should not be used from an interrupt handler. Blocking is based on crossbeam::utils::Backoff, and will be reduced to a spin lock in #[no_std] environments.

Panics

If f panics, the panic is propagated to the caller, and the cell remains uninitialized.

It is an error to reentrantly initialize the cell from f. Doing so results in a panic.

Examples

use atomic_once_cell::AtomicOnceCell;

let cell = AtomicOnceCell::new();
let value = cell.get_or_init(|| 92);
assert_eq!(value, &92);
let value = cell.get_or_init(|| unreachable!());
assert_eq!(value, &92);

source

pub fn get_or_try_init<F, E>(&self, f: F) -> Result<&T, E> where
F: FnOnce() -> Result<T, E>,

Gets the contents of the cell, initializing it with f if the cell was empty. If the cell was empty and f failed, an error is returned.

Blocking

This method might block and should not be used from an interrupt handler. Blocking is based on crossbeam::utils::Backoff, and will be reduced to a spin lock in #[no_std] environments.

Panics

If f panics, the panic is propagated to the caller, and the cell remains uninitialized.

It is an error to reentrantly initialize the cell from f. Doing so results in a panic.

Examples

use atomic_once_cell::AtomicOnceCell;

let cell = AtomicOnceCell::new();
assert_eq!(cell.get_or_try_init(|| Err(())), Err(()));
assert!(cell.get().is_none());
let value = cell.get_or_try_init(|| -> Result<i32, ()> {
    Ok(92)
});
assert_eq!(value, Ok(&92));
assert_eq!(cell.get(), Some(&92))

source

pub fn into_inner(self) -> Option<T>

Consumes the cell, returning the wrapped value.

Returns None if the cell was empty.

Examples

use atomic_once_cell::AtomicOnceCell;

let cell: AtomicOnceCell<String> = AtomicOnceCell::new();
assert_eq!(cell.into_inner(), None);

let cell = AtomicOnceCell::new();
cell.set("hello".to_string()).unwrap();
assert_eq!(cell.into_inner(), Some("hello".to_string()));

source

pub fn take(&mut self) -> Option<T>

Takes the value out of this OnceCell, moving it back to an uninitialized state.

Has no effect and returns None if the OnceCell hasn’t been initialized.

Safety is guaranteed by requiring a mutable reference.

Examples

use atomic_once_cell::AtomicOnceCell;

let mut cell: AtomicOnceCell<String> = AtomicOnceCell::new();
assert_eq!(cell.take(), None);

let mut cell = AtomicOnceCell::new();
cell.set("hello".to_string()).unwrap();
assert_eq!(cell.take(), Some("hello".to_string()));
assert_eq!(cell.get(), None);