Struct zerogc::cell::GcCell

#[repr(transparent)]
pub struct GcCell<T: Trace + Copy>(_);

A Cell pointing to a garbage collected object.

This only supports mutating NullTrace types, becuase garbage collected pointers need write barriers.

Implementations

impl<T: Trace + Copy> GcCell<T>

pub fn new(value: T) -> Self

Create a new cell

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

Get a mutable reference to this cell’s value

This is safe because the &mut self guarentes exclusive access to the cell.

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

Get a pointer to this cell’s conent

pub fn get(&self) -> T

Get the current value of this cell

impl<T: NullTrace + Copy> GcCell<T>

pub fn set(&self, value: T)

Change the interior of this type to the specified type

The type must be NullTrace because garbage collected types need write barriers.

Trait Implementations

impl<T: Clone + Trace + Copy> Clone for GcCell<T>

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

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T: Debug + Trace + Copy> Debug for GcCell<T>

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

Formats the value using the given formatter.

impl<T: Default + Trace + Copy> Default for GcCell<T>

fn default() -> GcCell<T>

Returns the “default value” for a type.

impl<'gc, OwningRef, Value> GcDirectBarrier<'gc, OwningRef> for GcCell<Value> where
    Value: GcDirectBarrier<'gc, OwningRef> + Copy, 

unsafe fn write_barrier(&self, owner: &OwningRef, field_offset: usize)

Trigger a write barrier, before writing to one of the owning object’s managed fields

impl<'min, T, Id> GcErase<'min, Id> for GcCell<T> where
    T: Trace + Copy + GcErase<'min, Id>,
    Id: CollectorId,
    T::Erased: Copy + Trace, 

type Erased = GcCell<T::Erased>

This type with all garbage collected lifetimes changed to 'static (or erased)

impl<'new_gc, T, Id> GcRebrand<'new_gc, Id> for GcCell<T> where
    T: Trace + Copy + GcRebrand<'new_gc, Id>,
    Id: CollectorId,
    T::Branded: Copy + Trace, 

type Branded = GcCell<T::Branded>

This type with all garbage collected lifetimes changed to 'new_gc

impl<T: GcSafe + Copy> GcSafe for GcCell<T>

const NEEDS_DROP: bool

Since T is Copy, we shouldn’t need to be dropped

impl<T: GcSafe + Copy + NullTrace> NullTrace for GcCell<T>

impl<T: Trace + Copy> Trace for GcCell<T>

GcCell can only support mutating types that are NullTrace, because garbage collected types need write barriers.

However, this is already enforced by the bounds of GcCell::set, so we don’t need to verify here. In other words is possible to safely trace a GcCell with a garbage collected type, as long as it is never mutated.

const NEEDS_TRACE: bool

Whether this type needs to be traced by the garbage collector.

fn visit<V: GcVisitor>(&mut self, visitor: &mut V) -> Result<(), V::Err>

Visit each field in this type

impl<T: GcSafe + NullTrace + Copy> TraceImmutable for GcCell<T>

See Trace documentation on the safety of mutation

We require NullTrace in order to set our internals

fn visit_immutable<V: GcVisitor>(
    &self,
    visitor: &mut V
) -> Result<(), <V as GcVisitor>::Err>

Visit an immutable reference to this type