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 guarentees 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.

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<'new_gc, T: Trace + Copy, Id: CollectorId> 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<'gc, T: Trace + Copy, Id: CollectorId> GcSafe<'gc, Id> for GcCell<T> where
    T: GcSafe<'gc, Id> + Copy, 

unsafe fn trace_inside_gc<Visitor>(
    gc: &mut Gc<'gc, Self, Id>,
    visitor: &mut Visitor
) -> Result<(), Visitor::Err> where
    Visitor: GcVisitor, 

Trace this object behind a Gc pointer.

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

const NEEDS_TRACE: bool

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

const NEEDS_DROP: bool

If this type needs a destructor run.

fn trace<Visitor: GcVisitor + ?Sized>(
    &mut self,
    visitor: &mut Visitor
) -> Result<(), Visitor::Err>

Trace each field in this type.

impl<T: Trace + Copy> TraceImmutable for GcCell<T> where
    T: NullTrace + Copy, 

fn trace_immutable<Visitor: GcVisitor + ?Sized>(
    &self,
    visitor: &mut Visitor
) -> Result<(), Visitor::Err>

Trace an immutable reference to this type

impl<T: Trace + Copy> NullTrace for GcCell<T> where
    T: Copy + NullTrace, 

impl<T: Trace + Copy> TrustedDrop for GcCell<T> where
    T: TrustedDrop,