Struct singleton_cell::SCell

#[repr(transparent)]
pub struct SCell<Key: ?Sized, T: ?Sized> { /* fields omitted */ }

SCell, or SingletonCell provides an interface of a Ghost Cell, where the Key is allowed to be any singleton, rather than a particular token type.

As a result, the uniqueness for the key can be provided by any means, and the key type / resulting cell may also be ’static for long-lived data structures

Implementations

impl<Key: ?Sized, T: ?Sized> SCell<Key, T>

pub fn from_mut(t: &mut T) -> &mut Self

Convert a unique reference to a value to a unique reference to this cell type. These two types are equivalent when accessed uniquely.

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

Uniquely borrow this cell in order to access T mutably.

Unique access to this cell guarantees that no other accesses to it can be performed simultaneously.

pub fn as_ptr(&self) -> *mut T

Get a raw pointer to this cell’s data

impl<Key: ?Sized, T> SCell<Key, T>

pub fn new(t: T) -> Self

Construct a new SCell from underlying data.

pub fn into_inner(self) -> T

Destruct the SCell and access the inner data.

impl<Key: ?Sized, T> SCell<Key, [T]>

pub fn as_slice_of_cells(&self) -> &[SCell<Key, T>]

Returns a slice of cells from a cell of a slice

impl<Key: Singleton + ?Sized, T: ?Sized> SCell<Key, T>

pub fn borrow<'a>(&'a self, _: impl Exists<&'a Key>) -> &'a T where
    Key: 'a, 

Borrow the data underlying this cell, using a reference to the singleton Key type.

Safety to borrow is guaranteed by the immutable borrow to the singleton key for this cell.

pub fn borrow_mut<'a>(&'a self, _: impl Exists<&'a mut Key>) -> &'a mut T where
    Key: 'a, 

Mutably borrow the data underlying this cell, using a mutable reference to the singleton Key type.

Safety to borrow mutably is guaranteed by the mutable borrow to the singleton key for this cell.

impl<Key: Singleton + ?Sized, T> SCell<Key, T>

pub fn replace<'a>(&'a self, value: T, token: impl Exists<&'a mut Key>) -> T where
    Key: 'a, 

Replace the value behind this cell with a new one.

This requires unique access to the token in order to ensure there are no other active borrows we could be invalidating.

pub fn take<'a>(&'a self, token: impl Exists<&'a mut Key>) -> T where
    Key: 'a,
    T: Default, 

Replace the value behind this cell with the default one.

This requires unique access to the token in order to ensure there are no other active borrows we could be invalidating.

Trait Implementations

impl<Key, T: Send> Send for SCell<Key, T>

An owned SCell is equivalent to its underlying value, and can be converted between them, so SCell<Key, T> is Send if and only if T is Send

impl<Key, T: Send + Sync> Sync for SCell<Key, T>

A shared reference to SCell can access the underlying value both via shared reference, and via mutable reference, so it can be Sync only if T is both Sync and Send.

SCell does not otherwise put any constraints on Sync since all shared usages must use references to the Key, which must be sent between threads as normal.