Struct zerogc::vec::GcVec

pub struct GcVec<'gc, T: GcSafe, Ctx: GcSimpleAlloc> {
    pub context: &'gc Ctx,
    pub raw: GcRawVec<'gc, T, Ctx::Id>,
}

A version of Vec for use with garbage collectors.

This is simply a thin wrapper around [RawGcVec] that also contains a reference to the owning [GcContext].

Fields

context: &'gc Ctx

A reference to the owning GcContext

raw: GcRawVec<'gc, T, Ctx::Id>

The underlying [RawGcVec], which actually manages the memory

Implementations

impl<'gc, T: GcSafe, Ctx: GcSimpleAlloc> GcVec<'gc, T, Ctx>

pub fn into_raw(self) -> GcRawVec<'gc, T, Ctx::Id>

Convert this vector into its underlying GcRawVec

pub fn reserve(&mut self, amount: usize)

Reserve enough capacity for the specified number of additional elements.

pub fn extend_from_slice(&mut self, src: &[T]) where
    T: Copy, 

Extend the vector with elements copied from the specified slice

pub fn push(&mut self, val: T)

Push the specified value onto the vector

Methods from Deref<Target = GcRawVec<'gc, T, Ctx::Id>>

pub fn with_context_mut<Ctx, F, R>(&mut self, ctx: &'gc Ctx, func: F) -> R where
    Ctx: GcSimpleAlloc<Id = Id>,
    F: FnOnce(&mut GcVec<'gc, T, Ctx>) -> R, 

View this [RawGcVec] as a GcVec for the duration of the specified closure, with an implicit reference to the specified [GcContext]

pub fn with_context<Ctx, F, R>(&self, ctx: &'gc Ctx, func: F) -> R where
    Ctx: GcSimpleAlloc<Id = Id>,
    F: FnOnce(&GcVec<'gc, T, Ctx>) -> R, 

View this [RawGcVec] as a GcVec for the duration of the specified closure

pub fn len(&self) -> usize

The length of this vector

pub fn capacity(&self) -> usize

The capacity of this vector.

pub fn clear(&mut self)

Clear the vector, setting its length to zero

pub fn try_push(&mut self, val: T) -> Result<(), InsufficientCapacityError>

Push a value onto this vector, returning an error if there is insufficient space.

pub unsafe fn as_repr(&self) -> Gc<'gc, Id::RawVecRepr, Id>

Get the raw representation of this vector as a GcVecRepr

Safety

The user must not violate the invariants of the repr.

pub unsafe fn as_repr_mut(&mut self) -> &mut Gc<'gc, Id::RawVecRepr, Id>

Get a mutable reference to the raw represnetation of this vector

Safety

The user must preserve the validity of the underlying representation.

pub fn as_slice(&self) -> &[T]

Interpret this vector as a slice

Because the length may change, this is bound to the lifetime of the current value.

pub unsafe fn as_ptr(&self) -> *const T

Give a pointer to the underlying slice of memory

Safety

The returned memory must not be mutated.

Trait Implementations

impl<'gc, T: GcSafe, Ctx: GcSimpleAlloc> Deref for GcVec<'gc, T, Ctx>

type Target = GcRawVec<'gc, T, Ctx::Id>

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl<'gc, T: GcSafe, Ctx: GcSimpleAlloc> DerefMut for GcVec<'gc, T, Ctx>

fn deref_mut(&mut self) -> &mut Self::Target

Mutably dereferences the value.

impl<'gc, T: GcSafe, Ctx: GcSimpleAlloc> Trace for GcVec<'gc, T, Ctx> where
    T: GcSafe + 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<'gc, T: GcSafe, Ctx: GcSimpleAlloc> GcSafe for GcVec<'gc, T, Ctx> where
    T: GcSafe,
    Ctx: GcSafe,
    T: GcSafe + Trace,