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>

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

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

Potentially perform a garbage collection, freeing all objects that aren’t reachable from the specified root.

unsafe fn freeze(&mut self)

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

unsafe fn unfreeze(&mut self)

Unfreeze this context, allowing it to be used again.

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, preserving the specified object as a root of garbage collection.

unsafe fn basic_safepoint<T>(&mut self, root: &mut &mut T) where
    T: Trace, 

Potentially perform a garbage collection, freeing all objects that aren’t reachable from the specified root.

unsafe fn rebrand_static<'a, T>(
    &self,
    value: T
) -> <T as GcErase<'a, Self::Id>>::Erased where
    T: GcErase<'a, Self::Id>,
    <T as GcErase<'a, Self::Id>>::Erased: Sized, 

Rebrand to the specified root so that it lives for the 'static lifetime.

unsafe fn rebrand_self<'gc, T>(
    &'gc self,
    value: T
) -> <T as GcRebrand<'gc, Self::Id>>::Branded where
    T: GcRebrand<'gc, Self::Id>,
    <T as GcRebrand<'gc, Self::Id>>::Branded: Sized, 

Rebrand the specified root so that it lives for the lifetime of this context.

impl<C> GcSimpleAlloc for CollectorContext<C> where
    C: RawSimpleAlloc, 

unsafe fn alloc_uninit<'gc, T>(&'gc self) -> (CollectorId<C>, *mut T) where
    T: GcSafe + 'gc, 

Allocate room for a object in, but don’t finish initializing it.

unsafe fn alloc_uninit_slice<'gc, T>(
    &'gc self,
    len: usize
) -> (Self::Id, *mut T) where
    T: GcSafe + 'gc, 

Allocate a slice with the specified length, whose memory is uninitialized

fn alloc_vec<'gc, T>(&'gc self) -> GcVec<'gc, T, Self> where
    T: GcSafe + 'gc, 

Create a new GcVec with zero initial length, with an implicit reference to this GcContext.

fn alloc_vec_with_capacity<'gc, T>(
    &'gc self,
    capacity: usize
) -> GcVec<'gc, T, Self> where
    T: GcSafe + 'gc, 

Allocate a new GcVec with the specified capacity and an implcit reference to this GcContext

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

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

fn alloc_slice_copy<'gc, T>(&'gc self, src: &[T]) -> GcArray<'gc, T, Self::Id> where
    T: GcSafe + Copy + 'gc, 

Allocate a slice, copied from the specified input

unsafe fn alloc_slice_fill_with<'gc, T, F>(
    &'gc self,
    len: usize,
    func: F
) -> GcArray<'gc, T, Self::Id> where
    T: GcSafe + 'gc,
    F: FnMut(usize) -> T, 

Allocate a slice by filling it with results from the specified closure.

fn alloc_slice_none<'gc, T>(
    &'gc self,
    len: usize
) -> GcArray<'gc, Option<T>, Self::Id> where
    T: GcSafe + 'gc, 

Allocate a slice of the specified length, initializing everything to None

fn alloc_slice_fill_copy<'gc, T>(
    &'gc self,
    len: usize,
    val: T
) -> GcArray<'gc, T, Self::Id> where
    T: GcSafe + Copy + 'gc, 

Allocate a slice by repeatedly copying a single value.

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