Struct zerogc_simple::layout::SimpleVecRepr

#[repr(C)]
pub struct SimpleVecRepr<T: GcSafe> { /* fields omitted */ }

The raw representation of a vector in the simple collector

NOTE: Length and capacity are stored implicitly in the GcVecHeader

Trait Implementations

impl<'min, T: GcSafe, Id: CollectorId> GcErase<'min, Id> for SimpleVecRepr<T> where
    <T as GcErase<'min, Id>>::Erased: GcSafe + GcErase<'min, Id>,
    T: GcSafe + GcErase<'min, Id>,
    T: Trace,
    <T as GcErase<'min, Id>>::Erased: Sized, 

type Erased = SimpleVecRepr<<T as GcErase<'min, Id>>::Erased>

This type with all garbage collected lifetimes changed to 'static (or erased)

impl<'new_gc, T: GcSafe, Id: CollectorId> GcRebrand<'new_gc, Id> for SimpleVecRepr<T> where
    <T as GcRebrand<'new_gc, Id>>::Branded: GcSafe + GcRebrand<'new_gc, Id>,
    T: GcSafe + GcRebrand<'new_gc, Id>,
    T: Trace,
    <T as GcRebrand<'new_gc, Id>>::Branded: Sized, 

type Branded = SimpleVecRepr<<T as GcRebrand<'new_gc, Id>>::Branded>

This type with all garbage collected lifetimes changed to 'new_gc

impl<T: GcSafe> GcVecRepr for SimpleVecRepr<T>

const SUPPORTS_REALLOC: bool

Right now, there is no stable API for in-place re-allocation

fn element_layout(&self) -> Layout

The layout of the underlying element type

fn len(&self) -> usize

The length of the vector.

unsafe fn set_len(&self, len: usize)

Set the length of the vector.

fn capacity(&self) -> usize

The total number of elements that are available

unsafe fn ptr(&self) -> *const c_void

A pointer to the underlying memory

fn realloc_in_place(
    &self,
    new_capacity: usize
) -> Result<(), ReallocFailedError>

Attempt to reallocate the vector in-place, without moving the underlying pointer.

impl<T: GcSafe> Trace for SimpleVecRepr<T> where
    T: Trace, 

const NEEDS_TRACE: bool

Whether this type needs to be traced by the garbage collector.

const NEEDS_DROP: bool

If this type needs a destructor run.

fn visit<Visitor: GcVisitor + ?Sized>(
    &mut self,
    visitor: &mut Visitor
) -> Result<(), Visitor::Err>

Visit each field in this type

unsafe fn visit_inside_gc<'actual_gc, Visitor, ActualId>(
    gc: &mut Gc<'actual_gc, Self, ActualId>,
    visitor: &mut Visitor
) -> Result<(), Visitor::Err> where
    Visitor: GcVisitor,
    ActualId: CollectorId,
    Self: GcSafe + 'actual_gc, 

Visit this object, assuming its already inside a GC pointer.

impl<T: GcSafe> TraceImmutable for SimpleVecRepr<T> where
    T: TraceImmutable, 

fn visit_immutable<Visitor: GcVisitor + ?Sized>(
    &self,
    visitor: &mut Visitor
) -> Result<(), Visitor::Err>

Visit an immutable reference to this type

impl<T: GcSafe> GcSafe for SimpleVecRepr<T> where
    T: GcSafe,
    T: Trace, 

impl<T: GcSafe> NullTrace for SimpleVecRepr<T> where
    T: NullTrace,