Struct CacheCell

pub struct CacheCell<T>(/* private fields */);

Wrapper for OnceCell with support for [rkyv].

Implementations

impl<T> CacheCell<T>

pub fn new() -> Self

Methods from Deref<Target = OnceCell<T>>

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

Gets the reference to the underlying value.

Returns None if the cell is empty, or being initialized. This method never blocks.

pub fn wait(&self) -> &T

Gets the reference to the underlying value, blocking the current thread until it is set.

use once_cell::sync::OnceCell;

let mut cell = std::sync::Arc::new(OnceCell::new());
let t = std::thread::spawn({
    let cell = std::sync::Arc::clone(&cell);
    move || cell.set(92).unwrap()
});

// Returns immediately, but might return None.
let _value_or_none = cell.get();

// Will return 92, but might block until the other thread does `.set`.
let value: &u32 = cell.wait();
assert_eq!(*value, 92);
t.join().unwrap();

pub unsafe fn get_unchecked(&self) -> &T

Get the reference to the underlying value, without checking if the cell is initialized.

Safety

Caller must ensure that the cell is in initialized state, and that the contents are acquired by (synchronized to) this thread.

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::new();

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 try_insert(&self, value: T) -> Result<&T, (&T, T)>

Like set, but also returns a reference to the final cell value.

Example

use once_cell::unsync::OnceCell;

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

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

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

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.

Many threads may call get_or_init concurrently with different initializing functions, but it is guaranteed that only one function will be executed.

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. The exact outcome is unspecified. Current implementation deadlocks, but this may be changed to a panic in the future.

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);

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.

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. The exact outcome is unspecified. Current implementation deadlocks, but this may be changed to a panic in the future.

Example

use once_cell::sync::OnceCell;

let cell = OnceCell::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))

Trait Implementations

impl<T: Archive> Archive for CacheCell<T>

type Archived = ArchivedOption<<T as Archive>::Archived>

The archived representation of this type.

type Resolver = Option<<T as Archive>::Resolver>

The resolver for this type. It must contain all the additional information from serializing needed to make the archived type from the normal type.

fn resolve(&self, resolver: Self::Resolver, out: Place<Self::Archived>)

Creates the archived version of this value at the given position and writes it to the given output.

const COPY_OPTIMIZATION: CopyOptimization<Self> = _

An optimization flag that allows the bytes of this type to be copied directly to a writer instead of calling serialize.

impl<T: Clone> Clone for CacheCell<T>

fn clone(&self) -> CacheCell<T>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T: Debug> Debug for CacheCell<T>

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

Formats the value using the given formatter.

impl<T> Default for CacheCell<T>

fn default() -> Self

Returns the “default value” for a type.

impl<T> Deref for CacheCell<T>

type Target = OnceCell<T>

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl<T, D> Deserialize<CacheCell<T>, D> for ArchivedOption<T::Archived>

where T: Archive, T::Archived: Deserialize<T, D>, D: Fallible + ?Sized,

fn deserialize(&self, deserializer: &mut D) -> Result<CacheCell<T>, D::Error>

Deserializes using the given deserializer

impl<T> From<T> for CacheCell<T>

fn from(value: T) -> Self

Converts to this type from the input type.

impl<T: Serialize<S>, S: Fallible + ?Sized> Serialize<S> for CacheCell<T>

fn serialize(&self, serializer: &mut S) -> Result<Self::Resolver, S::Error>

Writes the dependencies for the object and returns a resolver that can create the archived type.