TreeTraversal

Value Members

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

   

   Definition Classes

   AnyRef → Any

2. final def ##(): Int

   

   Definition Classes

   AnyRef → Any

3. final def ==(arg0: Any): Boolean

   

   Definition Classes

   AnyRef → Any

4. final def asInstanceOf[T0]: T0

   

   Definition Classes

   Any

5. def clone(): AnyRef

   

   Attributes

   protected[java.lang]

   Definition Classes

   AnyRef

   Annotations

   @throws( ... )

6. implicit def depthFirst[Tree, K, V, T, A](implicit arg0: Ordering[V], treeOps: FullBinaryTreeOps[Tree, BranchLabel[K, V, A], LeafLabel[T, A]]): TreeTraversal[Tree, K, V, T, A]

   

   Performs a depth-first traversal of the tree, returning all matching leaf nodes.

7. final def eq(arg0: AnyRef): Boolean

   

   Definition Classes

   AnyRef

8. def equals(arg0: Any): Boolean

   

   Definition Classes

   AnyRef → Any

9. def finalize(): Unit

   

   Attributes

   protected[java.lang]

   Definition Classes

   AnyRef

   Annotations

   @throws( classOf[java.lang.Throwable] )

10. final def getClass(): Class[_]

    

    Definition Classes

    AnyRef → Any

11. def hashCode(): Int

    

    Definition Classes

    AnyRef → Any

12. final def isInstanceOf[T0]: Boolean

    

    Definition Classes

    Any

13. final def ne(arg0: AnyRef): Boolean

    

    Definition Classes

    AnyRef

14. final def notify(): Unit

    

    Definition Classes

    AnyRef

15. final def notifyAll(): Unit

    

    Definition Classes

    AnyRef

16. def probabilisticWeightedDepthFirst[Tree, K, V, T, A](seed: Option[Int] = None)(implicit arg0: Ordering[V], treeOps: FullBinaryTreeOps[Tree, BranchLabel[K, V, A], LeafLabel[T, A]], conversion: (A) ⇒ Double): TreeTraversal[Tree, K, V, T, A]

    

    A depth-first search for matching leaves, where the candidate child leaves of a parent node are randomly shuffled, but with nodes with higher weight being given a higher probability of being ordered earlier.

    A depth-first search for matching leaves, where the candidate child leaves of a parent node are randomly shuffled, but with nodes with higher weight being given a higher probability of being ordered earlier. This is basically a mix between randomDepthFirst and weightedDepthFirst.

    The actual algorithm can best be though of as a random sample from a set of weighted elements without replacement. The weight is directly proportional to its probability of being sampled, relative to all the other elements still in the set.

17. def randomDepthFirst[Tree, K, V, T, A](seed: Option[Int] = None)(implicit arg0: Ordering[V], treeOps: FullBinaryTreeOps[Tree, BranchLabel[K, V, A], LeafLabel[T, A]]): TreeTraversal[Tree, K, V, T, A]

    

    A depth first search for matching leaves, randomly choosing the order of child candidate nodes to traverse at each step.

    A depth first search for matching leaves, randomly choosing the order of child candidate nodes to traverse at each step. Since it is depth-first, after a node is chosen to be traversed, all of the matching leafs that descend from that node are traversed before moving onto the node's sibling.

18. def search[Tree, K, V, T, A](tree: Tree, row: Map[K, V], id: Option[String] = None)(implicit ev: TreeTraversal[Tree, K, V, T, A]): Stream[LeafLabel[T, A]]

    

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

    

    Definition Classes

    AnyRef

20. def toString(): String

    

    Definition Classes

    AnyRef → Any

21. final def wait(): Unit

    

    Definition Classes

    AnyRef

    Annotations

    @throws( ... )

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

    

    Definition Classes

    AnyRef

    Annotations

    @throws( ... )

23. final def wait(arg0: Long): Unit

    

    Definition Classes

    AnyRef

    Annotations

    @throws( ... )

24. def weightedDepthFirst[Tree, K, V, T, A](implicit arg0: Ordering[V], arg1: Ordering[A], treeOps: FullBinaryTreeOps[Tree, BranchLabel[K, V, A], LeafLabel[T, A]]): TreeTraversal[Tree, K, V, T, A]

    

    A depth-first search for matching leaves, where the candidate child nodes for a given parent node are traversed in reverse order of their annotations.

    A depth-first search for matching leaves, where the candidate child nodes for a given parent node are traversed in reverse order of their annotations. This means that if we have multiple valid candidate children, we will traverse the child with the largest annotation first.