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