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

def addBranch(node: Node[K, V], branch: Node[K, V]): Unit

Adds a new branch to (internal) node.

Adds a new branch to (internal) node. branch is placed at an index equal to the length of node, given that the length of a node is the number of keys.

Attributes: protected
Definition Classes: MemoryBPlusTree → BPlusTree

def addKey(node: Node[K, V], key: K): Unit

Adds a new key to node.

Adds a new key to node. The length of node will increase by one as a result. This method should be called before either addBranch or addValue since those methods use the current node length to determine placemenet.

Attributes: protected
Definition Classes: MemoryBPlusTree → BPlusTree

final def asInstanceOf[T0]: T0

Definition Classes: Any

def binarySearch(node: N, target: K): Int

Performs a binary search for key target within node (tail recursively).

returns: the index of target within node if it exists, or (-insertionPoint - 1) where insertionPoint is the index of the correct insertion point for key target.

Attributes: protected
Definition Classes: BPlusTree

def boundedIterator(bounds: (Symbol, K)*): Iterator[(K, V)]

Returns a bounded iterator over a range of key/value pairs in the tree in ascending sorted key order.

Returns a bounded iterator over a range of key/value pairs in the tree in ascending sorted key order. The range of key/value pairs in the iterator is specified by bounds. bounds must contain one or two pairs where the first element in the pair is a symbol corresponding to the type of bound (i.e. '<, '<=, '>, '>=) and the second element is a key value.

An example of a bounded iterator over all elements in a tree (with String keys) that will include all keys that sort greater than or equal to "a" and up to but not including "e" is boundedIterator( ('>=, "a"), ('<, "e") ).

Definition Classes: BPlusTree

def boundedKeysIterator(bounds: (Symbol, K)*): Iterator[K]

Returns a bounded iterator over a range of keys in the tree in ascending sorted key order.

Returns a bounded iterator over a range of keys in the tree in ascending sorted key order. The bounds parameter is the same as for boundedIterator.

Definition Classes: BPlusTree

def boundedPositionIterator(bounds: (Symbol, K)*): Iterator[(N, Int)]

Returns a bounded iterator over a range of key positions (node/index pairs) in the tree in ascending sorted key order.

Returns a bounded iterator over a range of key positions (node/index pairs) in the tree in ascending sorted key order. The bounds parameter is the same as for boundedIterator.

Attributes: protected
Definition Classes: BPlusTree

def boundedValuesIterator(bounds: (Symbol, K)*): Iterator[V]

Returns a bounded iterator over a range of values in the tree in ascending sorted key order.

Returns a bounded iterator over a range of values in the tree in ascending sorted key order. The bounds parameter is the same as for boundedIterator.

Definition Classes: BPlusTree

def build(s: String): BPlusTree[K, V]

Returns a B+ tree build from a string representation of the tree.

Returns a B+ tree build from a string representation of the tree. The syntax of the input string is simple: internal nodes are coded as lists of nodes alternating with keys (alpha strings with no quotation marks) using parentheses with elements separated by space, leaf nodes are coded as lists of alpha strings (no quotation marks) using brackets with elements separated by space.

Definition Classes: BPlusTree

def clone(): AnyRef

Attributes: protected[java.lang]
Definition Classes: AnyRef
Annotations: @throws( ... )

def delete(key: K): Boolean

Performs the B+ tree deletion algorithm to remove key and it's associated value from the tree, rebalancing the tree if necessary.

returns: true if key was found (and therefore removed), false otherwise

Definition Classes: BPlusTree

def diagram(name: String): Unit

Creates a PNG image file called name (with .png added) which visually represents the structure and contents of the tree, only showing the keys.

Creates a PNG image file called name (with .png added) which visually represents the structure and contents of the tree, only showing the keys. This method uses GraphViz (specifically the dot command) to produce the diagram, and ImageMagik (specifically the convert command) to convert it from SVG to PNG. dot can product PNG files directly but I got better results producing SVG and converting to PNG.

Definition Classes: BPlusTree

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] )

var first: Node[K, V]

Attributes: protected
Definition Classes: MemoryBPlusTree → BPlusTree

def freeKey(node: N, index: Int): Unit

Free the storage previously allocated for the key at index in node.

Free the storage previously allocated for the key at index in node. For in-memory implementations, this method probably won't do anything.

Attributes: protected
Definition Classes: MemoryBPlusTree → BPlusTree

def freeNode(node: Node[K, V]): Unit

Free the storage previously allocated for node.

Free the storage previously allocated for node. For in-memory implementations, this method probably won't do anything.

Attributes: protected
Definition Classes: MemoryBPlusTree → BPlusTree

def freeValue(node: N, index: Int): Unit

Free the storage previously allocated for the value at index in node.

Free the storage previously allocated for the value at index in node. For in-memory implementations, this method probably won't do anything.

Attributes: protected
Definition Classes: MemoryBPlusTree → BPlusTree

def getBranch(n: Node[K, V], index: Int): Node[K, V]

Returns a branch pointer from an internal node at a given index.

Returns a branch pointer from an internal node at a given index. There is always one more branch pointer than there are keys in an internal node so the highest index is equal to nodeLength( node ).

Attributes: protected
Definition Classes: MemoryBPlusTree → BPlusTree

def getBranches(n: Node[K, V]): ArrayBuffer[Node[K, V]]

Returns the branches of node as a non-strict immutable sequence.

Attributes: protected
Definition Classes: MemoryBPlusTree → BPlusTree

final def getClass(): Class[_]

Definition Classes: AnyRef → Any

def getKey(n: Node[K, V], index: Int): K

Returns a key from a leaf node at a given index.

Attributes: protected
Definition Classes: MemoryBPlusTree → BPlusTree

def getKeyValue(leaf: N, index: Int): (K, V)

Returns the key/value pair at index within leaf.

Attributes: protected
Definition Classes: BPlusTree

def getKeys(node: Node[K, V]): ArrayBuffer[K]

Returns the keys of node as a non-strict immutable sequence.

Attributes: protected
Definition Classes: MemoryBPlusTree → BPlusTree

def getNext(node: Node[K, V]): Node[K, V]

Returns the next pointer of (leaf) node.

Attributes: protected
Definition Classes: MemoryBPlusTree → BPlusTree

def getParent(node: Node[K, V]): InternalNode[K, V]

Returns the parent pointer of node.

Attributes: protected
Definition Classes: MemoryBPlusTree → BPlusTree

def getPrev(node: Node[K, V]): Node[K, V]

Returns the previous leaf node link pointer of (leaf) node.

Attributes: protected
Definition Classes: MemoryBPlusTree → BPlusTree

def getValue(n: Node[K, V], index: Int): V

Returns a value from a leaf node at a given index.

Attributes: protected
Definition Classes: MemoryBPlusTree → BPlusTree

def getValues(node: Node[K, V]): ArrayBuffer[V]

Returns the values of node as a non-strict immutable sequence.

Attributes: protected
Definition Classes: MemoryBPlusTree → BPlusTree

def greatestLT(key: K): (N, Int)

Returns the leaf position of the key that is greatest less than key.

Attributes: protected
Definition Classes: BPlusTree

def greatestLTE(key: K): (N, Int)

Returns the leaf position of the key that is greatest less than or equal to key.

Attributes: protected
Definition Classes: BPlusTree

def greatestLessThan(key: K): Option[(K, V)]

Returns the key/value pair whose key is greatest less than key.

Definition Classes: BPlusTree

def greatestLessThanOrEqual(key: K): Option[(K, V)]

Returns the key/value pair whose key is greatest less than or equal to key.

Definition Classes: BPlusTree

def hashCode(): Int

Definition Classes: AnyRef → Any

def insert[V1 >: V](key: K, value: V1 = null.asInstanceOf[V1]): Boolean

Inserts key with associated value into the tree.

Inserts key with associated value into the tree. If key exists, then it's new associated value will be value.

returns: true if key exists

Definition Classes: BPlusTree

def insertAt[V1 >: V](key: K, value: V1, leaf: N, index: Int): Unit

Performs the B+ tree insertion algorithm to insert key and associated value into the tree, specifically in leaf at index, rebalancing the tree if necessary.

Performs the B+ tree insertion algorithm to insert key and associated value into the tree, specifically in leaf at index, rebalancing the tree if necessary. If leaf and index is not the correct insertion point for key then this method will probably result in an invalid B+ tree.

Attributes: protected
Definition Classes: BPlusTree

def insertIfNotFound[V1 >: V](key: K, value: V1 = null.asInstanceOf[V1]): Boolean

Inserts key with associated value into the tree only if key does not exist.

returns: true if key exists

Definition Classes: BPlusTree

def insertInternal(n: Node[K, V], keyIndex: Int, key: K, branchIndex: Int, branch: Node[K, V]): Unit

Inserts key and branch into (internal) node at keyIndex and branchIndex, respectively.

Attributes: protected
Definition Classes: MemoryBPlusTree → BPlusTree

def insertKeys(keys: K*): Unit

Inserts keys into the tree each with an associated value of null.

Inserts keys into the tree each with an associated value of null. If a given key exists, then it's new associated value will be null.

Definition Classes: BPlusTree

def insertKeysAndCheck(keys: K*): String

Inserts keys into the tree each with an associated value of null, and checks that the tree is well constructed after each key is inserted.

Inserts keys into the tree each with an associated value of null, and checks that the tree is well constructed after each key is inserted. If a given key exists, then it's new associated value will be null. This method is used for testing.

Definition Classes: BPlusTree

def insertLeaf[V1 >: V](n: Node[K, V], index: Int, key: K, value: V1): Unit

Inserts key and value into (leaf) node at index.

Attributes: protected
Definition Classes: MemoryBPlusTree → BPlusTree

def isEmpty: Boolean

Returns true is the tree is empty.

Definition Classes: BPlusTree

final def isInstanceOf[T0]: Boolean

Definition Classes: Any

def isLeaf(node: Node[K, V]): Boolean

Returns true if node is a leaf node

Attributes: protected
Definition Classes: MemoryBPlusTree → BPlusTree

def iterator: Iterator[(K, V)]

Returns an iterator over all key/value pairs in the tree in ascending sorted key order.

Definition Classes: BPlusTree

def keys: Iterable[K]

Returns a non-strict Iterable containing the keys in the tree.

Definition Classes: BPlusTree

def keysIterator: Iterator[K]

Returns an iterator over all keys in the tree in ascending sorted order.

Definition Classes: BPlusTree

var last: Node[K, V]

Attributes: protected
Definition Classes: MemoryBPlusTree → BPlusTree

var lastlen: Int

Attributes: protected
Definition Classes: MemoryBPlusTree → BPlusTree

def leastGT(key: K): (N, Int)

Returns the leaf position of the key that is least greater than key.

Attributes: protected
Definition Classes: BPlusTree

def leastGTE(key: K): (N, Int)

Returns the leaf position of the key that is least greater than or equal to key.

Attributes: protected
Definition Classes: BPlusTree

def leastGreaterThan(key: K): Option[(K, V)]

Returns the key/value pair whose key is least greater than key.

Definition Classes: BPlusTree

def leastGreaterThanOrEqual(key: K): Option[(K, V)]

Returns the key/value pair whose key is least greater than or equal to key.

Definition Classes: BPlusTree

def leftmost(node: N): K

Returns the left most or least key within or under node.

Attributes: protected
Definition Classes: BPlusTree

def load[V1 >: V](kvs: (K, V1)*): Unit

Performs the B+ tree bulk loading algorithm to insert key/value pairs kvs into the tree efficiently.

Performs the B+ tree bulk loading algorithm to insert key/value pairs kvs into the tree efficiently. This method is more efficient than using insert because insert performs a search to determine the correct insertion point for the key whereas load does not. load can only work if the tree is empty, or if the minimum key to be inserted is greater than the maximum key in the tree.

Definition Classes: BPlusTree

def lookup(key: K): (Boolean, N, Int)

Performs the B+ tree lookup algorithm (tail recursively) beginning at the root, in search of the location (if found) or correct insertion point (if not found) of key.

returns: a triple where the first element is true if key exists and false otherwise, the second element is the node containing key if found or the correct insertion point for key if not found, the third is the index within that node.

Attributes: protected
Definition Classes: BPlusTree

def lookupGTE(key: K): (Boolean, N, Int)

Searches for key returning a point in a leaf node that is the least greater than (if not found) or equal to (if found) key.

Searches for key returning a point in a leaf node that is the least greater than (if not found) or equal to (if found) key. The leaf node and index returned in case key does not exist is not necessarily the correct insertion point. This method is used by boundedIterator.

returns: a triple where the first element is true if key exists and false otherwise, and the second element is the leaf node containing the least greater than or equal key, and the third is the index of that key.

Attributes: protected
Definition Classes: BPlusTree

def lookupLTE(key: K): (Boolean, N, Int)

Searches for key returning a point in a leaf node that is the greatest less than (if not found) or equal to (if found) key.

Searches for key returning a point in a leaf node that is the greatest less than (if not found) or equal to (if found) key. The leaf node and index returned in case key does not exist is not necessarily the correct insertion point. This method is used by reverseBoundedIterator.

returns: a triple where the first element is true if key exists and false otherwise, and the second element is the leaf node containing the greatest less than or equal key, and the third is the index of that key.

Attributes: protected
Definition Classes: BPlusTree

def max: Option[(K, V)]

Returns the maximum key and it's associated value.

returns: Some( (key, value) ) where key is the maximum key and value is it's associated value if the tree is non-empty, or None if the tree is empty.

Definition Classes: BPlusTree

def maxKey: Option[K]

Returns the maximum key.

Definition Classes: BPlusTree

def min: Option[(K, V)]

Returns the minimum key and it's associated value.

returns: Some( (key, value) ) where key is the minimum key and value is it's associated value if the tree is non-empty, or None if the tree is empty.

Definition Classes: BPlusTree

def minKey: Option[K]

Returns the minimum key.

Definition Classes: BPlusTree

val minlen: Int

The minimum length (number of keys) that a non-root node (internal or leaf) may have is ceil(order/2) - 1.

The minimum length (number of keys) that a non-root node (internal or leaf) may have is ceil(order/2) - 1. The minimum length for a root leaf node is 0. The minimum length for a root internal node is 1.

Attributes: protected
Definition Classes: BPlusTree

def moveInternal(src: N, begin: Int, end: Int, dst: N, index: Int): Unit

Moves key/branch pairs from node src beginning at index begin up to but not including index end to node dst at index.

Attributes: protected
Definition Classes: MemoryBPlusTree → BPlusTree

def moveLeaf(src: Node[K, V], begin: Int, end: Int, dst: Node[K, V], index: Int): Unit

Moves key/value pairs from node src to node dst beginning at index begin and ending up to but not including index end.

Attributes: protected
Definition Classes: MemoryBPlusTree → BPlusTree

final def ne(arg0: AnyRef): Boolean

Definition Classes: AnyRef

def newInternal(parent: Node[K, V]): InternalNode[K, V]

Creates a new internal node with parent as its parent pointer.

Attributes: protected
Definition Classes: MemoryBPlusTree → BPlusTree

def newLeaf(parent: Node[K, V]): LeafNode[K, V]

Creates a new leaf node with parent as its parent pointer.

Attributes: protected
Definition Classes: MemoryBPlusTree → BPlusTree

def newRoot(branch: Node[K, V]): InternalNode[K, V]

Creates a new root (internal) node with branch as its leftmost branch pointer and null parent pointer.

Creates a new root (internal) node with branch as its leftmost branch pointer and null parent pointer. Implementations are require to update the in-storage copy of the root pointer if needed (only really applies to on-disk implementations).

Attributes: protected
Definition Classes: MemoryBPlusTree → BPlusTree

def nextPosition(leaf: N, index: Int): (N, Int)

Returns the node/index pair pointing to the location of the leaf node key following the one at index in leaf.

Attributes: protected
Definition Classes: BPlusTree

def nodeLength(node: Node[K, V]): Int

Returns the length (number of keys) of node.

Returns the length (number of keys) of node. For internal nodes, the number of branch pointers will one more than the length.

Attributes: protected
Definition Classes: MemoryBPlusTree → BPlusTree

final def notify(): Unit

Definition Classes: AnyRef

final def notifyAll(): Unit

Definition Classes: AnyRef

def nul: Null

Returns the null node pointer.

Returns the null node pointer. For in-memory implementations this will usually be a Scala null value. For on-disk it would make sense for this to be 0L.

Attributes: protected
Definition Classes: MemoryBPlusTree → BPlusTree

def optionalKey(pos: (N, Int)): Option[K]

Attributes: protected
Definition Classes: BPlusTree

def optionalKeyValue(pos: (N, Int)): Option[(K, V)]

Attributes: protected
Definition Classes: BPlusTree

val order: Int

Definition Classes: MemoryBPlusTree → BPlusTree

def positionIterator: Iterator[(N, Int)]

Returns an iterator over all key positions (node/index pairs) in the tree in ascending sorted key order.

Attributes: protected
Definition Classes: BPlusTree

def prettyPrint: Unit

Prints (to stdout) a readable representation of the structure and contents of the tree.

Definition Classes: BPlusTree

def prettyPrintKeysOnly: Unit

Prints (to stdout) a readable representation of the structure and contents of the tree, omitting the values and only printing the keys.

Definition Classes: BPlusTree

def prettySearch(key: K): String

Returns a string representing a search result for key that will be consistant with prettyPrint.

Returns a string representing a search result for key that will be consistant with prettyPrint. This method is used mainly for unit testing.

Definition Classes: BPlusTree

def prettyString: String

Returns a string containing a readable representation of the structure and contents of the tree, omitting the values and only printing the keys.

Returns a string containing a readable representation of the structure and contents of the tree, omitting the values and only printing the keys. This method is used mainly for unit testing.

Definition Classes: BPlusTree

def prettyStringWithValues: String

Returns a string containing a readable representation of the structure and contents of the tree.

Returns a string containing a readable representation of the structure and contents of the tree. This method is used mainly for unit testing.

Definition Classes: BPlusTree

def prevPosition(leaf: N, index: Int): (N, Int)

Returns the node/index pair pointing to the location of the leaf node key preceding the one at index in leaf.

Attributes: protected
Definition Classes: BPlusTree

def removeInternal(node: Node[K, V], keyIndex: Int, branchIndex: Int): Int

Removes the key and branch pair from internal node at keyIndex and branchIndex, respectively.

Removes the key and branch pair from internal node at keyIndex and branchIndex, respectively. This method is perhaps poorly named: it does not remove an internal node from the tree.

returns: length of node after removal

Attributes: protected
Definition Classes: MemoryBPlusTree → BPlusTree

def removeLeaf(node: Node[K, V], index: Int): Int

Removes the key/value pair from leaf node at index.

Removes the key/value pair from leaf node at index. This method is perhaps poorly named: it does not remove a leaf node from the tree.

returns: length of node after removal

Attributes: protected
Definition Classes: MemoryBPlusTree → BPlusTree

def reverseBoundedIterator(bounds: (Symbol, K)*): Iterator[(K, V)]

Returns a bounded iterator over a range of key/value pairs in the tree in descending sorted key order.

Returns a bounded iterator over a range of key/value pairs in the tree in descending sorted key order. The range of key/value pairs in the iterator is specified by bounds. bounds must contain one or two pairs where the first element in the pair is a symbol corresponding to the type of bound (i.e. '<, '<=, '>, '>=) and the second element is a key value.

An example of a reverse bounded iterator over all elements in a tree (with String keys) that will include all keys that sort greater than or equal to "a" and up to but not including "e", iterated over in reverse order, is reverseBoundedIterator( ('>=, "a"), ('<, "e") ).

Definition Classes: BPlusTree

def reverseBoundedKeysIterator(bounds: (Symbol, K)*): Iterator[K]

Returns a bounded iterator over a range of keys in the tree in descending sorted key order.

Returns a bounded iterator over a range of keys in the tree in descending sorted key order. The bounds parameter is the same as for boundedIterator.

Definition Classes: BPlusTree

def reverseBoundedPositionIterator(bounds: (Symbol, K)*): Iterator[(N, Int)]

Returns a bounded iterator over a range of key positions (node/index pairs) in the tree in descending sorted key order.

Returns a bounded iterator over a range of key positions (node/index pairs) in the tree in descending sorted key order. The bounds parameter is the same as for boundedIterator.

Attributes: protected
Definition Classes: BPlusTree

def reverseBoundedValuesIterator(bounds: (Symbol, K)*): Iterator[V]

Returns a bounded iterator over a range of values in the tree in descending sorted key order.

Returns a bounded iterator over a range of values in the tree in descending sorted key order. The bounds parameter is the same as for boundedIterator.

Definition Classes: BPlusTree

def reverseIterator: Iterator[(K, V)]

Returns an iterator over all key/value pairs in the tree in descending sorted key order.

Definition Classes: BPlusTree

def reverseKeysIterator: Iterator[K]

Returns a reverse iterator over all keys in the tree in descending sorted order.

Definition Classes: BPlusTree

def reversePositionIterator: Iterator[(N, Int)]

Returns a reverse iterator over all key positions (node/index pairs) in the tree in descending sorted key order.

Attributes: protected
Definition Classes: BPlusTree

def rightmost(node: N): K

Returns the right most or greatest key within or under node.

Attributes: protected
Definition Classes: BPlusTree

var root: Node[K, V]

Attributes: protected
Definition Classes: MemoryBPlusTree → BPlusTree

def search(key: K): Option[V]

Searches for key returning it's associated value if key exists.

returns: Some( value ) where value is the value associated to key if it exists, or None otherwise

Definition Classes: BPlusTree

def serialize(before: String, prefix: String, internalnode: (N, (N) ⇒ String, (String) ⇒ Unit) ⇒ String, leafnode: (N, (N) ⇒ String) ⇒ String, after: String): String

Returns a serialization (string representation of the tree) using string and function arguments to specify the exact form of the serialization.

Returns a serialization (string representation of the tree) using string and function arguments to specify the exact form of the serialization. This method is used for pretty printing and to generate a DOT (graph description language) description of the tree so that it can be visualized.

before: string to be prepended to the serialization
prefix: string to be place before each line of the serialization that includes internal and leaf nodes
internalnode: function to generate internal node serializations using three parameters: the current node, a function to return a string id of a node, a function that allows a line of text to be appended after all nodes have been serialized
leafnode: function to generate leaf node serializations using two parameters: the current node, a function to return a string id of a node
after: string to be appended to the serialization

Attributes: protected
Definition Classes: BPlusTree

def setFirst(leaf: Node[K, V]): Unit

Sets the in-storage copy of the first leaf node pointer.

Sets the in-storage copy of the first leaf node pointer. This method is not responsable for setting the first variable.

Attributes: protected
Definition Classes: MemoryBPlusTree → BPlusTree

def setKey(node: Node[K, V], index: Int, key: K): Unit

Sets the key at index of node to key.

Attributes: protected
Definition Classes: MemoryBPlusTree → BPlusTree

def setLast(leaf: Node[K, V]): Unit

Sets the in-storage copy of the last leaf node pointer.

Sets the in-storage copy of the last leaf node pointer. This method is not responsable for setting the last variable nor the lastlen variable.

Attributes: protected
Definition Classes: MemoryBPlusTree → BPlusTree

def setNext(node: Node[K, V], p: Node[K, V]): Unit

Sets the next pointer of (leaf) node to p.

Attributes: protected
Definition Classes: MemoryBPlusTree → BPlusTree

def setParent(node: Node[K, V], p: Node[K, V]): Unit

Sets the parent pointer of node to p.

Attributes: protected
Definition Classes: MemoryBPlusTree → BPlusTree

def setPrev(node: Node[K, V], p: Node[K, V]): Unit

Sets previous leaf node link pointer of (leaf) node to p.

Attributes: protected
Definition Classes: MemoryBPlusTree → BPlusTree

def setRoot(node: Node[K, V]): Unit

Sets the in-storage copy of the root node pointer.

Sets the in-storage copy of the root node pointer. This method is not responsable for setting the root variable.

Attributes: protected
Definition Classes: MemoryBPlusTree → BPlusTree

def setValue[V1 >: V](node: Node[K, V], index: Int, v: V1): Unit

Sets the value at index of node to v.

Attributes: protected
Definition Classes: MemoryBPlusTree → BPlusTree

def str(node: N): String

Returns a string representation of the keys in node.

Returns a string representation of the keys in node. This method was used in debugging FileBPlusTree since the node type is Long.

Attributes: protected
Definition Classes: BPlusTree

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

Definition Classes: AnyRef

def toString(): String

Definition Classes: AnyRef → Any

def traverseBreadthFirst(level: (List[N]) ⇒ Unit): Unit

Performs a breadth first traversal of the tree (tail recursively), applying level to each level of the tree beginning at the root.

Attributes: protected
Definition Classes: BPlusTree

def valuesIterator: Iterator[V]

Returns an iterator over all values in the tree in the order corresponding to ascending keys.

Definition Classes: BPlusTree

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( ... )

def wellConstructed: String

Analyzes the tree to determine if it is well constructed.

returns: "true" (as a string) if the tree is a well constructed B+ tree, a string description of the flaw otherwise.

Definition Classes: BPlusTree

Packages

Overview

MemoryBPlusTree

class MemoryBPlusTree[K, V] extends BPlusTree[K, V]

Instance Constructors

Type Members

Value Members

Inherited from BPlusTree[K, V]

Inherited from AnyRef

Inherited from Any

Ungrouped