Struct zerogc::epsilon::EpsilonContext

pub struct EpsilonContext { /* private fields */ }

A never-collecting garbage collector context.

WARNING: This never actually collects any garbage.

Trait Implementations

impl Drop for EpsilonContext

fn drop(&mut self)

Executes the destructor for this type.

impl GcContext for EpsilonContext

type System = EpsilonSystem

The system used with this context

type Id = EpsilonCollectorId

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.

fn system(&self) -> &Self::System

Get the GcSystem associated with this context

fn id(&self) -> Self::Id

Get the id of this context

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

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

unsafe fn rebrand_static<T>(&self, value: T) -> T::Branded where
    T: GcRebrand<'static, Self::Id>,
    T::Branded: 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::Branded where
    T: GcRebrand<'gc, Self::Id>,
    T::Branded: Sized, 

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

impl GcSimpleAlloc for EpsilonContext

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

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

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

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

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

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

fn alloc_raw_vec_with_capacity<'gc, T>(
    &'gc self,
    capacity: usize
) -> EpsilonRawVec<'gc, T> where
    T: GcSafe<'gc, Self::Id>, 

Create a new GcRawVec with the specified capacity and an implicit reference to this GcContext.

fn alloc_str<'gc>(&'gc self, src: &str) -> GcString<'gc, Self::Id>

Allocate a GcString, copied from the specified source

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

Allocate a slice, copied from the specified input

fn alloc_array_from_vec<'gc, T>(
    &'gc self,
    src: Vec<T>
) -> GcArray<'gc, T, Self::Id> where
    T: GcSafe<'gc, Self::Id>, 

Allocate an array, taking ownership of the values in the specified vec.

unsafe fn alloc_slice_fill_with<'gc, T, F>(
    &'gc self,
    len: usize,
    func: F
) -> GcArray<'gc, T, Self::Id> where
    T: GcSafe<'gc, Self::Id>,
    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, Self::Id>, 

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<'gc, Self::Id> + Copy, 

Allocate a slice by repeatedly copying a single value.

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

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::Id> where
    T: GcSafe<'gc, Self::Id>, 

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