Struct BufferedOutputObserver 

pub struct BufferedOutputObserver<O, E>
where
    O: Write + Send,
    E: Write + Send,
{ /* private fields */ }

Buffered-mode RunObserver per EXEC-016.

See the module-level docs for the presentation contract. Constructed with two sinks via Self::new; the inner sinks can be reclaimed with Self::into_inner after the run completes.

Errors

Same write-failure contract as LiveOutputObserver.

Implementations

impl<O, E> BufferedOutputObserver<O, E>

where O: Write + Send, E: Write + Send,

pub fn new(stdout: O, stderr: E) -> Self

Build an observer that accumulates per-task bytes and emits them as two contiguous blocks (stdout then stderr) on task completion, with prefix and summary-line rendering delegated to PlainPresenter. Equivalent to Self::with_presenter called with Arc::new(PlainPresenter).

pub fn with_presenter( stdout: O, stderr: E, presenter: Arc<dyn TaskPresenter>, ) -> Self

Build an observer that delegates prefix and summary-line rendering to presenter. Buffered mode ignores the prefix (captured bytes flush verbatim), but the presenter’s summary_* methods are still consulted on terminal callbacks; a None return suppresses the summary line.

pub fn into_inner(self) -> (O, E)

Reclaim the two sinks after the run has finished. Returns (stdout, stderr).

Trait Implementations

impl<O, E> RunObserver for BufferedOutputObserver<O, E>

where O: Write + Send, E: Write + Send,

fn on_task_started(&self, task: &TaskId)

Called once at the start of the run, before any cache work.

fn on_stdout(&self, task: &TaskId, bytes: &[u8])

One chunk of captured stdout bytes. For a cache hit, called exactly once with the recorded stdout in full. For a fresh run, the call shape depends on the observer’s presentation strategy: a buffered observer typically receives a single call with the whole captured stdout; a live observer may receive many sub-line chunks as bytes flow from the pipe.

fn on_stderr(&self, task: &TaskId, bytes: &[u8])

One chunk of captured stderr bytes. Same call shape as Self::on_stdout.

fn on_task_finished(&self, task: &TaskId, record: &CompletedRecord)

Called once at the end of the run with the run-record classification. Fires only for tasks the scheduler admitted into the lookup-then-spawn pipeline; cascade- skipped tasks surface through Self::on_task_skipped instead.

fn on_task_skipped(&self, task: &TaskId, record: &SkipRecord)

Called once at the moment the scheduler marks task cascade-skipped per EXEC-010 / EXEC-011. Fires before the next admission round; NEVER paired with Self::on_task_started or Self::on_task_finished for the same task.

fn on_task_cancelled(&self, task: &TaskId, record: &CancelledRecord)

Called once at the moment the cancellation flow records a terminal state for task per EXEC-012..015. The CancelledRecord variant distinguishes the three shapes: an in-flight task that was signalled by the executor; a cascade descendant of a cancelled task; or a task drained from state.ready on cancel-fire. For an in-flight task, Self::on_task_started has already fired and Self::on_task_finished does NOT fire; for the other two shapes, no other lifecycle callback fires for the same task.