Struct Stage 

pub struct Stage { /* private fields */ }

A running stage: the slots, and the one lock every terminal write inside the stage goes through.

Implementations

impl Stage

pub fn begin(settings: &Settings, names: &[&str]) -> Arc<Stage>

A stage over names, in dispatch order. Does nothing visible until checks start entering (the region) or finishing (the blocks).

pub fn enter(self: &Arc<Stage>, idx: usize) -> SinkGuard

Route this thread’s say calls into slot idx until the guard drops. Installed by the dispatcher around each check.run. Also starts the slot’s clock and puts it in the region.

pub fn queue(&self, idx: usize, since: Option<(Instant, u64)>)

Slot idx is waiting for a host slot (Some), or no longer is.

pub fn attach( self: &Arc<Stage>, idx: usize, activity: Arc<Activity>, ) -> AttachGuard

Show slot idx’s spawned command in the displays while the returned guard lives. A check that runs several commands in turn attaches each one; between them the slot falls back to its own output clock.

pub fn append_raw(&self, idx: usize, bytes: &[u8])

Append raw bytes (a captured child’s output) to slot idx.

pub fn finish(&self, settings: &Settings, idx: usize)

The check is over: emit everything it said as ONE contiguous write, with the region lifted out of the way first and repainted after — blocks pile up above, spinners stay below.

Called by the dispatcher after check.run returns (still on the check’s thread, so a torn-down thread cannot strand a buffer — the same catch_unwind that feeds the dead-check outcome runs first).

Trait Implementations

impl Drop for Stage

fn drop(&mut self)

The stage’s end erases whatever the region still shows — a Block verdict, a panic on the dispatcher path, anything: no spinner junk above the roll-up. (get_mut: dropping proves no other thread holds the stage, so the locks are free.)

fn pin_drop(self: Pin<&mut Self>)

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

Execute the destructor for this type, but different to Drop::drop, it requires self to be pinned.