Interface RootGraphModel

DOT model representing a root graphs(digraph and graph).

interface RootGraphModel {
    $$type: "Graph";
    attributes: Readonly<GraphCommonAttributes>;
    comment?: string;
    directed: boolean;
    edges: readonly EdgeModel[];
    id?: string;
    nodes: readonly NodeModel[];
    size: number;
    strict: boolean;
    subgraphs: readonly SubgraphModel[];
    values: readonly [values, Attribute<values>][];
    addEdge(edge): void;
    addNode(node): void;
    addSubgraph(subgraph): void;
    apply(attributes): void;
    clear(): void;
    createEdge(targets, attributes?): EdgeModel;
    createNode(id, attributes?): NodeModel;
    createSubgraph(id?, attributes?): SubgraphModel;
    createSubgraph(attributes?): SubgraphModel;
    delete(key): void;
    edge(targets, callback?): EdgeModel;
    edge(targets, attributes, callback?): EdgeModel;
    edge(attributes): void;
    existEdge(edge): boolean;
    existNode(nodeId): boolean;
    existSubgraph(subgraph): boolean;
    get<K>(key): undefined | Attribute<K>;
    getNode(id): undefined | NodeModel;
    getSubgraph(id): undefined | SubgraphModel;
    graph(attributes): void;
    node(id, callback?): NodeModel;
    node(id, attributes, callback?): NodeModel;
    node(attributes): void;
    removeEdge(edge): void;
    removeNode(node): void;
    removeSubgraph(subgraph): void;
    set<K>(key, value): void;
    subgraph(id, callback?): SubgraphModel;
    subgraph(id, attributes, callback?): SubgraphModel;
    subgraph(attributes, callback?): SubgraphModel;
    subgraph(callback?): SubgraphModel;
    with(models): void;
}

Hierarchy (view full)

Properties

$$type attributes comment? directed edges id? nodes size strict subgraphs values

Methods

addEdge addNode addSubgraph apply clear createEdge createNode createSubgraph delete edge existEdge existNode existSubgraph get getNode getSubgraph graph node removeEdge removeNode removeSubgraph set subgraph with

Properties

$$type

$$type: "Graph"

The type of the DotObjectType.

Readonly attributes

attributes: Readonly<GraphCommonAttributes>

Optional comment

comment?: string

Comments to include when outputting with toDot.

directed

directed: boolean

Readonly edges

edges: readonly EdgeModel[]

Edge objects in the graph.

Optional Readonly id

id?: string

Readonly nodes

nodes: readonly NodeModel[]

Node objects in the graph.

Readonly size

size: number

Size of the set of keys and values held by the DOT object.

strict

strict: boolean

Strict mode.

Description

A graph may also be described as strict. This forbids the creation of multi-edges, i.e., there can be at most one edge with a given tail node and head node in the directed case. For undirected graphs, there can be at most one edge connected to the same two nodes. Subsequent edge statements using the same two nodes will identify the edge with the previously defined one and apply any attributes given in the edge statement.

Readonly subgraphs

subgraphs: readonly SubgraphModel[]

Subgraph objects in the graph.

Readonly values

values: readonly [values, Attribute<values>][]

The key/value tuples of the object attributes.

Methods

addEdge

addNode

addSubgraph

apply

clear

createEdge

createNode

createSubgraph

delete

  • delete(key): void

  • Delete the value of an attribute from a DOT object by specifying a key.

    Parameters

    • key: values

    Returns void

edge

  • edge(targets, callback?): EdgeModel

  • Create a edge.

    By specifying a callback function, the target edge can be received and manipulated as an argument.

    const G = digraph('G', (g) => {
      // Create a edge.
      g.edge(['a', 'b']);
    });

    console.log(toDot(G));
    // digraph "G" {
    //   "a" -> "b";
    // }

    Parameters

    • targets: EdgeTargetLikeTuple

      Nodes.

    • Optional callback: ((edge) => void)

      Callbacks for manipulating created or retrieved edge.

        • (edge): void

        • Parameters

          Returns void

    Returns EdgeModel

  • edge(targets, attributes, callback?): EdgeModel

  • Create a edge and adapt the attributes.

    By specifying a callback function, the target edge can be received and manipulated as an argument.

    const G = digraph('G', (g) => {
      // Create a edge and specifying its attributes.
      g.edge(['a', 'b'], {
        [attribute.color]: 'red',
        [attribute.label]: 'my label',
      });
    });

    console.log(toDot(G));
    // digraph "G" {
    //   "a" -> "b" [
    //     color = "red",
    //     label = "my label",
    //   ];
    // }

    Parameters

    • targets: EdgeTargetLikeTuple
    • attributes: EdgeAttributesObject

      Object of attributes to be adapted to the edge.

    • Optional callback: ((edge) => void)

      Callbacks for manipulating created or retrieved edge.

        • (edge): void

        • Parameters

          Returns void

    Returns EdgeModel

  • edge(attributes): void

  • Set a common attribute for the edges in the graph.

    const G = digraph('G', (g) => {
      // Set a common attribute for the edges in the graph.
      g.edge({
        [attribute.color]: 'red',
        [attribute.label]: 'my label',
      });
    });

    console.log(toDot(G));
    // digraph "G" {
    //   edge [
    //     color = "red",
    //     label = "my label",
    //   ];
    // }

    Parameters

    Returns void

existEdge

existNode

existSubgraph

get

  • get<K>(key): undefined | Attribute<K>

  • Get the value of an attribute by a DOT object by specifying its key.

    If the value corresponding to the key does not exist, undefined is returned.

    Type Parameters

    • K extends values

    Parameters

    • key: K

    Returns undefined | Attribute<K>

getNode

  • getNode(id): undefined | NodeModel

  • Get Node in cluster by specifying id.

    Parameters

    • id: string

    Returns undefined | NodeModel

    Description

    If there is no Node with the specified id in the graph, return undefined.

getSubgraph

graph

  • graph(attributes): void

  • Set a common attribute for the graph in the graph.

    const G = digraph('G', (g) => {
      g.graph({
        [attribute.color]: 'red',
        [attribute.label]: 'my label',
      });
    });

    console.log(toDot(G));
    // digraph "G" {
    //   graph [
    //     color = "red",
    //     label = "my label",
    //   ];
    // }

    Parameters

    Returns void

node

  • node(id, callback?): NodeModel

  • Create a node by specifying its id (or get it if it already exists).

    By specifying a callback function, the target node can be received and manipulated as an argument.

    const G = digraph('G', (g) => {
      // Create a node with id as A.
      g.node('A');
    });

    console.log(toDot(G));
    // digraph "G" {
    //   "A";
    // }

    Parameters

    • id: string

      Node ID.

    • Optional callback: ((node) => void)

      Callbacks for manipulating created or retrieved node.

        • (node): void

        • Parameters

          Returns void

    Returns NodeModel

  • node(id, attributes, callback?): NodeModel

  • Create a node (or get one if it already exists) and adapt the attributes.

    By specifying a callback function, the target node can be received and manipulated as an argument.

    const G = digraph('G', (g) => {
      // Create a node by specifying its id and specifying its attributes.
      g.node('A', {
        [attribute.color]: 'red',
        [attribute.label]: 'my label',
      });
    });

    console.log(toDot(G));
    // digraph "G" {
    //   "A" [
    //     color = "red",
    //     label = "my label",
    //   ];
    // }

    Parameters

    • id: string

      Node ID.

    • attributes: NodeAttributesObject

      Object of attributes to be adapted to the node.

    • Optional callback: ((node) => void)

      Callbacks for manipulating created or retrieved node.

        • (node): void

        • Parameters

          Returns void

    Returns NodeModel

  • node(attributes): void

  • Set a common attribute for the nodes in the graph.

    const G = digraph('G', (g) => {
      // Set a common attribute for the nodes in the graph.
      g.node({
        [attribute.color]: 'red',
        [attribute.label]: 'my label',
      });
    });

    console.log(toDot(G));
    // digraph "G" {
    //   node [
    //     color = "red",
    //     label = "my label",
    //   ];
    // }

    Parameters

    Returns void

removeEdge

removeNode

removeSubgraph

set

  • set<K>(key, value): void

  • Set a value, by specifying the key of the attributes in the DOT object.

    Type Parameters

    • K extends values

    Parameters

    Returns void

subgraph

  • subgraph(id, callback?): SubgraphModel

  • Create a subgraph by specifying its id (or get it if it already exists).

    By specifying a callback function, the target subgraph can be received and manipulated as an argument.

    const G = digraph('G', (g) => {
      // Create a cluster with id as A.
      g.subgraph('A', (A) => {
        // Create a node with id as A1 in cluster A.
        A.node('A1');
      });
    });

    console.log(toDot(G));
    // digraph "G" {
    //   subgraph "A" {
    //     "A1";
    //   }
    // }

    Parameters

    • id: string

      Subgraph ID.

    • Optional callback: ((subgraph) => void)

      Callbacks for manipulating created or retrieved subgraph.

    Returns SubgraphModel

  • subgraph(id, attributes, callback?): SubgraphModel

  • Create a subgraph (or get one if it already exists) and adapt the attributes.

    By specifying a callback function, the target subgraph can be received and manipulated as an argument.

    const G = digraph('G', (g) => {
      // Create a cluster with id as A and specifying its attributes.
      g.subgraph('A', { [attribute.color]: 'red', [attribute.label]: 'my label' }, (A) => {
        // Create a node with id as A1 in cluster A.
        A.node('A1');
      });
    });

    console.log(toDot(G));
    // digraph "G" {
    //   subgraph "A" {
    //     color = "red";
    //     label = "my label";
    //     "A1";
    //   }
    // }

    Parameters

    • id: string

      Subgraph ID.

    • attributes: SubgraphAttributesObject

      Object of attributes to be adapted to the subgraph.

    • Optional callback: ((subgraph) => void)

      Callbacks for manipulating created or retrieved subgraph.

    Returns SubgraphModel

  • subgraph(attributes, callback?): SubgraphModel

  • Create anonymous subgraphs and and adapt the attributes.

    By specifying a callback function, the target subgraph can be received and manipulated as an argument.

    const G = digraph('G', (g) => {
      // Create a anonymous cluster and specifying its attributes.
      g.subgraph({ [attribute.color]: 'red', [attribute.label]: 'my label' }, (A) => {
        // Create a node with id as A1 in anonymous cluster.
        A.node('A1');
      });
    });

    console.log(toDot(G));
    // digraph "G" {
    //   subgraph {
    //     color = "red";
    //     label = "my label";
    //     "A1";
    //   }
    // }

    Parameters

    • attributes: SubgraphAttributesObject

      Object of attributes to be adapted to the subgraph.

    • Optional callback: ((subgraph) => void)

      Callbacks for manipulating created or retrieved subgraph.

    Returns SubgraphModel

  • subgraph(callback?): SubgraphModel

  • Create anonymous subgraphs and manipulate them with callback functions.

    By specifying a callback function, the target subgraph can be received and manipulated as an argument.

    Parameters

    • Optional callback: ((subgraph) => void)

      Callbacks for manipulating created or retrieved subgraph.

    Returns SubgraphModel

with

Settings

Member Visibility

Theme

On This Page

$$typeattributescommentdirectededgesidnodessizestrictsubgraphsvaluesaddEdgeaddNodeaddSubgraphapplyclearcreateEdgecreateNodecreateSubgraphdeleteedgeexistEdgeexistNodeexistSubgraphgetgetNodegetSubgraphgraphnoderemoveEdgeremoveNoderemoveSubgraphsetsubgraphwith

Generated using TypeDoc