dangraph

## Classes <dl> <dt><a href="#DanDirectedGraph">DanDirectedGraph</a></dt> <dd></dd> <dt><a href="#DanDirectedGraphBreadthFirstIterator">DanDirectedGraphBreadthFirstIterator</a></dt> <dd>The class DanDirectedGraphBreadthFirstIterator implements GraphIterator interface</dd> <dt><a href="#DanDirectedGraphDepthFirstIterator">DanDirectedGraphDepthFirstIterator</a></dt> <dd>The class DanDirectedGraphDepthFirstIterator implements GraphIterator interface</dd> <dt><a href="#DanUndirectedGraph">DanUndirectedGraph</a></dt> <dd>The DanUndirectedGraph class handles undirected graphs</dd> <dt><a href="#DanStack">DanStack</a></dt> <dd>DanStack is a simple class implementing Stackable interface</dd> </dl> ## Members <dl> <dt><a href="#ArcType">ArcType</a></dt> <dd>The directed arc type: incoming or outgoing</dd> <dt><a href="#ArcType">ArcType</a></dt> <dd>The class DanDirectedGraph handles directed graphs</dd> </dl> ## Functions <dl> <dt><a href="#randomIntFromInterval">randomIntFromInterval(min, max)</a> ⇒ <code>number</code></dt> <dd>Get a random integer number between min and max (included)</dd> </dl> <a name="DanDirectedGraph"></a> ## DanDirectedGraph **Kind**: global class - [DanDirectedGraph](#DanDirectedGraph) - [new DanDirectedGraph()](#new_DanDirectedGraph_new) - _instance_ - [.\_getCopyOfInnerGraph()](#DanDirectedGraph+_getCopyOfInnerGraph) ⇒ <code>Map.<I, DanNodeAndDirectedArcs.<I, D>></code> - [.getNodeAndDirectedArcsFromNodeId(idNode)](#DanDirectedGraph+getNodeAndDirectedArcsFromNodeId) ⇒ <code>DanNodeAndDirectedArcs.<I, D></code> \| <code>undefined</code> - [.addNode(node)](#DanDirectedGraph+addNode) ⇒ <code>boolean</code> - [.addArcToNodeId(idNode, arcToAdd, arcType)](#DanDirectedGraph+addArcToNodeId) ⇒ <code>boolean</code> - [.addArcToNode(node, arcToAdd, arcType)](#DanDirectedGraph+addArcToNode) ⇒ <code>boolean</code> - [.removeNode(idNode)](#DanDirectedGraph+removeNode) ⇒ <code>boolean</code> - [.isNodeALeaf(idNode)](#DanDirectedGraph+isNodeALeaf) ⇒ <code>boolean</code> - [.\_getALeaf()](#DanDirectedGraph+_getALeaf) ⇒ <code>DanNode.<I, D></code> \| <code>undefined</code> - [.toString(showDetails)](#DanDirectedGraph+toString) ⇒ <code>string</code> - [.countNodes()](#DanDirectedGraph+countNodes) ⇒ <code>number</code> - [.isEmpty()](#DanDirectedGraph+isEmpty) ⇒ <code>boolean</code> - [.\_getOutgoingNodesList(idNode)](#DanDirectedGraph+_getOutgoingNodesList) ⇒ <code>Array.<DanNode></code> - [.\_isAcyclic()](#DanDirectedGraph+_isAcyclic) ⇒ <code>boolean</code> - [.isAcyclic()](#DanDirectedGraph+isAcyclic) ⇒ <code>boolean</code> - [.\_visitNodes(visitedNodes, nextNode)](#DanDirectedGraph+_visitNodes) - [.sourceConnectedToAllNodes(idNode)](#DanDirectedGraph+sourceConnectedToAllNodes) ⇒ <code>boolean</code> - [.getDepthFirstIterator(startingNodeId)](#DanDirectedGraph+getDepthFirstIterator) ⇒ <code>GraphIterator.<DanNode.<I, D>></code> - [.getBreadthFirstIterator(startingNodeId)](#DanDirectedGraph+getBreadthFirstIterator) ⇒ <code>GraphIterator.<DanNode.<I, D>></code> - _static_ - [.generateConsecutiveNodeGraph(numOfNodes)](#DanDirectedGraph.generateConsecutiveNodeGraph) ⇒ <code>DanDirectedGraph.<number, undefined></code> - [.generateRandomNodeGraph(numOfNodes)](#DanDirectedGraph.generateRandomNodeGraph) ⇒ <code>DanDirectedGraph.<number, undefined></code> <a name="new_DanDirectedGraph_new"></a> ### new DanDirectedGraph() the public class constructor <a name="DanDirectedGraph+_getCopyOfInnerGraph"></a> ### danDirectedGraph.\_getCopyOfInnerGraph() ⇒ <code>Map.<I, DanNodeAndDirectedArcs.<I, D>></code> Clone the inner graph structure **Kind**: instance method of [<code>DanDirectedGraph</code>](#DanDirectedGraph) **Returns**: <code>Map.<I, DanNodeAndDirectedArcs.<I, D>></code> - a copy of the inner graph structure <a name="DanDirectedGraph+getNodeAndDirectedArcsFromNodeId"></a> ### danDirectedGraph.getNodeAndDirectedArcsFromNodeId(idNode) ⇒ <code>DanNodeAndDirectedArcs.<I, D></code> \| <code>undefined</code> Get node and directed arcs structure (as DanNodeAndDirectedArcs) from nodeId **Kind**: instance method of [<code>DanDirectedGraph</code>](#DanDirectedGraph) **Returns**: <code>DanNodeAndDirectedArcs.<I, D></code> \| <code>undefined</code> - node and directed arcs structure or undefined if nodeId is not present in the graph | Param | Type | Description | | ------ | -------------- | -------------------------- | | idNode | <code>I</code> | the node identifier | <a name="DanDirectedGraph+addNode"></a> ### danDirectedGraph.addNode(node) ⇒ <code>boolean</code> Add a node to the graph **Kind**: instance method of [<code>DanDirectedGraph</code>](#DanDirectedGraph) **Returns**: <code>boolean</code> - true if the node was correctly added to the graph; false if the node is already present | Param | Type | Description | | ----- | --------------------------------- | ---------------------- | | node | <code>DanNode.<I, D></code> | the node to add | <a name="DanDirectedGraph+addArcToNodeId"></a> ### danDirectedGraph.addArcToNodeId(idNode, arcToAdd, arcType) ⇒ <code>boolean</code> Add arc to node given a node id **Kind**: instance method of [<code>DanDirectedGraph</code>](#DanDirectedGraph) **Returns**: <code>boolean</code> - true if arcToAdd was correctly added to the icoming/ougoing arcs of idNode; false if the idNode does not exist or if arcToAdd was already present | Param | Type | Description | | -------- | -------------------------------- | ------------------------------------------------------------------------------------------------------------------- | | idNode | <code>I</code> | the id of the node receiving arcToAdd | | arcToAdd | <code>DanArc.<I, D></code> | the arc being added | | arcType | [<code>ArcType</code>](#ArcType) | arcToAdd will be added among the incoming or outgoing arcs of idNode, based on the value of arcType | <a name="DanDirectedGraph+addArcToNode"></a> ### danDirectedGraph.addArcToNode(node, arcToAdd, arcType) ⇒ <code>boolean</code> Add arc to node given a node structure **Kind**: instance method of [<code>DanDirectedGraph</code>](#DanDirectedGraph) **Returns**: <code>boolean</code> - true if arcToAdd was correctly added to the icoming/ougoing arcs of node; false if arcToAdd was already present | Param | Type | Description | | -------- | --------------------------------- | ----------------------------------------------------------------------------------------------------------------- | | node | <code>DanNode.<I, D></code> | the node receiving arcToAdd | | arcToAdd | <code>DanArc.<I, D></code> | the arc being added | | arcType | [<code>ArcType</code>](#ArcType) | arcToAdd will be added among the incoming or outgoing arcs of node, based on the value of arcType | <a name="DanDirectedGraph+removeNode"></a> ### danDirectedGraph.removeNode(idNode) ⇒ <code>boolean</code> Remove a node given in input from the graph **Kind**: instance method of [<code>DanDirectedGraph</code>](#DanDirectedGraph) **Returns**: <code>boolean</code> - true if the node is correctly removed | Param | Type | Description | | ------ | -------------- | ----------------------------------- | | idNode | <code>I</code> | the id of the node to remove | <a name="DanDirectedGraph+isNodeALeaf"></a> ### danDirectedGraph.isNodeALeaf(idNode) ⇒ <code>boolean</code> Check if node is a leaf **Kind**: instance method of [<code>DanDirectedGraph</code>](#DanDirectedGraph) **Returns**: <code>boolean</code> - true if the node is a leaf (no outgoing arcs) | Param | Type | Description | | ------ | -------------- | ---------------------------------- | | idNode | <code>I</code> | the id of the node to check | <a name="DanDirectedGraph+_getALeaf"></a> ### danDirectedGraph.\_getALeaf() ⇒ <code>DanNode.<I, D></code> \| <code>undefined</code> Get a leaf in the graph or return undefined. **Kind**: instance method of [<code>DanDirectedGraph</code>](#DanDirectedGraph) **Returns**: <code>DanNode.<I, D></code> \| <code>undefined</code> - the first leaf found, or undefined if no leaf is found <a name="DanDirectedGraph+toString"></a> ### danDirectedGraph.toString(showDetails) ⇒ <code>string</code> The string representation of the directed graph **Kind**: instance method of [<code>DanDirectedGraph</code>](#DanDirectedGraph) **Returns**: <code>string</code> - the string representation of the directed graph | Param | Type | Description | | ----------- | -------------------- | ------------------------------------------------------------------------------------------------------------------ | | showDetails | <code>boolean</code> | if this option is true, all the node and arc details will be included in the output string (default: false) | <a name="DanDirectedGraph+countNodes"></a> ### danDirectedGraph.countNodes() ⇒ <code>number</code> Public method to retrieve the number of nodes in the graph **Kind**: instance method of [<code>DanDirectedGraph</code>](#DanDirectedGraph) **Returns**: <code>number</code> - the number of nodes in the graph <a name="DanDirectedGraph+isEmpty"></a> ### danDirectedGraph.isEmpty() ⇒ <code>boolean</code> Check if the graph is empty **Kind**: instance method of [<code>DanDirectedGraph</code>](#DanDirectedGraph) **Returns**: <code>boolean</code> - true if the graph does not contain any node <a name="DanDirectedGraph+_getOutgoingNodesList"></a> ### danDirectedGraph.\_getOutgoingNodesList(idNode) ⇒ <code>Array.<DanNode></code> Get all the outgoing nodes from a node identifier **Kind**: instance method of [<code>DanDirectedGraph</code>](#DanDirectedGraph) **Returns**: <code>Array.<DanNode></code> - the list of outgoing nodes of idNode as array of DanNode<I, D> | Param | Type | Description | | ------ | -------------- | ---------------------------------- | | idNode | <code>I</code> | the id of the node to check | <a name="DanDirectedGraph+_isAcyclic"></a> ### danDirectedGraph.\_isAcyclic() ⇒ <code>boolean</code> Protected method to check if the graph is acyclic. Remove leaves iteratively from the graph: stop if the graph gets empty (acyclic graph), or if there are no more leaves to remove (cyclic graph). **Kind**: instance method of [<code>DanDirectedGraph</code>](#DanDirectedGraph) **Returns**: <code>boolean</code> - true if the graph does not contain cycles, otherwise false <a name="DanDirectedGraph+isAcyclic"></a> ### danDirectedGraph.isAcyclic() ⇒ <code>boolean</code> Public method to check if the graph is acyclic. First we keep a copy of the current inner graph. Then we invoke the protected [this._isAcyclic](#DanDirectedGraph<I, D>+_isAcyclic) method to check if the graph is acyclic. Then we restore the inner state (memento pattern). **Kind**: instance method of [<code>DanDirectedGraph</code>](#DanDirectedGraph) **Returns**: <code>boolean</code> - true if the graph does not contain cycles <a name="DanDirectedGraph+_visitNodes"></a> ### danDirectedGraph.\_visitNodes(visitedNodes, nextNode) Protected method to visit all the neighbours of a node, given in input the node id and a previous set of visitedNodes **Kind**: instance method of [<code>DanDirectedGraph</code>](#DanDirectedGraph) | Param | Type | Description | | ------------ | -------------------------- | -------------------------------- | | visitedNodes | <code>Set.</code> | the nodes already visited | | nextNode | <code>I</code> | the next node to visit | <a name="DanDirectedGraph+sourceConnectedToAllNodes"></a> ### danDirectedGraph.sourceConnectedToAllNodes(idNode) ⇒ <code>boolean</code> Public method to check if all nodes are connected to the source node in input **Kind**: instance method of [<code>DanDirectedGraph</code>](#DanDirectedGraph) **Returns**: <code>boolean</code> - true if source can reach all of the nodes in the graph | Param | Type | Description | | ------ | -------------- | -------------------------------- | | idNode | <code>I</code> | source node to be checked | <a name="DanDirectedGraph+getDepthFirstIterator"></a> ### danDirectedGraph.getDepthFirstIterator(startingNodeId) ⇒ <code>GraphIterator.<DanNode.<I, D>></code> Get depth-first iterator **Kind**: instance method of [<code>DanDirectedGraph</code>](#DanDirectedGraph) **Returns**: <code>GraphIterator.<DanNode.<I, D>></code> - the depth-first iterator | Param | Type | Description | | -------------- | -------------- | ---------------------------------------------------- | | startingNodeId | <code>I</code> | the starting node identifier for the iterator | <a name="DanDirectedGraph+getBreadthFirstIterator"></a> ### danDirectedGraph.getBreadthFirstIterator(startingNodeId) ⇒ <code>GraphIterator.<DanNode.<I, D>></code> Get breadth-first iterator **Kind**: instance method of [<code>DanDirectedGraph</code>](#DanDirectedGraph) **Returns**: <code>GraphIterator.<DanNode.<I, D>></code> - the breadth-first iterator | Param | Type | Description | | -------------- | -------------- | ---------------------------------------------------- | | startingNodeId | <code>I</code> | the starting node identifier for the iterator | <a name="DanDirectedGraph.generateConsecutiveNodeGraph"></a> ### DanDirectedGraph.generateConsecutiveNodeGraph(numOfNodes) ⇒ <code>DanDirectedGraph.<number, undefined></code> A utility public static method to generate a directed graph with a number of numOfNodes consecutive nodes **Kind**: static method of [<code>DanDirectedGraph</code>](#DanDirectedGraph) **Returns**: <code>DanDirectedGraph.<number, undefined></code> - a directed graph witn numOfNodes nodes | Param | Type | Description | | ---------- | ------------------- | ---------------------------------------------- | | numOfNodes | <code>number</code> | the number of nodes of the output graph | <a name="DanDirectedGraph.generateRandomNodeGraph"></a> ### DanDirectedGraph.generateRandomNodeGraph(numOfNodes) ⇒ <code>DanDirectedGraph.<number, undefined></code> A utility public static method to generate a directed graph with a number of numOfNodes random nodes **Kind**: static method of [<code>DanDirectedGraph</code>](#DanDirectedGraph) **Returns**: <code>DanDirectedGraph.<number, undefined></code> - a directed graph witn numOfNodes nodes | Param | Type | Description | | ---------- | ------------------- | ---------------------------------------------- | | numOfNodes | <code>number</code> | the number of nodes of the output graph | <a name="DanDirectedGraphBreadthFirstIterator"></a> ## DanDirectedGraphBreadthFirstIterator The class DanDirectedGraphBreadthFirstIterator implements GraphIterator interface **Kind**: global class - [DanDirectedGraphBreadthFirstIterator](#DanDirectedGraphBreadthFirstIterator) - [new DanDirectedGraphBreadthFirstIterator(collection, startingNodeId)](#new_DanDirectedGraphBreadthFirstIterator_new) - [.\_getNodeAndDirectedArcsFromNodeId(nodeId)](#DanDirectedGraphBreadthFirstIterator+_getNodeAndDirectedArcsFromNodeId) ⇒ <code>DanNodeAndDirectedArcs.<I, D></code> - [.\_initFields(startingNodeId)](#DanDirectedGraphBreadthFirstIterator+_initFields) - [.current()](#DanDirectedGraphBreadthFirstIterator+current) ⇒ <code>DanNode.<I, D></code> \| <code>undefined</code> - [.next()](#DanDirectedGraphBreadthFirstIterator+next) ⇒ <code>DanNode.<I, D></code> \| <code>undefined</code> - [.\_addNextNodeOutgoingsToNextLevelQueueIfNotAlreadyVisitedOrQueued()](#DanDirectedGraphBreadthFirstIterator+_addNextNodeOutgoingsToNextLevelQueueIfNotAlreadyVisitedOrQueued) ⇒ <code>boolean</code> - [.\_advance()](#DanDirectedGraphBreadthFirstIterator+_advance) - [.hasNext()](#DanDirectedGraphBreadthFirstIterator+hasNext) ⇒ <code>boolean</code> - [.rewind()](#DanDirectedGraphBreadthFirstIterator+rewind) <a name="new_DanDirectedGraphBreadthFirstIterator_new"></a> ### new DanDirectedGraphBreadthFirstIterator(collection, startingNodeId) The public class constructor **Throws**: - <code>Error</code> exception if startingNodeId was not found in graph | Param | Type | Description | | -------------- | ------------------------------------------ | ----------------------------------- | | collection | <code>DanDirectedGraph.<I, D></code> | the directed graph | | startingNodeId | <code>I</code> | the starting node identifier | <a name="DanDirectedGraphBreadthFirstIterator+_getNodeAndDirectedArcsFromNodeId"></a> ### danDirectedGraphBreadthFirstIterator.\_getNodeAndDirectedArcsFromNodeId(nodeId) ⇒ <code>DanNodeAndDirectedArcs.<I, D></code> Retrieve node and directed arcs structure from node identifier **Kind**: instance method of [<code>DanDirectedGraphBreadthFirstIterator</code>](#DanDirectedGraphBreadthFirstIterator) **Returns**: <code>DanNodeAndDirectedArcs.<I, D></code> - the node and directed arcs structure DanNodeAndDirectedArcs **Throws**: - <code>Error</code> exception if nodeId was not found in graph | Param | Type | Description | | ------ | -------------- | -------------------------- | | nodeId | <code>I</code> | the node identifier | <a name="DanDirectedGraphBreadthFirstIterator+_initFields"></a> ### danDirectedGraphBreadthFirstIterator.\_initFields(startingNodeId) Init the class fields with the starting node identifier passed in input **Kind**: instance method of [<code>DanDirectedGraphBreadthFirstIterator</code>](#DanDirectedGraphBreadthFirstIterator) **Throws**: - <code>Error</code> exception if startingNodeId was not found in graph | Param | Type | Description | | -------------- | -------------- | ----------------------------------- | | startingNodeId | <code>I</code> | the starting node identifier | <a name="DanDirectedGraphBreadthFirstIterator+current"></a> ### danDirectedGraphBreadthFirstIterator.current() ⇒ <code>DanNode.<I, D></code> \| <code>undefined</code> Get the current node, or return undefined if iterator was not yet started **Kind**: instance method of [<code>DanDirectedGraphBreadthFirstIterator</code>](#DanDirectedGraphBreadthFirstIterator) **Throws**: - <code>Error</code> exception if this.\_currentNodeId was not found in graph <a name="DanDirectedGraphBreadthFirstIterator+next"></a> ### danDirectedGraphBreadthFirstIterator.next() ⇒ <code>DanNode.<I, D></code> \| <code>undefined</code> Get the next node, or return undefined if the iterator's end was reached **Kind**: instance method of [<code>DanDirectedGraphBreadthFirstIterator</code>](#DanDirectedGraphBreadthFirstIterator) **Throws**: - <code>Error</code> exception if this.\_nextNodeId was not found in graph <a name="DanDirectedGraphBreadthFirstIterator+_addNextNodeOutgoingsToNextLevelQueueIfNotAlreadyVisitedOrQueued"></a> ### danDirectedGraphBreadthFirstIterator.\_addNextNodeOutgoingsToNextLevelQueueIfNotAlreadyVisitedOrQueued() ⇒ <code>boolean</code> Add the outgoing nodes of this._nextNodeId to the next-level-queue, if the node was not already visited, and if it's not already present inside the queue **Kind**: instance method of [<code>DanDirectedGraphBreadthFirstIterator</code>](#DanDirectedGraphBreadthFirstIterator) **Returns**: <code>boolean</code> - true if this.\_nextNodeId is not null, otherwise false **Throws**: - <code>Error</code> exception if this.\_nextNodeId was not found in graph <a name="DanDirectedGraphBreadthFirstIterator+_advance"></a> ### danDirectedGraphBreadthFirstIterator.\_advance() Advance to the next node in a breadth first fashion **Kind**: instance method of [<code>DanDirectedGraphBreadthFirstIterator</code>](#DanDirectedGraphBreadthFirstIterator) <a name="DanDirectedGraphBreadthFirstIterator+hasNext"></a> ### danDirectedGraphBreadthFirstIterator.hasNext() ⇒ <code>boolean</code> Check if the iterator can step to a next node **Kind**: instance method of [<code>DanDirectedGraphBreadthFirstIterator</code>](#DanDirectedGraphBreadthFirstIterator) **Returns**: <code>boolean</code> - true if the iterator can step to a next node, false if there are no more nodes left to visit in the iterator <a name="DanDirectedGraphBreadthFirstIterator+rewind"></a> ### danDirectedGraphBreadthFirstIterator.rewind() Restart the iterator **Kind**: instance method of [<code>DanDirectedGraphBreadthFirstIterator</code>](#DanDirectedGraphBreadthFirstIterator) <a name="DanDirectedGraphDepthFirstIterator"></a> ## DanDirectedGraphDepthFirstIterator The class DanDirectedGraphDepthFirstIterator implements GraphIterator interface **Kind**: global class - [DanDirectedGraphDepthFirstIterator](#DanDirectedGraphDepthFirstIterator) - [new DanDirectedGraphDepthFirstIterator(collection, startingNodeId)](#new_DanDirectedGraphDepthFirstIterator_new) - [.\_getNodeAndDirectedArcsFromNodeId(nodeId)](#DanDirectedGraphDepthFirstIterator+_getNodeAndDirectedArcsFromNodeId) ⇒ <code>DanNodeAndDirectedArcs.<I, D></code> - [.\_initFields(startingNodeId)](#DanDirectedGraphDepthFirstIterator+_initFields) - [.current()](#DanDirectedGraphDepthFirstIterator+current) ⇒ <code>DanNode.<I, D></code> \| <code>undefined</code> - [.next()](#DanDirectedGraphDepthFirstIterator+next) ⇒ <code>DanNode.<I, D></code> \| <code>undefined</code> - [.\_advance()](#DanDirectedGraphDepthFirstIterator+_advance) - [.hasNext()](#DanDirectedGraphDepthFirstIterator+hasNext) ⇒ <code>boolean</code> - [.rewind()](#DanDirectedGraphDepthFirstIterator+rewind) <a name="new_DanDirectedGraphDepthFirstIterator_new"></a> ### new DanDirectedGraphDepthFirstIterator(collection, startingNodeId) The public class constructor **Throws**: - <code>Error</code> exception if startingNodeId was not found in graph | Param | Type | Description | | -------------- | ------------------------------------------ | ----------------------------------- | | collection | <code>DanDirectedGraph.<I, D></code> | the directed graph | | startingNodeId | <code>I</code> | the starting node identifier | <a name="DanDirectedGraphDepthFirstIterator+_getNodeAndDirectedArcsFromNodeId"></a> ### danDirectedGraphDepthFirstIterator.\_getNodeAndDirectedArcsFromNodeId(nodeId) ⇒ <code>DanNodeAndDirectedArcs.<I, D></code> Retrieve node and directed arcs structure from node identifier **Kind**: instance method of [<code>DanDirectedGraphDepthFirstIterator</code>](#DanDirectedGraphDepthFirstIterator) **Returns**: <code>DanNodeAndDirectedArcs.<I, D></code> - the node and directed arcs structure DanNodeAndDirectedArcs **Throws**: - <code>Error</code> exception if nodeId was not found in graph | Param | Type | Description | | ------ | -------------- | -------------------------- | | nodeId | <code>I</code> | the node identifier | <a name="DanDirectedGraphDepthFirstIterator+_initFields"></a> ### danDirectedGraphDepthFirstIterator.\_initFields(startingNodeId) Init the class fields with the starting node identifier passed in input **Kind**: instance method of [<code>DanDirectedGraphDepthFirstIterator</code>](#DanDirectedGraphDepthFirstIterator) **Throws**: - <code>Error</code> exception if startingNodeId was not found in graph | Param | Type | Description | | -------------- | -------------- | ----------------------------------- | | startingNodeId | <code>I</code> | the starting node identifier | <a name="DanDirectedGraphDepthFirstIterator+current"></a> ### danDirectedGraphDepthFirstIterator.current() ⇒ <code>DanNode.<I, D></code> \| <code>undefined</code> Get the current node, or return undefined if iterator was not yet started **Kind**: instance method of [<code>DanDirectedGraphDepthFirstIterator</code>](#DanDirectedGraphDepthFirstIterator) **Throws**: - <code>Error</code> exception if this.\_currentNodeId was not found in graph <a name="DanDirectedGraphDepthFirstIterator+next"></a> ### danDirectedGraphDepthFirstIterator.next() ⇒ <code>DanNode.<I, D></code> \| <code>undefined</code> Get the next node, or return undefined if the iterator's end was reached **Kind**: instance method of [<code>DanDirectedGraphDepthFirstIterator</code>](#DanDirectedGraphDepthFirstIterator) **Throws**: - <code>Error</code> exception if this.\_nextNodeId was not found in graph <a name="DanDirectedGraphDepthFirstIterator+_advance"></a> ### danDirectedGraphDepthFirstIterator.\_advance() Advance to the next node in a depth first fashion **Kind**: instance method of [<code>DanDirectedGraphDepthFirstIterator</code>](#DanDirectedGraphDepthFirstIterator) <a name="DanDirectedGraphDepthFirstIterator+hasNext"></a> ### danDirectedGraphDepthFirstIterator.hasNext() ⇒ <code>boolean</code> Check if the iterator can step to a next node **Kind**: instance method of [<code>DanDirectedGraphDepthFirstIterator</code>](#DanDirectedGraphDepthFirstIterator) **Returns**: <code>boolean</code> - true if the iterator can step to a next node, false if there are no more nodes left to visit in the iterator <a name="DanDirectedGraphDepthFirstIterator+rewind"></a> ### danDirectedGraphDepthFirstIterator.rewind() Restart the iterator **Kind**: instance method of [<code>DanDirectedGraphDepthFirstIterator</code>](#DanDirectedGraphDepthFirstIterator) <a name="DanUndirectedGraph"></a> ## DanUndirectedGraph The DanUndirectedGraph class handles undirected graphs **Kind**: global class - [DanUndirectedGraph](#DanUndirectedGraph) - [new DanUndirectedGraph()](#new_DanUndirectedGraph_new) - _instance_ - [.addNode(node)](#DanUndirectedGraph+addNode) ⇒ <code>boolean</code> - [.addArcToNodeId(idNode, arcToAdd)](#DanUndirectedGraph+addArcToNodeId) ⇒ <code>boolean</code> - [.addArcToNode(node, nodeToAdd)](#DanUndirectedGraph+addArcToNode) ⇒ <code>boolean</code> - [.removeNode(idNode)](#DanUndirectedGraph+removeNode) ⇒ <code>boolean</code> - [.\_getAdjacentNodesList(idNode)](#DanUndirectedGraph+_getAdjacentNodesList) ⇒ <code>Array.<DanNode></code> - [.\_getANode()](#DanUndirectedGraph+_getANode) ⇒ <code>DanNode.<I, D></code> \| <code>undefined</code> - [.\_visitNodes(visitedNodes, nextNode)](#DanUndirectedGraph+_visitNodes) - [.\_checkForCycle(visitedNodes, nextNode, fromNode)](#DanUndirectedGraph+_checkForCycle) ⇒ <code>boolean</code> - [.isConnected()](#DanUndirectedGraph+isConnected) ⇒ <code>boolean</code> - [.isAcyclic()](#DanUndirectedGraph+isAcyclic) ⇒ <code>boolean</code> - [.countNodes()](#DanUndirectedGraph+countNodes) ⇒ <code>number</code> - [.isEmpty()](#DanUndirectedGraph+isEmpty) ⇒ <code>boolean</code> - [.toString(showDetails)](#DanUndirectedGraph+toString) ⇒ <code>string</code> - [.getInnerGraph()](#DanUndirectedGraph+getInnerGraph) ⇒ <code>Map.<I, DanNodeAndUndirectedArcs.<I, D>></code> - _static_ - [.generateConsecutiveNodeGraph(numOfNodes)](#DanUndirectedGraph.generateConsecutiveNodeGraph) ⇒ <code>DanUndirectedGraph.<number, undefined></code> - [.generateRandomNodeGraph(numOfNodes)](#DanUndirectedGraph.generateRandomNodeGraph) ⇒ <code>DanUndirectedGraph.<number, undefined></code> <a name="new_DanUndirectedGraph_new"></a> ### new DanUndirectedGraph() the public class constructor <a name="DanUndirectedGraph+addNode"></a> ### danUndirectedGraph.addNode(node) ⇒ <code>boolean</code> Add a node to the graph **Kind**: instance method of [<code>DanUndirectedGraph</code>](#DanUndirectedGraph) **Returns**: <code>boolean</code> - true if the node was correctly added to the graph; false if the node is already present | Param | Type | Description | | ----- | --------------------------------- | ---------------------- | | node | <code>DanNode.<I, D></code> | the node to add | <a name="DanUndirectedGraph+addArcToNodeId"></a> ### danUndirectedGraph.addArcToNodeId(idNode, arcToAdd) ⇒ <code>boolean</code> Add an arc to a node, given the node identifier **Kind**: instance method of [<code>DanUndirectedGraph</code>](#DanUndirectedGraph) **Returns**: <code>boolean</code> - true if arcToAdd was correctly added to the adjacent arcs of idNode; false if the idNode does not exist or if arcToAdd was already present | Param | Type | Description | | -------- | -------------------------------- | ----------------------------------------------------- | | idNode | <code>I</code> | the id of the node receiving arcToAdd | | arcToAdd | <code>DanArc.<I, D></code> | the arc being added | <a name="DanUndirectedGraph+addArcToNode"></a> ### danUndirectedGraph.addArcToNode(node, nodeToAdd) ⇒ <code>boolean</code> Add arc to node, given the node interface structure **Kind**: instance method of [<code>DanUndirectedGraph</code>](#DanUndirectedGraph) **Returns**: <code>boolean</code> - true if arcToAdd was correctly added to the adjacent arcs of node; false if arcToAdd was already present | Param | Type | Description | | --------- | --------------------------------- | ------------------------------------------- | | node | <code>DanNode.<I, D></code> | the node receiving arcToAdd | | nodeToAdd | <code>DanArc.<I, D></code> | the node being added | <a name="DanUndirectedGraph+removeNode"></a> ### danUndirectedGraph.removeNode(idNode) ⇒ <code>boolean</code> Remove the node given in input from the graph **Kind**: instance method of [<code>DanUndirectedGraph</code>](#DanUndirectedGraph) **Returns**: <code>boolean</code> - true if the node is correctly removed | Param | Type | Description | | ------ | -------------- | ----------------------------------- | | idNode | <code>I</code> | the id of the node to remove | <a name="DanUndirectedGraph+_getAdjacentNodesList"></a> ### danUndirectedGraph.\_getAdjacentNodesList(idNode) ⇒ <code>Array.<DanNode></code> Get the list of adjacent nodes of a given node identifier **Kind**: instance method of [<code>DanUndirectedGraph</code>](#DanUndirectedGraph) **Returns**: <code>Array.<DanNode></code> - the list of adjacent nodes of idNode as array of DanNode<I, D> | Param | Type | Description | | ------ | -------------- | ---------------------------------- | | idNode | <code>I</code> | the id of the node to check | <a name="DanUndirectedGraph+_getANode"></a> ### danUndirectedGraph.\_getANode() ⇒ <code>DanNode.<I, D></code> \| <code>undefined</code> Get a node in the graph **Kind**: instance method of [<code>DanUndirectedGraph</code>](#DanUndirectedGraph) **Returns**: <code>DanNode.<I, D></code> \| <code>undefined</code> - a node in the graph or undefined if the graph is empty <a name="DanUndirectedGraph+_visitNodes"></a> ### danUndirectedGraph.\_visitNodes(visitedNodes, nextNode) Protected method to visit all the neighbours of a node, given in input the node id and a previous set of visitedNodes **Kind**: instance method of [<code>DanUndirectedGraph</code>](#DanUndirectedGraph) | Param | Type | Description | | ------------ | -------------------------- | -------------------------------- | | visitedNodes | <code>Set.</code> | the nodes already visited | | nextNode | <code>I</code> | the next node to visit | <a name="DanUndirectedGraph+_checkForCycle"></a> ### danUndirectedGraph.\_checkForCycle(visitedNodes, nextNode, fromNode) ⇒ <code>boolean</code> Recursively checks for the presence of a cycle starting from node id nextNode **Kind**: instance method of [<code>DanUndirectedGraph</code>](#DanUndirectedGraph) **Returns**: <code>boolean</code> - true if a cycle is found, false if no cycle is found | Param | Type | Description | | ------------ | ---------------------------------------- | ------------------------------------------- | | visitedNodes | <code>Set.</code> | the nodes already visited | | nextNode | <code>I</code> | the next node to visit | | fromNode | <code>I</code> \| <code>undefined</code> | the parent node (default: undefined) | <a name="DanUndirectedGraph+isConnected"></a> ### danUndirectedGraph.isConnected() ⇒ <code>boolean</code> Check if the graph is connected **Kind**: instance method of [<code>DanUndirectedGraph</code>](#DanUndirectedGraph) **Returns**: <code>boolean</code> - true if the graph is connected <a name="DanUndirectedGraph+isAcyclic"></a> ### danUndirectedGraph.isAcyclic() ⇒ <code>boolean</code> Public method to check if the graph is acyclic **Kind**: instance method of [<code>DanUndirectedGraph</code>](#DanUndirectedGraph) **Returns**: <code>boolean</code> - true if the graph does not contain cycles <a name="DanUndirectedGraph+countNodes"></a> ### danUndirectedGraph.countNodes() ⇒ <code>number</code> Public method to retrieve the number of nodes in the graph **Kind**: instance method of [<code>DanUndirectedGraph</code>](#DanUndirectedGraph) **Returns**: <code>number</code> - the number of nodes in the graph <a name="DanUndirectedGraph+isEmpty"></a> ### danUndirectedGraph.isEmpty() ⇒ <code>boolean</code> Check if the graph is empty **Kind**: instance method of [<code>DanUndirectedGraph</code>](#DanUndirectedGraph) **Returns**: <code>boolean</code> - true if the graph does not contain any node <a name="DanUndirectedGraph+toString"></a> ### danUndirectedGraph.toString(showDetails) ⇒ <code>string</code> The string representation of the undirected graph **Kind**: instance method of [<code>DanUndirectedGraph</code>](#DanUndirectedGraph) **Returns**: <code>string</code> - the string representation of the undirected graph | Param | Type | Description | | ----------- | -------------------- | ------------------------------------------------------------------------------------------------------------------ | | showDetails | <code>boolean</code> | if this option is true, all the node and arc details will be included in the output string (default: false) | <a name="DanUndirectedGraph+getInnerGraph"></a> ### danUndirectedGraph.getInnerGraph() ⇒ <code>Map.<I, DanNodeAndUndirectedArcs.<I, D>></code> Get the inner graph object **Kind**: instance method of [<code>DanUndirectedGraph</code>](#DanUndirectedGraph) **Returns**: <code>Map.<I, DanNodeAndUndirectedArcs.<I, D>></code> - the inner graph Map object <a name="DanUndirectedGraph.generateConsecutiveNodeGraph"></a> ### DanUndirectedGraph.generateConsecutiveNodeGraph(numOfNodes) ⇒ <code>DanUndirectedGraph.<number, undefined></code> A utility public static method to generate an undirected graph with a number of numOfNodes consecutive nodes **Kind**: static method of [<code>DanUndirectedGraph</code>](#DanUndirectedGraph) **Returns**: <code>DanUndirectedGraph.<number, undefined></code> - an undirected graph witn numOfNodes nodes | Param | Type | Description | | ---------- | ------------------- | ---------------------------------------------- | | numOfNodes | <code>number</code> | the number of nodes of the output graph | <a name="DanUndirectedGraph.generateRandomNodeGraph"></a> ### DanUndirectedGraph.generateRandomNodeGraph(numOfNodes) ⇒ <code>DanUndirectedGraph.<number, undefined></code> A utility public static method to generate an undirected graph with a number of numOfNodes random nodes **Kind**: static method of [<code>DanUndirectedGraph</code>](#DanUndirectedGraph) **Returns**: <code>DanUndirectedGraph.<number, undefined></code> - an undirected graph witn numOfNodes nodes | Param | Type | Description | | ---------- | ------------------- | ---------------------------------------------- | | numOfNodes | <code>number</code> | the number of nodes of the output graph | <a name="DanStack"></a> ## DanStack DanStack is a simple class implementing Stackable interface **Kind**: global class - [DanStack](#DanStack) - [new DanStack()](#new_DanStack_new) - [.push(val)](#DanStack+push) - [.pop()](#DanStack+pop) ⇒ <code>T</code> \| <code>undefined</code> - [.peek()](#DanStack+peek) ⇒ <code>T</code> \| <code>undefined</code> - [.isEmpty()](#DanStack+isEmpty) ⇒ <code>boolean</code> - [.clear()](#DanStack+clear) <a name="new_DanStack_new"></a> ### new DanStack() The public class constructor <a name="DanStack+push"></a> ### danStack.push(val) Insert a value to the top of the stack We use the 'push' method of the private member '_list' **Kind**: instance method of [<code>DanStack</code>](#DanStack) | Param | Type | Description | | ----- | -------------- | ---------------------------------------------- | | val | <code>T</code> | the value to be pushed inside the stack | <a name="DanStack+pop"></a> ### danStack.pop() ⇒ <code>T</code> \| <code>undefined</code> Get the value from the top of the stack and remove it from the stack itself We use the 'pop' method of the private member '_list' **Kind**: instance method of [<code>DanStack</code>](#DanStack) **Returns**: <code>T</code> \| <code>undefined</code> - the element on top of the stack if the stack is not empty; conversely it returns undefined <a name="DanStack+peek"></a> ### danStack.peek() ⇒ <code>T</code> \| <code>undefined</code> Get the value from the top of the stack but do not remove it from the stack itself **Kind**: instance method of [<code>DanStack</code>](#DanStack) **Returns**: <code>T</code> \| <code>undefined</code> - the element on top of the stack if the stack is not empty; conversely it returns undefined <a name="DanStack+isEmpty"></a> ### danStack.isEmpty() ⇒ <code>boolean</code> Check if the stack is empty We use the 'length' method of the private member '_list' to check the number of elements present: if the number is less than 1, the stack is empty **Kind**: instance method of [<code>DanStack</code>](#DanStack) **Returns**: <code>boolean</code> - true if the stack is empty; it returns false is the stack is not empty <a name="DanStack+clear"></a> ### danStack.clear() Clear all stack's elements We use the 'splice' method of the private member '_list' **Kind**: instance method of [<code>DanStack</code>](#DanStack) <a name="ArcType"></a> ## ArcType The directed arc type: incoming or outgoing **Kind**: global variable <a name="ArcType"></a> ## ArcType The class DanDirectedGraph handles directed graphs **Kind**: global variable <a name="randomIntFromInterval"></a> ## randomIntFromInterval(min, max) ⇒ <code>number</code> Get a random integer number between min and max (included) **Kind**: global function **Returns**: <code>number</code> - an integer between min and max (included) | Param | Type | Description | | ----- | ------------------- | --------------------- | | min | <code>number</code> | minimum number | | max | <code>number</code> | maximum number |