Struct FrameContext 

pub struct FrameContext<'a> {
    pub scratch: &'a Arena,
}

Frame-scoped facilities a system may use for the duration of its step.

The scratch arena is reset by the frame loop, so nothing allocated from it may outlive the step that allocated it. That is enforced rather than documented: reset takes &mut Arena, so the borrow checker will not let the loop reclaim the arena while any allocation from it is still live.

Take the arena out before using the rest of the context:

let scratch = ctx.frame.scratch;   // an &Arena that outlives this borrow
let mut ids = scratch.vec::<Entity>(count)?;
// `ctx` is still free to be used mutably here

The copy matters. scratch is a shared reference with the context’s own lifetime, so copying it out detaches it from the borrow of ctx and leaves the context usable. Reaching through ctx.frame.scratch at each call site instead would hold ctx borrowed for as long as the allocation lives.

Fields

scratch: &'a Arena

Bump scratch for temporaries that do not outlive this frame. Returns None when full, which is the caller’s cue to fall back to the heap; the frame loop reports that it happened rather than absorbing it.

Implementations

impl<'a> FrameContext<'a>

pub fn new(scratch: &'a Arena) -> Self

A context over one frame’s scratch arena.

pub fn collect<T, I>(&self, items: I) -> FrameVec<'a, T>

where T: Copy, I: IntoIterator<Item = T>,

Gather items into frame scratch, falling back to the heap if the reserve is exhausted.

This is the shape most frame temporaries take: a system reads something out of the context, needs the context mutably to act on it, and so has to copy the values out first to end the borrow. That copy is what the arena is for. Reserves from the iterator’s upper size bound, so anything that knows how much it can yield qualifies – not just ExactSizeIterator. An unbounded iterator goes to the heap rather than guessing a reservation.

pub fn filled<T: Copy>(&self, len: usize, value: T) -> FrameVec<'a, T>

len copies of value in frame scratch, falling back to the heap if the reserve is exhausted.

The mutable counterpart to collect: a working frame a system fills in as it runs, rather than a gathered set it reads back.

pub fn vec<T: Copy>(&self, capacity: usize) -> FrameVec<'a, T>

An empty frame temporary reserving room for capacity pushes, falling back to the heap if the reserve is exhausted.

For the gathers collect cannot express: values found by a loop that also mutates what it walks, so no iterator exists to hand over. Reserve the loop’s upper bound; a push past it moves the values to the heap (see FrameVec::push) rather than failing.

Trait Implementations

impl<'a> Clone for FrameContext<'a>

fn clone(&self) -> FrameContext<'a>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<'a> Copy for FrameContext<'a>