Struct ResultDispenser 

pub struct ResultDispenser { /* private fields */ }

Wraps an inner OpDispenser to expose declared op-result fields as Polydat named wires (SRD-40b §5).

Per cycle, after the inner adapter returns its OpResult, this wrapper walks the op template’s result: HashMap<String, ResultWireSpec> declarations, computes each value from the result body, and writes it through ctx.wires.write(name, value) onto the per-fiber op-template kernel’s input slot. Wrappers later in the stack (e.g. MetricsDispenser) read freshly through ctx.wires.get(name), so SRD-40b §5.2 metric evaluation sees the values landed this cycle — no HashMap intermediary.

Insertion order in the wrapper stack (SRD-40b §5.2): inner adapter → ResultDispenser → MetricsDispenser (Phase E).

Source grammars (SRD-40b §5.1):

• count — built-in; OpResult::body.element_count().
• ok — built-in; true iff the inner adapter returned Ok(_) (errors short-circuit before this wrapper’s body runs, so reaching this code already implies success — ok is true unless the result was a skip).
• <path-expr> — JSON-pointer-style lookup into the result body. Supports bare names (field), dotted paths (rows.0.field), and bracketed indices (rows[0].field).
• <polydat-call> — DEFERRED. Recognized as anything containing a ( token; currently logged once and skipped. Phase E or a follow-up adds the GK-eval-against-result-context path.

Implementations

impl ResultDispenser

pub fn wrap( inner: Arc<dyn OpDispenser>, result_spec: Option<&ResultSpec>, interface_results: Option<&BTreeMap<String, String>>, ) -> Arc<dyn OpDispenser>

Wrap an inner dispenser with result-as-GK exposure (SRD-40b §5.2’s result-as-GK adapter layer).

Always wraps. Per the SRD, this layer is part of the canonical per-cycle pipeline: it writes the magic externs (body / count / ok) into the op-template kernel’s input slots after the inner adapter returns, so any downstream wrapper (metrics, validation, conditional next op) reading those names through ctx.wires.get sees fresh values. Writes to slots the kernel didn’t allocate (the closure-binding economy’s DCE) silently no-op via WriteOutcome::NoSlot — no overhead for ops whose op-template kernel doesn’t reference any magic extern.

The optional result_spec adds additional dispenser-side dispatch slots (legacy SRD-40b §5.1 path-expr / count / ok map-shape forms). Kernel-driven entries (string-shape source blocks, polydat-call entries) need no per-cycle code here — add_result_bindings compiled them into the op-template kernel; the magic-extern population this wrapper always performs is what makes them resolve.

Trait Implementations

impl OpDispenser for ResultDispenser

fn execute<'a>( &'a self, cycle: u64, ctx: &'a ExecCtx<'a>, ) -> Pin<Box<dyn Future<Output = Result<OpResult, ExecutionError>> + Send + 'a>>

Execute an operation for the given cycle.

fn inner_dispenser(&self) -> Option<&dyn OpDispenser>

Returns the wrapped dispenser when this is a wrapper, None when this is a leaf (the adapter’s base dispenser — e.g. CQL raw / prepared / batch, HTTP, stdout, plotter, …).

fn describe(&self) -> Option<String>

One-line description of the op this dispenser represents — typically the statement text / request shape with bind-point placeholders left unresolved ({table}, {key}, ?, …).

fn describe_resolved(&self, wires: &dyn WireSource) -> Option<String>

Render the actual op the dispenser would fire for the given cycle — the dryrun-equivalent view of the statement after every bind point is interpolated.

fn canonical_kernel(&self) -> Option<&Arc<dyn Kernel>>

SRD-68 invariant I-3 — the dispenser’s canonical Polydat Kernel, established at construction by map_op from its parent — the parent itself, or a kernel bound under it. Any engine: the executor finds the program to bind per fiber by program_id. Returns None for dispensers that don’t own a kernel (adapters with no Polydat needs, or wrappers that delegate to an inner dispenser).

fn adapter_metrics(&self) -> Vec<(String, Labels, MetricValue)>

Snapshot adapter-specific metrics for inclusion in the capture snapshot.

fn status_counters(&self) -> Vec<(&str, u64)>

Adapter-specific status line entries (cumulative, non-destructive read).

fn rows_per_op(&self) -> usize

The op’s uniform per-invocation cursor consumption — how many consecutive wire ordinals one execute call reads and covers.

impl WrappingDispenser for ResultDispenser