overflowdb.traversal.PathAwareRepeatStep.scala Maven / Gradle / Ivy

Go to download
package overflowdb.traversal

import overflowdb.traversal.RepeatStep._
import overflowdb.traversal.RepeatBehaviour.SearchAlgorithm

import scala.collection.{Iterator, mutable}

object PathAwareRepeatStep {

  /** @see [[Traversal.repeat]] for a detailed overview
   *
   * Implementation note: using recursion results in nicer code, but uses the JVM stack, which only has enough space
   * for ~10k steps. So instead, this uses a programmatic Stack which is semantically identical.
   * The RepeatTraversalTests cover this case.
   * */
  def apply[A](repeatTraversal: Traversal[A] => Traversal[A], behaviour: RepeatBehaviour[A]): A => PathAwareTraversal[A] = {
    val worklist: Worklist[A] = behaviour.searchAlgorithm match {
      case SearchAlgorithm.DepthFirst   => new LifoWorklist[A]
      case SearchAlgorithm.BreadthFirst => new FifoWorklist[A]
    }

    element: A => new PathAwareTraversal[A](new Iterator[(A, Vector[Any])] {
      val visited = mutable.Set.empty[A]
      val emitSack: mutable.Queue[(A, Vector[Any])] = mutable.Queue.empty
      worklist.addItem(WorklistItem(PathAwareTraversal.fromSingle(element), 0))

      def hasNext: Boolean = {
        if (emitSack.isEmpty) {
          // this may add elements to the emit sack and/or modify the worklist
          traverseOnWorklist
        }
        emitSack.nonEmpty || worklistTopHasNext
      }

      private def traverseOnWorklist: Unit = {
        var stop = false
        while (worklist.nonEmpty && !stop) {
          val WorklistItem(trav0, depth) = worklist.head
          val trav = trav0.path
          if (trav.isEmpty) worklist.removeHead
          else if (behaviour.timesReached(depth)) stop = true
          else {
            val path0 = trav.next
            val (path1, elementInSeq) = path0.splitAt(path0.size - 1)
            val element = elementInSeq.head.asInstanceOf[A]
            if (behaviour.dedupEnabled) visited.addOne(element)
            if (depth > 0  // `repeat/until` behaviour, i.e. only checking the `until` condition from depth 1
              && behaviour.untilConditionReached(element)) {
              // we just consumed an element from the traversal, so in lieu adding to the emit sack
              emitSack.enqueue((element, path1))
              stop = true
            } else {
              val nextLevelTraversal = {
                val repeat = repeatTraversal(new PathAwareTraversal(Iterator.single((element, path1))))
                if (behaviour.dedupEnabled) repeat.filterNot(visited.contains)
                else repeat
              }
              worklist.addItem(WorklistItem(nextLevelTraversal, depth + 1))

              if (behaviour.shouldEmit(element, depth))
                emitSack.enqueue((element, path1))

              if (emitSack.nonEmpty)
                stop = true
            }
          }
        }
      }

      private def worklistTopHasNext: Boolean =
        worklist.nonEmpty && worklist.head.traversal.hasNext

      override def next(): (A, Vector[Any]) = {
        val result = {
          if (emitSack.hasNext) emitSack.dequeue()
          else if (worklistTopHasNext) {
            val entirePath = worklist.head.traversal.path.next
            val (path, lastElement) = entirePath.splitAt(entirePath.size - 1)
            (lastElement.head.asInstanceOf[A], path)
          }
          else throw new NoSuchElementException("next on empty iterator")
        }
        if (behaviour.dedupEnabled) visited.addOne(result._1)
        result
      }
    })
  }

}