Interface GraphBaseModel<T>

DOT model representing a graph/digraph/subgraph.

interface GraphBaseModel<T> {
    attributes: Readonly<GraphCommonAttributes>;
    comment?: string;
    edges: readonly EdgeModel[];
    id?: string;
    nodes: readonly NodeModel[];
    size: number;
    subgraphs: readonly SubgraphModel[];
    values: readonly [T, Attribute<T>][];
    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;
}

Type Parameters

Hierarchy (view full)

Properties

attributes comment? edges id? nodes size 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

Readonly attributes

attributes: Readonly<GraphCommonAttributes>

Optional comment

comment?: string

Comments to include when outputting with toDot.

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.

Readonly subgraphs

subgraphs: readonly SubgraphModel[]

Subgraph objects in the graph.

Readonly values

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

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: T

    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

  • existEdge(edge): boolean

  • Check if the Edge exists in the graph.

    Parameters

    Returns boolean

existNode

  • existNode(nodeId): boolean

  • Check if the Node exists in the graph.

    Parameters

    • nodeId: string

    Returns boolean

existSubgraph

  • existSubgraph(subgraph): boolean

  • Check if the Subgraph exists in the graph.

    Parameters

    Returns boolean

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

    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

  • getSubgraph(id): 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): 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

  • removeEdge(edge): void

  • Remove Edge from the graph.

    Parameters

    Returns void

removeNode

  • removeNode(node): void

  • Remove Node from the graph.

    Parameters

    Returns void

removeSubgraph

  • removeSubgraph(subgraph): void

  • Remove Subgraph from the graph.

    Parameters

    Returns void

set

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

attributescommentedgesidnodessizesubgraphsvaluesaddEdgeaddNodeaddSubgraphapplyclearcreateEdgecreateNodecreateSubgraphdeleteedgeexistEdgeexistNodeexistSubgraphgetgetNodegetSubgraphgraphnoderemoveEdgeremoveNoderemoveSubgraphsetsubgraphwith

Generated using TypeDoc