Class Subgraph

Readonlyattributes

Optionalcomment

edges

• get edges(): readonly EdgeModel[]

  Edge objects in the graph.

  Returns readonly EdgeModel[]

nodes

• get nodes(): readonly NodeModel[]

  Node objects in the graph.

  Returns readonly NodeModel[]

size

• get size(): number

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

  Returns number

subgraphs

• get subgraphs(): readonly SubgraphModel[]

  Subgraph objects in the graph.

  Returns readonly SubgraphModel[]

values

• get values(): readonly [T, Attribute<T>][]

  The key/value tuples of the object attributes.

  Returns readonly [T, Attribute<T>][]

addEdge

• addEdge(edge: EdgeModel): void

  Add Edge to the graph.

  Parameters

  • edge: EdgeModel

  Returns void

addNode

• addNode(node: NodeModel): void

  Add a Node to the graph.

  Parameters

  • node: NodeModel

  Returns void

addSubgraph

• addSubgraph(subgraph: SubgraphModel): void

  Add a Subgraph to the graph.

  Parameters

  • subgraph: SubgraphModel

  Returns void

apply

• apply(
      attributes:
          | AttributesObject<"rank" | values>
          | AttributesEntities<"rank" | values>,
  ): void

  Apply keys and values that can be specified for DOT objects collectively.

  Parameters

  • attributes: AttributesObject<"rank" | values> | AttributesEntities<"rank" | values>

    An array of objects or tuples of attribute key/value pairs.

  Returns void

clear

• clear(): void

  Delete all attributes specified for the DOT object.

  Returns void

createEdge

• createEdge(
      targets: EdgeTargetLikeTuple,
      attributes?: EdgeAttributesObject,
  ): EdgeModel

  Create Edge and add it to the graph.

  Parameters

  • targets: EdgeTargetLikeTuple
  • Optionalattributes: EdgeAttributesObject

  Returns EdgeModel

createNode

• createNode(id: string, attributes?: NodeAttributesObject): NodeModel

  Create a Node in the graph.

  Parameters

  • id: string
  • Optionalattributes: NodeAttributesObject

  Returns NodeModel

createSubgraph

• createSubgraph(
      id?: string,
      attributes?: SubgraphAttributesObject,
  ): SubgraphModel

  Create a Subgraph and add it to the graph.

  Parameters

  • Optionalid: string

    Subgraph ID
  • Optionalattributes: SubgraphAttributesObject

    Subgraph attribute object

  Returns SubgraphModel
• createSubgraph(attributes?: SubgraphAttributesObject): SubgraphModel

  Parameters

  • Optionalattributes: SubgraphAttributesObject

  Returns SubgraphModel

delete

• delete(key: "rank" | values): void

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

  Parameters

  • key: "rank" | values

  Returns void

edge

• edge(
      targets: EdgeTargetLikeTuple,
      callback?: (edge: EdgeModel) => void,
  ): 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";
  // }
  Copy

  Parameters

  • targets: EdgeTargetLikeTuple

    Nodes.
  • Optionalcallback: (edge: EdgeModel) => void

    Callbacks for manipulating created or retrieved edge.

  Returns EdgeModel
• edge(
      targets: EdgeTargetLikeTuple,
      attributes: EdgeAttributesObject,
      callback?: (edge: EdgeModel) => void,
  ): 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",
  //   ];
  // }
  Copy

  Parameters

  • targets: EdgeTargetLikeTuple
  • attributes: EdgeAttributesObject

    Object of attributes to be adapted to the edge.
  • Optionalcallback: (edge: EdgeModel) => void

    Callbacks for manipulating created or retrieved edge.

  Returns EdgeModel
• edge(attributes: EdgeAttributesObject): 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",
  //   ];
  // }
  Copy

  Parameters

  • attributes: EdgeAttributesObject

    Object of attributes to be adapted to the edges.

  Returns void

existEdge

• existEdge(edge: EdgeModel): boolean

  Check if the Edge exists in the graph.

  Parameters

  • edge: EdgeModel

  Returns boolean

existNode

• existNode(nodeId: string): boolean

  Check if the Node exists in the graph.

  Parameters

  • nodeId: string

  Returns boolean

existSubgraph

• existSubgraph(subgraph: SubgraphModel): boolean

  Check if the Subgraph exists in the graph.

  Parameters

  • subgraph: SubgraphModel

  Returns boolean

get

• get<K extends "rank" | values>(key: K): 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 "rank" | values

  Parameters

  • key: K

  Returns undefined | Attribute<K>

getNode

• getNode(id: string): undefined | NodeModel

  Get Node in cluster by specifying id.

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

  Parameters

  • id: string

  Returns undefined | NodeModel

getSubgraph

• getSubgraph(id: string): undefined | SubgraphModel

  Get Subgraph in cluster by specifying id.

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

  Parameters

  • id: string

  Returns undefined | SubgraphModel

graph

• graph(attributes: SubgraphAttributesObject): 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",
  //   ];
  // }
  Copy

  Parameters

  • attributes: SubgraphAttributesObject

    Object of attributes to be adapted to the graph.

  Returns void

node

• node(id: string, callback?: (node: NodeModel) => void): 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";
  // }
  Copy

  Parameters

  • id: string

    Node ID.
  • Optionalcallback: (node: NodeModel) => void

    Callbacks for manipulating created or retrieved node.

  Returns NodeModel
• node(
      id: string,
      attributes: NodeAttributesObject,
      callback?: (node: NodeModel) => void,
  ): 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",
  //   ];
  // }
  Copy

  Parameters

  • id: string

    Node ID.
  • attributes: NodeAttributesObject

    Object of attributes to be adapted to the node.
  • Optionalcallback: (node: NodeModel) => void

    Callbacks for manipulating created or retrieved node.

  Returns NodeModel
• node(attributes: NodeAttributesObject): 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",
  //   ];
  // }
  Copy

  Parameters

  • attributes: NodeAttributesObject

    Object of attributes to be adapted to the nodes.

  Returns void

removeEdge

• removeEdge(edge: EdgeModel): void

  Remove Edge from the graph.

  Parameters

  • edge: EdgeModel

  Returns void

removeNode

• removeNode(node: string | NodeModel): void

  Remove Node from the graph.

  Parameters

  • node: string | NodeModel

  Returns void

removeSubgraph

• removeSubgraph(subgraph: SubgraphModel): void

  Remove Subgraph from the graph.

  Parameters

  • subgraph: SubgraphModel

  Returns void

set

• set<K extends "rank" | values>(key: K, value: Attribute<K>): void

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

  Type Parameters

  • K extends "rank" | values

  Parameters

  • key: K
  • value: Attribute<K>

  Returns void

subgraph

• subgraph(
      id: string,
      callback?: (subgraph: SubgraphModel) => void,
  ): 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";
  //   }
  // }
  Copy

  Parameters

  • id: string

    Subgraph ID.
  • Optionalcallback: (subgraph: SubgraphModel) => void

    Callbacks for manipulating created or retrieved subgraph.

  Returns SubgraphModel
• subgraph(
      id: string,
      attributes: SubgraphAttributesObject,
      callback?: (subgraph: SubgraphModel) => void,
  ): 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";
  //   }
  // }
  Copy

  Parameters

  • id: string

    Subgraph ID.
  • attributes: SubgraphAttributesObject

    Object of attributes to be adapted to the subgraph.
  • Optionalcallback: (subgraph: SubgraphModel) => void

    Callbacks for manipulating created or retrieved subgraph.

  Returns SubgraphModel
• subgraph(
      attributes: SubgraphAttributesObject,
      callback?: (subgraph: SubgraphModel) => void,
  ): 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";
  //   }
  // }
  Copy

  Parameters

  • attributes: SubgraphAttributesObject

    Object of attributes to be adapted to the subgraph.
  • Optionalcallback: (subgraph: SubgraphModel) => void

    Callbacks for manipulating created or retrieved subgraph.

  Returns SubgraphModel
• subgraph(callback?: (subgraph: SubgraphModel) => void): 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

  • Optionalcallback: (subgraph: SubgraphModel) => void

    Callbacks for manipulating created or retrieved subgraph.

  Returns SubgraphModel

with

• with(models: Partial<ModelsContext>): void

  Parameters

  • models: Partial<ModelsContext>

  Returns void