Struct rustc_arena_modified::typed_arena::TypedArenaGen

pub struct TypedArenaGen<T, RM: RefMutability> { /* private fields */ }

An arena that can hold objects of only one type. RM determines whether the references returned from allocation are mutable and whether iteration requires a mutable reference; either mutating returned references or iterating via immutable reference are possible, but not both.

Implementations

impl<T, RM: RefMutability> TypedArenaGen<T, RM>

pub fn new() -> Self

Creates a new, empty arena

pub fn alloc(&self, object: T) -> RM::Ref<'_, T>

Allocates an object in the TypedArena, returning a reference to it.

If the type parameter RM is Shared we return a shared reference. If RM is Mutable we return a mutable reference.

pub fn alloc_from_iter_reg( &self, iter: impl IntoIterator<Item = T> ) -> RM::SliceRef<'_, T>

Allocates multiple objects in a contiguous slice, returning a reference to the slice.

If the type parameter RM is Shared we return a shared reference. If RM is Mutable we return a mutable reference.

This collects into a SmallVec and then allocates by copying from it. Use alloc_from_iter if possible because it’s more efficient, copying directly without the intermediate collecting step. This default could be made more efficient, like crate::DroplessArena::alloc_from_iter, but it’s not hot enough to bother.

pub fn alloc_from_iter_fast( &self, iter: impl IterWithFastAlloc<T> ) -> RM::SliceRef<'_, T>

Allocates multiple objects in a contiguous slice, returning a reference to the slice.

If the type parameter RM is Shared we return a shared reference. If RM is Mutable we return a mutable reference.

This is equivalent semantics to Self::alloc_from_iter_reg except it’s faster, whereas Self::alloc_from_iter_reg permits more types.

pub fn len(&self) -> usize

Number of allocated elements in the arena.

pub fn is_empty(&self) -> bool

Does the arena have any allocated elements?

pub fn iter_mut(&mut self) -> IterMut<'_, T>

Iterates all allocated elements in the arena behind a mutable reference.

pub fn ptr_iter(&self) -> PtrIter<'_, T>

Iterates pointers to all allocated elements in the arena behind a shared reference. This is allows since we can have pointers even to mutably borrowed elements.

pub fn clear(&mut self)

Clears the arena, dropping all elements, but doesn’t free up its memory.

This means we can insert new elements without having to reallocate, until we reach the old capacity or allocate a slice too large to fit in an existing region.

pub fn retain(&mut self, predicate: impl FnMut(&mut T) -> bool)

Removes some elements from this arena, and coalesces the rest so that we don’t have gaps.

Pointers to regions in the memory may be invalidated as elements get rearranged. This function is behind a mutable reference, which ensures that there are no references to rearranged elements, but if there are any raw pointers they can no longer be dereferenced without UB.

pub fn convert<RM2: RefMutability>(self) -> TypedArenaGen<T, RM2>

Return self but with a different RefMutability.

With a mutable reference, we can convert between mutable and immutable variants, since there are no live allocated references.

pub fn into_vec(self) -> Vec<T>

Destroys this arena and collects all elements into a vector.

pub unsafe fn alloc_raw_slice(&self, len: usize) -> *mut T

Allocate a contiguous slice of data and return a pointer to the start of the slice. The slice is uninitialized (why we return a pointer), and you must initialize it before calling other arena methods or dropping the arena, or you will cause UB.

Safety

You must initialize the slice before calling other arena methods or dropping the arena. If iterating, you must initialize the slice before advancing the iterator.

impl<T> TypedArenaGen<T, Shared>

pub fn iter(&self) -> Iter<'_, T>

Iterates all allocated elements in the arena behind a shared reference.

The iterator can handle new objects being allocated. If you allocate new objects they will be added to the end. If the iterator has already ended and you allocate new objects, it will suddenly have more elements; if you don’t want that behavior use fuse.

Trait Implementations

impl<T, RM: RefMutability> Default for TypedArenaGen<T, RM>

fn default() -> Self

Creates a new, empty arena

impl<T, RM: RefMutability> Drop for TypedArenaGen<T, RM>

fn drop(&mut self)

Executes the destructor for this type.

impl<'a, T> IntoIterator for &'a TypedArenaGen<T, Shared>

type Item = &'a T

The type of the elements being iterated over.

type IntoIter = IterGen<'a, T, Shared>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<'a, T, RM: RefMutability> IntoIterator for &'a mut TypedArenaGen<T, RM>

type Item = &'a mut T

The type of the elements being iterated over.

type IntoIter = IterGen<'a, T, Mutable>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<T: Send, RM: RefMutability> Send for TypedArenaGen<T, RM>