Struct zerogc_context::collector::CollectorRef

#[repr(C)]
pub struct CollectorRef<C: RawCollectorImpl> { /* fields omitted */ }

A reference to the collector.

TODO: Devise better name

Implementations

impl<C: RawCollectorImpl> CollectorRef<C>

pub fn create() -> Self where
    C::Ptr: CollectorInit<C>, 

pub fn with_logger(logger: Logger) -> Self where
    C::Ptr: CollectorInit<C>, 

pub fn with_config(config: C::Config, logger: Logger) -> Self where
    C::Ptr: CollectorInit<C>, 

pub fn as_raw(&self) -> &C

pub fn id(&self) -> CollectorId<C>

The id of this collector

pub fn into_context(self) -> CollectorContext<C>

Convert this collector into a unique context

The single-threaded implementation only allows a single context, so this method is nessicary to support it.

impl<C: SyncCollector> CollectorRef<C>

pub fn create_context(&self) -> CollectorContext<C>

Create a new context bound to this collector

Warning: Only one collector should be created per thread. Doing otherwise can cause deadlocks/panics.

Trait Implementations

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

fn drop(&mut self)

Executes the destructor for this type.

impl<'gc, 'a, T, C> GcHandleSystem<'gc, 'a, T> for CollectorRef<C> where
    C: RawHandleImpl,
    T: GcSafe + 'gc,
    T: GcErase<'a, CollectorId<C>>,
    T::Erased: GcSafe + Sized, 

We support handles

type Handle = GcHandle<T::Erased, C>

The type of handles to this object.

fn create_handle(gc: Gc<'gc, T, CollectorId<C>>) -> Self::Handle

impl<C: RawCollectorImpl> GcSystem for CollectorRef<C>

type Id = CollectorId<C>

The type of collector IDs given by this system

type Context = CollectorContext<C>

The type of contexts used in this sytem

impl<C: SyncCollector> Send for CollectorRef<C>

We actually are thread safe ;)

impl<C: SyncCollector> Sync for CollectorRef<C>