BPlusTree

Definitions

def arity(t: BPlusTree[k, v, r]): Int32 Source

Returns the arity of t.

def computeIfAbsent(f: Unit -> v \ ef, k: k, t: BPlusTree[k, v, r]): v \ ef + r with Order[k] Source

Returns v if k => v is in t. Otherwise, computes v = f(), inserts k => v and returns v. That is, f is only evaluated if k is not in t.

This operation is atomic.

Thread-safe.

def empty(rc: Region[r]): BPlusTree[k, v, r] \ r Source

Returns a fresh empty BPlusTree tree of standard arity.

def emptyWithArity(rc: Region[r], m: Int32): BPlusTree[k, v, r] \ r Source

Returns a fresh empty BPlusTree tree with arity m (the maximum keys/values per node). The arity must be at least 3.

def forEach(f: k -> (v -> Unit \ ef), t: BPlusTree[k, v, r]): Unit \ ef + r Source

Applies f to all mappings k => v in t.

Not thread-safe.

def get(k: k, t: BPlusTree[k, v, r]): Option[v] \ r with Order[k] Source

Returns Some(v) if k => v is in t. Otherwise, returns None.

def getWithDefault(k: k, d: v, t: BPlusTree[k, v, r]): v \ r with Order[k] Source

Returns v if k => v is in t. Otherwise, returns d.

def isEmpty(t: BPlusTree[k, v, r]): Bool \ r Source

Returns true if and only if t is the empty tree.

Thread-safe.

def memberOf(k: k, t: BPlusTree[k, v, r]): Bool \ r with Order[k] Source

Returns true if and only if t contains the key k.

Thread-safe.

def memberOfPair(k: k, v: v, t: BPlusTree[k, v, r]): Bool \ r with Order[k], Eq[v] Source

Returns true if and only if t contains the mapping k => v.

Thread-safe.

def merge(src: BPlusTree[k, v, r], dst: BPlusTree[k, v, r]): Unit \ r with Order[k] Source

Merge src into dst modyfing dst in a left-biased manner.

That is, key collisions are resolved by taking the mapping from src.

Not thread-safe.

def mergeWith(f: v -> (v -> v \ ef), src: BPlusTree[k, v, r], dst: BPlusTree[k, v, r]): Unit \ r + ef with Order[k] Source

Merges src into dst modyfing dst. If k => v1 is in src and k => v2 is in dst, updates dst to with k => f(v1, v2).

Not thread-safe.

def minimumKey(t: BPlusTree[k, v, r]): Option[(k, v)] \ r Source

Optionally returns k => v where k is the minimum key.

Not thread-safe.

def put(k: k, v: v, t: BPlusTree[k, v, r]): Unit \ r with Order[k] Source

Updates the tree t with the mapping k => v. Replaces any existing mapping.

Thread-safe.

def putWith(f: v -> (v -> v \ ef), k: k, v: v, t: BPlusTree[k, v, r]): Unit \ ef + r with Order[k] Source

Updates t with k => f(k, v, v1) if k => v1 is in t.

Otherwise, updates t with k => v.

Thread-safe.

def rangeQueryWith(f: k -> (v -> Unit \ ef), min: k, max: k, t: BPlusTree[k, v, r]): Unit \ r + ef with Order[k] Source

Applies f in ascending order to all mappings k => v in t where min <= k <= max.

Not thread-safe.

def toList(t: BPlusTree[k, v, r]): List[(k, v)] \ r Source

Returns a list of the key-value pairs in t. Elements are ordered from smallest (left) to largest (right).

Not thread-safe.

def toString(t: BPlusTree[k, v, r]): String \ r with ToString[k], ToString[v] Source

Returns a string representation of t.

Not thread-safe.