scalax.collection.mutable.AdjacencyListGraph

InnerNodeImpl

trait InnerNodeImpl extends InnerNodeLike

Self Type
InnerNodeImpl with AdjacencyListGraph.NodeT
Linear Supertypes
AdjacencyListGraph.InnerNodeLike, AdjacencyListGraph.InnerNodeOps, AdjacencyListGraph.InnerNodeLike, AdjacencyListGraph.InnerNodeLike, AdjacencyListGraph.InnerNodeLike, AdjacencyListGraph.Node, Serializable, Serializable, NodeOut[N], GraphParamNode[N], GraphParamOut[N, Nothing], GraphParam[N, Nothing], AnyRef, Any
Known Subclasses
Ordering
  1. Alphabetic
  2. By inheritance
Inherited
  1. InnerNodeImpl
  2. InnerNodeLike
  3. InnerNodeOps
  4. InnerNodeLike
  5. InnerNodeLike
  6. InnerNodeLike
  7. Node
  8. Serializable
  9. Serializable
  10. NodeOut
  11. GraphParamNode
  12. GraphParamOut
  13. GraphParam
  14. AnyRef
  15. Any
  1. Hide All
  2. Show all
Learn more about member selection
Visibility
  1. Public
  2. All

Abstract Value Members

  1. abstract def findConnected(pred: (AdjacencyListGraph.NodeT) ⇒ Boolean, nodeFilter: (AdjacencyListGraph.NodeT) ⇒ Boolean = anyNode, edgeFilter: (EdgeT) ⇒ Boolean = anyEdge, nodeVisitor: (AdjacencyListGraph.NodeT) ⇒ VisitorReturn = noNodeAction, edgeVisitor: (EdgeT) ⇒ Unit = noEdgeAction, ordering: AdjacencyListGraph.ElemOrdering = noOrdering): Option[AdjacencyListGraph.NodeT]

    Finds a node (not necessarily directly) connected with this node for which the predicate pred holds taking optional filters and visitors into account.

    Finds a node (not necessarily directly) connected with this node for which the predicate pred holds taking optional filters and visitors into account.. For directed or mixed graphs the node to be found is weekly connected with this node. Node/edge visitor functions allow arbitrary user-defined computation during the traversal.

    This node itself does not count as a match. This is also true if it has a hook. If several connected nodes exist with pred the algorithm selects the first of them it founds.

    pred

    The predicate which must hold true for the resulting node.

    nodeFilter

    Predicate to filter the nodes to be visited during traversal. The default value is anyNode, that is no filtering. A return of true signals that the traversal is to be canceled.

    edgeFilter

    Predicate to filter the edges to be visited during traversal. The default value is anyEdge meaning that no filtering takes place.

    nodeVisitor

    Function to be called on visiting a node for the first time during a traversal. It can mutate the node or carry out any other side effect. The default value is the empty function noNodeAction.

    edgeVisitor

    Function to be called on visiting an edge. It can mutate the node or carry out any other side effect. The default value is the empty function noEdgeAction.

    ordering

    If a NodeOrdering or EdgeOrdering different from noOrdering is supplied neighbor nodes will be sorted during the traversal. Thus it is guaranteed that the smaller an element's ranking the sooner it will be processed. In case of EdgeOrdering it is guaranteed that the smaller an edge's ranking the sooner its relevant end(s) will be processed.

    returns

    A node with the predicate pred or None if either a) there is no node with pred or b) there exists no connection to such a node at all c) there exists a connection to such a node but due to user filtering or canceling the traversal this connection had to be disregarded.

    Definition Classes
    InnerNodeLike
  2. abstract def findCycle(nodeFilter: (AdjacencyListGraph.NodeT) ⇒ Boolean = anyNode, edgeFilter: (EdgeT) ⇒ Boolean = anyEdge, maxDepth: Int = 0, nodeVisitor: (AdjacencyListGraph.NodeT) ⇒ VisitorReturn = noNodeAction, edgeVisitor: (EdgeT) ⇒ Unit = noEdgeAction, ordering: AdjacencyListGraph.ElemOrdering = noOrdering): Option[AdjacencyListGraph.Cycle]

    Finds a cycle starting the search at this node taking optional filters and visitors into account.

    Finds a cycle starting the search at this node taking optional filters and visitors into account., if any. The resulting cycle may start at any node connected with this node.

    nodeFilter

    Predicate to filter the nodes to be visited during traversal. The default value is anyNode, that is no filtering. A return of true signals that the traversal is to be canceled.

    edgeFilter

    Predicate to filter the edges to be visited during traversal. The default value is anyEdge meaning that no filtering takes place.

    maxDepth

    A positive value limits the number of layers for BFS respectively the number of consecutive child visits before siblings are visited for DFS. 0 - the default - indicates that the traversal should have an unlimited depth meaning that it will be continued either until it's canceled by nodeVisitor or until all nodes have been visited.

    nodeVisitor

    Function to be called on visiting a node for the first time during a traversal. It can mutate the node or carry out any other side effect. The default value is the empty function noNodeAction.

    edgeVisitor

    Function to be called on visiting an edge. It can mutate the node or carry out any other side effect. The default value is the empty function noEdgeAction.

    ordering

    If a NodeOrdering or EdgeOrdering different from noOrdering is supplied neighbor nodes will be sorted during the traversal. Thus it is guaranteed that the smaller an element's ranking the sooner it will be processed. In case of EdgeOrdering it is guaranteed that the smaller an edge's ranking the sooner its relevant end(s) will be processed.

    returns

    A cycle or None if either a) there exists no cycle in the component this node belongs to or b) there exists a cycle in the component but due to the given filtering conditions or a Cancel return by a visitor this cycle had to be disregarded.

    Definition Classes
    InnerNodeLike
  3. abstract def findPredecessor(pred: (AdjacencyListGraph.NodeT) ⇒ Boolean, nodeFilter: (AdjacencyListGraph.NodeT) ⇒ Boolean = anyNode, edgeFilter: (EdgeT) ⇒ Boolean = anyEdge, nodeVisitor: (AdjacencyListGraph.NodeT) ⇒ VisitorReturn = noNodeAction, edgeVisitor: (EdgeT) ⇒ Unit = noEdgeAction, ordering: AdjacencyListGraph.ElemOrdering = noOrdering): Option[AdjacencyListGraph.NodeT]

    Finds a predecessor of this node for which the predicate pred holds taking optional filters and visitors into account.

    Finds a predecessor of this node for which the predicate pred holds taking optional filters and visitors into account.. Node/edge visitor functions allow arbitrary user-defined computation during the traversal.

    This node itself does not count as a match. This is also true if it has a hook. If several predecessors exist the algorithm selects the first of them found.

    pred

    The predicate which must hold true for the resulting node.

    nodeFilter

    Predicate to filter the nodes to be visited during traversal. The default value is anyNode, that is no filtering. A return of true signals that the traversal is to be canceled.

    edgeFilter

    Predicate to filter the edges to be visited during traversal. The default value is anyEdge meaning that no filtering takes place.

    nodeVisitor

    Function to be called on visiting a node for the first time during a traversal. It can mutate the node or carry out any other side effect. The default value is the empty function noNodeAction.

    edgeVisitor

    Function to be called on visiting an edge. It can mutate the node or carry out any other side effect. The default value is the empty function noEdgeAction.

    ordering

    If a NodeOrdering or EdgeOrdering different from noOrdering is supplied neighbor nodes will be sorted during the traversal. Thus it is guaranteed that the smaller an element's ranking the sooner it will be processed. In case of EdgeOrdering it is guaranteed that the smaller an edge's ranking the sooner its relevant end(s) will be processed.

    returns

    A node with the predicate pred or None if either a) there is no node with pred or b) there exists no path from such a node to this node at all or c) there exists a path from such a node to this node but due to user filtering or canceling the traversal this path had to be disregarded.

    Definition Classes
    InnerNodeLike
  4. abstract def findSuccessor(pred: (AdjacencyListGraph.NodeT) ⇒ Boolean, nodeFilter: (AdjacencyListGraph.NodeT) ⇒ Boolean = anyNode, edgeFilter: (EdgeT) ⇒ Boolean = anyEdge, nodeVisitor: (AdjacencyListGraph.NodeT) ⇒ VisitorReturn = noNodeAction, edgeVisitor: (EdgeT) ⇒ Unit = noEdgeAction, ordering: AdjacencyListGraph.ElemOrdering = noOrdering): Option[AdjacencyListGraph.NodeT]

    Finds a successor of this node for which the predicate pred holds taking optional filters and visitors into account.

    Finds a successor of this node for which the predicate pred holds taking optional filters and visitors into account.. Node/edge visitor functions allow arbitrary user-defined computation during the traversal.

    This node itself does not count as a match. This is also true if it has a hook. If several successors exist the algorithm selects the first of them it founds.

    pred

    The predicate which must hold true for the resulting node.

    nodeFilter

    Predicate to filter the nodes to be visited during traversal. The default value is anyNode, that is no filtering. A return of true signals that the traversal is to be canceled.

    edgeFilter

    Predicate to filter the edges to be visited during traversal. The default value is anyEdge meaning that no filtering takes place.

    nodeVisitor

    Function to be called on visiting a node for the first time during a traversal. It can mutate the node or carry out any other side effect. The default value is the empty function noNodeAction.

    edgeVisitor

    Function to be called on visiting an edge. It can mutate the node or carry out any other side effect. The default value is the empty function noEdgeAction.

    ordering

    If a NodeOrdering or EdgeOrdering different from noOrdering is supplied neighbor nodes will be sorted during the traversal. Thus it is guaranteed that the smaller an element's ranking the sooner it will be processed. In case of EdgeOrdering it is guaranteed that the smaller an edge's ranking the sooner its relevant end(s) will be processed.

    returns

    A node with the predicate pred or None if either a) there is no node with pred or b) there exists no path to such a node at all c) there exists a path to such a node but due to user filtering or canceling the traversal this path had to be disregarded.

    Definition Classes
    InnerNodeLike
  5. abstract def pathUntil(pred: (AdjacencyListGraph.NodeT) ⇒ Boolean, nodeFilter: (AdjacencyListGraph.NodeT) ⇒ Boolean = anyNode, edgeFilter: (EdgeT) ⇒ Boolean = anyEdge, nodeVisitor: (AdjacencyListGraph.NodeT) ⇒ VisitorReturn = noNodeAction, edgeVisitor: (EdgeT) ⇒ Unit = noEdgeAction, ordering: AdjacencyListGraph.ElemOrdering = noOrdering): Option[AdjacencyListGraph.Path]

    Finds a path from this node to a successor of this node for which the predicate pred holds taking optional filters and visitors into account.

    Finds a path from this node to a successor of this node for which the predicate pred holds taking optional filters and visitors into account..

    This node itself does not count as a match. This is also true if it has a hook. If several successors exist the algorithm selects any first matching node.

    pred

    The predicate which must hold true for the successor.

    nodeFilter

    Predicate to filter the nodes to be visited during traversal. The default value is anyNode, that is no filtering. A return of true signals that the traversal is to be canceled.

    edgeFilter

    Predicate to filter the edges to be visited during traversal. The default value is anyEdge meaning that no filtering takes place.

    nodeVisitor

    Function to be called on visiting a node for the first time during a traversal. It can mutate the node or carry out any other side effect. The default value is the empty function noNodeAction.

    edgeVisitor

    Function to be called on visiting an edge. It can mutate the node or carry out any other side effect. The default value is the empty function noEdgeAction.

    ordering

    If a NodeOrdering or EdgeOrdering different from noOrdering is supplied neighbor nodes will be sorted during the traversal. Thus it is guaranteed that the smaller an element's ranking the sooner it will be processed. In case of EdgeOrdering it is guaranteed that the smaller an edge's ranking the sooner its relevant end(s) will be processed.

    returns

    A path to a node with the predicate pred or None if either a) there is no node with pred or b) there exists no path to such a node at all c) there exists a path to such a node but due to the given filter conditions this path had to be disregarded.

    Definition Classes
    InnerNodeLike
  6. abstract def shortestPathTo(potentialSuccessor: AdjacencyListGraph.NodeT, nodeFilter: (AdjacencyListGraph.NodeT) ⇒ Boolean = anyNode, edgeFilter: (EdgeT) ⇒ Boolean = anyEdge, nodeVisitor: (AdjacencyListGraph.NodeT) ⇒ VisitorReturn = noNodeAction, edgeVisitor: (EdgeT) ⇒ Unit = noEdgeAction, ordering: AdjacencyListGraph.ElemOrdering = noOrdering): Option[AdjacencyListGraph.Path]

    Finds the shortest path from this node to potentialSuccessor.

    Finds the shortest path from this node to potentialSuccessor.

    The calculation is based on the weight of the edges on the path. As a default, edges have a weight of 1 what can be overridden by custom edges.

    potentialSuccessor

    The node the shortest path is to be found to.

    nodeFilter

    Predicate to filter the nodes to be visited during traversal. The default value is anyNode, that is no filtering. A return of true signals that the traversal is to be canceled.

    edgeFilter

    Predicate to filter the edges to be visited during traversal. The default value is anyEdge meaning that no filtering takes place.

    nodeVisitor

    Function to be called on visiting a node for the first time during a traversal. It can mutate the node or carry out any other side effect. The default value is the empty function noNodeAction.

    edgeVisitor

    Function to be called on visiting an edge. It can mutate the node or carry out any other side effect. The default value is the empty function noEdgeAction.

    ordering

    If a NodeOrdering or EdgeOrdering different from noOrdering is supplied neighbor nodes will be sorted during the traversal. Thus it is guaranteed that the smaller an element's ranking the sooner it will be processed. In case of EdgeOrdering it is guaranteed that the smaller an edge's ranking the sooner its relevant end(s) will be processed.

    returns

    The shortest path to potentialSuccessor or None if either a) there exists no path to potentialSuccessor or b) there exists a path to potentialSuccessor but due to the given filtering conditions this path had to be disregarded.

    Definition Classes
    InnerNodeLike
  7. abstract def traverse(direction: Direction = Successors, nodeFilter: (AdjacencyListGraph.NodeT) ⇒ Boolean = anyNode, edgeFilter: (EdgeT) ⇒ Boolean = anyEdge, breadthFirst: Boolean = true, maxDepth: Int = 0, ordering: AdjacencyListGraph.ElemOrdering = noOrdering)(nodeVisitor: (AdjacencyListGraph.NodeT) ⇒ VisitorReturn = noNodeAction, edgeVisitor: (EdgeT) ⇒ Unit = noEdgeAction): Unit

    Traverses this graph starting at this (root) node for side-effects allowing

    Traverses this graph starting at this (root) node for side-effects allowing

    a) to filter nodes and/or edges, b) to carry out any side effect at visited nodes and/or edges and c) to cancel the traversal at any node.

    direction

    Determines which connected nodes the traversal has to follow. The default value is Successors.

    nodeFilter

    Predicate to filter the nodes to be visited during traversal. The default value is anyNode, that is no filtering. A return of true signals that the traversal is to be canceled.

    edgeFilter

    Predicate to filter the edges to be visited during traversal. The default value is anyEdge meaning that no filtering takes place.

    breadthFirst

    If true the traversal is based on a breath first (BFS, layer-for-layer) search, otherwise on a depth first search (DFS). The default value is BFS.

    maxDepth

    A positive value limits the number of layers for BFS respectively the number of consecutive child visits before siblings are visited for DFS. 0 - the default - indicates that the traversal should have an unlimited depth meaning that it will be continued either until it's canceled by nodeVisitor or until all nodes have been visited.

    ordering

    If a NodeOrdering or EdgeOrdering different from noOrdering is supplied neighbor nodes will be sorted during the traversal. Thus it is guaranteed that the smaller an element's ranking the sooner it will be processed. In case of EdgeOrdering it is guaranteed that the smaller an edge's ranking the sooner its relevant end(s) will be processed.

    nodeVisitor

    Function to be called on visiting a node for the first time during a traversal. It can mutate the node or carry out any other side effect. The default value is the empty function noNodeAction.

    edgeVisitor

    Function to be called on visiting an edge. It can mutate the node or carry out any other side effect. The default value is the empty function noEdgeAction.

    Definition Classes
    InnerNodeLike
  8. abstract def value: N

    The outer node as supplied by the user at instantiation time or by adding nodes this graph.

    The outer node as supplied by the user at instantiation time or by adding nodes this graph.

    returns

    Reference to the user-supplied outer node.

    Definition Classes
    InnerNodeLikeGraphParamNode

Concrete Value Members

  1. final def !=(arg0: AnyRef): Boolean

    Definition Classes
    AnyRef
  2. final def !=(arg0: Any): Boolean

    Definition Classes
    Any
  3. final def ##(): Int

    Definition Classes
    AnyRef → Any
  4. final def +~(that: N, those: N*)(implicit edgeFactory: HyperEdgeCompanion[E]): EdgeT

    Synonym to connectWith

    Synonym to connectWith

    Definition Classes
    InnerNodeOps
    Annotations
    @inline()
  5. final def +~(that: N)(implicit edgeFactory: EdgeCompanion[E]): EdgeT

    Synonym to connectWith

    Synonym to connectWith

    Definition Classes
    InnerNodeOps
    Annotations
    @inline()
  6. final def +~%[EE[X] <: E[X] with EdgeLikeIn[X] with WEdgeBound[_, EE]](that: N, those: N*)(weight: Long)(implicit edgeFactory: WHyperEdgeCompanion[EE]): EdgeT

    Synonym to connectWithW(that, those)(weight).

    Synonym to connectWithW(that, those)(weight).

    Definition Classes
    InnerNodeOps
    Annotations
    @inline()
  7. final def +~%[EE[X] <: E[X] with EdgeLikeIn[X] with WEdgeBound[_, EE]](that: N)(weight: Long)(implicit edgeFactory: WEdgeCompanion[EE]): EdgeT

    Synonym to connectWithW(that)(weight).

    Synonym to connectWithW(that)(weight).

    Definition Classes
    InnerNodeOps
    Annotations
    @inline()
  8. final def +~%+[EE[X] <: E[X] with EdgeLikeIn[X] with WLEdgeBound[_, EE], L](that: N, those: N*)(weight: Long, label: L)(implicit edgeFactory: WLHyperEdgeCompanion[EE]): EdgeT

    Synonym to connectWithWL(that, those)(weight, label).

    Synonym to connectWithWL(that, those)(weight, label).

    Definition Classes
    InnerNodeOps
    Annotations
    @inline()
  9. final def +~%+[EE[X] <: E[X] with EdgeLikeIn[X] with WLEdgeBound[_, EE], L](that: N)(weight: Long, label: L)(implicit edgeFactory: WLEdgeCompanion[EE]): EdgeT

    Synonym to connectWithWL(that)(weight, label).

    Synonym to connectWithWL(that)(weight, label).

    Definition Classes
    InnerNodeOps
    Annotations
    @inline()
  10. final def +~+[EE[X] <: E[X] with EdgeLikeIn[X] with LEdgeBound[_, EE], L](that: N, those: N*)(label: L)(implicit edgeFactory: LHyperEdgeCompanion[EE]): EdgeT

    Synonym to connectWithL(that, those)(label).

    Synonym to connectWithL(that, those)(label).

    Definition Classes
    InnerNodeOps
    Annotations
    @inline()
  11. final def +~+[EE[X] <: E[X] with EdgeLikeIn[X] with LEdgeBound[_, EE], L](that: N)(label: L)(implicit edgeFactory: LEdgeCompanion[EE]): EdgeT

    Synonym to connectWithL(that)(label).

    Synonym to connectWithL(that)(label).

    Definition Classes
    InnerNodeOps
    Annotations
    @inline()
  12. final def <~(from: AdjacencyListGraph.NodeT): Set[EdgeT]

    Synonym for incomingFrom.

    Synonym for incomingFrom.

    Definition Classes
    InnerNodeLike
    Annotations
    @inline()
  13. final def <~: Set[EdgeT]

    Synonym for incoming.

    Synonym for incoming.

    Definition Classes
    InnerNodeLike
    Annotations
    @inline()
  14. final def <~?(from: AdjacencyListGraph.NodeT): Option[EdgeT]

    Synonym for findIncomingFrom.

    Synonym for findIncomingFrom.

    Definition Classes
    InnerNodeLike
    Annotations
    @inline()
  15. final def <~|: Set[AdjacencyListGraph.NodeT]

    Synonym for diPredecessors.

    Synonym for diPredecessors.

    Definition Classes
    InnerNodeLike
    Annotations
    @inline()
  16. final def ==(arg0: AnyRef): Boolean

    Definition Classes
    AnyRef
  17. final def ==(arg0: Any): Boolean

    Definition Classes
    Any
  18. def addDiPredecessors(edge: EdgeT, add: (AdjacencyListGraph.NodeT) ⇒ Unit): Unit

    Attributes
    protected[scalax.collection]
    Definition Classes
    InnerNodeLike
  19. def addDiSuccessors(edge: EdgeT, add: (AdjacencyListGraph.NodeT) ⇒ Unit): Unit

    Attributes
    protected[scalax.collection]
    Definition Classes
    InnerNodeLike
  20. def addNeighbors(edge: EdgeT, add: (AdjacencyListGraph.NodeT) ⇒ Unit): Unit

    Attributes
    protected[scalax.collection]
    Definition Classes
    InnerNodeLike
  21. final def asInstanceOf[T0]: T0

    Definition Classes
    Any
  22. def canEqual(that: Any): Boolean

    Definition Classes
    InnerNodeLike
  23. def clone(): AnyRef

    Attributes
    protected[java.lang]
    Definition Classes
    AnyRef
    Annotations
    @throws()
  24. final def connectWith(that: N, those: N*)(implicit edgeFactory: HyperEdgeCompanion[E]): EdgeT

    Creates a new inner hyperedge between this node and that plus those using edgeFactory and adds it to the edge set of this graph.

    Creates a new inner hyperedge between this node and that plus those using edgeFactory and adds it to the edge set of this graph. Node arguments not yet contained in this graph will be added to the node set. Same as calling addAndGetEdge(this, that, those) on a Graph instance.

    that

    The second outer node to be incident with the edge to be created. In case of a directed edge, this becomes the target.

    those

    The third and possibly more inner or outer nodes to be incident with the hyperedge to be created. In case of a directed edge, these become targets.

    edgeFactory

    An edge companion who's from is to serve as the edge factory.

    returns

    true if a new hyperedge has been created. false if no new hyperedge could be created because there exists a corresponding equaling hyperedge.

    Definition Classes
    InnerNodeOps
    Annotations
    @inline()
  25. final def connectWith(that: N)(implicit edgeFactory: EdgeCompanion[E]): EdgeT

    Creates a new inner edge between this node and that using edgeFactory and adds it to the edge set of this graph.

    Creates a new inner edge between this node and that using edgeFactory and adds it to the edge set of this graph. Node arguments not yet contained in this graph will be added to the node set. Same as calling addAndGetEdge(this, that).

    that

    The second outer node to be incident with the edge to be created. In case of a directed edge, this becomes the target.

    edgeFactory

    An edge companion who's from is to serve as the edge factory.

    returns

    true if a new edge has been created. false if no new edge could be created because there exists a corresponding equaling edge.

    Definition Classes
    InnerNodeOps
    Annotations
    @inline()
  26. final def connectWithL[EE[X] <: E[X] with EdgeLikeIn[X] with LEdgeBound[_, EE], L](that: N, those: N*)(label: L)(implicit edgeFactory: LHyperEdgeCompanion[EE]): EdgeT

    Creates a new labeled inner hyperedge between this node and that plus those using edgeFactory and adds it to the edge set of this graph.

    Creates a new labeled inner hyperedge between this node and that plus those using edgeFactory and adds it to the edge set of this graph. Node arguments not yet contained in this graph will be added to the node set. Same as addAndGetLEdge(this, that, those)(label) on a Graph instance.

    that

    The second outer node to be incident with the edge to be created. In case of a directed edge, this becomes the target.

    those

    The third and possibly more inner or outer nodes to be incident with the hyperedge to be created. In case of a directed edge, these become targets.

    label

    The value the labeled edge to be created should have as its label.

    edgeFactory

    An edge companion who's from is to serve as the edge factory.

    returns

    true if a new hyperedge has been created. false if no new hyperedge could be created because there exists a corresponding equaling hyperedge.

    Definition Classes
    InnerNodeOps
    Annotations
    @inline()
  27. final def connectWithL[EE[X] <: E[X] with EdgeLikeIn[X] with LEdgeBound[_, EE], L](that: N)(label: L)(implicit edgeFactory: LEdgeCompanion[EE]): EdgeT

    Creates a new labeled inner edge between this node and that using edgeFactory and adds it to the edge set of this graph.

    Creates a new labeled inner edge between this node and that using edgeFactory and adds it to the edge set of this graph. Node arguments not yet contained in this graph will be added to the node set. Same as addAndGetLEdge(this, that)(label) on a Graph instance.

    that

    The second outer node to be incident with the edge to be created. In case of a directed edge, this becomes the target.

    label

    The value the labeled edge to be created should have as its label.

    edgeFactory

    An edge companion who's from is to serve as the edge factory.

    returns

    true if a new edge has been created. false if no new edge could be created because there exists a corresponding equaling edge.

    Definition Classes
    InnerNodeOps
    Annotations
    @inline()
  28. final def connectWithW[EE[X] <: E[X] with EdgeLikeIn[X] with WEdgeBound[_, EE]](that: N, those: N*)(weight: Long)(implicit edgeFactory: WHyperEdgeCompanion[EE]): EdgeT

    Creates a new weighted inner hyperedge between this node and that plus those using edgeFactory and adds it to the edge set of this graph.

    Creates a new weighted inner hyperedge between this node and that plus those using edgeFactory and adds it to the edge set of this graph. Node arguments not yet contained in this graph will be added to the node set. Same as addAndGetWEdge(this, that, those)(weight) on a Graph instance.

    that

    The second outer node to be incident with the edge to be created. In case of a directed edge, this becomes the target.

    those

    The third and possibly more inner or outer nodes to be incident with the hyperedge to be created. In case of a directed edge, these become targets.

    weight

    The number the weighted edge to be created should have as its weight.

    edgeFactory

    An edge companion who's from is to serve as the edge factory.

    returns

    true if a new hyperedge has been created. false if no new hyperedge could be created because there exists a corresponding equaling hyperedge.

    Definition Classes
    InnerNodeOps
    Annotations
    @inline()
  29. final def connectWithW[EE[X] <: E[X] with EdgeLikeIn[X] with WEdgeBound[_, EE]](that: N)(weight: Long)(implicit edgeFactory: WEdgeCompanion[EE]): EdgeT

    Creates a new weighted inner edge between this node and that using edgeFactory and adds it to the edge set of this graph.

    Creates a new weighted inner edge between this node and that using edgeFactory and adds it to the edge set of this graph. Node arguments not yet contained in this graph will be added to the node set. Same as addAndGetWEdge(this, that)(weight) on a Graph instance.

    that

    The second outer node to be incident with the edge to be created. In case of a directed edge, this becomes the target.

    weight

    The number the weighted edge to be created should have as its weight.

    edgeFactory

    An edge companion who's from is to serve as the edge factory.

    returns

    true if a new edge has been created. false if no new edge could be created because there exists a corresponding equaling edge.

    Definition Classes
    InnerNodeOps
    Annotations
    @inline()
  30. final def connectWithWL[EE[X] <: E[X] with EdgeLikeIn[X] with WLEdgeBound[_, EE], L](that: N, those: N*)(weight: Long, label: L)(implicit edgeFactory: WLHyperEdgeCompanion[EE]): EdgeT

    Creates a new weighted and labeled inner hyperedge between this node and that plus those using edgeFactory and adds it to the edge set of this graph.

    Creates a new weighted and labeled inner hyperedge between this node and that plus those using edgeFactory and adds it to the edge set of this graph. Node arguments not yet contained in this graph will be added to the node set. Same as addAndGetWLEdge(this, that, those)(weight, label) on a Graph instance.

    that

    The second outer node to be incident with the edge to be created. In case of a directed edge, this becomes the target.

    those

    The third and possibly more inner or outer nodes to be incident with the hyperedge to be created. In case of a directed edge, these become targets.

    weight

    The number the weighted edge to be created should have as its weight.

    label

    The value the labeled edge to be created should have as its label.

    edgeFactory

    An edge companion who's from is to serve as the edge factory.

    returns

    true if a new hyperedge has been created. false if no new hyperedge could be created because there exists a corresponding equaling hyperedge.

    Definition Classes
    InnerNodeOps
    Annotations
    @inline()
  31. final def connectWithWL[EE[X] <: E[X] with EdgeLikeIn[X] with WLEdgeBound[_, EE], L](that: N)(weight: Long, label: L)(implicit edgeFactory: WLEdgeCompanion[EE]): EdgeT

    Creates a new weighted and labeled inner edge between this node and that using edgeFactory and adds it to the edge set of this graph.

    Creates a new weighted and labeled inner edge between this node and that using edgeFactory and adds it to the edge set of this graph. Node arguments not yet contained in this graph will be added to the node set. Same as addAndGetWLEdge(this, that)(weight, label) on a Graph instance.

    that

    The second outer node to be incident with the edge to be created. In case of a directed edge, this becomes the target.

    weight

    The number the weighted edge to be created should have as its weight.

    label

    The value the labeled edge to be created should have as its label.

    edgeFactory

    An edge companion who's from is to serve as the edge factory.

    returns

    true if a new edge has been created. false if no new edge could be created because there exists a corresponding equaling edge.

    Definition Classes
    InnerNodeOps
    Annotations
    @inline()
  32. def containingGraph: AdjacencyListGraph.ThisGraph

    The Graph instance this node is contained in.

    The Graph instance this node is contained in.

    Definition Classes
    InnerNodeLike
  33. def degree: Int

    The degree of this node.

    The degree of this node.

    returns

    the number of edges that connect to this node. An edge that connects to this node at more than one ends (loop) is counted as much times as it is connected to this node.

    Definition Classes
    InnerNodeLike
  34. def diPredecessors: Set[AdjacencyListGraph.NodeT]

    All direct predecessors of this node, also called predecessor set or open in-neighborhood: source nodes of directed incident edges and / or adjacent nodes of undirected incident edges excluding this node.

    All direct predecessors of this node, also called predecessor set or open in-neighborhood: source nodes of directed incident edges and / or adjacent nodes of undirected incident edges excluding this node.

    returns

    set of all direct predecessors of this node.

    Definition Classes
    InnerNodeLike
  35. def diSuccessors: Set[AdjacencyListGraph.NodeT]

    All direct successors of this node, also called successor set or open out-neighborhood: target nodes of directed incident edges and / or adjacent nodes of undirected incident edges excluding this node.

    All direct successors of this node, also called successor set or open out-neighborhood: target nodes of directed incident edges and / or adjacent nodes of undirected incident edges excluding this node.

    returns

    set of all direct successors of this node.

    Definition Classes
    InnerNodeLike
  36. final def edges: Set[EdgeT]

    All edges at this node - commonly denoted as E(v).

    All edges at this node - commonly denoted as E(v).

    As in this default implementation simply the edge set is traversed, this method should be overridden if a more performant lookup is possible.

    returns

    all edges with at least one end connecting to this node.

    Definition Classes
    InnerNodeImplInnerNodeLike
    Annotations
    @inline()
  37. final def eq(arg0: AnyRef): Boolean

    Definition Classes
    AnyRef
  38. def equals(other: Any): Boolean

    Definition Classes
    InnerNodeLike → AnyRef → Any
  39. def finalize(): Unit

    Attributes
    protected[java.lang]
    Definition Classes
    AnyRef
    Annotations
    @throws()
  40. final def findCycle: Option[AdjacencyListGraph.Cycle]

    Same as findCycle(...) with default arguments.

    Same as findCycle(...) with default arguments.

    Definition Classes
    InnerNodeLike
    Annotations
    @inline()
  41. def findIncomingFrom(from: AdjacencyListGraph.NodeT): Option[EdgeT]

    An edge at from having this node as a successor.

    An edge at from having this node as a successor.

    from

    The node being at an edge which has this node as a successor.

    returns

    An edges at from having this node as a successor. If from equals this node a hook may be returned. If from is not an adjacent node None is returned.

    Definition Classes
    InnerNodeLike
  42. def findOutgoingTo(to: AdjacencyListGraph.NodeT): Option[EdgeT]

    An outgoing edge connecting this node with to.

    An outgoing edge connecting this node with to.

    to

    The node which is the end point of an edge starting at this node.

    returns

    One of possibly several edges connecting this node with to. If to equals this node a hook may be returned. If to is not an adjacent node None is returned.

    Definition Classes
    InnerNodeLike
  43. final def getClass(): Class[_]

    Definition Classes
    AnyRef → Any
  44. def hasOnlyHooks: Boolean

    Checks whether this node has only hooks or no edges at all.

    Checks whether this node has only hooks or no edges at all.

    returns

    true if this node has only hooks or it does not participate in any edge

    Definition Classes
    InnerNodeLike
  45. final def hasPredecessor(potentialPredecessor: AdjacencyListGraph.NodeT, nodeFilter: (AdjacencyListGraph.NodeT) ⇒ Boolean = anyNode, edgeFilter: (EdgeT) ⇒ Boolean = anyEdge, nodeVisitor: (AdjacencyListGraph.NodeT) ⇒ VisitorReturn = noNodeAction, edgeVisitor: (EdgeT) ⇒ Unit = noEdgeAction, ordering: AdjacencyListGraph.ElemOrdering = noOrdering): Boolean

    Checks whether potentialPredecessor is a predecessor of this node taking optional filters and visitors into account.

    Checks whether potentialPredecessor is a predecessor of this node taking optional filters and visitors into account.. Node/edge visitor functions allow arbitrary user-defined computation during the traversal. Same as isSuccessorOf.

    potentialPredecessor

    The node which is potentially a predecessor of this node.

    nodeFilter

    Predicate to filter the nodes to be visited during traversal. The default value is anyNode, that is no filtering. A return of true signals that the traversal is to be canceled.

    edgeFilter

    Predicate to filter the edges to be visited during traversal. The default value is anyEdge meaning that no filtering takes place.

    nodeVisitor

    Function to be called on visiting a node for the first time during a traversal. It can mutate the node or carry out any other side effect. The default value is the empty function noNodeAction.

    edgeVisitor

    Function to be called on visiting an edge. It can mutate the node or carry out any other side effect. The default value is the empty function noEdgeAction.

    ordering

    If a NodeOrdering or EdgeOrdering different from noOrdering is supplied neighbor nodes will be sorted during the traversal. Thus it is guaranteed that the smaller an element's ranking the sooner it will be processed. In case of EdgeOrdering it is guaranteed that the smaller an edge's ranking the sooner its relevant end(s) will be processed.

    returns

    true if a path exists from potentialPredecessor to this node and it had not to be excluded due to user filtering or canceling the traversal.

    Definition Classes
    InnerNodeLike
    Annotations
    @inline()
  46. final def hasSuccessor(potentialSuccessor: AdjacencyListGraph.NodeT, nodeFilter: (AdjacencyListGraph.NodeT) ⇒ Boolean = anyNode, edgeFilter: (EdgeT) ⇒ Boolean = anyEdge, nodeVisitor: (AdjacencyListGraph.NodeT) ⇒ VisitorReturn = noNodeAction, edgeVisitor: (EdgeT) ⇒ Unit = noEdgeAction, ordering: AdjacencyListGraph.ElemOrdering = noOrdering): Boolean

    Checks whether potentialSuccessor is a successor of this node taking optional filters and visitors into account.

    Checks whether potentialSuccessor is a successor of this node taking optional filters and visitors into account.. Node/edge visitor functions allow arbitrary user-defined computation during the traversal. Same as isPredecessorOf.

    potentialSuccessor

    The node which is potentially a successor of this node.

    nodeFilter

    Predicate to filter the nodes to be visited during traversal. The default value is anyNode, that is no filtering. A return of true signals that the traversal is to be canceled.

    edgeFilter

    Predicate to filter the edges to be visited during traversal. The default value is anyEdge meaning that no filtering takes place.

    nodeVisitor

    Function to be called on visiting a node for the first time during a traversal. It can mutate the node or carry out any other side effect. The default value is the empty function noNodeAction.

    edgeVisitor

    Function to be called on visiting an edge. It can mutate the node or carry out any other side effect. The default value is the empty function noEdgeAction.

    ordering

    If a NodeOrdering or EdgeOrdering different from noOrdering is supplied neighbor nodes will be sorted during the traversal. Thus it is guaranteed that the smaller an element's ranking the sooner it will be processed. In case of EdgeOrdering it is guaranteed that the smaller an edge's ranking the sooner its relevant end(s) will be processed.

    returns

    true if a path exists from this node to potentialSuccessor and it had not to be excluded due to user filtering or canceling the traversal.

    Definition Classes
    InnerNodeLike
    Annotations
    @inline()
  47. def hashCode(): Int

    Definition Classes
    InnerNodeLike → AnyRef → Any
  48. def inDegree: Int

    The incoming degree of this node.

    The incoming degree of this node.

    returns

    the number of edges that come in to this node including undirected edges. Every loop on this node is counted twice.

    Definition Classes
    InnerNodeLike
  49. final def inNeighbors: Set[AdjacencyListGraph.NodeT]

    Synonym for diPredecessors.

    Synonym for diPredecessors.

    Definition Classes
    InnerNodeLike
    Annotations
    @inline()
  50. def incoming: Set[EdgeT]

    Incoming edges of this node.

    Incoming edges of this node.

    returns

    set of all edges incoming to of this including undirected edges.

    Definition Classes
    InnerNodeLike
  51. def incomingFrom(from: AdjacencyListGraph.NodeT): Set[EdgeT]

    All incoming edges connecting from with this node.

    All incoming edges connecting from with this node.

    from

    The node with zero, one or more edges having this node as a direct successor.

    returns

    All edges at from having this node as a direct successor. If from equals this node all hooks are returned. If from is not an adjacent node an empty set is returned.

    Definition Classes
    InnerNodeLike
  52. final def isConnectedWith(potentialConnected: AdjacencyListGraph.NodeT, nodeFilter: (AdjacencyListGraph.NodeT) ⇒ Boolean = anyNode, edgeFilter: (EdgeT) ⇒ Boolean = anyEdge, nodeVisitor: (AdjacencyListGraph.NodeT) ⇒ VisitorReturn = noNodeAction, edgeVisitor: (EdgeT) ⇒ Unit = noEdgeAction, ordering: AdjacencyListGraph.ElemOrdering = noOrdering): Boolean

    Checks whether potentialConnected is a node (not necessarily directly) connected with this node taking optional filters and visitors into account.

    Checks whether potentialConnected is a node (not necessarily directly) connected with this node taking optional filters and visitors into account.. For directed or mixed graphs it is satisfactory that potentialConnected is weekly connected with this node. Node/edge visitor functions allow arbitrary user-defined computation during the traversal.

    potentialConnected

    The node which is potentially connected with this node.

    nodeFilter

    Predicate to filter the nodes to be visited during traversal. The default value is anyNode, that is no filtering. A return of true signals that the traversal is to be canceled.

    edgeFilter

    Predicate to filter the edges to be visited during traversal. The default value is anyEdge meaning that no filtering takes place.

    nodeVisitor

    Function to be called on visiting a node for the first time during a traversal. It can mutate the node or carry out any other side effect. The default value is the empty function noNodeAction.

    edgeVisitor

    Function to be called on visiting an edge. It can mutate the node or carry out any other side effect. The default value is the empty function noEdgeAction.

    ordering

    If a NodeOrdering or EdgeOrdering different from noOrdering is supplied neighbor nodes will be sorted during the traversal. Thus it is guaranteed that the smaller an element's ranking the sooner it will be processed. In case of EdgeOrdering it is guaranteed that the smaller an edge's ranking the sooner its relevant end(s) will be processed.

    returns

    true if a path exists from this node to potentialConnected and it had not to be excluded due to user filtering or canceling the traversal.

    Definition Classes
    InnerNodeLike
    Annotations
    @inline()
  53. def isDirectPredecessorOf(that: AdjacencyListGraph.NodeT): Boolean

    Whether that is an adjacent (direct successor) to this node.

    Whether that is an adjacent (direct successor) to this node.

    that

    The node to check for adjacency.

    returns

    true if that is adjacent to this node.

    Definition Classes
    InnerNodeLike
  54. def isEdge: Boolean

    Definition Classes
    GraphParamNode
  55. def isIn: Boolean

    Definition Classes
    GraphParamOutGraphParam
  56. def isIndependentOf(that: AdjacencyListGraph.NodeT): Boolean

    Whether that is independent of this node meaning that there exists no edge connecting this node with that.

    Whether that is independent of this node meaning that there exists no edge connecting this node with that.

    that

    The node to check for independency.

    returns

    true if that node is independent of this node.

    Definition Classes
    InnerNodeLike
  57. final def isInstanceOf[T0]: Boolean

    Definition Classes
    Any
  58. final def isIsolated: Boolean

    Returns whether this node's degree equals to 0.

    Returns whether this node's degree equals to 0.

    Definition Classes
    InnerNodeLike
    Annotations
    @inline()
  59. final def isLeaf: Boolean

    Returns whether this node's degree equals to 1.

    Returns whether this node's degree equals to 1.

    Definition Classes
    InnerNodeLike
    Annotations
    @inline()
  60. def isNode: Boolean

    Definition Classes
    GraphParamNode
  61. def isOut: Boolean

    Definition Classes
    GraphParamOutGraphParam
  62. final def isPredecessorOf(potentialSuccessor: AdjacencyListGraph.NodeT, nodeFilter: (AdjacencyListGraph.NodeT) ⇒ Boolean = anyNode, edgeFilter: (EdgeT) ⇒ Boolean = anyEdge, nodeVisitor: (AdjacencyListGraph.NodeT) ⇒ VisitorReturn = noNodeAction, edgeVisitor: (EdgeT) ⇒ Unit = noEdgeAction, ordering: AdjacencyListGraph.ElemOrdering = noOrdering): Boolean

    Same as hasSuccessor.

    Same as hasSuccessor.

    Definition Classes
    InnerNodeLike
    Annotations
    @inline()
  63. final def isSuccessorOf(potentialPredecessor: AdjacencyListGraph.NodeT, nodeFilter: (AdjacencyListGraph.NodeT) ⇒ Boolean = anyNode, edgeFilter: (EdgeT) ⇒ Boolean = anyEdge, nodeVisitor: (AdjacencyListGraph.NodeT) ⇒ VisitorReturn = noNodeAction, edgeVisitor: (EdgeT) ⇒ Unit = noEdgeAction, ordering: AdjacencyListGraph.ElemOrdering = noOrdering): Boolean

    Same as hasPredecessor.

    Same as hasPredecessor.

    Definition Classes
    InnerNodeLike
    Annotations
    @inline()
  64. final def ne(arg0: AnyRef): Boolean

    Definition Classes
    AnyRef
  65. def neighbors: Set[AdjacencyListGraph.NodeT]

    All adjacent nodes (direct successors and predecessors) of this node, also called open neighborhood excluding this node.

    All adjacent nodes (direct successors and predecessors) of this node, also called open neighborhood excluding this node.

    returns

    set of all neighbors.

    Definition Classes
    InnerNodeLike
  66. final def notify(): Unit

    Definition Classes
    AnyRef
  67. final def notifyAll(): Unit

    Definition Classes
    AnyRef
  68. def outDegree: Int

    The outgoing degree of this node.

    The outgoing degree of this node.

    returns

    the number of edges that go out from this node including undirected edges. Every loop on this node is counted twice.

    Definition Classes
    InnerNodeLike
  69. final def outNeighbors: Set[AdjacencyListGraph.NodeT]

    Synonym for diSuccessors.

    Synonym for diSuccessors.

    Definition Classes
    InnerNodeLike
    Annotations
    @inline()
  70. def outgoing: Set[EdgeT]

    All edges outgoing from this node.

    All edges outgoing from this node.

    returns

    set of all edges outgoing from this node including undirected edges and hooks.

    Definition Classes
    InnerNodeLike
  71. def outgoingTo(to: AdjacencyListGraph.NodeT): Set[EdgeT]

    All outgoing edges connecting this node with to.

    All outgoing edges connecting this node with to.

    to

    The node which is the end point of zero, one or more edges starting at this node.

    returns

    All edges connecting this node with to. If to equals this node all hooks are returned. If to is not an adjacent an empty set is returned.

    Definition Classes
    InnerNodeLike
  72. final def pathTo(potentialSuccessor: AdjacencyListGraph.NodeT, nodeFilter: (AdjacencyListGraph.NodeT) ⇒ Boolean = anyNode, edgeFilter: (EdgeT) ⇒ Boolean = anyEdge, nodeVisitor: (AdjacencyListGraph.NodeT) ⇒ VisitorReturn = noNodeAction, edgeVisitor: (EdgeT) ⇒ Unit = noEdgeAction, ordering: AdjacencyListGraph.ElemOrdering = noOrdering): Option[AdjacencyListGraph.Path]

    Finds a path from this node to potentialSuccessor taking optional filters and visitors into account.

    Finds a path from this node to potentialSuccessor taking optional filters and visitors into account..

    potentialSuccessor

    The node a path is to be found to.

    nodeFilter

    Predicate to filter the nodes to be visited during traversal. The default value is anyNode, that is no filtering. A return of true signals that the traversal is to be canceled.

    edgeFilter

    Predicate to filter the edges to be visited during traversal. The default value is anyEdge meaning that no filtering takes place.

    nodeVisitor

    Function to be called on visiting a node for the first time during a traversal. It can mutate the node or carry out any other side effect. The default value is the empty function noNodeAction.

    edgeVisitor

    Function to be called on visiting an edge. It can mutate the node or carry out any other side effect. The default value is the empty function noEdgeAction.

    ordering

    If a NodeOrdering or EdgeOrdering different from noOrdering is supplied neighbor nodes will be sorted during the traversal. Thus it is guaranteed that the smaller an element's ranking the sooner it will be processed. In case of EdgeOrdering it is guaranteed that the smaller an edge's ranking the sooner its relevant end(s) will be processed.

    returns

    A path to potentialSuccessor or None if either a) there is no node with pred or b) there exists no path to such a node at all c) there exists a path to such a node but due to the given filter conditions this path had to be disregarded.

    Definition Classes
    InnerNodeLike
    Annotations
    @inline()
  73. final def pathTo(potentialSuccessor: AdjacencyListGraph.NodeT): Option[AdjacencyListGraph.Path]

    Finds a path from this node to potentialSuccessor.

    Finds a path from this node to potentialSuccessor.

    potentialSuccessor

    The node a path is to be found to.

    returns

    A path to potentialSuccessor or None if either a) there is no node with pred or b) there exists no path to such a node at all

    Definition Classes
    InnerNodeLike
    Annotations
    @inline()
  74. def stringPrefix: String

    Definition Classes
    GraphParamNode
  75. final def synchronized[T0](arg0: ⇒ T0): T0

    Definition Classes
    AnyRef
  76. def toString(): String

    Definition Classes
    GraphParamNode → AnyRef → Any
  77. final def traverseDownUp(direction: Direction = Successors, nodeFilter: (AdjacencyListGraph.NodeT) ⇒ Boolean = anyNode, edgeFilter: (EdgeT) ⇒ Boolean = anyEdge, edgeVisitor: (EdgeT) ⇒ Unit = noEdgeAction, maxDepth: Int = 0, ordering: AdjacencyListGraph.ElemOrdering = noOrdering)(nodeDown: (AdjacencyListGraph.NodeT) ⇒ VisitorReturn, nodeUp: (AdjacencyListGraph.NodeT) ⇒ Unit): Option[AdjacencyListGraph.NodeT]

    Traverses this graph starting at this node for side-effects using dfs and applying 'down' and 'up' node visitors to allow computations in a stack-wise manner:

    Traverses this graph starting at this node for side-effects using dfs and applying 'down' and 'up' node visitors to allow computations in a stack-wise manner:

    val root = "A"
    val g = Graph(root~>"B1", root~>"B2")
    val result = ListBuffer.empty[String]
    (g get root).traverseDownUp()(
      nodeDown = (n: g.NodeT) => {
        result. += (if (n == root) "{" else "(")
        result. += (n.value)
        Continue
      },
      nodeUp = (n: g.NodeT) =>
        result. += (if (n == root) "}" else ")")
    )
    ("" /: result)(_+_) // yields "{A(B1)(B2)}"
    direction

    Determines which connected nodes the traversal has to follow. The default value is Successors.

    nodeFilter

    Predicate to filter the nodes to be visited during traversal. The default value is anyNode, that is no filtering. A return of true signals that the traversal is to be canceled.

    edgeFilter

    Predicate to filter the edges to be visited during traversal. The default value is anyEdge meaning that no filtering takes place.

    edgeVisitor

    Function to be called on visiting an edge. It can mutate the node or carry out any other side effect. The default value is the empty function noEdgeAction.

    maxDepth

    A positive value limits the number of layers for BFS respectively the number of consecutive child visits before siblings are visited for DFS. 0 - the default - indicates that the traversal should have an unlimited depth meaning that it will be continued either until it's canceled by nodeVisitor or until all nodes have been visited.

    ordering

    If a NodeOrdering or EdgeOrdering different from noOrdering is supplied neighbor nodes will be sorted during the traversal. Thus it is guaranteed that the smaller an element's ranking the sooner it will be processed. In case of EdgeOrdering it is guaranteed that the smaller an edge's ranking the sooner its relevant end(s) will be processed.

    nodeDown

    Function to be called on visiting a node for the first time during a traversal. It can mutate the node or carry out any other side effect. The default value is the empty function noNodeAction.

    nodeUp

    Function to be called on reaching an already visited node when moving up in the imaginary tree of a depth first search. Paired with nodeVisitor (the 'down-visitor'), this 'up-visitor' enables a stack-wise view of the traversed nodes. The default value is the empty function noNodeUpAction.

    Definition Classes
    InnerNodeLike
    Annotations
    @inline()
  78. final def traverseEdges(direction: Direction = Successors, nodeFilter: (AdjacencyListGraph.NodeT) ⇒ Boolean = anyNode, edgeFilter: (EdgeT) ⇒ Boolean = anyEdge, breadthFirst: Boolean = true, maxDepth: Int = 0, ordering: AdjacencyListGraph.ElemOrdering = noOrdering)(edgeVisitor: (EdgeT) ⇒ Unit): Unit

    Shortcut for calling 'traverse' with a non-default edgeVisitor but the default nodeVisitor allowing a foreach-like call syntax:

    Shortcut for calling 'traverse' with a non-default edgeVisitor but the default nodeVisitor allowing a foreach-like call syntax:

    rootNode traverseEdges() {
    print( if(_.directed) "d" else "u" )
    Continue
    }
    Definition Classes
    InnerNodeLike
    Annotations
    @inline()
  79. final def traverseNodes(direction: Direction = Successors, nodeFilter: (AdjacencyListGraph.NodeT) ⇒ Boolean = anyNode, edgeFilter: (EdgeT) ⇒ Boolean = anyEdge, breadthFirst: Boolean = true, maxDepth: Int = 0, ordering: AdjacencyListGraph.ElemOrdering = noOrdering)(nodeVisitor: (AdjacencyListGraph.NodeT) ⇒ VisitorReturn): Unit

    Shortcut for calling traverse with a non-default nodeVisitor and the default edgeVisitor allowing a foreach-like call syntax:

    Shortcut for calling traverse with a non-default nodeVisitor and the default edgeVisitor allowing a foreach-like call syntax:

    rootNode traverseNodes() {
    print("d" + _.degree)
    Continue
    }
    Definition Classes
    InnerNodeLike
    Annotations
    @inline()
  80. final def wait(): Unit

    Definition Classes
    AnyRef
    Annotations
    @throws()
  81. final def wait(arg0: Long, arg1: Int): Unit

    Definition Classes
    AnyRef
    Annotations
    @throws()
  82. final def wait(arg0: Long): Unit

    Definition Classes
    AnyRef
    Annotations
    @throws()
  83. final def ~: Set[EdgeT]

    Synonym for edges.

    Synonym for edges.

    Definition Classes
    InnerNodeLike
    Annotations
    @inline()
  84. final def ~>(to: AdjacencyListGraph.NodeT): Set[EdgeT]

    Synonym for outgoingTo.

    Synonym for outgoingTo.

    Definition Classes
    InnerNodeLike
    Annotations
    @inline()
  85. final def ~>: Set[EdgeT]

    Synonym for outgoing.

    Synonym for outgoing.

    Definition Classes
    InnerNodeLike
    Annotations
    @inline()
  86. final def ~>?(to: AdjacencyListGraph.NodeT): Option[EdgeT]

    Synonym for outgoingTo.

    Synonym for outgoingTo.

    Definition Classes
    InnerNodeLike
    Annotations
    @inline()
  87. final def ~>|: Set[AdjacencyListGraph.NodeT]

    Synonym for diSuccessors.

    Synonym for diSuccessors.

    Definition Classes
    InnerNodeLike
    Annotations
    @inline()
  88. final def ~|: Set[AdjacencyListGraph.NodeT]

    Synonym for neighbors.

    Synonym for neighbors.

    Definition Classes
    InnerNodeLike
    Annotations
    @inline()

Inherited from AdjacencyListGraph.InnerNodeLike

Inherited from AdjacencyListGraph.InnerNodeOps

Inherited from AdjacencyListGraph.InnerNodeLike

Inherited from AdjacencyListGraph.InnerNodeLike

Inherited from AdjacencyListGraph.InnerNodeLike

Inherited from AdjacencyListGraph.Node

Inherited from Serializable

Inherited from Serializable

Inherited from NodeOut[N]

Inherited from GraphParamNode[N]

Inherited from GraphParamOut[N, Nothing]

Inherited from GraphParam[N, Nothing]

Inherited from AnyRef

Inherited from Any

Ungrouped