InnerNodeTraversalImpl

abstract def addDiPredecessors(edge: GraphTraversalImpl.EdgeT, add: (NodeT) ⇒ Unit): Unit

abstract def addDiSuccessors(edge: GraphTraversalImpl.EdgeT, add: (NodeT) ⇒ Unit): Unit

abstract def addNeighbors(edge: GraphTraversalImpl.EdgeT, add: (NodeT) ⇒ Unit): Unit

abstract def connectionsWith(other: NodeT): Set[GraphTraversalImpl.EdgeT]

All edges connecting this node with other including outgoing and incoming edges.

abstract def diPredecessors: Set[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.

abstract def diSuccessors: Set[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.

abstract def edges: ExtSet[GraphTraversalImpl.EdgeT]

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

abstract def findIncomingFrom(from: NodeT): Option[GraphTraversalImpl.EdgeT]

An edge at from having this node as a successor.

abstract def findOutgoingTo(to: NodeT): Option[GraphTraversalImpl.EdgeT]

An outgoing edge connecting this node with to.

abstract def hasOnlyHooks: Boolean

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

abstract def incoming: Set[GraphTraversalImpl.EdgeT]

Incoming edges of this node.

abstract def incomingFrom(from: NodeT): Set[GraphTraversalImpl.EdgeT]

All incoming edges connecting from with this node.

abstract def isContaining[N, E[X] <: EdgeLikeIn[X]](g: GraphBase[N, E]): Boolean

abstract def isDirectPredecessorOf(that: NodeT): Boolean

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

abstract def isIndependentOf(that: NodeT): Boolean

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

abstract def neighbors: Set[NodeT]

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

abstract def outgoing: Set[GraphTraversalImpl.EdgeT]

All edges outgoing from this node.

abstract def outgoingTo(to: NodeT): Set[GraphTraversalImpl.EdgeT]

All outgoing edges connecting this node with to.

abstract def value: N

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

final def !=(arg0: AnyRef): Boolean

final def !=(arg0: Any): Boolean

final def ##(): Int

def +(other: String): String

def ->[B](y: B): (InnerNodeTraversalImpl, B)

final def <~(from: NodeT): Set[GraphTraversalImpl.EdgeT]

Synonym for incomingFrom.

final def <~: Set[GraphTraversalImpl.EdgeT]

Synonym for incoming.

final def <~?(from: NodeT): Option[GraphTraversalImpl.EdgeT]

Synonym for findIncomingFrom.

final def <~|: Set[NodeT]

Synonym for diPredecessors.

final def ==(arg0: AnyRef): Boolean

final def ==(arg0: Any): Boolean

final def asInstanceOf[T0]: T0

final def asNodeT[N <: N, E[X] <: EdgeLikeIn[X], G <: GraphBase[N, E] with Singleton](g: G): GraphPredef.InnerNodeParam.asNodeT.G.NodeT

final def asNodeTProjection[N <: N, E[X] <: EdgeLikeIn[X]]: GraphBase.NodeT

final def bit[T](implicit handle: Handle): Boolean

final def bit_=[T](isSet: Boolean)(implicit handle: Handle): Unit

def canEqual(that: Any): Boolean

def clone(): AnyRef

def degree: Int

The degree of this node.

def dumpState: Array[Long]

def ensuring(cond: (InnerNodeTraversalImpl) ⇒ Boolean, msg: ⇒ Any): InnerNodeTraversalImpl

def ensuring(cond: (InnerNodeTraversalImpl) ⇒ Boolean): InnerNodeTraversalImpl

def ensuring(cond: Boolean, msg: ⇒ Any): InnerNodeTraversalImpl

def ensuring(cond: Boolean): InnerNodeTraversalImpl

final def eq(arg0: AnyRef): Boolean

def equals(other: Any): Boolean

def finalize(): Unit

final def findConnected(pred: (NodeT) ⇒ Boolean)(implicit visitor: (NodeT) ⇒ Unit = emptyVisitor): Option[NodeT]

Finds a node connected with root by any number of edges with any direction for which the predicate pred holds considering all traversal properties passed to the traverser factory method like innerNodeTraverser or altered by any with* method.

def findCycle(implicit visitor: (NodeT) ⇒ Unit = emptyVisitor): Option[GraphTraversalImpl.Cycle]

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

final def findPredecessor(pred: (NodeT) ⇒ Boolean)(implicit visitor: (NodeT) ⇒ Unit = emptyVisitor): Option[NodeT]

Finds a predecessor of root for which the predicate pred holds considering all traversal properties passed to the traverser factory method like innerNodeTraverser or altered by any with* method.

final def findSuccessor(pred: (NodeT) ⇒ Boolean)(implicit visitor: (NodeT) ⇒ Unit = emptyVisitor): Option[NodeT]

Finds a successor of root for which the predicate pred holds considering all traversal properties passed to the traverser factory method like innerNodeTraverser or altered by any with* method.

var flags: FlagWord

var flagsExt: FlagWords

final def fold[N <: N, E[X] <: EdgeLikeIn[X], G <: GraphBase[N, E] with Singleton, T](g: G)(fa: (GraphPredef.InnerNodeParam.fold.G.NodeT) ⇒ T, fb: (GraphBase.NodeT) ⇒ T): T

def formatted(fmtstr: String): String

final def getClass(): Class[_]

final def hasPredecessor(potentialPredecessor: NodeT)(implicit visitor: (NodeT) ⇒ Unit = emptyVisitor): Boolean

Checks whether potentialPredecessor is a predecessor of root considering all traversal properties passed to the traverser factory method like innerNodeTraverser or altered by any with* method.

final def hasSuccessor(potentialSuccessor: NodeT)(implicit visitor: (NodeT) ⇒ Unit = emptyVisitor): Boolean

Checks whether potentialSuccessor is a successor of this node considering all traversal properties passed to the traverser factory method like innerNodeTraverser or altered by any with* method.

def hashCode(): Int

def inDegree: Int

The incoming degree of this node.

final def inNeighbors: Set[NodeT]

Synonym for diPredecessors.

final def innerEdgeTraverser(implicit parameters: Parameters = Parameters()): GraphTraversalImpl.InnerEdgeTraverser

Instantiates an InnerEdgeTraverser which extends scala.collection.Traversable with elements of type EdgeT and sets its root to this node.

final def innerElemTraverser(implicit parameters: Parameters = Parameters()): GraphTraversalImpl.InnerElemTraverser

Instantiates an InnerElemTraverser which extends scala.collection.Traversable with elements of type InnerElem and sets its root to this node.

final def innerNodeDownUpTraverser(implicit parameters: Parameters = Parameters()): GraphTraversalImpl.InnerNodeDownUpTraverser

Instantiates an InnerNodeDownUpTraverser which extends scala.collection.Traversable with elements of type (Boolean, NodeT) and sets its root to this node.

final def innerNodeTraverser(implicit parameters: Parameters = Parameters()): GraphTraversalImpl.InnerNodeTraverser

Instantiates an InnerNodeTraverser which extends scala.collection.Traversable with elements of type NodeT and sets its root to this node.

final def isConnectedWith(potentialConnected: NodeT)(implicit visitor: (NodeT) ⇒ Unit = emptyVisitor): Boolean

Checks whether potentialConnected is a node (not necessarily directly) connected with root by any number of edges with any direction considering all traversal properties passed to the traverser factory method like innerNodeTraverser or altered by any with* method.

def isDefined: Boolean

def isEdge: Boolean

def isIn: Boolean

final def isInstanceOf[T0]: Boolean

final def isIsolated: Boolean

Returns whether this node's degree equals to 0.

final def isLeaf: Boolean

Returns whether this node's degree equals to 1.

def isNode: Boolean

def isOut: Boolean

final def isPredecessorOf(potentialSuccessor: NodeT)(implicit visitor: (NodeT) ⇒ Unit = emptyVisitor): Boolean

Same as hasSuccessor.

final def isSuccessorOf(potentialPredecessor: NodeT)(implicit visitor: (NodeT) ⇒ Unit = emptyVisitor): Boolean

Same as hasPredecessor.

val n1: InnerNodeTraversalImpl

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

def outDegree: Int

The outgoing degree of this node.

final def outNeighbors: Set[NodeT]

Synonym for diSuccessors.

final def outerEdgeTraverser(implicit parameters: Parameters = Parameters()): GraphTraversalImpl.OuterEdgeTraverser

Instantiates an OuterEdgeTraverser which extends scala.collection.Traversable with elements of type E[N] and sets its root to this node.

final def outerElemTraverser(implicit parameters: Parameters = Parameters()): GraphTraversalImpl.OuterElemTraverser

Instantiates an OuterElemTraverser which extends scala.collection.Traversable with elements of type OuterElem and sets its root to this node.

final def outerNodeDownUpTraverser(implicit parameters: Parameters = Parameters()): GraphTraversalImpl.OuterNodeDownUpTraverser

Instantiates an OuterNodeDownUpTraverser which extends scala.collection.Traversable with elements of type (Boolean, N) and sets its root to this node.

final def outerNodeTraverser(implicit parameters: Parameters = Parameters()): GraphTraversalImpl.OuterNodeTraverser

Instantiates an OuterNodeTraverser which extends scala.collection.Traversable with elements of type N and sets its root to this node.

final def pathTo(potentialSuccessor: NodeT)(implicit visitor: (NodeT) ⇒ Unit = emptyVisitor): Option[GraphTraversalImpl.Path]

Finds a path from root to potentialSuccessor considering all traversal properties passed to the traverser factory method like innerNodeTraverser or altered by any with* method.

def pathUntil(pred: (NodeT) ⇒ Boolean)(implicit visitor: (NodeT) ⇒ Unit = emptyVisitor): Option[GraphTraversalImpl.Path]

Finds a path from root to a successor of root for which pred holds considering all traversal properties passed to the traverser factory method like innerNodeTraverser or altered by any with* method.

def root: NodeT

final def shortestPathTo[T](potentialSuccessor: NodeT, weight: (GraphTraversalImpl.EdgeT) ⇒ T)(implicit arg0: Numeric[T]): Option[GraphTraversalImpl.Path]

Finds the shortest path from root to potentialSuccessor considering all traversal properties passed to the traverser factory method like innerNodeTraverser or altered by any with* method.

final def shortestPathTo(potentialSuccessor: NodeT)(implicit visitor: (NodeT) ⇒ Unit = emptyVisitor): Option[GraphTraversalImpl.Path]

Finds the shortest path from root to potentialSuccessor considering all traversal properties passed to the traverser factory method like innerNodeTraverser or altered by any with* method.

def shortestPathTo[T](potentialSuccessor: NodeT, weight: (GraphTraversalImpl.EdgeT) ⇒ T, visitor: (NodeT) ⇒ Unit)(implicit arg0: Numeric[T]): Option[GraphTraversalImpl.Path]

Finds the shortest path from root to potentialSuccessor considering all traversal properties passed to the traverser factory method like innerNodeTraverser or altered by any with* method.

def stringPrefix: String

final def synchronized[T0](arg0: ⇒ T0): T0

final def toInnerElemTraverser(root: NodeT): GraphTraversalImpl.InnerElemTraverser

final def toNodeT[N <: N, E[X] <: EdgeLikeIn[X], G <: GraphBase[N, E] with Singleton](g: G)(f: (GraphBase.NodeT) ⇒ GraphPredef.InnerNodeParam.toNodeT.G.NodeT): GraphPredef.InnerNodeParam.toNodeT.G.NodeT

def toString(): String

final def visited(implicit handle: Handle): Boolean

Whether this node is marked as visited with respect to handle.

final def visited_=(visited: Boolean)(implicit handle: Handle): Unit

Sets this node to visited with respect to to handle.

final def wait(): Unit

final def wait(arg0: Long, arg1: Int): Unit

final def wait(arg0: Long): Unit

final def withDirection(direction: Direction): GraphTraversalImpl.InnerNodeTraverser

Creates a new FluentProperties based on this except for an updated direction.

final def withFlagsExt[T](block: (ExtBitSet) ⇒ T): T

final def withKind(kind: Kind): GraphTraversalImpl.InnerNodeTraverser

Creates a new FluentProperties based on this except for an updated kind.

final def withMaxDepth(maxDepth: Int): GraphTraversalImpl.InnerNodeTraverser

Creates a new FluentProperties based on this except for an updated maxDepth.

final def withOrdering(ordering: GraphTraversalImpl.ElemOrdering): GraphTraversalImpl.InnerNodeTraverser

Creates a new FluentProperties based on this except for an updated ordering.

final def withParameters(parameters: Parameters): GraphTraversalImpl.InnerNodeTraverser

Creates a new FluentProperties based on this except for an updated parameters.

final def withRoot(root: NodeT): GraphTraversalImpl.InnerNodeTraverser

Creates a new FluentProperties based on this except for an updated root.

final def withSubgraph(nodes: (NodeT) ⇒ Boolean = anyNode, edges: (GraphTraversalImpl.EdgeT) ⇒ Boolean = anyEdge): GraphTraversalImpl.InnerNodeTraverser

Creates a new FluentProperties based on this except for an updated subgraphNodes and/or subgraphEdges.

final def ~: ExtSet[GraphTraversalImpl.EdgeT]

Synonym for edges.

final def ~>(to: NodeT): Set[GraphTraversalImpl.EdgeT]

Synonym for outgoingTo.

final def ~>: Set[GraphTraversalImpl.EdgeT]

Synonym for outgoing.

final def ~>?(to: NodeT): Option[GraphTraversalImpl.EdgeT]

Synonym for findOutgoingTo.

final def ~>|: Set[NodeT]

Synonym for diSuccessors.

final def ~|: Set[NodeT]

Synonym for neighbors.

def →[B](y: B): (InnerNodeTraversalImpl, B)

def isDefined: Boolean

def isEdge: Boolean

def isIn: Boolean

def isNode: Boolean

def isOut: Boolean

val self: Any

val self: Any

def stringPrefix: String

def toString(): String

val value: InnerNodeTraversalImpl

def ~[N >: N1, N2 <: N](n2: N2): UnDiEdge[N]

def ~>[N >: N1, N2 <: N](n2: N2): DiEdge[N]

final def traverse(direction: Direction = Successors, nodeFilter: (NodeT) ⇒ Boolean = anyNode, edgeFilter: (GraphTraversalImpl.EdgeT) ⇒ Boolean = anyEdge, breadthFirst: Boolean = true, maxDepth: Int = 0, ordering: GraphTraversalImpl.ElemOrdering = noOrdering)(nodeVisitor: (NodeT) ⇒ VisitorReturn = noNodeAction, edgeVisitor: (GraphTraversalImpl.EdgeT) ⇒ Unit = noEdgeAction): Option[NodeT]

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

final def traverseDownUp(direction: Direction = Successors, nodeFilter: (NodeT) ⇒ Boolean = anyNode, edgeFilter: (GraphTraversalImpl.EdgeT) ⇒ Boolean = anyEdge, edgeVisitor: (GraphTraversalImpl.EdgeT) ⇒ Unit = noEdgeAction, maxDepth: Int = 0, ordering: GraphTraversalImpl.ElemOrdering = noOrdering)(nodeDown: (NodeT) ⇒ VisitorReturn, nodeUp: (NodeT) ⇒ Unit): Option[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:

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)}"

final def traverseEdges(direction: Direction = Successors, nodeFilter: (NodeT) ⇒ Boolean = anyNode, edgeFilter: (GraphTraversalImpl.EdgeT) ⇒ Boolean = anyEdge, breadthFirst: Boolean = true, maxDepth: Int = 0, ordering: GraphTraversalImpl.ElemOrdering = noOrdering)(edgeVisitor: (GraphTraversalImpl.EdgeT) ⇒ Unit): Option[NodeT]

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
}

final def traverseNodes(direction: Direction = Successors, nodeFilter: (NodeT) ⇒ Boolean = anyNode, edgeFilter: (GraphTraversalImpl.EdgeT) ⇒ Boolean = anyEdge, breadthFirst: Boolean = true, maxDepth: Int = 0, ordering: GraphTraversalImpl.ElemOrdering = noOrdering)(nodeVisitor: (NodeT) ⇒ VisitorReturn): Option[NodeT]

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
}

def x: InnerNodeTraversalImpl

def x: InnerNodeTraversalImpl