RangedSeq

Abstract Value Members

abstract def +(elem: Elem): RangedSeq[Elem, P]

Adds a new element to the tree.
abstract def -(elem: Elem): RangedSeq[Elem, P]

Removes an element from the tree.
abstract def filterIncludes(interval: (P, P)): Iterator[Elem]

Filters the tree to contain only those elements that are completely contained within a given interval.
Filters the tree to contain only those elements that are completely contained within a given interval. Containment means that found_start <= query_start &&
interval
the query interval
returns
the filtered tree whose elements are contained within the query interval
abstract def filterOverlaps(interval: (P, P)): Iterator[Elem]

Filters the tree to contain only those elements that overlap a given interval.
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.
interval
the query interval
returns
the filtered tree whose elements overlap the query interval
abstract def find(point: P): Option[Elem]

Find an element that contains a given point.
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)
point
the query point
returns
the element containing the point, or None if such an element does not exist.
abstract def findOverlaps(interval: (P, P)): Option[Elem]

Finds an element that overlaps a given interval.
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.
interval
the query interval
returns
the element which overlaps the query interval, or None if there is none.
abstract def includes(interval: (P, P)): Boolean
abstract def includes(point: P): Boolean
abstract def intersect(point: P): Iterator[Elem]

Filters the tree to contain only those elements that contain a given point.
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.
point
the intersection point
returns
the filtered tree having only elements which contain the point
abstract def interval: Option[(P, P)]

Returns the total interval covered by the sequence, or None if the range is empty
implicit abstract def m: Measure[Elem, Option[(P, P)]]

Attributes
protected
Definition Classes
FingerTreeLike
abstract def overlaps(interval: (P, P)): Boolean
abstract def tree: FingerTree[Option[(P, P)], Elem]

Attributes
protected
Definition Classes
FingerTreeLike
abstract def wrap(tree: FingerTree[Option[(P, P)], Elem]): RangedSeq[Elem, P]

Attributes
protected
Definition Classes
FingerTreeLike

Concrete Value Members

final def !=(arg0: Any): Boolean

Definition Classes
AnyRef → Any
final def ##(): Int

Definition Classes
AnyRef → Any
final def ==(arg0: Any): Boolean

Definition Classes
AnyRef → Any
final def asInstanceOf[T0]: T0

Definition Classes
Any
def clone(): AnyRef

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( ... )
final def eq(arg0: AnyRef): Boolean

Definition Classes
AnyRef
def equals(arg0: Any): Boolean

Definition Classes
AnyRef → Any
def finalize(): Unit

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( classOf[java.lang.Throwable] )
final def getClass(): Class[_]

Definition Classes
AnyRef → Any
def hashCode(): Int

Definition Classes
AnyRef → Any
final def head: Elem

Definition Classes
FingerTreeLike
final def headOption: Option[Elem]

Definition Classes
FingerTreeLike
final def init: RangedSeq[Elem, P]

Definition Classes
FingerTreeLike
final def isEmpty: Boolean

Definition Classes
FingerTreeLike
final def isInstanceOf[T0]: Boolean

Definition Classes
Any
final def iterator: Iterator[Elem]

Definition Classes
FingerTreeLike
final def last: Elem

Definition Classes
FingerTreeLike
final def lastOption: Option[Elem]

Definition Classes
FingerTreeLike
final def ne(arg0: AnyRef): Boolean

Definition Classes
AnyRef
final def nonEmpty: Boolean

Definition Classes
FingerTreeLike
final def notify(): Unit

Definition Classes
AnyRef
final def notifyAll(): Unit

Definition Classes
AnyRef
final def synchronized[T0](arg0: ⇒ T0): T0

Definition Classes
AnyRef
final def tail: RangedSeq[Elem, P]

Definition Classes
FingerTreeLike
final def to[Col[_]](implicit cbf: CanBuildFrom[Nothing, Elem, Col[Elem]]): Col[Elem]

Definition Classes
FingerTreeLike
final def toList: List[Elem]

Definition Classes
FingerTreeLike
def toString(): String

Definition Classes
AnyRef → Any
final def wait(): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )
final def wait(arg0: Long, arg1: Int): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )
final def wait(arg0: Long): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )

sealed trait RangedSeq[Elem, P] extends FingerTreeLike[Option[(P, P)], Elem, RangedSeq[Elem, P]]

Abstract Value Members

abstract def +(elem: Elem): RangedSeq[Elem, P]

abstract def -(elem: Elem): RangedSeq[Elem, P]

abstract def filterIncludes(interval: (P, P)): Iterator[Elem]

abstract def filterOverlaps(interval: (P, P)): Iterator[Elem]

abstract def find(point: P): Option[Elem]

abstract def findOverlaps(interval: (P, P)): Option[Elem]

abstract def includes(interval: (P, P)): Boolean

abstract def includes(point: P): Boolean

abstract def intersect(point: P): Iterator[Elem]

abstract def interval: Option[(P, P)]

implicit abstract def m: Measure[Elem, Option[(P, P)]]

abstract def overlaps(interval: (P, P)): Boolean

abstract def tree: FingerTree[Option[(P, P)], Elem]

abstract def wrap(tree: FingerTree[Option[(P, P)], Elem]): RangedSeq[Elem, P]

Concrete Value Members

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

final def asInstanceOf[T0]: T0

def clone(): AnyRef

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def finalize(): Unit

final def getClass(): Class[_]

def hashCode(): Int

final def head: Elem

final def headOption: Option[Elem]

final def init: RangedSeq[Elem, P]

final def isEmpty: Boolean

final def isInstanceOf[T0]: Boolean

final def iterator: Iterator[Elem]

final def last: Elem

final def lastOption: Option[Elem]

final def ne(arg0: AnyRef): Boolean

final def nonEmpty: Boolean

final def notify(): Unit

final def notifyAll(): Unit

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

final def tail: RangedSeq[Elem, P]

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

final def toList: List[Elem]

def toString(): String

final def wait(): Unit

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

final def wait(arg0: Long): Unit

Inherited from FingerTreeLike[Option[(P, P)], Elem, RangedSeq[Elem, P]]

Inherited from AnyRef

Inherited from Any

Ungrouped