RTreeIndex

Instance Constructors

new RTreeIndex(t: RTree[U, V], c: List[RTreeNode[U, V, _]])(implicit view: (U) ⇒ ManagedNumber[U], mgr: NumberManager[U])

Value Members

final def !=(arg0: AnyRef): Boolean

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

Definition Classes
Any
final def ##(): Int

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

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

Definition Classes
Any
def asIndex: Index

Definition Classes
RTreeIndex → RTreeNode
final def asInstanceOf[T0]: T0

Definition Classes
Any
def asLeaf: Leaf

Definition Classes
RTreeIndex → RTreeNode
var b: Shape[U]

Attributes
protected
Definition Classes
RTreeNode
var bValid: Boolean

Attributes
protected
Definition Classes
RTreeNode
def bounds: Shape[U]

Definition Classes
RTreeNode
var children: List[RTreeNode[U, V, _]]

Attributes
protected
Definition Classes
RTreeNode
def chooseLeaf(v: V): (Seq[Index], Leaf)

Definition Classes
RTreeIndex → RTreeNode
final def chooseLeaf(path: List[Index], shape: Shape[U]): (Seq[Index], Leaf)

Attributes
protected
Definition Classes
RTreeNode
Annotations
@tailrec()
def clone(): AnyRef

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws()
def debugDump(level: Int): Unit

Definition Classes
RTreeIndex → RTreeNode
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()
def findLeaf(v: V): (Seq[Index], Leaf)

Definition Classes
RTreeIndex → RTreeNode
final def findLeaf(path: List[Index], v: V): (Seq[Index], Leaf)

Attributes
protected
Definition Classes
RTreeNode
def findOverlapping(shape: Shape[U], visitor: (V) ⇒ Unit): Unit

Definition Classes
RTreeIndex → RTreeNode
def getChildren: List[RTreeNode[U, V, _]]

Definition Classes
RTreeNode
final def getClass(): Class[_]

Definition Classes
AnyRef → Any
def hashCode(): Int

Definition Classes
AnyRef → Any
def insert(n: RTreeNode[U, V, _]): Unit
final def isInstanceOf[T0]: Boolean

Definition Classes
Any
val isLeaf: Boolean

Definition Classes
RTreeNode
final def linearSplit[A <: Shaped[U]](seq: List[A]): (List[A], List[A])

Attributes
protected
Definition Classes
RTreeNode
final def ne(arg0: AnyRef): Boolean

Definition Classes
AnyRef
def newInstance(c: List[Node]): RTreeNode[U, V, Node]

Definition Classes
RTreeIndex → RTreeNode
final def notify(): Unit

Definition Classes
AnyRef
final def notifyAll(): Unit

Definition Classes
AnyRef
var numChildren: Int

Definition Classes
RTreeNode
final def pickSeeds[A <: Shaped[U]](entries: List[A]): (A, A, List[A])

Attributes
protected
Definition Classes
RTreeNode
def remove(n: RTreeNode[U, V, _]): Unit

Definition Classes
RTreeNode
def shape: Shape[U]

Definition Classes
RTreeNode → Shaped
def splitNode(n: RTreeNode[U, V, _]): (RTreeNode[U, V, _], RTreeNode[U, V, _])
final def synchronized[T0](arg0: ⇒ T0): T0

Definition Classes
AnyRef
def toString(): String

Definition Classes
RTreeIndex → AnyRef → Any
val tree: RTree[U, V]

Definition Classes
RTreeNode
def updateBounds(): Unit

Definition Classes
RTreeIndex → RTreeNode
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()

class RTreeIndex[U, V <: Shaped[U]] extends RTreeNode[U, V, RTreeNode[U, V, _]]

Instance Constructors

new RTreeIndex(t: RTree[U, V], c: List[RTreeNode[U, V, _]])(implicit view: (U) ⇒ ManagedNumber[U], mgr: NumberManager[U])

Value Members

final def !=(arg0: AnyRef): Boolean

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: AnyRef): Boolean

final def ==(arg0: Any): Boolean

def asIndex: Index

final def asInstanceOf[T0]: T0

def asLeaf: Leaf

var b: Shape[U]

var bValid: Boolean

def bounds: Shape[U]

var children: List[RTreeNode[U, V, _]]

def chooseLeaf(v: V): (Seq[Index], Leaf)

final def chooseLeaf(path: List[Index], shape: Shape[U]): (Seq[Index], Leaf)

def clone(): AnyRef

def debugDump(level: Int): Unit

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def finalize(): Unit

def findLeaf(v: V): (Seq[Index], Leaf)

final def findLeaf(path: List[Index], v: V): (Seq[Index], Leaf)

def findOverlapping(shape: Shape[U], visitor: (V) ⇒ Unit): Unit

def getChildren: List[RTreeNode[U, V, _]]

final def getClass(): Class[_]

def hashCode(): Int

def insert(n: RTreeNode[U, V, _]): Unit

final def isInstanceOf[T0]: Boolean

val isLeaf: Boolean

final def linearSplit[A <: Shaped[U]](seq: List[A]): (List[A], List[A])

final def ne(arg0: AnyRef): Boolean

def newInstance(c: List[Node]): RTreeNode[U, V, Node]

final def notify(): Unit

final def notifyAll(): Unit

var numChildren: Int

final def pickSeeds[A <: Shaped[U]](entries: List[A]): (A, A, List[A])

def remove(n: RTreeNode[U, V, _]): Unit

def shape: Shape[U]

def splitNode(n: RTreeNode[U, V, _]): (RTreeNode[U, V, _], RTreeNode[U, V, _])

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

def toString(): String

val tree: RTree[U, V]

def updateBounds(): Unit

final def wait(): Unit

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

final def wait(arg0: Long): Unit

Inherited from RTreeNode[U, V, RTreeNode[U, V, _]]

Inherited from Shaped[U]

Inherited from AnyRef

Inherited from Any

Ungrouped