Struct GcScopeState 

pub struct GcScopeState<'s> { /* private fields */ }

Implementations

impl<'s> GcScopeState<'s>

pub fn new(heap: &'s mut GcHeap, partition_id: GcPartitionId) -> Self

pub fn partition_id(&self) -> GcPartitionId

pub fn heap(&self) -> &GcHeap

pub fn heap_mut(&mut self) -> &mut GcHeap

pub fn depth(&self) -> u8

pub fn count(&self) -> usize

pub fn parent(&self) -> Option<(&GcScopeState<'_>, u8)>

get parent scope, and its level.

pub fn alloc_root<T: GcNode>( &self, payload: T, ) -> Result<GcRef<T>, (GcError, T)>

pub fn alloc_local<T: GcNode>( &self, payload: T, ) -> Result<GcRef<T>, (GcError, T)>

alloc a local node in scope.

Examples found in repository

examples/gc_node_usage.rs (line 36)

fn alloc_static(
    heap: &mut GcHeap,
    scope: GcPartitionId,
    value: i32,
) -> GcResult<GcRef<StaticNode>> {
    let ctx = GcScope::new(heap, scope);
    let r = ctx
        .alloc_local(StaticNode { _value: value })
        .map_err(|(err, _)| err)?;
    ctx.flush();
    Ok(r)
}

fn alloc_other(heap: &mut GcHeap, scope: GcPartitionId, value: i32) -> GcResult<GcRef<OtherNode>> {
    let ctx = GcScope::new(heap, scope);
    let r = ctx
        .alloc_local(OtherNode { _value: value })
        .map_err(|(err, _)| err)?;
    ctx.flush();
    Ok(r)
}

pub fn add_non_local(&self, node: NonNull<GcHead>) -> bool

pub fn remove_node(&self, node: NonNull<GcHead>) -> bool

Remove a LOCAL node from this scope’s cache and clear its LOCAL flag.

This is the inverse of add_node: it undoes the LOCAL protection that was granted when the node was allocated in this scope. After this call, the node is no longer protected by this scope and will be traced by GC solely through other GC references.

Returns true if the node was found and removed from this scope’s cache. Returns false if the node was not in this scope’s cache (e.g., it was already promoted, or belongs to a different scope).

Safety

The caller must ensure the node is still alive and valid. This method does NOT check whether the node is the current promote node; the caller (e.g., ScopedContext::throw) is responsible for ensuring the node is not the promote target.

pub fn get_promote(&self) -> Option<NonNull<GcHead>>

pub fn set_promote(&self, node: Option<NonNull<GcHead>>)

Set a node to be promoted.

Promote means when the scope is dropped, the node will be added to upper scope.

pub fn flush(&self)

clear and unprotect locals nodes in this scope; promote the result node to upper scope.

Examples found in repository

examples/gc_node_usage.rs (line 38)

fn alloc_static(
    heap: &mut GcHeap,
    scope: GcPartitionId,
    value: i32,
) -> GcResult<GcRef<StaticNode>> {
    let ctx = GcScope::new(heap, scope);
    let r = ctx
        .alloc_local(StaticNode { _value: value })
        .map_err(|(err, _)| err)?;
    ctx.flush();
    Ok(r)
}

fn alloc_other(heap: &mut GcHeap, scope: GcPartitionId, value: i32) -> GcResult<GcRef<OtherNode>> {
    let ctx = GcScope::new(heap, scope);
    let r = ctx
        .alloc_local(OtherNode { _value: value })
        .map_err(|(err, _)| err)?;
    ctx.flush();
    Ok(r)
}

pub fn contains(&self, node: NonNull<GcHead>) -> bool

Trait Implementations

impl<'s> Debug for GcScopeState<'s>

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

Formats the value using the given formatter.

impl<'s> Drop for GcScopeState<'s>

fn drop(&mut self)

Executes the destructor for this type.

fn pin_drop(self: Pin<&mut Self>)

🔬This is a nightly-only experimental API. (pin_ergonomics)

Execute the destructor for this type, but different to Drop::drop, it requires self to be pinned.