Struct singletonum::OnceCell

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

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

Unlike ::std::sync::Mutex, a OnceCell provides simple & references to the contents.

Example

use once_cell::sync::OnceCell;

static CELL: OnceCell<String> = OnceCell::INIT;
assert!(CELL.get().is_none());

::std::thread::spawn(|| {
    let value: &String = CELL.get_or_init(|| {
        "Hello, World!".to_string()
    });
    assert_eq!(value, "Hello, World!");
}).join().unwrap();

let value: Option<&String> = CELL.get();
assert!(value.is_some());
assert_eq!(value.unwrap().as_str(), "Hello, World!");

Implementations

impl<T> OnceCell<T>

pub const INIT: OnceCell<T> = OnceCell{ once: ONCE_INIT, value: UnsafeCell::new(None),}

An empty cell, for initialization in a const context.

pub fn new() -> OnceCell<T>

Creates a new empty cell.

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

Gets the reference to the underlying value. Returns None if the cell is empty.

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

Sets the contents of this cell to value. Returns Ok(()) if the cell was empty and Err(value) if it was full.

Example

use once_cell::sync::OnceCell;

static CELL: OnceCell<i32> = OnceCell::INIT;

fn main() {
    assert!(CELL.get().is_none());

    ::std::thread::spawn(|| {
        assert_eq!(CELL.set(92), Ok(()));
    }).join().unwrap();

    assert_eq!(CELL.set(62), Err(62));
    assert_eq!(CELL.get(), Some(&92));
}

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

Gets the contents of the cell, initializing it with f if the cell was empty. May threads may call get_or_init concurrently with different initializing functions, but it is guaranteed that only one function will be executed.

Example

use once_cell::sync::OnceCell;

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

Trait Implementations

impl<T> Debug for OnceCell<T>where
    T: Debug,

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

Formats the value using the given formatter.

impl<T> Default for OnceCell<T>

fn default() -> OnceCell<T>

Returns the “default value” for a type.

impl<T> From<T> for OnceCell<T>

fn from(value: T) -> OnceCell<T>

Converts to this type from the input type.

impl<T> PartialEq<OnceCell<T>> for OnceCell<T>where
    T: PartialEq<T>,

fn eq(&self, other: &OnceCell<T>) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<T> Send for OnceCell<T>where
    T: Send,

impl<T> Sync for OnceCell<T>where
    T: Sync + Send,