Struct zerogc_context::CollectorContext

pub struct CollectorContext<C: RawCollectorImpl> { /* fields omitted */ }

Implementations

impl<C: RawCollectorImpl> CollectorContext<C>

pub fn collector(&self) -> &C

Trait Implementations

impl<C: RawCollectorImpl> Drop for CollectorContext<C>

pub fn drop(&mut self)

Executes the destructor for this type.

impl<C: RawCollectorImpl> GcContext for CollectorContext<C>

type System = CollectorRef<C>

The system used with this context

type Id = CollectorId<C>

The type of ids used in the system

pub unsafe fn basic_safepoint<T: Trace>(&mut self, value: &mut &mut T)

Inform the garbage collection system we are at a safepoint and are ready for a potential garbage collection.

pub unsafe fn freeze(&mut self)

Inform the garbage collection system we are at a safepoint and are ready for a potential garbage collection.

pub unsafe fn unfreeze(&mut self)

Unfreeze this context, allowing it to be used again.

pub unsafe fn recurse_context<T, F, R>(&self, value: &mut &mut T, func: F) -> R where
    T: Trace,
    F: for<'gc> FnOnce(&'gc mut Self, &'gc mut T) -> R, 

Invoke the closure with a temporary GcContext.

impl<'gc, T, C> GcSimpleAlloc<'gc, T> for CollectorContext<C> where
    T: GcSafe + 'gc,
    C: RawSimpleAlloc, 

pub fn alloc(&'gc self, value: T) -> Gc<'gc, T, Self::Id>

Allocate the specified object in this garbage collector, binding it to the lifetime of this collector.

impl<C: RawCollectorImpl> !Send for CollectorContext<C>

It's not safe for a context to be sent across threads.

We use (thread-unsafe) interior mutability to maintain the shadow stack. Since we could potentially be cloned via safepoint_recurse!, implementing Send would allow another thread to obtain a reference to our internal &RefCell. Further mutation/access would be undefined.....