Struct TakeCell

pub struct TakeCell<T: ?Sized> { /* private fields */ }

A cell type which value can be taken only once.

See crate-level documentation for more.

Implementations

impl<T> TakeCell<T>

pub const fn new(v: T) -> Self

Creates a new TakeCell containing the given value.

pub fn into_inner(self) -> T

Unwraps the underlying value.

impl<T: ?Sized> TakeCell<T>

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

Returns a reference to the underlying value.

After this function once returns Some(_) all consequtive calls before heal will return None as the reference is already taken.

Examples

let cell = TakeCell::new(0);

let uref: &mut _ = cell.take().unwrap();
*uref = 17;

// Already taken
assert!(cell.take().is_none());

let value = cell.into_inner();
assert_eq!(value, 17);

pub fn is_taken(&self) -> bool

Returns true if a reference to the underlying value has been already taken.

ie if this function returns true, then take will return None. Note however that the oposite is not true: if this function returned false it doesn’t guarantee that take will return Some(_) since there may have been concurent calls to take.

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

Returns a unique reference to the underlying data.

This call borrows TakeCell uniquely (at compile-time) which guarantees that we possess the only reference.

Note that this function is not affected nor affects the take. ie this function will return a reference even if take was already called

pub fn heal(&mut self)

Heal this cell. After a call to this function next call to take will succeed again, even if take was called before.

Examples

let mut cell = TakeCell::new(0);

assert!(cell.take().is_some());
assert!(cell.is_taken());

cell.heal();

assert!(!cell.is_taken());
assert!(cell.take().is_some());

pub fn is_taken_unsync(&mut self) -> bool

Similar to is_taken, but uses unique reference instead of runtime synchronization.

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

Similar to take, but uses unique reference instead of runtime synchronization.

pub unsafe fn steal(&self) -> &mut T

Unchecked version of take.

Safety

Call to this function must be the first call to steal or take after cell creation or heal.

Trait Implementations

impl<T: Default + ?Sized> Default for TakeCell<T>

fn default() -> TakeCell<T>

Returns the “default value” for a type.

impl<T> From<T> for TakeCell<T>

fn from(v: T) -> Self

Converts to this type from the input type.

impl<T: ?Sized + Send> Sync for TakeCell<T>

Safety

It is possible to pass ownership via &TakeCell. As such, TakeCell<T> may be Sync (TakeCell<T>: Send) if and only if T is Send. Otherwise there may be UB, see this example, adopted from sslab-gatech rust group.

Sync on the other hand is not required because TakeCell’s value is only accesible from one thread at a time.

This is again similar to a Mutex.