Struct Port 

pub struct Port<T, const BUF_SIZE: usize>
where
    T: Transcendental,
{
    pub id: PortId,
    pub name: String,
    pub direction: PortDirection,
    pub action: Option<Box<dyn Algorithm<T>>>,
    pub pending_command: Option<T>,
    pub buffer: Buffer<T, BUF_SIZE>,
    pub feedback_buffer: Option<Buffer<T, BUF_SIZE>>,
    pub downstream: Vec<(usize, usize)>,
    pub feedback_downstream: Vec<(usize, usize)>,
}

A port on a node.

Each port has an owned Buffer<T, BUF_SIZE> for its data and an optional Action that defines per-port processing. Output ports typically have an action; input ports may have one for preprocessing.

Ports can optionally participate in feedback edges:

• On an output port in a feedback edge, feedback_buffer stores the previous block’s output, snapshotted after DSP via snapshot_feedback().
• On an input port in a feedback edge, feedback_buffer holds the delayed feedback value that gets mixed into buffer by pre_process().
• downstream lists audio connections from this output port to input ports of other nodes, populated at build time by the graph builder.

Fields

id: PortId

Port identifier

name: String

Port name

direction: PortDirection

Port direction (input/output)

action: Option<Box<dyn Algorithm<T>>>

Per-port processing algorithm (None for simple input ports)

pending_command: Option<T>

Pending command value from the control path, delivered to the algorithm via Algorithm::apply_command() before the next process() call. When there is no algorithm, this value is written directly into the buffer.

buffer: Buffer<T, BUF_SIZE>

Owned audio buffer

feedback_buffer: Option<Buffer<T, BUF_SIZE>>

Delayed feedback state (None if not on a feedback edge). On output ports: snapshotted from buffer after DSP for next block. On input ports: receives the delayed feedback from the source output, mixed into buffer by pre_process().

downstream: Vec<(usize, usize)>

Downstream audio connections: (target_node_index, target_port_index). Set at build time by GraphBuilder; immutable during processing.

feedback_downstream: Vec<(usize, usize)>

Feedback edge targets from this output port: (target_node_index, target_port_index). Populated at build time by GraphBuilder; the delayed feedback buffer is written to these input ports by a processing driver.

Implementations

impl<T, const BUF_SIZE: usize> Port<T, BUF_SIZE>

where T: Transcendental,

pub fn output(node_id: NodeId, index: u16, name: &str) -> Port<T, BUF_SIZE>

Create a new audio output port

pub fn output_with_action( node_id: NodeId, index: u16, name: &str, action: Box<dyn Algorithm<T>>, ) -> Port<T, BUF_SIZE>

Create a new audio output port with an algorithm

pub fn input(node_id: NodeId, index: u16, name: &str) -> Port<T, BUF_SIZE>

Create a new audio input port

pub fn control_output( node_id: NodeId, index: u16, name: &str, ) -> Port<T, BUF_SIZE>

Create a new control output port

pub fn control_output_with_action( node_id: NodeId, index: u16, name: &str, action: Box<dyn Algorithm<T>>, ) -> Port<T, BUF_SIZE>

Create a new control output port with an algorithm

pub fn control_input( node_id: NodeId, index: u16, name: &str, ) -> Port<T, BUF_SIZE>

Create a new control input port

pub fn id(&self) -> PortId

Get the port ID

pub fn name(&self) -> &str

Get the port name

pub fn is_input(&self) -> bool

Check if port is an input

pub fn is_output(&self) -> bool

Check if port is an output

pub fn buffer(&self) -> &Buffer<T, BUF_SIZE>

Get a reference to the buffer

pub fn buffer_mut(&mut self) -> &mut Buffer<T, BUF_SIZE>

Get a mutable reference to the buffer

pub fn pre_process(&mut self, _tick: &ClockTick)

Pre-process this port before node DSP.

For input ports on a feedback edge, mixes the delayed feedback (from feedback_buffer) into the current buffer. No-op when feedback_buffer is None.

tick is the current clock tick, available for future sample-accurate or time-varying port-level processing.

pub fn snapshot_feedback(&mut self)

Snapshot the buffer into feedback_buffer after node DSP.

For output ports on a feedback edge, saves the current buffer so it can be used as delayed feedback in the next block. No-op when feedback_buffer is None.

pub fn propagate( &self, _tick: &ClockTick, nodes: &mut [NodeVariant<T, BUF_SIZE>], )

Propagate this port’s buffer to all downstream input ports.

Iterates over downstream and copies buffer into each target input port’s buffer. The caller must ensure no aliasing between this port’s node and any target node (guaranteed by DAG topology).

tick is the current clock tick, available for future sample-accurate or time-varying port-level propagation.

pub fn run_action( &mut self, input: Option<&[T; BUF_SIZE]>, ctx: &ActionContext<'_>, ) -> Result<(), ProcessError>

Run the port’s algorithm.

Delivers any pending command via Algorithm::apply_command(), then calls Algorithm::process() with the input and output slices. When no algorithm is attached, the pending command value (if any) is written directly into the buffer; otherwise input is passed through or zero-filled.

pub fn set_value(&mut self, value: T)

Set a command value for this port.

The value is stored as a pending command and delivered to the algorithm (or written directly to the buffer) on the next run_action() call.

Trait Implementations

impl<T, const BUF_SIZE: usize> ActivePort<T, BUF_SIZE> for Port<T, BUF_SIZE>

where T: Transcendental,

fn pull(&mut self) -> Option<[T; BUF_SIZE]>

Pull data from the port (for input ports).

fn push(&mut self, data: [T; BUF_SIZE]) -> Result<(), PortError>

Push data into the port (for output ports).

fn is_connected(&self) -> bool

Check if the port is connected.

fn on_tick(&mut self, _tick: &ClockTick)

Called on each clock tick (optional).

impl<T, const BUF_SIZE: usize> Debug for Port<T, BUF_SIZE>

where T: Transcendental,

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

Formats the value using the given formatter.