Struct NodeIo 

pub struct NodeIo<'a> { /* private fields */ }

Minimal node I/O surface backed by executor queues.

use daedalus_runtime::io::NodeIo;
use daedalus_runtime::executor::EdgePayload;

fn handler(io: &mut NodeIo) {
    io.push_output(Some("out"), EdgePayload::Unit);
}

Implementations

impl<'a> NodeIo<'a>

pub fn new( incoming_edges: Vec<usize>, outgoing_edges: Vec<usize>, queues: &'a Arc<Vec<EdgeStorage>>, warnings_seen: &'a Arc<Mutex<HashSet<String>>>, edges: &'a [(NodeRef, String, NodeRef, String, EdgePolicyKind)], sync_groups: Vec<SyncGroup>, seg_idx: usize, node_idx: usize, node_id: String, telemetry: &'a mut ExecutionTelemetry, backpressure: BackpressureStrategy, const_inputs: &[(String, Value)], const_coercers: Option<ConstCoercerMap>, output_movers: Option<OutputMoverMap>, ) -> Self

Construct the I/O facade for a node (internal runtime API).

pub fn inputs(&self) -> &[(String, CorrelatedPayload)]

Returns the consumed inputs for this node. Borrow the drained inputs.

use daedalus_runtime::io::NodeIo;
fn handler(io: &NodeIo) {
    let _ = io.inputs();
}

pub fn has_incoming_edges(&self) -> bool

Whether this node has any incoming edges.

pub fn sync_groups(&self) -> &[SyncGroup]

Returns sync groups metadata for this node. Return sync group metadata.

use daedalus_runtime::io::NodeIo;
fn handler(io: &NodeIo) {
    let _ = io.sync_groups();
}

pub fn push_output(&mut self, port: Option<&str>, payload: EdgePayload)

Push a payload to all outgoing edges (fan-out). Optionally filter by port. Push a prepared payload to an output port.

use daedalus_runtime::io::NodeIo;
use daedalus_runtime::executor::EdgePayload;
fn handler(io: &mut NodeIo) {
    io.push_output(Some("out"), EdgePayload::Unit);
}

pub fn push_correlated_payload( &mut self, port: Option<&str>, correlated: CorrelatedPayload, )

Push a pre-correlated payload (used by host-bridge style nodes).

pub fn push_any<T: Any + Send + Sync + 'static>( &mut self, port: Option<&str>, value: T, )

pub fn push_typed<T>(&mut self, port: Option<&str>, value: T)

where T: Any + Clone + Send + Sync + 'static,

pub fn push_value(&mut self, port: Option<&str>, value: Value)

Push a Value payload to an output port.

use daedalus_runtime::io::NodeIo;
use daedalus_data::model::Value;
fn handler(io: &mut NodeIo) {
    io.push_value(Some("out"), Value::Int(1));
}

pub fn inputs_for<'b>( &'b self, port: &str, ) -> impl Iterator<Item = &'b CorrelatedPayload>

Iterate all inputs for a given port name. Iterate inputs for a named port.

use daedalus_runtime::io::NodeIo;
fn handler(io: &NodeIo) {
    for _payload in io.inputs_for("in") {}
}

pub fn get_any<T: Any + Clone + Send + Sync>(&self, port: &str) -> Option<T>

Typed accessor for Any payloads.

pub fn get_any_ref<T: Any + Send + Sync>(&self, port: &str) -> Option<&T>

Borrow a typed Any payload without cloning.

pub fn get_typed_ref<T>(&self, port: &str) -> Option<&T>

where T: Any + Clone + Send + Sync,

Borrow a typed input with constant coercion support.

pub fn get_any_mut<T>(&mut self, port: &str) -> Option<T>

where T: Any + Clone + Send + Sync,

Move a typed Any payload, cloning only when shared.

pub fn get_typed_mut<T>(&mut self, port: &str) -> Option<T>

where T: Any + Clone + Send + Sync,

Move a typed input with constant coercion support, cloning only when shared.

pub fn get_any_all<T: Any + Clone + Send + Sync>(&self, port: &str) -> Vec<T>

Collect all typed Any payloads for a port (in arrival order).

pub fn get_any_all_fanin<T: Any + Clone + Send + Sync>( &self, prefix: &str, ) -> Vec<T>

Collect typed Any payloads for indexed fan-in ports {prefix}{N} ordered by N.

Example: prefix="in" collects from in0, in1, … in numeric order.

pub fn get_any_all_fanin_indexed<T: Any + Clone + Send + Sync>( &self, prefix: &str, ) -> Vec<(u32, T)>

Collect typed Any payloads for indexed fan-in ports {prefix}{N} ordered by N, preserving the parsed index.

pub fn get_typed<T>(&self, port: &str) -> Option<T>

where T: Any + Clone + Send + Sync,

Best-effort typed accessor that supports constant defaults.

Daedalus graph JSON encodes constant inputs as daedalus_data::model::Value. At runtime we inject these into the node as Any payloads (e.g. i64, f64, bool, String, or Value). This helper bridges the gap so node handlers can request their native types (e.g. u32, f32, enums) without failing a TypeId downcast.

This is intended for scalar/enum config inputs, not large payload types (e.g. image buffers).

pub fn get_any_raw(&self, port: &str) -> Option<&dyn Any>

Get a raw Any reference for capability-based dispatch.

pub fn get_value(&self, port: &str) -> Option<&Value>

Convenience accessor for value payloads. Get a structured Value payload for a port.

use daedalus_runtime::io::NodeIo;
fn handler(io: &NodeIo) {
    let _ = io.get_value("in");
}

pub fn get_int(&self, port: &str) -> Option<i64>

pub fn get_float(&self, port: &str) -> Option<f64>

pub fn inputs_grouped(&self) -> Vec<(String, Vec<&CorrelatedPayload>)>

Group inputs by port name (preserves encounter order per port).

pub fn flush(&mut self) -> Result<(), ExecuteError>

Flush is a no-op now since we apply immediately; kept for symmetry.