ComputeNodeGraph

addNode

addNode(node: ComputeNodeGraph_Node): number

mutating func addNode(_ node: ComputeNodeGraph.Node) throws -> ComputeNodeGraph.NodeID

Adds a node to the graph. - Parameter node: The node to add. - Returns: The key assigned to the newly added node. - Throws: A `NodeError` if the node cannot be added.

canAddNode

canAddNode(node: ComputeNodeGraph_Node): boolean

func canAddNode(_ node: ComputeNodeGraph.Node) -> Bool

Returns whether the given node can be added to the graph. This is the non-throwing preflight check for ``addNode(_:)``. Use it to validate a node — for example, to gate UI affordances — without modifying the graph. - Parameter node: The node to test. - Returns: `true` if calling ``addNode(_:)`` with this node would succeed.

removeNode

removeNode(node: number): void

mutating func removeNode(_ node: ComputeNodeGraph.NodeID) throws

Removes a node from the graph. - Parameter node: The key of the node to remove. - Throws: if the node cannot be removed.

updateNode

updateNode(node: ComputeNodeGraph_Node, nodeID: number): void

mutating func updateNode(_ node: ComputeNodeGraph.Node, forKey nodeID: ComputeNodeGraph.NodeID) throws

Updates an existing node in the graph. - Parameters: - node: The updated node data. - forKey: The key of the node to update. - Throws: if the node cannot be updated.

canAddEdge

canAddEdge(edge: ComputeNodeGraph_Edge): boolean

func canAddEdge(_ edge: ComputeNodeGraph.Edge) -> Bool

Returns whether the given edge can be added to the graph. This is the non-throwing preflight check for ``addEdge(_:)``. Use it to validate a connection — for example, to highlight compatible ports during drag-and-drop — without modifying the graph. - Parameter edge: The edge to test. - Returns: `true` if calling ``addEdge(_:)`` with this edge would succeed.

removeEdge

removeEdge(edge: ComputeNodeGraph_Edge): boolean

@discardableResult mutating func removeEdge(_ edge: ComputeNodeGraph.Edge) -> Bool

Removes an edge from the graph. - Parameter edge: The edge to remove. - Throws: if the edge cannot be removed. - Returns: `true` if the edge was found and removed.

replaceAll

replaceAll(nodes: Record<number, ComputeNodeGraph_Node>, edges: Array<ComputeNodeGraph_Edge>): void

mutating func replaceAll(nodes: [ComputeNodeGraph.NodeID : ComputeNodeGraph.Node], edges: [ComputeNodeGraph.Edge]) throws

Replaces all nodes and edges in the graph with the provided collections. This bulk operation allows for efficient wholesale replacement of the graph's structure. - Parameters: - nodes: A sequence of nodes and their keys to add to the graph. - edges: A sequence of edges to add to the graph. - Throws: An error if the replacement operation fails.

data

data(format: ComputeNodeGraph_Format): ArrayBuffer

func data(using format: ComputeNodeGraph.Format) throws -> Data

Returns the graph encoded in the specified format. To reconstruct the graph, pass the data to ``ComputeNodeGraph/init(data:)``. - Parameter format: The serialization format to use when encoding the graph. - Returns: The graph encoded using the specified format. - Throws: An error if the graph can't be encoded in the requested format.

init

static initData(data: ArrayBuffer): ComputeNodeGraph

init(data: Data) throws

Creates a graph by decoding a computegraph. This initializer infers the serialization format from the contents of `data`, so you can pass data produced by ``ComputeNodeGraph/data(using:)`` regardless of the ``Format`` you chose when encoding. - Parameter data: The encoded graph data to decode. - Throws: An error if `data` isn't a recognized graph format, or if the contents can't be decoded into a valid graph.

edges

get edges(): Array<ComputeNodeGraph_Edge>

var edges: [ComputeNodeGraph.Edge] { get }

nodes

get nodes(): Record<number, ComputeNodeGraph_Node>

var nodes: [ComputeNodeGraph.NodeID : ComputeNodeGraph.Node]

nodes

set nodes(value: Record<number, ComputeNodeGraph_Node>)

var nodes: [ComputeNodeGraph.NodeID : ComputeNodeGraph.Node]

addEdge

addEdge(edge: ComputeNodeGraph_Edge): void

mutating func addEdge(_ edge: ComputeNodeGraph.Edge) throws

contains

containsEdge(edge: ComputeNodeGraph_Edge): boolean

func contains(edge: ComputeNodeGraph.Edge) -> Bool

Returns whether the graph contains the given edge. - Parameter edge: The edge to look up. - Returns: `true` if the graph contains the edge; otherwise, `false`.

contains

containsNode(node: number): boolean

func contains(node: ComputeNodeGraph.NodeID) -> Bool

Returns whether the graph contains a node with the given key. - Parameter node: The key of the node to look up. - Returns: `true` if the graph contains the node; otherwise, `false`.

init

static init(): ComputeNodeGraph

init()

subscript

subscript(node: number): (ComputeNodeGraph_Node) | null

subscript(node: ComputeNodeGraph.NodeID) -> ComputeNodeGraph.Node? { get }

Accesses the node associated with the given key. - Parameter node: The key identifying the node to retrieve. - Returns: The node if it exists, or `nil` if no node is associated with the key.