Struct ProcessingGraph 

pub struct ProcessingGraph {
    pub nodes: Vec<GraphNode>,
    pub edges: Vec<GraphEdge>,
    pub is_locked: bool,
}

A directed acyclic graph of media processing nodes.

Fields

nodes: Vec<GraphNode>

All nodes in the graph.

edges: Vec<GraphEdge>

All edges in the graph.

is_locked: bool

When true the graph is considered executing and hot-swap is refused.

Implementations

impl ProcessingGraph

pub fn new() -> Self

Creates an empty processing graph.

pub fn add_node(&mut self, node: GraphNode)

Adds node to the graph. Duplicate IDs are allowed but discouraged.

pub fn remove_node(&mut self, id: u64) -> bool

Removes the node with id and all edges referencing it.

Returns true if a node was removed.

pub fn connect( &mut self, from: u64, from_port: u32, to: u64, to_port: u32, ) -> bool

Adds an edge from (from, from_port) to (to, to_port).

Returns false if either node does not exist; true on success.

pub fn disconnect(&mut self, from: u64, to: u64) -> bool

Removes all edges from node from to node to.

Returns true if at least one edge was removed.

pub fn source_nodes(&self) -> Vec<&GraphNode>

Returns references to all nodes whose type has zero inputs (source nodes).

pub fn sink_nodes(&self) -> Vec<&GraphNode>

Returns references to all nodes whose type has zero outputs (sink nodes).

pub fn execution_order(&self) -> Vec<u64>

Returns node IDs in topological execution order (Kahn’s algorithm).

Nodes not reachable from any source, or that form cycles, are appended in arbitrary order at the end.

impl ProcessingGraph

pub fn hot_swap_node( &mut self, node_id: u64, replacement: GraphNode, ) -> HotSwapResult

Replace the node identified by node_id with replacement.

All edges connected to node_id are preserved — only the node’s internal data (name, params, type) is swapped. The swap is refused if:

• node_id is not present in the graph → HotSwapResult::NodeNotFound
• the graph is locked (executing) → HotSwapResult::GraphLocked
• the port signatures are incompatible → HotSwapResult::IncompatiblePorts

When HotSwapResult::Success is returned the replacement node’s id field is forced to node_id so that all edge references remain valid.

Complexity

O(n) where n is the number of nodes (linear scan to locate the node slot). Edge preservation is trivially O(1) because edges reference node IDs, not positions; no edge data is modified.

pub fn lock(&mut self)

Lock the graph to simulate an executing state (prevents hot-swap).

Call ProcessingGraph::unlock when execution completes.

pub fn unlock(&mut self)

Unlock the graph after execution completes.

pub fn is_locked(&self) -> bool

Returns true if the graph is currently locked (executing).

Trait Implementations

impl Debug for ProcessingGraph

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

Formats the value using the given formatter.

impl Default for ProcessingGraph

fn default() -> ProcessingGraph

Returns the “default value” for a type.