occam-directed-graphs 3.0.34 → 3.0.37

package/src/directedAcyclicGraph.js

@@ -0,0 +1,422 @@
+"use strict";
+
+import { arrayUtilities } from "necessary";
+
+import Edge from "./edge";
+import Vertex from "./vertex";
+
+import { vertexNamesFromVertices, orderVertices } from "./utilities/vertex";
+
+const { last } = arrayUtilities;
+
+export default class DirectedAcyclicGraph {
+  constructor(vertexMap) {
+    this.vertexMap = vertexMap;
+  }
+
+  isEmpty() {
+    const vertices = this.getVertices(),
+          verticesLength = vertices.length,
+          empty = (verticesLength === 0);
+
+    return empty;
+  }
+
+  getVertices() {
+    const vertexMapValues = Object.values(this.vertexMap),
+          vertices = vertexMapValues; ///
+
+    return vertices;
+  }
+
+  getVertexNames() {
+    const vertexMapKeys = Object.keys(this.vertexMap),
+          vertexNames = vertexMapKeys;  ///
+
+    return vertexNames;
+  }
+
+  getVertexByVertexName(vertexName) {
+    const vertexPresent = this.isVertexPresentByVertexName(vertexName),
+          vertex = vertexPresent ?
+                     this.vertexMap[vertexName] :
+                       null;
+
+    return vertex;
+  }
+
+  getImmediatePredecessorVertexNamesByVertexName(vertexName) {
+    const vertex = this.getVertexByVertexName(vertexName),
+          immediatePredecessorVertexNames = vertex.getImmediatePredecessorVertexNames();
+
+    return immediatePredecessorVertexNames;
+  }
+
+  getImmediateSuccessorVertexNamesByVertexName(vertexName) {
+    const vertex = this.getVertexByVertexName(vertexName),
+          immediateSuccessorVertexNames = vertex.getImmediateSuccessorVertexNames();
+
+    return immediateSuccessorVertexNames;
+  }
+
+  getPredecessorVertexNamesByVertexName(vertexName) {
+    const vertex = this.getVertexByVertexName(vertexName),
+          predecessorVertexNames = vertex.getPredecessorVertexNames();
+
+    return predecessorVertexNames;
+  }
+
+  getSuccessorVertexNamesByVertexName(vertexName) {
+    const vertex = this.getVertexByVertexName(vertexName),
+          successorVertexNames = vertex.getSuccessorVertexNames();
+
+    return successorVertexNames;
+  }
+
+  getEdgesByTargetVertexName(targetVertexName) {
+    const edges = [],
+          targetVertex = this.getVertexByVertexName(targetVertexName);
+
+    if (targetVertex !== null) {
+      const immediatePredecessorVertexNames = targetVertex.getImmediatePredecessorVertexNames(),
+            sourceVertexNames = immediatePredecessorVertexNames;  ///
+
+      sourceVertexNames.forEach((sourceVertexName) => {
+        const edge = Edge.fromSourceVertexNameAndTargetVertexName(sourceVertexName, targetVertexName);
+
+        edges.push(edge);
+      });
+    }
+
+    return edges;
+  }
+
+  getEdgesBySourceVertexName(sourceVertexName) {
+    const edges = [],
+          sourceVertex = this.getVertexByVertexName(sourceVertexName);
+
+    if (sourceVertex !== null) {
+      const immediateSuccessorVertexNames = sourceVertex.getImmediateSuccessorVertexNames(),
+            targetVertexNames = immediateSuccessorVertexNames;  ///
+
+      targetVertexNames.forEach((targetVertexName) => {
+        const edge = Edge.fromSourceVertexNameAndTargetVertexName(sourceVertexName, targetVertexName);
+
+        edges.push(edge);
+      });
+    }
+
+    return edges;
+  }
+
+  setVertexByVertexName(vertexName, vertex) {
+    this.vertexMap[vertexName] = vertex;
+  }
+
+  deleteVertexByVertexName(vertexName) {
+    delete this.vertexMap[vertexName];
+  }
+
+  isEdgePresent(edge) {
+    const sourceVertexName = edge.getSourceVertexName(),
+          targetVertexName = edge.getTargetVertexName(),
+          edgePresent = this.isEdgePresentByVertexNames(sourceVertexName, targetVertexName);
+    
+    return edgePresent;
+  }
+
+  isEdgePresentByVertexNames(sourceVertexName, targetVertexName) {
+    let edgePresent = false;
+
+    const sourceVertex = this.getVertexByVertexName(sourceVertexName),
+          targetVertex = this.getVertexByVertexName(targetVertexName),
+          sourceVertexAndTargetVertexPresent = (sourceVertex !== null) && (targetVertex !== null);
+
+    if (sourceVertexAndTargetVertexPresent) {
+      edgePresent = sourceVertex.isEdgePresentByTargetVertex(targetVertex);
+    }
+
+    return edgePresent;
+  }
+
+  isVertexPresentByVertexName(vertexName) {
+    const vertexNames = this.getVertexNames(),
+          vertexNamesIncludesVertexName = vertexNames.includes(vertexName),
+          vertexPresent = vertexNamesIncludesVertexName;  ///
+
+    return vertexPresent;
+  }
+
+  getOrderedVertexNames() {
+    const vertices = this.getVertices();
+
+    orderVertices(vertices);
+
+    const orderedVertices = vertices, ///
+          orderedVertexNames = vertexNamesFromVertices(orderedVertices);
+
+    return orderedVertexNames;
+  }
+
+  addEdge(edge) {
+    const sourceVertexName = edge.getSourceVertexName(),
+          targetVertexName = edge.getTargetVertexName(),
+          success = this.addEdgeByVertexNames(sourceVertexName, targetVertexName);
+
+    return success;
+  }
+
+  removeEdge(edge) {
+    const sourceVertexName = edge.getSourceVertexName(),
+          targetVertexName = edge.getTargetVertexName();
+
+    this.removeEdgeByVertexNames(sourceVertexName, targetVertexName);
+  }
+
+  addEdgeByVertexNames(sourceVertexName, targetVertexName) {
+    let success = false;
+
+    if (sourceVertexName !== targetVertexName) {
+      const sourceVertex = this.addVertexByVertexName(sourceVertexName),
+            targetVertex = this.addVertexByVertexName(targetVertexName),
+            edgePresent = sourceVertex.isEdgePresentByTargetVertex(targetVertex);
+      
+      if (edgePresent) {
+        success = true;
+      } else {
+        const sourceVertexIndex = sourceVertex.getIndex(),
+              targetVertexIndex = targetVertex.getIndex(),
+              invalidatingEdge = (sourceVertexIndex > targetVertexIndex);
+
+        success = invalidatingEdge ?
+                    addInvalidatingEdgeByVertices(sourceVertex, targetVertex) :
+                      true;
+
+        if (success) {
+          const immediatePredecessorVertex = sourceVertex, ///
+                immediateSuccessorVertex = targetVertex; ///
+
+          immediatePredecessorVertex.addImmediateSuccessorVertex(immediateSuccessorVertex);
+
+          immediateSuccessorVertex.addImmediatePredecessorVertex(immediatePredecessorVertex);
+        }
+      }
+    }
+    
+    return success;
+  }
+
+  removeEdgeByVertexNames(sourceVertexName, targetVertexName) {
+    const edgePresent = this.isEdgePresentByVertexNames(sourceVertexName, targetVertexName);
+
+    if (edgePresent) {
+      const sourceVertex = this.getVertexByVertexName(sourceVertexName),
+            targetVertex = this.getVertexByVertexName(targetVertexName);
+
+      sourceVertex.removeImmediateSuccessorVertex(targetVertex);
+      targetVertex.removeImmediatePredecessorVertex(sourceVertex);
+    }
+  }
+
+  removeEdgesBySourceVertexName(sourceVertexName) {
+    const sourceVertexPresent = this.isVertexPresentByVertexName(sourceVertexName);
+
+    if (sourceVertexPresent) {
+      const sourceVertex = this.getVertexByVertexName(sourceVertexName);
+
+      sourceVertex.removeOutgoingEdges();
+    }
+  }
+
+  removeEdgesByTargetVertexName(targetVertexName) {
+    const targetVertexPresent = this.isVertexPresentByVertexName(targetVertexName);
+
+    if (targetVertexPresent) {
+      const targetVertex = this.getVertexByVertexName(targetVertexName);
+
+      targetVertex.removeIncomingEdges();
+    }
+  }
+
+  addVertexByVertexName(vertexName) {
+    const vertexPresent = this.isVertexPresentByVertexName(vertexName);
+
+    if (!vertexPresent) {
+      const vertexNames = this.getVertexNames(),
+            vertexNamesLength = vertexNames.length,
+            name = vertexName,  ///
+            index = vertexNamesLength, ///
+            vertex = Vertex.fromNameAndIndex(name, index);
+
+      this.setVertexByVertexName(vertexName, vertex);
+    }
+
+    const vertex = this.getVertexByVertexName(vertexName);
+
+    return vertex;
+  }
+
+  removeVertexByVertexName(vertexName) {
+    let removedEdges = null;
+
+    const vertexPresent = this.isVertexPresentByVertexName(vertexName);
+
+    if (vertexPresent) {
+      removedEdges = [];
+
+      const vertex = this.getVertexByVertexName(vertexName);
+
+      vertex.forEachImmediateSuccessorVertex((immediateSuccessVertex) => {
+        const immediatePredecessorVertex = vertex,  ///
+              immediatePredecessorVertexName = immediatePredecessorVertex.getName(),
+              immediateSuccessVertexName = immediateSuccessVertex.getName(),
+              removedEdgeSourceVertexName = immediatePredecessorVertexName, ///
+              removedEdgeTargetVertexName = immediateSuccessVertexName, ///
+              removedEdge = new Edge(removedEdgeSourceVertexName, removedEdgeTargetVertexName);
+
+        removedEdges.push(removedEdge);
+
+        immediateSuccessVertex.removeImmediatePredecessorVertex(immediatePredecessorVertex);
+      });
+
+      vertex.forEachImmediatePredecessorVertex((immediatePredecessorVertex) => {
+        const immediateSuccessVertex = vertex,  ///
+              immediatePredecessorVertexName = immediatePredecessorVertex.getName(),
+              immediateSuccessVertexName = immediateSuccessVertex.getName(),  ///
+              removedEdgeSourceVertexName = immediatePredecessorVertexName, ///
+              removedEdgeTargetVertexName = immediateSuccessVertexName, ///
+              removedEdge = new Edge(removedEdgeSourceVertexName, removedEdgeTargetVertexName);
+
+        removedEdges.push(removedEdge);
+
+        immediatePredecessorVertex.removeImmediateSuccessorVertex(immediateSuccessVertex);
+      });
+
+      this.deleteVertexByVertexName(vertexName);
+
+      const deletedVertex = vertex, ///
+            deletedVertexIndex = deletedVertex.getIndex(),
+            vertices = this.getVertices(),
+            affectedVertices = vertices.reduce((affectedVertices, vertex) => {
+              const vertexIndex = vertex.getIndex(),
+                    vertexAffected = (vertexIndex > deletedVertexIndex);
+
+              if (vertexAffected) {
+                const affectedVertex = vertex;  ///
+
+                affectedVertices.push(affectedVertex);
+              }
+
+              return affectedVertices;
+            }, []);
+
+      affectedVertices.forEach((affectedVertex) => affectedVertex.decrementIndex());
+    }
+
+    return removedEdges;
+  }
+
+  static fromNothing() {
+    const vertexMap = {},
+          directedAcyclicGraph = new DirectedAcyclicGraph(vertexMap);
+
+    return directedAcyclicGraph;
+  }
+  
+  static fromVertexNames(vertexNames) {
+    const vertexMap = vertexMapFromVertexNames(vertexNames);
+
+    const directedAcyclicGraph = new DirectedAcyclicGraph(vertexMap);
+
+    return directedAcyclicGraph;
+  }
+
+  static fromOrderedVertices(orderedVertices) {
+    const vertexMap = vertexMapFromOrderedVertices(orderedVertices);
+    
+    addEdgesToVertices(orderedVertices, vertexMap);
+    
+    const directedAcyclicGraph = new DirectedAcyclicGraph(vertexMap);
+    
+    return directedAcyclicGraph;
+  }
+}
+
+function addInvalidatingEdgeByVertices(sourceVertex, targetVertex) {
+  let success = false;
+
+  const forwardsAffectedVertices = targetVertex.retrieveForwardsAffectedVertices(sourceVertex),
+        lastForwardsAffectedVertex = last(forwardsAffectedVertices),
+        resultsInCycle = (lastForwardsAffectedVertex === sourceVertex);
+
+  if (!resultsInCycle) {
+    const backwardsAffectedVertices = sourceVertex.retrieveBackwardsAffectedVertices();
+
+    orderVertices(backwardsAffectedVertices);
+
+    orderVertices(forwardsAffectedVertices);
+
+    const affectedVertices = [].concat(backwardsAffectedVertices).concat(forwardsAffectedVertices),
+          affectedVertexIndices = affectedVertices.map((affectedVertex) => {
+            const affectedVertexIndex = affectedVertex.getIndex();
+
+            return affectedVertexIndex;
+          });
+
+    affectedVertexIndices.sort((indexA, indexB) => (indexA - indexB));
+
+    affectedVertices.forEach((affectedVertex, index) => {
+      const affectedVertexIndex = affectedVertexIndices[index];
+
+      affectedVertex.setIndex(affectedVertexIndex);
+    });
+
+    success = true;
+  }
+
+  return success;
+}
+
+function vertexMapFromVertexNames(vertexNames) {
+  const vertexMap = {};
+  
+  vertexNames.forEach((vertexName, index) => {
+    const name = vertexName,  ///
+          vertex = Vertex.fromNameAndIndex(name, index);
+
+    vertexMap[vertexName] = vertex;
+  });
+  
+  return vertexMap;
+}
+
+function vertexMapFromOrderedVertices(orderedVertices) {
+  const vertexMap = {};
+  
+  orderedVertices.forEach((orderedVertex, index) => {
+    const name = orderedVertex.getName(),
+          vertex = Vertex.fromNameAndIndex(name, index),
+          vertexName = name;  ///
+
+    vertexMap[vertexName] = vertex;
+  });
+
+  return vertexMap;
+}
+
+function addEdgesToVertices(orderedVertices, vertexMap) {
+  orderedVertices.forEach((orderedVertex) => {
+    orderedVertex.forEachOutgoingEdge((outgoingEdge) => {
+      const sourceVertexName = outgoingEdge.getSourceVertexName(),
+            targetVertexName = outgoingEdge.getTargetVertexName(),
+            immediatePredecessorVertexName = sourceVertexName,  ///
+            immediateSuccessorVertexName = targetVertexName,
+            immediatePredecessorVertex = vertexMap[immediatePredecessorVertexName], ///
+            immediateSuccessorVertex = vertexMap[immediateSuccessorVertexName]; ///
+
+      immediatePredecessorVertex.addImmediateSuccessorVertex(immediateSuccessorVertex);
+
+      immediateSuccessorVertex.addImmediatePredecessorVertex(immediatePredecessorVertex);
+    });
+  });
+}

package/src/directedGraph.js

@@ -1,15 +1,14 @@
 "use strict";
 
-import { Graph } from "occam-kahn";
 import { arrayUtilities } from "necessary";
-import { DirectedAcyclicGraph } from "occam-pearce-kelly";
 
 import Edge from "./edge";
 import Cycle from "./cycle";
 import PartialCycle from "./partialCycle";
+import DirectedAcyclicGraph from "./directedAcyclicGraph";
 
-import { vertexNamesFromVertexLiterals, forwardsDepthFirstSearch } from "./utilities/vertex";
-import { edgesFromVertexLiterals, checkEdgesIncludesEdge, removeEdgeFromEdges, edgesBySourceVertexName, edgesByTargetVertexName } from "./utilities/edge";
+import { forwardsDepthFirstSearch } from "./utilities/vertex";
+import { checkEdgesIncludesEdge, removeEdgeFromEdges, edgesBySourceVertexName, edgesByTargetVertexName } from "./utilities/edge";
 
 const { first, filter } = arrayUtilities;
 
@@ -309,36 +308,4 @@ export default class DirectedGraph {
     
     return directedGraph;    
   }
-
-  static fromVertexLiterals(vertexLiterals) {
-    const vertexNames = vertexNamesFromVertexLiterals(vertexLiterals),
-          edges = edgesFromVertexLiterals(vertexLiterals),
-          directedGraph = DirectedGraph.fromVertexNamesAndEdges(vertexNames, edges);
-
-    return directedGraph;
-  }
-
-  static fromVertexNamesAndEdges(vertexNames, edges) {
-    let directedGraph;
-
-    const graph = Graph.fromVertexNamesAndEdges(vertexNames, edges),
-          cyclesPresent = graph.areCyclesPresent();
-
-    if (cyclesPresent) {
-      const cyclicEdges = [],
-            directedAcyclicGraph = DirectedAcyclicGraph.fromVertexNames(vertexNames);
-
-      directedGraph = new DirectedGraph(cyclicEdges, directedAcyclicGraph);
-
-      edges.forEach((edge) => directedGraph.addEdge(edge));
-    } else {
-      const orderedVertices = graph.getOrderedVertices(),
-            cyclicEdges = [],
-            directedAcyclicGraph = DirectedAcyclicGraph.fromOrderedVertices(orderedVertices);
-
-      directedGraph = new DirectedGraph(cyclicEdges, directedAcyclicGraph);
-    }
-
-    return directedGraph;
-  }
 }

package/src/edge.js

@@ -1,5 +1,54 @@
 "use strict";
 
-import { Edge } from "occam-pearce-kelly";
+export default class Edge {
+  constructor(sourceVertexName, targetVertexName) {
+    this.sourceVertexName = sourceVertexName;
+    this.targetVertexName = targetVertexName;
+  }
+  
+  getSourceVertexName() {
+    return this.sourceVertexName;
+  }
+  
+  getTargetVertexName() {
+    return this.targetVertexName;
+  }
+  
+  match(edge) {
+    const sourceVertexName = edge.getSourceVertexName(),
+          targetVertexName = edge.getTargetVertexName(),
+          matches = ((this.sourceVertexName === sourceVertexName) && (this.targetVertexName === targetVertexName));
+    
+    return matches;
+  }
 
-export default Edge;
+  matchVertexName(vertexName) {
+    const matches = ((this.sourceVertexName === vertexName) || (this.targetVertexName === vertexName));
+
+    return matches;
+  }
+
+  matchSourceVertexName(sourceVertexName) {
+    const matches = (this.sourceVertexName === sourceVertexName);
+
+    return matches;
+  }
+
+  matchTargetVertexName(targetVertexName) {
+    const matches = (this.targetVertexName === targetVertexName);
+
+    return matches;
+  }
+
+  matchVertexNames(sourceVertexName, targetVertexName) {
+    const matches = ((this.sourceVertexName === sourceVertexName) && (this.targetVertexName === targetVertexName));
+    
+    return matches;
+  }
+
+  static fromSourceVertexNameAndTargetVertexName(sourceVertexName, targetVertexName) {
+    const edge = new Edge(sourceVertexName, targetVertexName);
+
+    return edge;
+  }
+}

package/src/utilities/edge.js

@@ -6,27 +6,6 @@ const { prune } = arrayUtilities;
 
 const remove = prune;  ///
 
-export function edgesFromVertexLiterals(vertexLiterals) {
-  const edges = [];
-
-  vertexLiterals.forEach((vertexLiteral) => {
-    const firstVertexLiteralElement = first(vertexLiteral),
-          secondVertexLiteralElement = second(vertexLiteral),
-          ancestorVertexNames = secondVertexLiteralElement, ///
-          vertexName = firstVertexLiteralElement; ///
-
-    ancestorVertexNames.forEach((ancestorVertexName) => {
-      const sourceVertexName = ancestorVertexName, ///
-            targetVertexName = vertexName,  ///
-            edge = new Edge(sourceVertexName, targetVertexName);
-
-      edges.push(edge);
-    });
-  });
-
-  return edges;
-}
-
 export function checkEdgesIncludesEdge(edge, edges) {
   const edge1 = edge, ///
         edgesIncludesEdge = edges.some((edge) => {

package/src/utilities/vertex.js

@@ -1,37 +1,22 @@
 "use strict";
 
-import { arrayUtilities } from "necessary";
-
-const { first, second } = arrayUtilities;
-
-export function vertexNamesFromVertexLiterals(vertexLiterals) {
-  const vertexNameMap = {};
-
-  vertexLiterals.forEach((vertexLiteral) => {
-    const firstVertexLiteralElement = first(vertexLiteral),
-          vertexName = firstVertexLiteralElement, ///
-          vertexExists = vertexNameMap.hasOwnProperty(vertexName);
-
-    if (!vertexExists) {
-      vertexNameMap[vertexName] = vertexName;
+export function orderVertices(vertices) {  ///
+  vertices.sort((firstVertex, secondVertex) => {
+    const firstVertexIndex = firstVertex.getIndex(),
+          secondVertexIndex = secondVertex.getIndex();
+
+    if (false) {
+      ///
+    } else if (firstVertexIndex < secondVertexIndex) {
+      return -1;
+    } else  if (firstVertexIndex > secondVertexIndex) {
+      return +1;
     }
-
-      const secondVertexLiteralElement = second(vertexLiteral),
-            ancestorVertexNames = secondVertexLiteralElement; ///
-
-    ancestorVertexNames.forEach((ancestorVertexName) => {
-      const ancestorVertexExists = vertexNameMap.hasOwnProperty(ancestorVertexName);
-
-      if (!ancestorVertexExists) {
-        vertexNameMap[ancestorVertexName] = ancestorVertexName;
-      }
-    });
   });
 
-  const vertexNameMapKeys = Object.keys(vertexNameMap),
-        vertexNames = vertexNameMapKeys;  ///
+  const orderedVertices = vertices;  ///
 
-  return vertexNames;
+  return orderedVertices;
 }
 
 export function vertexNamesFromVertices(vertices) {