Struct RefLock

pub struct RefLock<T>
where
    T: ?Sized,
{ /* private fields */ }

A wrapper around a RefCell that implements Collect.

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

If the RefLock 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> RefLock<T>

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

Examples found in repository

examples/basic.rs (line 95)

fn get_running_project(xml: &str, system: Rc<StdSystem<C>>) -> EnvArena {
    EnvArena::new(|mc| {
        let parser = ast::Parser::default();
        let ast = parser.parse(xml).unwrap();
        assert_eq!(ast.roles.len(), 1); // this should be handled more elegantly in practice - for the sake of this example, we only allow one role

        let (bytecode, init_info, locs, _) = ByteCode::compile(&ast.roles[0]).unwrap();

        let mut proj = Project::from_init(mc, &init_info, Rc::new(bytecode), Settings::default(), system);
        proj.input(mc, Input::Start); // this is equivalent to clicking the green flag button

        Env { proj: Gc::new(mc, RefLock::new(proj)), locs }
    })
}

pub fn into_inner(self) -> T

pub fn take(&self) -> T

where T: Default,

impl<T> RefLock<T>

where T: ?Sized,

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

pub fn borrow<'a>(&'a self) -> Ref<'a, T>

pub fn try_borrow<'a>(&'a self) -> Result<Ref<'a, T>, BorrowError>

pub unsafe fn as_ref_cell(&self) -> &RefCell<T>

Access the wrapped RefCell.

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 RefCell, unless the write barrier for the containing Gc pointer is invoked manuall before collection is triggered.

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

Trait Implementations

impl<T> Clone for RefLock<T>

where T: Clone + ?Sized,

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

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<'gc, T> Collect for RefLock<T>

where T: Collect + 'gc,

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> Debug for RefLock<T>

where T: Debug + ?Sized,

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

Formats the value using the given formatter.

impl<T> Default for RefLock<T>

where T: Default + ?Sized,

fn default() -> RefLock<T>

Returns the “default value” for a type.

impl<T> From<RefCell<T>> for RefLock<T>

fn from(cell: RefCell<T>) -> RefLock<T>

Converts to this type from the input type.

impl<T> From<T> for RefLock<T>

fn from(t: T) -> RefLock<T>

Converts to this type from the input type.

impl<T> Ord for RefLock<T>

where T: Ord + ?Sized,

fn cmp(&self, other: &RefLock<T>) -> 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 for RefLock<T>

where T: PartialEq + ?Sized,

fn eq(&self, other: &RefLock<T>) -> 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 for RefLock<T>

where T: PartialOrd + ?Sized,

fn partial_cmp(&self, other: &RefLock<T>) -> 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> Unlock for RefLock<T>

where T: ?Sized,

type Unlocked = RefCell<T>

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

unsafe fn unlock_unchecked(&self) -> &<RefLock<T> as Unlock>::Unlocked

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

impl<T> Eq for RefLock<T>

where T: Eq + ?Sized,

impl<T> StructuralPartialEq for RefLock<T>

where T: ?Sized,