Struct Graph 

pub struct Graph {
    pub graph_id: GraphId,
    pub graph_version: u32,
    pub imports: BTreeMap<GraphId, GraphImport>,
    pub symbols: BTreeMap<SymbolId, Symbol>,
    pub nodes: BTreeMap<NodeId, Node>,
    pub ports: BTreeMap<PortId, Port>,
    pub edges: BTreeMap<EdgeId, Edge>,
    pub groups: BTreeMap<GroupId, Group>,
    pub sticky_notes: BTreeMap<StickyNoteId, StickyNote>,
    pub bindings: BTreeMap<BindingId, Binding>,
}

Node graph document.

Fields

graph_id: GraphId

Stable identity for editor-state lookup and cross-graph references.

graph_version: u32

Schema version for migrations.

imports: BTreeMap<GraphId, GraphImport>

Transitive graph dependencies (semantic subgraphs / libraries).

symbols: BTreeMap<SymbolId, Symbol>

Graph-scoped symbols (blackboard/variables).

nodes: BTreeMap<NodeId, Node>

Node instances.

ports: BTreeMap<PortId, Port>

Port instances (owned by nodes, but stored in a flat map for stable lookup).

edges: BTreeMap<EdgeId, Edge>

Edges between ports.

groups: BTreeMap<GroupId, Group>

Optional groups.

sticky_notes: BTreeMap<StickyNoteId, StickyNote>

Optional sticky notes.

bindings: BTreeMap<BindingId, Binding>

Optional knowledge-canvas bindings.

Implementations

impl Graph

pub fn new(graph_id: GraphId) -> Self

Creates a new, empty graph with the given id.

Examples found in repository

examples/build_graph.rs (line 34)

fn main() {
    let node_id = NodeId::from_u128(2);
    let mut graph = Graph::new(GraphId::from_u128(1));

    let mut tx = GraphTransaction::new().with_label("add source node");
    tx.push(GraphOp::AddNode {
        id: node_id,
        node: make_node("demo.source", 10.0, 20.0),
    });
    tx.apply_to(&mut graph).expect("transaction applies");

    assert_eq!(graph.nodes.len(), 1);
    assert_eq!(graph.nodes[&node_id].kind, NodeKindKey::new("demo.source"));
}

Trait Implementations

impl Clone for Graph

fn clone(&self) -> Graph

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Graph

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

Formats the value using the given formatter.

impl Default for Graph

fn default() -> Self

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for Graph

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl GraphOpBuilderExt for Graph

fn build_remove_edge_op(&self, id: EdgeId) -> Option<GraphOp>

Builds a RemoveEdge op for an existing edge.

fn build_remove_port_op(&self, id: PortId) -> Option<GraphOp>

Builds a RemovePort op for an existing port, including incident edges.

fn build_disconnect_port_ops(&self, id: PortId) -> Option<Vec<GraphOp>>

Builds ops that disconnect all edges incident to the port.

fn build_remove_port_tx( &self, id: PortId, label: impl Into<String>, ) -> Option<GraphTransaction>

Builds a transaction that removes a port (and its incident edges).

fn build_remove_node_op(&self, id: NodeId) -> Option<GraphOp>

Builds a RemoveNode op for an existing node, including owned ports and incident edges.

fn build_remove_node_tx( &self, id: NodeId, label: impl Into<String>, ) -> Option<GraphTransaction>

Builds a transaction that removes a node (and its ports/edges).

fn build_remove_group_op(&self, id: GroupId) -> Option<GraphOp>

Builds a RemoveGroup op for an existing group, including nodes detached from it.

fn build_remove_group_tx( &self, id: GroupId, label: impl Into<String>, ) -> Option<GraphTransaction>

Builds a transaction that removes a group (and detaches any child nodes).

fn build_remove_sticky_note_op(&self, id: StickyNoteId) -> Option<GraphOp>

Builds a RemoveStickyNote op for an existing sticky note, including attached bindings.

fn build_remove_sticky_note_tx( &self, id: StickyNoteId, label: impl Into<String>, ) -> Option<GraphTransaction>

Builds a transaction that removes a sticky note and attached bindings.

fn build_remove_binding_op(&self, id: BindingId) -> Option<GraphOp>

Builds a RemoveBinding op for an existing binding.

fn build_remove_binding_tx( &self, id: BindingId, label: impl Into<String>, ) -> Option<GraphTransaction>

Builds a transaction that removes a binding.

impl Serialize for Graph

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.