QueueBasedTraverser

abstract def depth(node: Int): Option[Int]

Depth of visit of a given node.

abstract def dir: GraphDir

Direction of the walk.

abstract def graph: Graph

Graph to be traversed.

abstract def homeNodeIds: Seq[Int]

Nodes to start the traversal from.

abstract def nodePriority: GraphTraverserNodePriority

The priority of nodes adding to the queue.

abstract def shouldBeEnqueued(color: Color): Boolean

Checks if the node of a given color should be enqueued.

final def !=(arg0: AnyRef): Boolean

final def !=(arg0: Any): Boolean

final def ##(): Int

def ++[B >: Node](that: ⇒ GenTraversableOnce[B]): Iterator[B]

def /:[B](z: B)(op: (B, Node) ⇒ B): B

def :\[B](z: B)(op: (Node, B) ⇒ B): B

final def ==(arg0: AnyRef): Boolean

final def ==(arg0: Any): Boolean

object GraphTraverserNodePriority extends Enumeration

The priority of nodes adding to the queue.

def addString(b: StringBuilder): StringBuilder

def addString(b: StringBuilder, sep: String): StringBuilder

def addString(b: StringBuilder, start: String, sep: String, end: String): StringBuilder

def aggregate[B](z: B)(seqop: (B, Node) ⇒ B, combop: (B, B) ⇒ B): B

final def asInstanceOf[T0]: T0

def buffered: BufferedIterator[Node]

def chooseNodesToEnqueue(node: Node): Seq[Int]

Returns nodes ids that should be added to the queue after visiting node.

def clone(): AnyRef

def collect[B](pf: PartialFunction[Node, B]): Iterator[B]

def collectFirst[B](pf: PartialFunction[Node, B]): Option[B]

lazy val coloring: NodeColoring

We mark nodes using 3 'colors': Unenqueued, Enqueued, Visited.

def contains(elem: Any): Boolean

def copyToArray[B >: Node](xs: Array[B], start: Int, len: Int): Unit

def copyToArray[B >: Node](xs: Array[B]): Unit

def copyToArray[B >: Node](xs: Array[B], start: Int): Unit

def copyToBuffer[B >: Node](dest: Buffer[B]): Unit

def corresponds[B](that: GenTraversableOnce[B])(p: (Node, B) ⇒ Boolean): Boolean

def count(p: (Node) ⇒ Boolean): Int

lazy val degreeLimit: Limit

lazy val depthLimit: Limit

def drop(n: Int): Iterator[Node]

def dropWhile(p: (Node) ⇒ Boolean): Iterator[Node]

def duplicate: (Iterator[Node], Iterator[Node])

def enqueue(nodes: Seq[Int], from: Option[Int]): Unit

Enqueues nodes added after from node is visited (or None when equeueing initial nodes).

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def exists(p: (Node) ⇒ Boolean): Boolean

def filter(p: (Node) ⇒ Boolean): Iterator[Node]

def filterNot(p: (Node) ⇒ Boolean): Iterator[Node]

def finalize(): Unit

def find(p: (Node) ⇒ Boolean): Option[Node]

def findNextNodeToVisit(): Option[Int]

Finds in the queue the node that will be visited next.

def flatMap[B](f: (Node) ⇒ GenTraversableOnce[B]): Iterator[B]

def fold[A1 >: Node](z: A1)(op: (A1, A1) ⇒ A1): A1

def foldLeft[B](z: B)(op: (B, Node) ⇒ B): B

def foldRight[B](z: B)(op: (Node, B) ⇒ B): B

def forall(p: (Node) ⇒ Boolean): Boolean

def foreach[U](f: (Node) ⇒ U): Unit

final def getClass(): Class[_]

def getExistingNodeById(graph: Graph, id: Int): Node

Traverser only visits node Ids listed in some node's edges, and thus we know that node must exist, safe to assume graph.

def grouped[B >: Node](size: Int): GroupedIterator[B]

def hasDefiniteSize: Boolean

def hasNext: Boolean

def hashCode(): Int

def indexOf[B >: Node](elem: B): Int

def indexWhere(p: (Node) ⇒ Boolean): Int

def isEmpty: Boolean

final def isInstanceOf[T0]: Boolean

def isTraversableAgain: Boolean

def length: Int

def limitAddedToQueue(nodes: Seq[Int]): Seq[Int]

If the queue is longer than the number of nodes that can be visited due to maxSteps bound, cuts the list of nodes that are to be added to the queue in order not to add too many of them.

lazy val limits: Limits

Options to limit traverser walk.

def map[B](f: (Node) ⇒ B): Iterator[B]

def max[B >: Node](implicit cmp: Ordering[B]): Node

def maxBy[B](f: (Node) ⇒ B)(implicit cmp: Ordering[B]): Node

lazy val maxSteps: Option[Long]

def min[B >: Node](implicit cmp: Ordering[B]): Node

def minBy[B](f: (Node) ⇒ B)(implicit cmp: Ordering[B]): Node

def mkString: String

def mkString(sep: String): String

def mkString(start: String, sep: String, end: String): String

final def ne(arg0: AnyRef): Boolean

def next(): Node

def nonEmpty: Boolean

final def notify(): Unit

final def notifyAll(): Unit

var numEnqueuedEver: Long

Number of nodes ever enqueued in the queue.

def padTo[A1 >: Node](len: Int, elem: A1): Iterator[A1]

def partition(p: (Node) ⇒ Boolean): (Iterator[Node], Iterator[Node])

def patch[B >: Node](from: Int, patchElems: Iterator[B], replaced: Int): Iterator[B]

lazy val prevNbrCounter: Option[PrevNbrCounter]

Optional counter of previous nodes to a given node.

def processNode(node: Node): Node

Performs action needed when visiting a node.

def product[B >: Node](implicit num: Numeric[B]): B

val queue: IntArrayFIFOQueue

Queue that stores nodes to be visited next.

def reduce[A1 >: Node](op: (A1, A1) ⇒ A1): A1

def reduceLeft[B >: Node](op: (B, Node) ⇒ B): B

def reduceLeftOption[B >: Node](op: (B, Node) ⇒ B): Option[B]

def reduceOption[A1 >: Node](op: (A1, A1) ⇒ A1): Option[A1]

def reduceRight[B >: Node](op: (Node, B) ⇒ B): B

def reduceRightOption[B >: Node](op: (Node, B) ⇒ B): Option[B]

def reversed: List[Node]

def sameElements(that: Iterator[_]): Boolean

def scanLeft[B](z: B)(op: (B, Node) ⇒ B): Iterator[B]

def scanRight[B](z: B)(op: (Node, B) ⇒ B): Iterator[B]

def seq: Iterator[Node]

val shouldBeDequeuedBeforeProcessing: Boolean

Set to true to deque a node from the queue before processing.

def size: Int

def slice(from: Int, until: Int): Iterator[Node]

def sliding[B >: Node](size: Int, step: Int): GroupedIterator[B]

def span(p: (Node) ⇒ Boolean): (Iterator[Node], Iterator[Node])

def sum[B >: Node](implicit num: Numeric[B]): B

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

def take(n: Int): Iterator[Node]

def takeWhile(p: (Node) ⇒ Boolean): Iterator[Node]

def to[Col[_]](implicit cbf: CanBuildFrom[Nothing, Node, Col[Node]]): Col[Node]

def toArray[B >: Node](implicit arg0: ClassTag[B]): Array[B]

def toBuffer[B >: Node]: Buffer[B]

def toIndexedSeq: IndexedSeq[Node]

def toIterable: Iterable[Node]

def toIterator: Iterator[Node]

def toList: List[Node]

def toMap[T, U](implicit ev: <:<[Node, (T, U)]): Map[T, U]

def toSeq: Seq[Node]

def toSet[B >: Node]: Set[B]

def toStream: Stream[Node]

def toString(): String

def toTraversable: Traversable[Node]

def toVector: Vector[Node]

def visitNode(node: Node): Unit

Action performed when visiting node node (before iteratur retuns node).

final def wait(): Unit

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

final def wait(arg0: Long): Unit

def withFilter(p: (Node) ⇒ Boolean): Iterator[Node]

def zip[B](that: Iterator[B]): Iterator[(Node, B)]

def zipAll[B, A1 >: Node, B1 >: B](that: Iterator[B], thisElem: A1, thatElem: B1): Iterator[(A1, B1)]

def zipWithIndex: Iterator[(Node, Int)]

def /:\[A1 >: Node](z: A1)(op: (A1, A1) ⇒ A1): A1