RangedSeq

sealed trait RangedSeq[Elem, P] extends FingerTreeLike[Option[(P, P)], Elem, RangedSeq[Elem, P]]
Companion
object
trait FingerTreeLike[Option[(P, P)], Elem, RangedSeq[Elem, P]]
class Object
trait Matchable
class Any

Value members

Methods

def +(elem: Elem): RangedSeq[Elem, P]
Adds a new element to the tree.
def -(elem: Elem): RangedSeq[Elem, P]
Removes an element from the tree.
def findOverlaps(interval: (P, P)): Option[Elem]
Finds an element that overlaps a given interval.
An overlap occurs if the intersection between query interval
and found interval is non-empty. In other words, found_start < query_stop && found_stop > query_start.
Of the candidates, returns the one with the lowest start point.
Value Params
interval
the query interval
Returns
the element which overlaps the query interval, or None if there is none.
def find(point: P): Option[Elem]
Find an element that contains a given point.
A point is contained in if found_start <= point && found_stop > point.
Elements with empty intervals will thus not be detected (the interval version of this method can)
Value Params
point
the query point
Returns
the element containing the point, or None if such an element does not exist.
def filterOverlaps(interval: (P, P)): Iterator[Elem]
Filters the tree to contain only those elements that overlap a given interval.
An overlap occurs if the intersection between query interval
and found interval is non-empty. In other words, found_start < query_stop && found_stop > query_start.
Value Params
interval
the query interval
Returns
the filtered tree whose elements overlap the query interval
def filterIncludes(interval: (P, P)): Iterator[Elem]
Filters the tree to contain only those elements that are completely contained within a given interval.
Containment means that found_start <= query_start &&
Value Params
interval
the query interval
Returns
the filtered tree whose elements are contained within the query interval
def intersect(point: P): Iterator[Elem]
Filters the tree to contain only those elements that contain a given point.
An element contains the point if its interval start is less than or equal to that point
and its interval stop is greater than that point.
Value Params
point
the intersection point
Returns
the filtered tree having only elements which contain the point
def interval: Option[(P, P)]
Returns the total interval covered by the sequence, or None if the range is empty
def includes(point: P): Boolean
def includes(interval: (P, P)): Boolean
def overlaps(interval: (P, P)): Boolean

Inherited methods

protected def tree: FingerTree[V, A]
Inhertied from
FingerTreeLike
final def to[To](factory: Factory[A, To]): To
Inhertied from
FingerTreeLike
final def isEmpty: Boolean
Inhertied from
FingerTreeLike
final def nonEmpty: Boolean
Inhertied from
FingerTreeLike
final def tail: Repr
Inhertied from
FingerTreeLike
final def toList: List[A]
Inhertied from
FingerTreeLike
final def iterator: Iterator[A]
Inhertied from
FingerTreeLike
final def init: Repr
Inhertied from
FingerTreeLike
final def lastOption: Option[A]
Inhertied from
FingerTreeLike
protected def wrap(tree: FingerTree[V, A]): Repr
Inhertied from
FingerTreeLike
final def last: A
Inhertied from
FingerTreeLike
final def headOption: Option[A]
Inhertied from
FingerTreeLike

Implicits

Inherited implicits

implicit protected def m: Measure[A, V]
Inhertied from
FingerTreeLike