pub struct TLCell<Q, T: ?Sized> { /* private fields */ }
Expand description
Cell whose contents is owned (for borrowing purposes) by a
TLCellOwner
.
To borrow from this cell, use the borrowing calls on the
TLCellOwner
instance that shares the same marker type. Since
there may be another indistinguishable TLCellOwner
in another
thread, Sync
is not supported for this type. However it is
possible to send the cell to another thread, which then allows its
contents to be borrowed using the owner in that thread.
See also crate documentation.
Implementations§
Source§impl<Q, T> TLCell<Q, T>
impl<Q, T> TLCell<Q, T>
Sourcepub const fn new(value: T) -> TLCell<Q, T>
pub const fn new(value: T) -> TLCell<Q, T>
Create a new TLCell
owned for borrowing purposes by the
TLCellOwner
derived from the same marker type Q
.
Sourcepub fn into_inner(self) -> T
pub fn into_inner(self) -> T
Destroy the cell and return the contained value
Safety: Since this consumes the cell, there can be no other references to the cell or the data at this point.
Source§impl<Q, T: ?Sized> TLCell<Q, T>
impl<Q, T: ?Sized> TLCell<Q, T>
Sourcepub fn ro<'a>(&'a self, owner: &'a TLCellOwner<Q>) -> &'a T
pub fn ro<'a>(&'a self, owner: &'a TLCellOwner<Q>) -> &'a T
Borrow contents of this cell immutably (read-only). Many
TLCell
instances can be borrowed immutably at the same time
from the same owner.
Sourcepub fn rw<'a>(&'a self, owner: &'a mut TLCellOwner<Q>) -> &'a mut T
pub fn rw<'a>(&'a self, owner: &'a mut TLCellOwner<Q>) -> &'a mut T
Borrow contents of this cell mutably (read-write). Only one
TLCell
at a time can be borrowed from the owner using this
call. The returned reference must go out of scope before
another can be borrowed. To mutably borrow from two or three
cells at the same time, see TLCellOwner::rw2
or
TLCellOwner::rw3
.
Sourcepub fn get_mut(&mut self) -> &mut T
pub fn get_mut(&mut self) -> &mut T
Returns a mutable reference to the underlying data
Note that this is only useful at the beginning-of-life or
end-of-life of the cell when you have exclusive access to it.
Normally you’d use TLCell::rw
or TLCellOwner::rw
to
get a mutable reference to the contents of the cell.
Safety: This call borrows TLCell
mutably which guarantees
that we possess the only reference. This means that there can
be no active borrows of other forms, even ones obtained using
an immutable reference.