Struct Lock 

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

A wrapper around a Cell that implements Collect.

Only provides safe read access to the wrapped Cell, full write access requires unsafety.

If the Lock is directly held in a Gc pointer, safe mutable access is provided, since methods on Gc can ensure that the write barrier is called.

Implementations

impl<T> Lock<T>

pub fn new(t: T) -> Lock<T>

pub fn into_inner(self) -> T

pub fn get(&self) -> T

where T: Copy,

pub fn take(&self) -> T

where T: Default,

impl<T: ?Sized> Lock<T>

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

pub unsafe fn as_cell(&self) -> &Cell<T>

Access the wrapped Cell.

Safety

In order to maintain the invariants of the garbage collector, no new Gc pointers may be adopted by this type as a result of the interior mutability afforded by directly accessing the inner Cell, unless the write barrier for the containing Gc pointer is invoked manually before collection is triggered.

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

Trait Implementations

impl<T: Copy> Clone for Lock<T>

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<'gc, T: Collect + Copy + 'gc> Collect for Lock<T>

fn needs_trace() -> bool

As an optimization, if this type can never hold a Gc pointer and trace is unnecessary to call, you may implement this method and return false. The default implementation returns true, signaling that Collect::trace must be called.

fn trace(&self, cc: &Collection)

Must call Collect::trace on all held Gc pointers. If this type holds inner types that implement Collect, a valid implementation would simply call Collect::trace on all the held values to ensure this.

impl<T: Copy + Debug> Debug for Lock<T>

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

Formats the value using the given formatter.

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

fn default() -> Lock<T>

Returns the “default value” for a type.

impl<T> From<Cell<T>> for Lock<T>

fn from(cell: Cell<T>) -> Self

Converts to this type from the input type.

impl<T> From<T> for Lock<T>

fn from(t: T) -> Self

Converts to this type from the input type.

impl<T: Ord + Copy> Ord for Lock<T>

fn cmp(&self, other: &Self) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

impl<T: PartialEq + Copy> PartialEq for Lock<T>

fn eq(&self, other: &Self) -> bool

Tests for self and other values to be equal, and is used by ==.

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

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

impl<T: PartialOrd + Copy> PartialOrd for Lock<T>

fn partial_cmp(&self, other: &Self) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

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

Tests less than (for self and other) and is used by the < operator.

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

Tests less than or equal to (for self and other) and is used by the <= operator.

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

Tests greater than (for self and other) and is used by the > operator.

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

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl<T: ?Sized> Unlock for Lock<T>

type Unlocked = Cell<T>

This will typically be a cell-like type providing some sort of interior mutability.

unsafe fn unlock_unchecked(&self) -> &Self::Unlocked

Provides unsafe access to the unlocked type, without triggering a write barrier.

impl<T: Eq + Copy> Eq for Lock<T>