Struct zerogc::epsilon::vec::EpsilonRawVec

pub struct EpsilonRawVec<'gc, T> { /* private fields */ }

The raw representation of a vector in the “epsilon” collector

Implementations

impl<'gc, T: GcSafe<'gc, EpsilonCollectorId>> EpsilonRawVec<'gc, T>

pub fn iter(&self) -> RawVecIter<'gc, T, Self> where
    T: Copy, 

See GcRawVec::iter

impl<'gc, T: GcSafe<'gc, EpsilonCollectorId>> EpsilonRawVec<'gc, T>

pub fn with_capacity_in(capacity: usize, ctx: &'gc EpsilonContext) -> Self

See IGcVec::with_capacity_in

pub fn len(&self) -> usize

See IGcVec::len

pub unsafe fn set_len(&mut self, len: usize)

See IGcVec::set_len

pub fn capacity(&self) -> usize

See IGcVec::capacity

pub fn reserve_in_place(
    &mut self,
    _additional: usize
) -> Result<(), ReallocFailedError>

See IGcVec::reserve_in_place

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

See IGcVec::as_ptr

pub fn context(&self) -> &'gc EpsilonContext

See IGcVec::context

pub unsafe fn as_mut_ptr(&mut self) -> *mut T

See IGcVec::as_mut_ptr

pub fn replace(&mut self, index: usize, val: T) -> T

See IGcVec::replace

pub fn set(&mut self, index: usize, val: T)

See IGcVec::set

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

See IGcVec::extend_from_slice

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

See IGcVec::push

pub fn pop(&mut self) -> Option<T>

See IGcVec::pop

pub fn swap_remove(&mut self, index: usize) -> T

See IGcVec::swap_remove

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

See IGcVec::reserve

pub fn is_empty(&self) -> bool

See IGcVec::is_empty

pub fn new_in(ctx: &'gc EpsilonContext) -> Self

See IGcVec::new_in

pub fn copy_from_slice(src: &[T], ctx: &'gc EpsilonContext) -> Self where
    T: Copy, 

See IGcVec::copy_from_slice

pub fn from_vec(src: Vec<T>, ctx: &'gc EpsilonContext) -> Self

See IGcVec::from_vec

pub fn get(&mut self, index: usize) -> Option<T> where
    T: Copy, 

See IGcVec::get

pub unsafe fn as_slice_unchecked(&self) -> &[T]

See IGcVec::as_slice_unchecked

Trait Implementations

impl<'gc, T> Clone for EpsilonRawVec<'gc, T>

fn clone(&self) -> Self

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<'gc, T: GcSafe<'gc, EpsilonCollectorId>> Extend<T> for EpsilonRawVec<'gc, T>

fn extend<E: IntoIterator<Item = T>>(&mut self, iter: E)

Extends a collection with the contents of an iterator.

fn extend_one(&mut self, item: A)

🔬 This is a nightly-only experimental API. (extend_one)

Extends a collection with exactly one element.

fn extend_reserve(&mut self, additional: usize)

🔬 This is a nightly-only experimental API. (extend_one)

Reserves capacity in a collection for the given number of additional elements.

impl<'gc, T: GcSafe<'gc, EpsilonCollectorId>> GcRawVec<'gc, T> for EpsilonRawVec<'gc, T>

unsafe fn steal_as_array_unchecked(self) -> GcArray<'gc, T, EpsilonCollectorId>

Steal ownership of this vector, converting it into a [GcArray].

fn iter(&self) -> RawVecIter<'gc, T, Self> where
    T: Copy, 

Iterate over the elements of the vectors

impl<'gc, 'new_gc, T: GcSafe<'gc, EpsilonCollectorId>> GcRebrand<'new_gc, EpsilonCollectorId> for EpsilonRawVec<'gc, T> where
    T: GcRebrand<'new_gc, EpsilonCollectorId>,
    T::Branded: Sized, 

type Branded = EpsilonRawVec<'new_gc, T::Branded>

This type with all garbage collected lifetimes changed to 'new_gc

impl<'gc, T: GcSafe<'gc, EpsilonCollectorId>> GcSafe<'gc, EpsilonCollectorId> for EpsilonRawVec<'gc, T> where
    T: GcSafe<'gc, EpsilonCollectorId>,
    T: Trace, 

unsafe fn trace_inside_gc<Visitor>(
    gc: &mut Gc<'gc, Self, EpsilonCollectorId>,
    visitor: &mut Visitor
) -> Result<(), Visitor::Err> where
    Visitor: GcVisitor, 

Trace this object behind a Gc pointer.

impl<'gc, T: GcSafe<'gc, EpsilonCollectorId>> IGcVec<'gc, T> for EpsilonRawVec<'gc, T>

type Id = EpsilonCollectorId

The id of the collector

fn with_capacity_in(capacity: usize, ctx: &'gc EpsilonContext) -> Self

Allocate a new vector with the specified capacity, using the specified context.

fn len(&self) -> usize

The length of the vector.

unsafe fn set_len(&mut self, len: usize)

Set the length of the vector.

fn capacity(&self) -> usize

The total amount of space that is available without needing reallocation.

fn reserve_in_place(
    &mut self,
    _additional: usize
) -> Result<(), ReallocFailedError>

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

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

Get a pointer to this vector’s underling data.

fn context(&self) -> &'gc EpsilonContext

Get the GcContext that this vector is associated with.

fn from_vec(src: Vec<T>, ctx: &'gc <Self::Id as CollectorId>::Context) -> Self

Copy the specified elements into a new vector, allocating it in the specified context

fn copy_from_slice(
    src: &[T],
    ctx: &'gc <Self::Id as CollectorId>::Context
) -> Self where
    T: Copy, 

Copy the specified elements into a new vector, allocating it in the specified context

fn new_in(ctx: &'gc <Self::Id as CollectorId>::Context) -> Self

Allocate a new vector inside the specified context

fn is_empty(&self) -> bool

Check if this vector is empty

fn reserve(&mut self, additional: usize)

Reserves capacity for at least additional.

fn push(&mut self, val: T)

Push the specified element onto the end of this vector.

fn pop(&mut self) -> Option<T>

Pop an element of the end of the vector, returning None if empty.

fn swap_remove(&mut self, index: usize) -> T

Removes an element from the vector and returns it.

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

Extend the vector with elements copied from the specified slice

fn get(&self, idx: usize) -> Option<T> where
    T: Copy, 

Get the item at the specified index, or None if it is out of bounds.

fn set(&mut self, index: usize, val: T)

Set the item at the specified index

fn replace(&mut self, index: usize, val: T) -> T

Replace the item at the specified index, returning the old value.

unsafe fn as_mut_ptr(&mut self) -> *mut T

Get a mutable pointer to the vector’s underlying data.

unsafe fn as_slice_unchecked(&self) -> &[T]

Get a slice of this vector’s elements.

impl<'gc, T: GcSafe<'gc, EpsilonCollectorId>> Trace for EpsilonRawVec<'gc, 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 trace<Visitor: GcVisitor + ?Sized>(
    &mut self,
    visitor: &mut Visitor
) -> Result<(), Visitor::Err>

Trace each field in this type.

impl<'gc, T> Copy for EpsilonRawVec<'gc, T>

impl<'gc, T: GcSafe<'gc, EpsilonCollectorId>> TrustedDrop for EpsilonRawVec<'gc, T> where
    T: TrustedDrop,