Struct Gc 

pub struct Gc<'a, T: GcNode> { /* private fields */ }

A safe GC reference with a lifetime guarantee.

Gc<'a, T> wraps a GcRef<T> and provides safe Deref/DerefMut implementations, where the lifetime 'a proves that the GC object is alive and protected (e.g., by a scope or a heap borrow).

Safety invariant

The lifetime 'a must be derived from a source that guarantees the GC object will not be collected during 'a. Typical sources:

• A GcScope or GcScopeState for scope-local allocations
• A &GcHeap borrow for GcWeak::upgrade results

Implementations

impl<'a, T: GcNode> Gc<'a, T>

pub unsafe fn from_raw(inner: GcRef<T>) -> Self

Create a Gc from a raw GcRef and a lifetime proof.

Safety

The caller must ensure that the object referenced by inner stays alive for the entire lifetime 'a. This is typically guaranteed by tying 'a to a scope or a heap borrow.

pub fn into_raw(self) -> GcRef<T>

Convert back to the raw GcRef handle.

Examples found in repository

examples/gc_node_usage.rs (line 35)

fn alloc_static(
    heap: &mut GcHeap,
    stack_id: GcScopeStackId,
    value: i32,
) -> GcResult<GcRef<StaticNode>> {
    heap.with_new_scope(stack_id, |ctx| {
        let r = ctx
            .alloc_local(StaticNode { _value: value })
            .map_err(|(err, _)| err)
            .map(|gc| gc.into_raw());
        ctx.clear();
        r
    })
}

fn alloc_other(
    heap: &mut GcHeap,
    stack_id: GcScopeStackId,
    value: i32,
) -> GcResult<GcRef<OtherNode>> {
    heap.with_new_scope(stack_id, |ctx| {
        let r = ctx
            .alloc_local(OtherNode { _value: value })
            .map_err(|(err, _)| err)
            .map(|gc| gc.into_raw());
        ctx.clear();
        r
    })
}

pub fn as_raw(&self) -> &GcRef<T>

Access the raw GcRef without consuming self.

Trait Implementations

impl<'a, T: GcNode> Clone for Gc<'a, T>

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<'a, T: GcNode> Copy for Gc<'a, T>

impl<'a, T: GcNode> Debug for Gc<'a, T>

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

Formats the value using the given formatter.

impl<'a, T: GcNode> Deref for Gc<'a, T>

type Target = T

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl<'a, T: GcNode> DerefMut for Gc<'a, T>

fn deref_mut(&mut self) -> &mut Self::Target

Mutably dereferences the value.

impl<'a, T: GcNode> Eq for Gc<'a, T>

impl<'a, T: GcNode> PartialEq for Gc<'a, T>

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

Equality operator ==.

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

Inequality operator !=.