org.apache.cassandra.utils.btree

## Class BTree

- java.lang.Object
- - org.apache.cassandra.utils.btree.BTree

    public class BTree
    extends java.lang.Object

### Nested Class Summary

Nested Classes
`static class` `BTree.Builder<V>`
`static class` `BTree.Dir`

### Constructor Summary

Constructors
Constructor and Description
`BTree()`

### Method Summary

All Methods Static Methods Concrete Methods
`static <V> void` `apply(java.lang.Object[] btree, java.util.function.Consumer<V> function, boolean reversed)` Simple method to walk the btree forwards or reversed and apply a function to each element Public method
`static <V> void` `apply(java.lang.Object[] btree, java.util.function.Consumer<V> function, com.google.common.base.Predicate<V> stopCondition, boolean reversed)` Simple method to walk the btree forwards or reversed and apply a function till a stop condition is reached Public method
`static <C,K extends C,V extends C> java.lang.Object[]` `build(java.util.Collection<K> source, UpdateFunction<K,V> updateF)`
`static <C,K extends C,V extends C> java.lang.Object[]` `build(java.lang.Iterable<K> source, int size, UpdateFunction<K,V> updateF)` Creates a BTree containing all of the objects in the provided collection
`static <C,K extends C,V extends C> java.lang.Object[]` `build(java.lang.Iterable<K> source, UpdateFunction<K,V> updateF)`
`static <V> BTree.Builder<V>` `builder(java.util.Comparator<? super V> comparator)`
`static <V> BTree.Builder<V>` `builder(java.util.Comparator<? super V> comparator, int initialCapacity)`
`static <V> V` `ceil(java.lang.Object[] btree, java.util.Comparator<? super V> comparator, V find)`
`static <V> int` `ceilIndex(java.lang.Object[] btree, java.util.Comparator<? super V> comparator, V find)`
`static int` `depth(java.lang.Object[] tree)`
`static java.lang.Object[]` `empty()`
`static boolean` `equals(java.lang.Object[] a, java.lang.Object[] b)`
`static <V> V` `find(java.lang.Object[] node, java.util.Comparator<? super V> comparator, V find)`
`static <V> V` `findByIndex(java.lang.Object[] tree, int index)`
`static <V> int` `findIndex(java.lang.Object[] node, java.util.Comparator<? super V> comparator, V find)` Honours result semantics of `Arrays.binarySearch(long[], long)`, as though it were performed on the tree flattened into an array
`static <V> V` `floor(java.lang.Object[] btree, java.util.Comparator<? super V> comparator, V find)`
`static <V> int` `floorIndex(java.lang.Object[] btree, java.util.Comparator<? super V> comparator, V find)`
`static int` `hashCode(java.lang.Object[] btree)`
`static <V> V` `higher(java.lang.Object[] btree, java.util.Comparator<? super V> comparator, V find)`
`static <V> int` `higherIndex(java.lang.Object[] btree, java.util.Comparator<? super V> comparator, V find)`
`static boolean` `isEmpty(java.lang.Object[] tree)`
`static boolean` `isWellFormed(java.lang.Object[] btree, java.util.Comparator<? extends java.lang.Object> cmp)`
`static <V> java.lang.Iterable<V>` `iterable(java.lang.Object[] btree)`
`static <V> java.lang.Iterable<V>` `iterable(java.lang.Object[] btree, BTree.Dir dir)`
`static <V> java.lang.Iterable<V>` `iterable(java.lang.Object[] btree, int lb, int ub, BTree.Dir dir)`
`static <V> java.util.Iterator<V>` `iterator(java.lang.Object[] btree)`
`static <V> java.util.Iterator<V>` `iterator(java.lang.Object[] btree, BTree.Dir dir)`
`static <V> java.util.Iterator<V>` `iterator(java.lang.Object[] btree, int lb, int ub, BTree.Dir dir)`
`static <V> V` `lower(java.lang.Object[] btree, java.util.Comparator<? super V> comparator, V find)`
`static <V> int` `lowerIndex(java.lang.Object[] btree, java.util.Comparator<? super V> comparator, V find)`
`static <K> java.lang.Object[]` `merge(java.lang.Object[] tree1, java.lang.Object[] tree2, java.util.Comparator<? super K> comparator, UpdateFunction<K,K> updateF)`
`static <V> void` `replaceInSitu(java.lang.Object[] node, java.util.Comparator<? super V> comparator, V find, V replace)` Modifies the provided btree directly.
`static <V> void` `replaceInSitu(java.lang.Object[] tree, int index, V replace)` Modifies the provided btree directly.
`static java.lang.Object[]` `singleton(java.lang.Object value)`
`static int` `size(java.lang.Object[] tree)`
`static long` `sizeOfStructureOnHeap(java.lang.Object[] tree)`
`static <K,V> BTreeSearchIterator<K,V>` `slice(java.lang.Object[] btree, java.util.Comparator<? super K> comparator, BTree.Dir dir)` Returns an Iterator over the entire tree
`static <K,V extends K> BTreeSearchIterator<K,V>` `slice(java.lang.Object[] btree, java.util.Comparator<? super K> comparator, K start, boolean startInclusive, K end, boolean endInclusive, BTree.Dir dir)`
`static <K,V extends K> BTreeSearchIterator<K,V>` `slice(java.lang.Object[] btree, java.util.Comparator<? super K> comparator, K start, K end, BTree.Dir dir)`
`static int` `toArray(java.lang.Object[] tree, int treeStart, int treeEnd, java.lang.Object[] target, int targetOffset)`
`static int` `toArray(java.lang.Object[] tree, java.lang.Object[] target, int targetOffset)` Fill the target array with the contents of the provided subtree, in ascending order, starting at targetOffset
`static <V> java.lang.Object[]` `transformAndFilter(java.lang.Object[] btree, com.google.common.base.Function<? super V,? extends V> function)` Takes a btree and transforms it using the provided function, filtering out any null results.
`static int` `treeIndexOfBranchKey(java.lang.Object[] root, int keyIndex)`
`static int` `treeIndexOffsetOfChild(java.lang.Object[] root, int childIndex)`
`static int` `treeIndexOfKey(java.lang.Object[] root, int keyIndex)` tree index => index of key wrt all items in the tree laid out serially This version of the method permits requesting out-of-bounds indexes, -1 and size
`static int` `treeIndexOfLeafKey(int keyIndex)`
`static <C,K extends C,V extends C> java.lang.Object[]` `update(java.lang.Object[] btree, java.util.Comparator<C> comparator, java.util.Collection<K> updateWith, UpdateFunction<K,V> updateF)`
`static <C,K extends C,V extends C> java.lang.Object[]` `update(java.lang.Object[] btree, java.util.Comparator<C> comparator, java.lang.Iterable<K> updateWith, int updateWithLength, UpdateFunction<K,V> updateF)` Returns a new BTree with the provided collection inserting/replacing as necessary any equal items

### Methods inherited from class java.lang.Object

`clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

### Constructor Detail

#### BTree

    public BTree()

### Method Detail

#### empty

    public static java.lang.Object[] empty()

#### singleton

    public static java.lang.Object[] singleton(java.lang.Object value)

#### build

    public static <C,K extends C,V extends C> java.lang.Object[] build(java.util.Collection<K> source,
                                                                       UpdateFunction<K,V> updateF)

#### build

    public static <C,K extends C,V extends C> java.lang.Object[] build(java.lang.Iterable<K> source,
                                                                       UpdateFunction<K,V> updateF)

#### build

    public static <C,K extends C,V extends C> java.lang.Object[] build(java.lang.Iterable<K> source,
                                                                       int size,
                                                                       UpdateFunction<K,V> updateF)

Creates a BTree containing all of the objects in the provided collection

Parameters:
  `source` - the items to build the tree with. MUST BE IN STRICTLY ASCENDING ORDER.
  `size` - the size of the source iterable
Returns:
  a btree representing the contents of the provided iterable

#### update

    public static <C,K extends C,V extends C> java.lang.Object[] update(java.lang.Object[] btree,
                                                                        java.util.Comparator<C> comparator,
                                                                        java.util.Collection<K> updateWith,
                                                                        UpdateFunction<K,V> updateF)

#### update

    public static <C,K extends C,V extends C> java.lang.Object[] update(java.lang.Object[] btree,
                                                                        java.util.Comparator<C> comparator,
                                                                        java.lang.Iterable<K> updateWith,
                                                                        int updateWithLength,
                                                                        UpdateFunction<K,V> updateF)

Returns a new BTree with the provided collection inserting/replacing as necessary any equal items

Type Parameters:
  `V` -
Parameters:
  `btree` - the tree to update
  `comparator` - the comparator that defines the ordering over the items in the tree
  `updateWith` - the items to either insert / update. MUST BE IN STRICTLY ASCENDING ORDER.
  `updateWithLength` - then number of elements in updateWith
  `updateF` - the update function to apply to any pairs we are swapping, and maybe abort early
Returns:

#### merge

    public static <K> java.lang.Object[] merge(java.lang.Object[] tree1,
                                               java.lang.Object[] tree2,
                                               java.util.Comparator<? super K> comparator,
                                               UpdateFunction<K,K> updateF)

#### iterator

    public static <V> java.util.Iterator<V> iterator(java.lang.Object[] btree)

#### iterator

    public static <V> java.util.Iterator<V> iterator(java.lang.Object[] btree,
                                                     BTree.Dir dir)

#### iterator

    public static <V> java.util.Iterator<V> iterator(java.lang.Object[] btree,
                                                     int lb,
                                                     int ub,
                                                     BTree.Dir dir)

#### iterable

    public static <V> java.lang.Iterable<V> iterable(java.lang.Object[] btree)

#### iterable

    public static <V> java.lang.Iterable<V> iterable(java.lang.Object[] btree,
                                                     BTree.Dir dir)

#### iterable

    public static <V> java.lang.Iterable<V> iterable(java.lang.Object[] btree,
                                                     int lb,
                                                     int ub,
                                                     BTree.Dir dir)

#### slice

    public static <K,V> BTreeSearchIterator<K,V> slice(java.lang.Object[] btree,
                                                       java.util.Comparator<? super K> comparator,
                                                       BTree.Dir dir)

Returns an Iterator over the entire tree

Type Parameters:
  `V` -
Parameters:
  `btree` - the tree to iterate over
  `dir` - direction of iteration
Returns:

#### slice

    public static <K,V extends K> BTreeSearchIterator<K,V> slice(java.lang.Object[] btree,
                                                                 java.util.Comparator<? super K> comparator,
                                                                 K start,
                                                                 K end,
                                                                 BTree.Dir dir)

Parameters:
  `btree` - the tree to iterate over
  `comparator` - the comparator that defines the ordering over the items in the tree
  `start` - the beginning of the range to return, inclusive (in ascending order)
  `end` - the end of the range to return, exclusive (in ascending order)
  `dir` - if false, the iterator will start at the last item and move backwards
Returns:
  an Iterator over the defined sub-range of the tree

#### slice

    public static <K,V extends K> BTreeSearchIterator<K,V> slice(java.lang.Object[] btree,
                                                                 java.util.Comparator<? super K> comparator,
                                                                 K start,
                                                                 boolean startInclusive,
                                                                 K end,
                                                                 boolean endInclusive,
                                                                 BTree.Dir dir)

Parameters:
  `btree` - the tree to iterate over
  `comparator` - the comparator that defines the ordering over the items in the tree
  `start` - low bound of the range
  `startInclusive` - inclusivity of lower bound
  `end` - high bound of the range
  `endInclusive` - inclusivity of higher bound
  `dir` - direction of iteration
Returns:
  an Iterator over the defined sub-range of the tree

#### find

    public static <V> V find(java.lang.Object[] node,
                             java.util.Comparator<? super V> comparator,
                             V find)

Returns:
  the item in the tree that sorts as equal to the search argument, or null if no such item

#### replaceInSitu

    public static <V> void replaceInSitu(java.lang.Object[] tree,
                                         int index,
                                         V replace)

Modifies the provided btree directly. THIS SHOULD NOT BE USED WITHOUT EXTREME CARE as BTrees are meant to be immutable. Finds and replaces the item provided by index in the tree.

#### replaceInSitu

    public static <V> void replaceInSitu(java.lang.Object[] node,
                                         java.util.Comparator<? super V> comparator,
                                         V find,
                                         V replace)

Modifies the provided btree directly. THIS SHOULD NOT BE USED WITHOUT EXTREME CARE as BTrees are meant to be immutable. Finds and replaces the provided item in the tree. Both should sort as equal to each other (although this is not enforced)

#### findIndex

    public static <V> int findIndex(java.lang.Object[] node,
                                    java.util.Comparator<? super V> comparator,
                                    V find)

Honours result semantics of `Arrays.binarySearch(long[], long)`, as though it were performed on the tree flattened into an array

Returns:
  index of item in tree, or `(-(insertion point) - 1)` if not present

#### findByIndex

    public static <V> V findByIndex(java.lang.Object[] tree,
                                    int index)

Returns:
  the value at the index'th position in the tree, in tree order

#### lowerIndex

    public static <V> int lowerIndex(java.lang.Object[] btree,
                                     java.util.Comparator<? super V> comparator,
                                     V find)

#### lower

    public static <V> V lower(java.lang.Object[] btree,
                              java.util.Comparator<? super V> comparator,
                              V find)

#### floorIndex

    public static <V> int floorIndex(java.lang.Object[] btree,
                                     java.util.Comparator<? super V> comparator,
                                     V find)

#### floor

    public static <V> V floor(java.lang.Object[] btree,
                              java.util.Comparator<? super V> comparator,
                              V find)

#### higherIndex

    public static <V> int higherIndex(java.lang.Object[] btree,
                                      java.util.Comparator<? super V> comparator,
                                      V find)

#### higher

    public static <V> V higher(java.lang.Object[] btree,
                               java.util.Comparator<? super V> comparator,
                               V find)

#### ceilIndex

    public static <V> int ceilIndex(java.lang.Object[] btree,
                                    java.util.Comparator<? super V> comparator,
                                    V find)

#### ceil

    public static <V> V ceil(java.lang.Object[] btree,
                             java.util.Comparator<? super V> comparator,
                             V find)

#### size

    public static int size(java.lang.Object[] tree)

#### sizeOfStructureOnHeap

    public static long sizeOfStructureOnHeap(java.lang.Object[] tree)

#### isEmpty

    public static boolean isEmpty(java.lang.Object[] tree)

#### depth

    public static int depth(java.lang.Object[] tree)

#### toArray

    public static int toArray(java.lang.Object[] tree,
                              java.lang.Object[] target,
                              int targetOffset)

Fill the target array with the contents of the provided subtree, in ascending order, starting at targetOffset

Parameters:
  `tree` - source
  `target` - array
  `targetOffset` - offset in target array
Returns:
  number of items copied (size of tree)

#### toArray

    public static int toArray(java.lang.Object[] tree,
                              int treeStart,
                              int treeEnd,
                              java.lang.Object[] target,
                              int targetOffset)

#### transformAndFilter

    public static <V> java.lang.Object[] transformAndFilter(java.lang.Object[] btree,
                                                            com.google.common.base.Function<? super V,? extends V> function)

Takes a btree and transforms it using the provided function, filtering out any null results. The result of any transformation must sort identically wrt the other results as their originals

#### equals

    public static boolean equals(java.lang.Object[] a,
                                 java.lang.Object[] b)

#### hashCode

    public static int hashCode(java.lang.Object[] btree)

#### treeIndexOfKey

    public static int treeIndexOfKey(java.lang.Object[] root,
                                     int keyIndex)

tree index => index of key wrt all items in the tree laid out serially This version of the method permits requesting out-of-bounds indexes, -1 and size

Parameters:
  `root` - to calculate tree index within
  `keyIndex` - root-local index of key to calculate tree-index
Returns:
  the number of items preceding the key in the whole tree of root

#### treeIndexOfLeafKey

    public static int treeIndexOfLeafKey(int keyIndex)

Parameters:
  `keyIndex` - node-local index of the key to calculate index of
Returns:
  keyIndex; this method is here only for symmetry and clarity

#### treeIndexOfBranchKey

    public static int treeIndexOfBranchKey(java.lang.Object[] root,
                                           int keyIndex)

Parameters:
  `root` - to calculate tree-index within
  `keyIndex` - root-local index of key to calculate tree-index of
Returns:
  the number of items preceding the key in the whole tree of root

#### treeIndexOffsetOfChild

    public static int treeIndexOffsetOfChild(java.lang.Object[] root,
                                             int childIndex)

Parameters:
  `root` - to calculate tree-index within
  `childIndex` - root-local index of *child* to calculate tree-index of
Returns:
  the number of items preceding the child in the whole tree of root

#### builder

    public static <V> BTree.Builder<V> builder(java.util.Comparator<? super V> comparator)

#### builder

    public static <V> BTree.Builder<V> builder(java.util.Comparator<? super V> comparator,
                                               int initialCapacity)

#### isWellFormed

    public static boolean isWellFormed(java.lang.Object[] btree,
                                       java.util.Comparator<? extends java.lang.Object> cmp)

#### apply

    public static <V> void apply(java.lang.Object[] btree,
                                 java.util.function.Consumer<V> function,
                                 boolean reversed)

Simple method to walk the btree forwards or reversed and apply a function to each element Public method

#### apply

    public static <V> void apply(java.lang.Object[] btree,
                                 java.util.function.Consumer<V> function,
                                 com.google.common.base.Predicate<V> stopCondition,
                                 boolean reversed)

Simple method to walk the btree forwards or reversed and apply a function till a stop condition is reached Public method