Struct zerogc_context::handle::GcHandle

pub struct GcHandle<T: GcSafe, C: RawHandleImpl> { /* fields omitted */ }

Trait Implementations

impl<T: GcSafe, C: RawHandleImpl> Clone for GcHandle<T, C>

fn clone(&self) -> Self

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<T: GcSafe, C: RawHandleImpl> Drop for GcHandle<T, C>

fn drop(&mut self)

Executes the destructor for this type.

impl<'new_gc, T, C> GcBindHandle<'new_gc, T> for GcHandle<T, C> where
    T: GcSafe,
    T: GcRebrand<'new_gc, CollectorId<C>>,
    T::Branded: GcSafe,
    C: RawHandleImplHack<'new_gc, T::Branded>, 

type Gc = C::Gc

The type of the rebranded references

fn bind_to(&self, context: &'new_gc CollectorContext<C>) -> Self::Gc

Associate this handle with the specified context, allowing its underlying object to be accessed as long as the context is valid.

impl<T: GcSafe, C: RawHandleImpl> GcHandle<T> for GcHandle<T, C>

type System = CollectorRef<C>

The type of the system used with this handle

type Id = CollectorId<C>

The type of CollectorId used with this sytem

fn use_critical<R>(&self, func: impl FnOnce(&T) -> R) -> R

Access this handle inside the closure, possibly associating it with the specified

impl<T: GcSafe, C: RawHandleImpl> Trace for GcHandle<T, C>

const NEEDS_TRACE: bool

See docs on reachability

fn visit<V>(&mut self, _visitor: &mut V) -> Result<(), V::Err> where
    V: GcVisitor, 

Visit each field in this type

impl<T: GcSafe, C: RawHandleImpl> TraceImmutable for GcHandle<T, C>

fn visit_immutable<V>(&self, _visitor: &mut V) -> Result<(), V::Err> where
    V: GcVisitor, 

Visit an immutable reference to this type

impl<T: GcSafe, C: RawHandleImpl> NullTrace for GcHandle<T, C>

impl<T: GcSafe + Sync, C: RawHandleImpl + Sync> Send for GcHandle<T, C>

In order to send references between threads, the underlying type must be sync.

This is the same reason that Arc<T>: Send requires T: Sync

Requires that the collector is thread-safe.

impl<T: GcSafe + Sync, C: RawHandleImpl + Sync> Sync for GcHandle<T, C>

If the underlying type is Sync, it’s safe to share garbage collected references between threads.

Requires that the collector is thread-safe.