Struct RecordBuffer 

pub struct RecordBuffer { /* private fields */ }

Collects the record of every dispatch it is told about, in the order the dispatches began, whatever order they resolve in. A dispatch recorded by it (Dispatch::recorded_by), and every dispatch nested in it, becomes one EffectRecord once resolved: a layer’s discard drops it and a patch replaces its request, as an effect log keeps them. Clones share the records.

It keeps no handler descriptions and no delivery boundaries: an owner that writes a log keeps those itself. Its records are Disposition::Ran with no reviewed outcome; a host that answers, reviews or cancels effects itself sets those on the records it takes.

Implementations

impl RecordBuffer

pub fn new() -> Self

An empty buffer that records a stream as its folded outcome and keeps no times.

pub fn keeping_stream_events(self) -> Self

This buffer keeping a streamed dispatch’s items verbatim in its record (EffectRecord::events), so a replay re-emits the original delta boundaries.

pub fn timed(self) -> Self

This buffer stamping each record with the wall-clock time its dispatch began (EffectRecord::started_ms) and resolved (EffectRecord::finished_ms). Without it records carry no times, so a recording is the same on every run.

pub fn take(&self, id: EffectId) -> Option<EffectRecord>

Takes the record of id once it resolved; None while it is in flight, or when the buffer has none.

pub fn take_resolved(&self) -> Vec<EffectRecord>

Takes every resolved record, in the order the dispatches began, leaving the ones in flight.

pub fn take_resolved_where( &self, take: impl FnMut(EffectId) -> bool, ) -> Vec<EffectRecord>

Takes every resolved record whose id take accepts, in the order the dispatches began, leaving the rest.

pub fn records(&self) -> Vec<EffectRecord>

A copy of every resolved record, in the order the dispatches began.

pub fn contains(&self, id: EffectId) -> bool

Whether the buffer holds a record of id, resolved or not.

pub fn remove(&self, id: EffectId) -> Option<HandlerKey>

Drops the record of id, resolved or not; the key its dispatch was routed to, or None when the buffer held none.

pub fn kept_events(&self, id: EffectId) -> Option<usize>

How many streamed items the record of id keeps so far, or None when it keeps none.

pub fn resolved(&self) -> usize

Records resolved and not yet taken.

pub fn in_flight(&self) -> usize

Records begun and not yet resolved.

Trait Implementations

impl Clone for RecordBuffer

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for RecordBuffer

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for RecordBuffer

fn default() -> Self

Returns the “default value” for a type.

impl Recorder for RecordBuffer

fn handlers(&self, _handlers: Vec<HandlerDescriptor>)

Handlers the driver serves: those registered when recording started, then each one installed later, as it is installed. A key described again is the same handler re-registered; the latest description stands.

fn begin( &self, id: EffectId, key: HandlerKey, kind: EffectKind, origin: DispatchContext, )

A dispatch begins: its id, the key it was routed to, the effect, and where it came from (its parent and scope).

fn discard(&self, id: EffectId)

Removes a begun dispatch decided by a layer before handler execution. Replay reruns layer decisions rather than recording them as handler outcomes.

fn patch(&self, id: EffectId, kind: EffectKind)

Replaces the recorded request with a same-family layer patch, so it reflects the request served by the innermost handler.

fn keep_events(&self) -> bool

Whether streamed items are wanted verbatim (Self::event).

fn event(&self, id: EffectId, item: &Item<StreamEvent>)

One streamed item of id.

fn origin(&self, id: EffectId, origin: &Origin)

Who the streamed reply of id is from, before its first item, when keep_events says so.

fn tool_output(&self, id: EffectId, output: ToolResultContext)

Explicitly published output, a tool’s or a layer’s facts, delivered before resolve. A driver snapshots it without consuming the caller’s published context.

fn resolve(&self, id: EffectId, outcome: Result<Answered, ErrorReport>)

The outcome of id.

fn stream_error(&self, _id: EffectId, _error: &ErrorReport)

An error item at its original position in a kept stream. Unlike the folded outcome, this includes errors after an earlier terminal item.