BTreeMap

java.lang.Object
- java.util.AbstractMap<K,V>
- - org.mapdb.BTreeMap<K,V>

All Implemented Interfaces:

java.util.concurrent.ConcurrentMap<K,V>, java.util.concurrent.ConcurrentNavigableMap<K,V>, java.util.Map<K,V>, java.util.NavigableMap<K,V>, java.util.SortedMap<K,V>, Bind.MapWithModificationListener<K,V>
```
public class BTreeMap<K,V>
extends java.util.AbstractMap<K,V>
implements java.util.concurrent.ConcurrentNavigableMap<K,V>, Bind.MapWithModificationListener<K,V>
```
A scalable concurrent ConcurrentNavigableMap implementation. The map is sorted according to the natural ordering of its keys, or by a Comparator provided at map creation time. Insertion, removal, update, and access operations safely execute concurrently by multiple threads. Iterators are weakly consistent, returning elements reflecting the state of the map at some point at or since the creation of the iterator. They do not throw ConcurrentModificationException, and may proceed concurrently with other operations. Ascending key ordered views and their iterators are faster than descending ones. It is possible to obtain consistent iterator by using snapshot() method. All Map.Entry pairs returned by methods in this class and its views represent snapshots of mappings at the time they were produced. They do not support the Entry.setValue method. (Note however that it is possible to change mappings in the associated map using put, putIfAbsent, or replace, depending on exactly which effect you need.) This collection has optional size counter. If this is enabled Map size is kept in Atomic.Long variable. Keeping counter brings considerable overhead on inserts and removals. If the size counter is not enabled the size method is not a constant-time operation. Determining the current number of elements requires a traversal of the elements. Additionally, the bulk operations putAll, equals, and clear are not guaranteed to be performed atomically. For example, an iterator operating concurrently with a putAll operation might view only some of the added elements. NOTE: there is an optional This class and its views and iterators implement all of the optional methods of the Map and Iterator interfaces. Like most other concurrent collections, this class does not permit the use of null keys or values because some null return values cannot be reliably distinguished from the absence of elements. Theoretical design of BTreeMap is based on paper from Philip L. Lehman and S. Bing Yao. More practical aspects of BTreeMap implementation are based on notes and demo application from Thomas Dinsdale-Young. B-Linked-Tree used here does not require locking for read. Updates and inserts locks only one, two or three nodes. This B-Linked-Tree structure does not support removal well, entry deletion does not collapse tree nodes. Massive deletion causes empty nodes and performance lost. There is workaround in form of compaction process, but it is not implemented yet.

Author:

Jan Kotek, some parts by Doug Lea and JSR-166 group

Nested Class Summary

Nested Classes
Modifier and Type	Class and Description
`protected static interface`	`BTreeMap.BNode` common interface for BTree node
`(package private) static class`	`BTreeMap.BTreeEntryIterator<K,V>`
`protected static class`	`BTreeMap.BTreeIterator`
`(package private) static class`	`BTreeMap.BTreeKeyIterator<K>`
`(package private) static class`	`BTreeMap.BTreeValueIterator<V>`
`protected static class`	`BTreeMap.DescendingMap<K,V>`
`protected static class`	`BTreeMap.DirNode`
`(package private) static class`	`BTreeMap.EntrySet<K1,V1>`
`static class`	`BTreeMap.KeySet<E>`
`protected static class`	`BTreeMap.LeafNode`
`protected static class`	`BTreeMap.NodeSerializer<A,B>`
`protected static class`	`BTreeMap.SubMap<K,V>`
`protected static class`	`BTreeMap.ValRef` if `valsOutsideNodes` is true, this class is used instead of values.
`(package private) static class`	`BTreeMap.Values<E>`

Nested classes/interfaces inherited from class java.util.AbstractMap
java.util.AbstractMap.SimpleEntry<K,V>, java.util.AbstractMap.SimpleImmutableEntry<K,V>

Nested classes/interfaces inherited from interface java.util.Map
java.util.Map.Entry<K,V>

Field Summary

Fields
Modifier and Type	Field and Description
`protected static int`	`B_TREE_NODE_DIR_C`
`protected static int`	`B_TREE_NODE_DIR_L`
`protected static int`	`B_TREE_NODE_DIR_LR`
`protected static int`	`B_TREE_NODE_DIR_R`
`protected static int`	`B_TREE_NODE_LEAF_C`
`protected static int`	`B_TREE_NODE_LEAF_L`
`protected static int`	`B_TREE_NODE_LEAF_LR`
`protected static int`	`B_TREE_NODE_LEAF_R`
`static java.util.Comparator`	`COMPARABLE_COMPARATOR`
`protected java.util.Comparator`	`comparator` keys are sorted by this
`protected Atomic.Long`	`counter`
`private java.util.concurrent.ConcurrentNavigableMap<K,V>`	`descendingMap`
`protected static java.lang.Object`	`EMPTY`
`protected Engine`	`engine` DB Engine in which entries are persisted
`private BTreeMap.EntrySet`	`entrySet`
`protected boolean`	`hasValues` is this a Map or Set? if false, entries do not have values, only keys are allowed
`protected BTreeKeySerializer`	`keySerializer` Serializer used to convert keys from/into binary form.
`private BTreeMap.KeySet`	`keySet`
`protected java.util.List<java.lang.Long>`	`leftEdges`
`protected int`	`maxNodeSize` maximal node size allowed in this BTree
`protected Bind.MapListener<K,V>[]`	`modListeners`
`protected java.lang.Object`	`modListenersLock`
`protected LongConcurrentHashMap<java.lang.Long>`	`nodeLocks` holds node level locks
`protected Serializer<BTreeMap.BNode>`	`nodeSerializer`
`protected int`	`numberOfNodeMetas`
`protected long`	`rootRecidRef` recid under which reference to rootRecid is stored
`protected boolean`	`valsOutsideNodes` store values as part of BTree nodes
`private BTreeMap.Values`	`values`
`protected Serializer<V>`	`valueSerializer` Serializer used to convert keys from/into binary form

Constructor Summary

Constructors
Constructor and Description
`BTreeMap(Engine engine, long rootRecidRef, int maxNodeSize, boolean valsOutsideNodes, long counterRecid, BTreeKeySerializer<K> keySerializer, Serializer<V> valueSerializer, java.util.Comparator<K> comparator, int numberOfNodeMetas, boolean disableLocks)` Constructor used to create new BTreeMap.

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`protected static long[]`	`arrayLongPut(long[] array, int pos, long value)`
`protected static java.lang.Object[]`	`arrayPut(java.lang.Object[] array, int pos, java.lang.Object value)` expand array size by 1, and put value at given position.
`protected static void`	`assertNoLocks(LongConcurrentHashMap<java.lang.Long> locks)`
`java.util.Map.Entry<K,V>`	`ceilingEntry(K key)`
`K`	`ceilingKey(K key)`
`void`	`clear()`
`void`	`close()` Closes underlying storage and releases all resources.
`java.util.Comparator<? super K>`	`comparator()`
`boolean`	`containsKey(java.lang.Object key)`
`boolean`	`containsValue(java.lang.Object value)`
`protected static long`	`createRootRef(Engine engine, BTreeKeySerializer keySer, Serializer valueSer, java.util.Comparator comparator, int numberOfNodeMetas)` creates empty root node and returns recid of its reference
`java.util.NavigableSet<K>`	`descendingKeySet()`
`java.util.concurrent.ConcurrentNavigableMap<K,V>`	`descendingMap()`
`(package private) java.util.Iterator<java.util.Map.Entry<K,V>>`	`entryIterator()`
`java.util.Set<java.util.Map.Entry<K,V>>`	`entrySet()`
`protected int`	`findChildren(java.lang.Object key, java.lang.Object[] keys)` Find the first children node with a key equal or greater than the given key.
`protected java.util.Map.Entry<K,V>`	`findLarger(K key, boolean inclusive)`
`protected Fun.Tuple2<java.lang.Integer,BTreeMap.LeafNode>`	`findLargerNode(K key, boolean inclusive)`
`protected java.util.Map.Entry<K,V>`	`findSmaller(K key, boolean inclusive)`
`private java.util.Map.Entry<K,V>`	`findSmallerRecur(BTreeMap.BNode n, K key, boolean inclusive)`
`java.util.Map.Entry<K,V>`	`firstEntry()`
`K`	`firstKey()`
`java.util.Map.Entry<K,V>`	`floorEntry(K key)`
`K`	`floorKey(K key)`
`V`	`get(java.lang.Object key)`
`protected java.lang.Object`	`get(java.lang.Object key, boolean expandValue)`
`Engine`	`getEngine()`
`java.util.concurrent.ConcurrentNavigableMap<K,V>`	`headMap(K toKey)`
`java.util.concurrent.ConcurrentNavigableMap<K,V>`	`headMap(K toKey, boolean inclusive)`
`java.util.Map.Entry<K,V>`	`higherEntry(K key)`
`K`	`higherKey(K key)`
`boolean`	`isEmpty()`
`(package private) java.util.Iterator<K>`	`keyIterator()`
`java.util.NavigableSet<K>`	`keySet()`
`java.util.Map.Entry<K,V>`	`lastEntry()`
`private java.util.Map.Entry<K,V>`	`lastEntryRecur(BTreeMap.BNode n)`
`K`	`lastKey()`
`protected static void`	`lock(LongConcurrentHashMap<java.lang.Long> locks, long recid)`
`java.util.Map.Entry<K,V>`	`lowerEntry(K key)`
`K`	`lowerKey(K key)`
`protected java.util.Map.Entry<K,V>`	`makeEntry(java.lang.Object key, java.lang.Object value)`
`void`	`modificationListenerAdd(Bind.MapListener<K,V> listener)` Add new modification listener notified when Map has been updated
`void`	`modificationListenerRemove(Bind.MapListener<K,V> listener)` Remove registered notification listener
`java.util.NavigableSet<K>`	`navigableKeySet()`
`protected long`	`nextDir(BTreeMap.DirNode d, java.lang.Object key)`
`protected void`	`notify(K key, V oldValue, V newValue)`
`java.util.Map.Entry<K,V>`	`pollFirstEntry()`
`java.util.Map.Entry<K,V>`	`pollLastEntry()`
`protected static java.util.SortedMap<java.lang.String,java.lang.Object>`	`preinitCatalog(DB db)` hack used for DB Catalog
`private static void`	`printRecur(BTreeMap m, long recid, java.lang.String s)`
`void`	`printTreeStructure()`
`V`	`put(K key, V value)`
`protected V`	`put2(K key, V value2, boolean putOnlyIfAbsent)`
`V`	`putIfAbsent(K key, V value)`
`V`	`remove(java.lang.Object key)`
`boolean`	`remove(java.lang.Object key, java.lang.Object value)`
`private V`	`remove2(java.lang.Object key, java.lang.Object value)`
`V`	`replace(K key, V value)`
`boolean`	`replace(K key, V oldValue, V newValue)`
`int`	`size()`
`long`	`sizeLong()`
`java.util.NavigableMap<K,V>`	`snapshot()` Make readonly snapshot view of current Map.
`java.util.concurrent.ConcurrentNavigableMap<K,V>`	`subMap(K fromKey, boolean fromInclusive, K toKey, boolean toInclusive)`
`java.util.concurrent.ConcurrentNavigableMap<K,V>`	`subMap(K fromKey, K toKey)`
`java.util.concurrent.ConcurrentNavigableMap<K,V>`	`tailMap(K fromKey)`
`java.util.concurrent.ConcurrentNavigableMap<K,V>`	`tailMap(K fromKey, boolean inclusive)`
`(package private) static <E> java.util.List<E>`	`toList(java.util.Collection<E> c)`
`protected static void`	`unlock(LongConcurrentHashMap<java.lang.Long> locks, long recid)`
`protected static void`	`unlockAll(LongConcurrentHashMap<java.lang.Long> locks)`
`protected V`	`valExpand(java.lang.Object ret)`
`(package private) java.util.Iterator<V>`	`valueIterator()`
`java.util.Collection<V>`	`values()`

Methods inherited from class java.util.AbstractMap
clone, equals, hashCode, putAll, toString

Methods inherited from class java.lang.Object
finalize, getClass, notify, notifyAll, wait, wait, wait

Methods inherited from interface java.util.concurrent.ConcurrentMap
compute, computeIfAbsent, computeIfPresent, forEach, getOrDefault, merge, replaceAll

Methods inherited from interface java.util.Map
equals, hashCode, putAll

- Field Detail
  - COMPARABLE_COMPARATOR
```
public static final java.util.Comparator COMPARABLE_COMPARATOR
```
  - EMPTY
```
protected static final java.lang.Object EMPTY
```
  - B_TREE_NODE_LEAF_LR
```
protected static final int B_TREE_NODE_LEAF_LR
```
    See Also:
    
    Constant Field Values
  - B_TREE_NODE_LEAF_L
```
protected static final int B_TREE_NODE_LEAF_L
```
    See Also:
    
    Constant Field Values
  - B_TREE_NODE_LEAF_R
```
protected static final int B_TREE_NODE_LEAF_R
```
    See Also:
    
    Constant Field Values
  - B_TREE_NODE_LEAF_C
```
protected static final int B_TREE_NODE_LEAF_C
```
    See Also:
    
    Constant Field Values
  - B_TREE_NODE_DIR_LR
```
protected static final int B_TREE_NODE_DIR_LR
```
    See Also:
    
    Constant Field Values
  - B_TREE_NODE_DIR_L
```
protected static final int B_TREE_NODE_DIR_L
```
    See Also:
    
    Constant Field Values
  - B_TREE_NODE_DIR_R
```
protected static final int B_TREE_NODE_DIR_R
```
    See Also:
    
    Constant Field Values
  - B_TREE_NODE_DIR_C
```
protected static final int B_TREE_NODE_DIR_C
```
    See Also:
    
    Constant Field Values
  - rootRecidRef
```
protected final long rootRecidRef
```
    recid under which reference to rootRecid is stored
  - keySerializer
```
protected final BTreeKeySerializer keySerializer
```
    Serializer used to convert keys from/into binary form.
  - valueSerializer
```
protected final Serializer<V> valueSerializer
```
    Serializer used to convert keys from/into binary form
  - comparator
```
protected final java.util.Comparator comparator
```
    keys are sorted by this
  - nodeLocks
```
protected final LongConcurrentHashMap<java.lang.Long> nodeLocks
```
    holds node level locks
  - maxNodeSize
```
protected final int maxNodeSize
```
    maximal node size allowed in this BTree
  - engine
```
protected final Engine engine
```
    DB Engine in which entries are persisted
  - hasValues
```
protected final boolean hasValues
```
    is this a Map or Set? if false, entries do not have values, only keys are allowed
  - valsOutsideNodes
```
protected final boolean valsOutsideNodes
```
    store values as part of BTree nodes
  - leftEdges
```
protected final java.util.List<java.lang.Long> leftEdges
```
  - keySet
```
private final BTreeMap.KeySet keySet
```
  - entrySet
```
private final BTreeMap.EntrySet entrySet
```
  - values
```
private final BTreeMap.Values values
```
  - descendingMap
```
private final java.util.concurrent.ConcurrentNavigableMap<K,V> descendingMap
```
  - counter
```
protected final Atomic.Long counter
```
  - numberOfNodeMetas
```
protected final int numberOfNodeMetas
```
  - nodeSerializer
```
protected final Serializer<BTreeMap.BNode> nodeSerializer
```
  - modListenersLock
```
protected final java.lang.Object modListenersLock
```
  - modListeners
```
protected Bind.MapListener<K,V>[] modListeners
```
- Constructor Detail
  - BTreeMap
```
public BTreeMap(Engine engine,
                long rootRecidRef,
                int maxNodeSize,
                boolean valsOutsideNodes,
                long counterRecid,
                BTreeKeySerializer<K> keySerializer,
                Serializer<V> valueSerializer,
                java.util.Comparator<K> comparator,
                int numberOfNodeMetas,
                boolean disableLocks)
```
    Constructor used to create new BTreeMap.
    
    Parameters:
    
    engine - used for persistence
    
    rootRecidRef - reference to root recid
    
    maxNodeSize - maximal BTree Node size. Node will split if number of entries is higher
    
    valsOutsideNodes - Store Values outside of BTree Nodes in separate record?
    
    counterRecid - recid under which `Atomic.Long` is stored, or `0` for no counter
    
    keySerializer - Serializer used for keys. May be null for default value.
    
    valueSerializer - Serializer used for values. May be null for default value
    
    comparator - Comparator to sort keys in this BTree, may be null.
    
    numberOfNodeMetas - number of meta records associated with each BTree node
    
    disableLocks - makes class thread-unsafe but bit faster
- Method Detail
  - preinitCatalog
```
protected static java.util.SortedMap<java.lang.String,java.lang.Object> preinitCatalog(DB db)
```
    hack used for DB Catalog
  - createRootRef
```
protected static long createRootRef(Engine engine,
                                    BTreeKeySerializer keySer,
                                    Serializer valueSer,
                                    java.util.Comparator comparator,
                                    int numberOfNodeMetas)
```
    creates empty root node and returns recid of its reference
  - findChildren
```
protected final int findChildren(java.lang.Object key,
                                 java.lang.Object[] keys)
```
    Find the first children node with a key equal or greater than the given key. If all items are smaller it returns `keys.length`
  - get
```
public V get(java.lang.Object key)
```
    Specified by:
    
    get in interface java.util.Map<K,V>
    
    Overrides:
    
    get in class java.util.AbstractMap<K,V>
  - get
```
protected java.lang.Object get(java.lang.Object key,
                               boolean expandValue)
```
  - valExpand
```
protected V valExpand(java.lang.Object ret)
```
  - nextDir
```
protected long nextDir(BTreeMap.DirNode d,
                       java.lang.Object key)
```
  - put
```
public V put(K key,
             V value)
```
    Specified by:
    
    put in interface java.util.Map<K,V>
    
    Overrides:
    
    put in class java.util.AbstractMap<K,V>
  - put2
```
protected V put2(K key,
                 V value2,
                 boolean putOnlyIfAbsent)
```
  - remove
```
public V remove(java.lang.Object key)
```
    Specified by:
    
    remove in interface java.util.Map<K,V>
    
    Overrides:
    
    remove in class java.util.AbstractMap<K,V>
  - remove2
```
private V remove2(java.lang.Object key,
                  java.lang.Object value)
```
  - clear
```
public void clear()
```
    Specified by:
    
    clear in interface java.util.Map<K,V>
    
    Overrides:
    
    clear in class java.util.AbstractMap<K,V>
  - makeEntry
```
protected java.util.Map.Entry<K,V> makeEntry(java.lang.Object key,
                                             java.lang.Object value)
```
  - isEmpty
```
public boolean isEmpty()
```
    Specified by:
    
    isEmpty in interface java.util.Map<K,V>
    
    Overrides:
    
    isEmpty in class java.util.AbstractMap<K,V>
  - size
```
public int size()
```
    Specified by:
    
    size in interface java.util.Map<K,V>
    
    Overrides:
    
    size in class java.util.AbstractMap<K,V>
  - sizeLong
```
public long sizeLong()
```
    Specified by:
    
    sizeLong in interface Bind.MapWithModificationListener<K,V>
    
    Returns:
    
    size of map, but in 64bit long which does not overflow at 2e9 items.
  - putIfAbsent
```
public V putIfAbsent(K key,
                     V value)
```
    Specified by:
    
    putIfAbsent in interface java.util.concurrent.ConcurrentMap<K,V>
    
    Specified by:
    
    putIfAbsent in interface java.util.Map<K,V>
  - remove
```
public boolean remove(java.lang.Object key,
                      java.lang.Object value)
```
    Specified by:
    
    remove in interface java.util.concurrent.ConcurrentMap<K,V>
    
    Specified by:
    
    remove in interface java.util.Map<K,V>
  - replace
```
public boolean replace(K key,
                       V oldValue,
                       V newValue)
```
    Specified by:
    
    replace in interface java.util.concurrent.ConcurrentMap<K,V>
    
    Specified by:
    
    replace in interface java.util.Map<K,V>
  - replace
```
public V replace(K key,
                 V value)
```
    Specified by:
    
    replace in interface java.util.concurrent.ConcurrentMap<K,V>
    
    Specified by:
    
    replace in interface java.util.Map<K,V>
  - comparator
```
public java.util.Comparator<? super K> comparator()
```
    Specified by:
    
    comparator in interface java.util.SortedMap<K,V>
  - firstEntry
```
public java.util.Map.Entry<K,V> firstEntry()
```
    Specified by:
    
    firstEntry in interface java.util.NavigableMap<K,V>
  - pollFirstEntry
```
public java.util.Map.Entry<K,V> pollFirstEntry()
```
    Specified by:
    
    pollFirstEntry in interface java.util.NavigableMap<K,V>
  - pollLastEntry
```
public java.util.Map.Entry<K,V> pollLastEntry()
```
    Specified by:
    
    pollLastEntry in interface java.util.NavigableMap<K,V>
  - findSmaller
```
protected java.util.Map.Entry<K,V> findSmaller(K key,
                                               boolean inclusive)
```
  - findSmallerRecur
```
private java.util.Map.Entry<K,V> findSmallerRecur(BTreeMap.BNode n,
                                                  K key,
                                                  boolean inclusive)
```
  - lastEntry
```
public java.util.Map.Entry<K,V> lastEntry()
```
    Specified by:
    
    lastEntry in interface java.util.NavigableMap<K,V>
  - lastEntryRecur
```
private java.util.Map.Entry<K,V> lastEntryRecur(BTreeMap.BNode n)
```
  - lowerEntry
```
public java.util.Map.Entry<K,V> lowerEntry(K key)
```
    Specified by:
    
    lowerEntry in interface java.util.NavigableMap<K,V>
  - lowerKey
```
public K lowerKey(K key)
```
    Specified by:
    
    lowerKey in interface java.util.NavigableMap<K,V>
  - floorEntry
```
public java.util.Map.Entry<K,V> floorEntry(K key)
```
    Specified by:
    
    floorEntry in interface java.util.NavigableMap<K,V>
  - floorKey
```
public K floorKey(K key)
```
    Specified by:
    
    floorKey in interface java.util.NavigableMap<K,V>
  - ceilingEntry
```
public java.util.Map.Entry<K,V> ceilingEntry(K key)
```
    Specified by:
    
    ceilingEntry in interface java.util.NavigableMap<K,V>
  - findLarger
```
protected java.util.Map.Entry<K,V> findLarger(K key,
                                              boolean inclusive)
```
  - findLargerNode
```
protected Fun.Tuple2<java.lang.Integer,BTreeMap.LeafNode> findLargerNode(K key,
                                                                         boolean inclusive)
```
  - ceilingKey
```
public K ceilingKey(K key)
```
    Specified by:
    
    ceilingKey in interface java.util.NavigableMap<K,V>
  - higherEntry
```
public java.util.Map.Entry<K,V> higherEntry(K key)
```
    Specified by:
    
    higherEntry in interface java.util.NavigableMap<K,V>
  - higherKey
```
public K higherKey(K key)
```
    Specified by:
    
    higherKey in interface java.util.NavigableMap<K,V>
  - containsKey
```
public boolean containsKey(java.lang.Object key)
```
    Specified by:
    
    containsKey in interface java.util.Map<K,V>
    
    Overrides:
    
    containsKey in class java.util.AbstractMap<K,V>
  - containsValue
```
public boolean containsValue(java.lang.Object value)
```
    Specified by:
    
    containsValue in interface java.util.Map<K,V>
    
    Overrides:
    
    containsValue in class java.util.AbstractMap<K,V>
  - firstKey
```
public K firstKey()
```
    Specified by:
    
    firstKey in interface java.util.SortedMap<K,V>
  - lastKey
```
public K lastKey()
```
    Specified by:
    
    lastKey in interface java.util.SortedMap<K,V>
  - subMap
```
public java.util.concurrent.ConcurrentNavigableMap<K,V> subMap(K fromKey,
                                                               boolean fromInclusive,
                                                               K toKey,
                                                               boolean toInclusive)
```
    Specified by:
    
    subMap in interface java.util.concurrent.ConcurrentNavigableMap<K,V>
    
    Specified by:
    
    subMap in interface java.util.NavigableMap<K,V>
  - headMap
```
public java.util.concurrent.ConcurrentNavigableMap<K,V> headMap(K toKey,
                                                                boolean inclusive)
```
    Specified by:
    
    headMap in interface java.util.concurrent.ConcurrentNavigableMap<K,V>
    
    Specified by:
    
    headMap in interface java.util.NavigableMap<K,V>
  - tailMap
```
public java.util.concurrent.ConcurrentNavigableMap<K,V> tailMap(K fromKey,
                                                                boolean inclusive)
```
    Specified by:
    
    tailMap in interface java.util.concurrent.ConcurrentNavigableMap<K,V>
    
    Specified by:
    
    tailMap in interface java.util.NavigableMap<K,V>
  - subMap
```
public java.util.concurrent.ConcurrentNavigableMap<K,V> subMap(K fromKey,
                                                               K toKey)
```
    Specified by:
    
    subMap in interface java.util.concurrent.ConcurrentNavigableMap<K,V>
    
    Specified by:
    
    subMap in interface java.util.NavigableMap<K,V>
    
    Specified by:
    
    subMap in interface java.util.SortedMap<K,V>
  - headMap
```
public java.util.concurrent.ConcurrentNavigableMap<K,V> headMap(K toKey)
```
    Specified by:
    
    headMap in interface java.util.concurrent.ConcurrentNavigableMap<K,V>
    
    Specified by:
    
    headMap in interface java.util.NavigableMap<K,V>
    
    Specified by:
    
    headMap in interface java.util.SortedMap<K,V>
  - tailMap
```
public java.util.concurrent.ConcurrentNavigableMap<K,V> tailMap(K fromKey)
```
    Specified by:
    
    tailMap in interface java.util.concurrent.ConcurrentNavigableMap<K,V>
    
    Specified by:
    
    tailMap in interface java.util.NavigableMap<K,V>
    
    Specified by:
    
    tailMap in interface java.util.SortedMap<K,V>
  - keyIterator
```
java.util.Iterator<K> keyIterator()
```
  - valueIterator
```
java.util.Iterator<V> valueIterator()
```
  - entryIterator
```
java.util.Iterator<java.util.Map.Entry<K,V>> entryIterator()
```
  - keySet
```
public java.util.NavigableSet<K> keySet()
```
    Specified by:
    
    keySet in interface java.util.concurrent.ConcurrentNavigableMap<K,V>
    
    Specified by:
    
    keySet in interface java.util.Map<K,V>
    
    Specified by:
    
    keySet in interface java.util.SortedMap<K,V>
    
    Overrides:
    
    keySet in class java.util.AbstractMap<K,V>
  - navigableKeySet
```
public java.util.NavigableSet<K> navigableKeySet()
```
    Specified by:
    
    navigableKeySet in interface java.util.concurrent.ConcurrentNavigableMap<K,V>
    
    Specified by:
    
    navigableKeySet in interface java.util.NavigableMap<K,V>
  - values
```
public java.util.Collection<V> values()
```
    Specified by:
    
    values in interface java.util.Map<K,V>
    
    Specified by:
    
    values in interface java.util.SortedMap<K,V>
    
    Overrides:
    
    values in class java.util.AbstractMap<K,V>
  - entrySet
```
public java.util.Set<java.util.Map.Entry<K,V>> entrySet()
```
    Specified by:
    
    entrySet in interface java.util.Map<K,V>
    
    Specified by:
    
    entrySet in interface java.util.SortedMap<K,V>
    
    Specified by:
    
    entrySet in class java.util.AbstractMap<K,V>
  - descendingMap
```
public java.util.concurrent.ConcurrentNavigableMap<K,V> descendingMap()
```
    Specified by:
    
    descendingMap in interface java.util.concurrent.ConcurrentNavigableMap<K,V>
    
    Specified by:
    
    descendingMap in interface java.util.NavigableMap<K,V>
  - descendingKeySet
```
public java.util.NavigableSet<K> descendingKeySet()
```
    Specified by:
    
    descendingKeySet in interface java.util.concurrent.ConcurrentNavigableMap<K,V>
    
    Specified by:
    
    descendingKeySet in interface java.util.NavigableMap<K,V>
  - toList
```
static <E> java.util.List<E> toList(java.util.Collection<E> c)
```
  - snapshot
```
public java.util.NavigableMap<K,V> snapshot()
```
    Make readonly snapshot view of current Map. Snapshot is immutable and not affected by modifications made by other threads. Useful if you need consistent view on Map. Maintaining snapshot have some overhead, underlying Engine is closed after Map view is GCed. Please make sure to release reference to this Map view, so snapshot view can be garbage collected.
    
    Returns:
    
    snapshot
  - modificationListenerAdd
```
public void modificationListenerAdd(Bind.MapListener<K,V> listener)
```
    Description copied from interface: Bind.MapWithModificationListener
    
    Add new modification listener notified when Map has been updated
    
    Specified by:
    
    modificationListenerAdd in interface Bind.MapWithModificationListener<K,V>
    
    Parameters:
    
    listener - callback interface notified when map changes
  - modificationListenerRemove
```
public void modificationListenerRemove(Bind.MapListener<K,V> listener)
```
    Description copied from interface: Bind.MapWithModificationListener
    
    Remove registered notification listener
    
    Specified by:
    
    modificationListenerRemove in interface Bind.MapWithModificationListener<K,V>
    
    Parameters:
    
    listener - callback interface notified when map changes
  - notify
```
protected void notify(K key,
                      V oldValue,
                      V newValue)
```
  - close
```
public void close()
```
    Closes underlying storage and releases all resources. Used mostly with temporary collections where engine is not accessible.
  - getEngine
```
public Engine getEngine()
```
  - printTreeStructure
```
public void printTreeStructure()
```
  - printRecur
```
private static void printRecur(BTreeMap m,
                               long recid,
                               java.lang.String s)
```
  - arrayLongPut
```
protected static long[] arrayLongPut(long[] array,
                                     int pos,
                                     long value)
```
  - arrayPut
```
protected static java.lang.Object[] arrayPut(java.lang.Object[] array,
                                             int pos,
                                             java.lang.Object value)
```
    expand array size by 1, and put value at given position. No items from original array are lost
  - assertNoLocks
```
protected static void assertNoLocks(LongConcurrentHashMap<java.lang.Long> locks)
```
  - unlock
```
protected static void unlock(LongConcurrentHashMap<java.lang.Long> locks,
                             long recid)
```
  - unlockAll
```
protected static void unlockAll(LongConcurrentHashMap<java.lang.Long> locks)
```
  - lock
```
protected static void lock(LongConcurrentHashMap<java.lang.Long> locks,
                           long recid)
```

Class BTreeMap<K,V>

Nested Class Summary

Nested classes/interfaces inherited from class java.util.AbstractMap

Nested classes/interfaces inherited from interface java.util.Map

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.util.AbstractMap

Methods inherited from class java.lang.Object

Methods inherited from interface java.util.concurrent.ConcurrentMap

Methods inherited from interface java.util.Map

Field Detail

COMPARABLE_COMPARATOR

EMPTY

B_TREE_NODE_LEAF_LR

B_TREE_NODE_LEAF_L

B_TREE_NODE_LEAF_R

B_TREE_NODE_LEAF_C

B_TREE_NODE_DIR_LR

B_TREE_NODE_DIR_L

B_TREE_NODE_DIR_R

B_TREE_NODE_DIR_C

rootRecidRef

keySerializer

valueSerializer

comparator

nodeLocks

maxNodeSize

engine

hasValues

valsOutsideNodes

leftEdges

keySet

entrySet

values

descendingMap

counter

numberOfNodeMetas

nodeSerializer

modListenersLock

modListeners

Constructor Detail

BTreeMap

Method Detail

preinitCatalog

createRootRef

findChildren

get

get

valExpand

nextDir

put

put2

remove

remove2

clear

makeEntry

isEmpty

size

sizeLong

putIfAbsent

remove

replace

replace

comparator

firstEntry

pollFirstEntry

pollLastEntry

findSmaller

findSmallerRecur

lastEntry

lastEntryRecur

lowerEntry

lowerKey

floorEntry

floorKey

ceilingEntry

findLarger

findLargerNode

ceilingKey