org.mapdb

Class SortedTableMap<K,V>

org.mapdb.SortedTableMap<K,V>

All Implemented Interfaces:

BTreeMapJava.ConcurrentNavigableMap2<K,V>, ConcurrentNavigableMapExtra<K,V>, MapExtra<K,V>

public class SortedTableMap<K,V>
implements ConcurrentNavigableMapExtra<K,V>

Read only Sorted Table Map. It stores data in table and uses binary search to find records

Nested Class Summary

Nested Classes

Modifier and Type	Class and Description
static class	SortedTableMap.Companion
static class	SortedTableMap.NodeIterator
static class	SortedTableMap.Sink<K,V>

Field Summary

Fields

Modifier and Type	Field and Description
static SortedTableMap.Companion	Companion

Constructor Summary

Constructors

Constructor and Description
SortedTableMap(GroupSerializer<K> keySerializer, GroupSerializer<V> valueSerializer, long pageSize, Volume volume, boolean hasValues) Read only Sorted Table Map. It stores data in table and uses binary search to find records

Method Summary

Modifier and Type	Method and Description
java.util.Map.Entry<K,V>	ceilingEntry(K key)
K	ceilingKey(K key)
void	clear()
void	close()
java.util.Comparator<? super K>	comparator()
boolean	containsKey(java.lang.Object key)
boolean	containsValue(java.lang.Object value)
java.util.Iterator<java.util.Map.Entry>	descendingEntryIterator()
java.util.Iterator<java.util.Map.Entry>	descendingEntryIterator(K lo, boolean loInclusive, K hi, boolean hiInclusive)
java.util.Iterator<K>	descendingKeyIterator()
java.util.Iterator<K>	descendingKeyIterator(K lo, boolean loInclusive, K hi, boolean hiInclusive)
java.util.NavigableSet<K>	descendingKeySet()
java.util.concurrent.ConcurrentNavigableMap<K,V>	descendingMap()
SortedTableMap.NodeIterator	descendingNodeIterator()
java.util.Iterator<V>	descendingValueIterator()
java.util.Iterator<V>	descendingValueIterator(K lo, boolean loInclusive, K hi, boolean hiInclusive)
java.util.Iterator<java.util.Map.Entry>	entryIterator()
java.util.Iterator<java.util.Map.Entry>	entryIterator(K lo, boolean loInclusive, K hi, boolean hiInclusive)
java.util.Set	entrySet()
boolean	equals(java.lang.Object other)
java.util.Map.Entry<K,V>	findHigher(K key, boolean inclusive)
K	findHigherKey(K key, boolean inclusive)
java.util.Map.Entry<K,V>	findLower(K key, boolean inclusive)
K	findLowerKey(K key, boolean inclusive)
java.util.Map.Entry<K,V>	firstEntry()
K	firstKey()
K	firstKey2()
java.util.Map.Entry<K,V>	floorEntry(K key)
K	floorKey(K key)
void	forEach(java.util.function.BiConsumer<? super K,? super V> action)
void	forEachKey(Function1<? super K,Unit> procedure)
void	forEachValue(Function1<? super V,Unit> procedure)
V	get(java.lang.Object key)
GroupSerializer<K>	getComparator()
java.util.Set<java.util.Map.Entry>	getEntries()
boolean	getHasValues()
GroupSerializer<K>	getKeySerializer()
java.util.NavigableSet<K>	getKeys()
long	getPageCount()
java.lang.Object	getPageKeys() first key at beginning of each page
long	getPageSize()
int	getSize()
long	getSizeLong()
GroupSerializer<V>	getValueSerializer()
java.util.Collection<V>	getValues()
Volume	getVolume()
java.util.concurrent.ConcurrentNavigableMap<K,V>	headMap(K toKey, boolean inclusive)
java.util.concurrent.ConcurrentNavigableMap<K,V>	headMap(K toKey)
java.util.Map.Entry<K,V>	higherEntry(K key)
K	higherKey(K key)
boolean	isClosed()
boolean	isEmpty()
java.util.Iterator<K>	keyIterator()
java.util.Iterator<K>	keyIterator(K lo, boolean loInclusive, K hi, boolean hiInclusive)
java.util.Set	keySet()
java.util.Map.Entry<K,V>	lastEntry()
K	lastKey()
K	lastKey2()
java.util.Map.Entry<K,V>	lowerEntry(K key)
K	lowerKey(K key)
java.util.NavigableSet<K>	navigableKeySet()
SortedTableMap.NodeIterator	nodeIterator()
SortedTableMap.NodeIterator	nodeIterator(K lo)
int	nodeSearch(K key, long offset, long offsetWithHead, int nodeCount)
java.util.Map.Entry<K,V>	pollFirstEntry()
java.util.Map.Entry<K,V>	pollLastEntry()
V	put(K key, V value)
void	putAll(java.util.Map<? extends K,? extends V> from)
V	putIfAbsent(K key, V value)
boolean	putIfAbsentBoolean(K key, V value) Atomically associates the specified key with the given value if it is not already associated with a value.
V	remove(java.lang.Object key)
boolean	remove(java.lang.Object key, java.lang.Object value)
boolean	replace(K key, V oldValue, V newValue)
V	replace(K key, V value)
int	size()
long	sizeLong() map size as long number
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, boolean inclusive)
java.util.concurrent.ConcurrentNavigableMap<K,V>	tailMap(K fromKey)
java.util.Iterator<V>	valueIterator()
java.util.Iterator<V>	valueIterator(K lo, boolean loInclusive, K hi, boolean hiInclusive)
java.util.Collection	values()

Methods inherited from interface org.mapdb.ConcurrentNavigableMapExtra

descendingEntryIterator, descendingEntryIterator, descendingKeyIterator, descendingKeyIterator, descendingValueIterator, descendingValueIterator, entryIterator, findHigher, findHigherKey, findLower, findLowerKey, getHasValues, keyIterator, keyIterator, valueIterator

Methods inherited from interface org.mapdb.MapExtra

forEach, forEachKey, forEachValue, getKeySerializer, getValueSerializer, isClosed, putIfAbsentBoolean, sizeLong

Methods inherited from interface org.mapdb.BTreeMapJava.ConcurrentNavigableMap2

firstKey2, lastKey2

Field Detail

Companion

public static SortedTableMap.Companion Companion

Constructor Detail

SortedTableMap

public SortedTableMap(GroupSerializer<K> keySerializer,
                      GroupSerializer<V> valueSerializer,
                      long pageSize,
                      Volume volume,
                      boolean hasValues)

Read only Sorted Table Map. It stores data in table and uses binary search to find records

Method Detail

getComparator

public GroupSerializer<K> getComparator()

getSizeLong

public long getSizeLong()

getPageCount

public long getPageCount()

getPageKeys

public java.lang.Object getPageKeys()

first key at beginning of each page

containsKey

public boolean containsKey(java.lang.Object key)

containsValue

public boolean containsValue(java.lang.Object value)

get

public V get(java.lang.Object key)

nodeSearch

public int nodeSearch(K key,
                      long offset,
                      long offsetWithHead,
                      int nodeCount)

isEmpty

public boolean isEmpty()

getSize

public int getSize()

size

public int size()

sizeLong

public long sizeLong()

map size as long number

nodeIterator

public SortedTableMap.NodeIterator nodeIterator()

nodeIterator

public SortedTableMap.NodeIterator nodeIterator(K lo)

descendingNodeIterator

public SortedTableMap.NodeIterator descendingNodeIterator()

keyIterator

public java.util.Iterator<K> keyIterator()

entryIterator

public java.util.Iterator<java.util.Map.Entry> entryIterator()

valueIterator

public java.util.Iterator<V> valueIterator()

getEntries

public java.util.Set<java.util.Map.Entry> getEntries()

entrySet

public java.util.Set entrySet()

getKeys

public java.util.NavigableSet<K> getKeys()

keySet

public java.util.Set keySet()

navigableKeySet

public java.util.NavigableSet<K> navigableKeySet()

getValues

public java.util.Collection<V> getValues()

values

public java.util.Collection values()

clear

public void clear()

put

public V put(K key,
             V value)

putAll

public void putAll(java.util.Map<? extends K,? extends V> from)

remove

public V remove(java.lang.Object key)

putIfAbsent

public V putIfAbsent(K key,
                     V value)

remove

public boolean remove(java.lang.Object key,
                      java.lang.Object value)

replace

public boolean replace(K key,
                       V oldValue,
                       V newValue)

replace

public V replace(K key,
                 V value)

equals

public boolean equals(java.lang.Object other)

comparator

public java.util.Comparator<? super K> comparator()

firstKey2

public K firstKey2()

lastKey2

public K lastKey2()

firstKey

public K firstKey()

lastKey

public K lastKey()

ceilingEntry

public java.util.Map.Entry<K,V> ceilingEntry(K key)

ceilingKey

public K ceilingKey(K key)

firstEntry

public java.util.Map.Entry<K,V> firstEntry()

floorEntry

public java.util.Map.Entry<K,V> floorEntry(K key)

floorKey

public K floorKey(K key)

higherEntry

public java.util.Map.Entry<K,V> higherEntry(K key)

higherKey

public K higherKey(K key)

lastEntry

public java.util.Map.Entry<K,V> lastEntry()

lowerEntry

public java.util.Map.Entry<K,V> lowerEntry(K key)

lowerKey

public K lowerKey(K key)

pollFirstEntry

public java.util.Map.Entry<K,V> pollFirstEntry()

pollLastEntry

public java.util.Map.Entry<K,V> pollLastEntry()

subMap

public java.util.concurrent.ConcurrentNavigableMap<K,V> subMap(K fromKey,
                                                               boolean fromInclusive,
                                                               K toKey,
                                                               boolean toInclusive)

headMap

public java.util.concurrent.ConcurrentNavigableMap<K,V> headMap(K toKey,
                                                                boolean inclusive)

tailMap

public java.util.concurrent.ConcurrentNavigableMap<K,V> tailMap(K fromKey,
                                                                boolean inclusive)

subMap

public java.util.concurrent.ConcurrentNavigableMap<K,V> subMap(K fromKey,
                                                               K toKey)

headMap

public java.util.concurrent.ConcurrentNavigableMap<K,V> headMap(K toKey)

tailMap

public java.util.concurrent.ConcurrentNavigableMap<K,V> tailMap(K fromKey)

descendingKeySet

public java.util.NavigableSet<K> descendingKeySet()

descendingMap

public java.util.concurrent.ConcurrentNavigableMap<K,V> descendingMap()

descendingEntryIterator

public java.util.Iterator<java.util.Map.Entry> descendingEntryIterator()

descendingEntryIterator

public java.util.Iterator<java.util.Map.Entry> descendingEntryIterator(K lo,
                                                                       boolean loInclusive,
                                                                       K hi,
                                                                       boolean hiInclusive)

descendingKeyIterator

public java.util.Iterator<K> descendingKeyIterator()

descendingKeyIterator

public java.util.Iterator<K> descendingKeyIterator(K lo,
                                                   boolean loInclusive,
                                                   K hi,
                                                   boolean hiInclusive)

descendingValueIterator

public java.util.Iterator<V> descendingValueIterator()

descendingValueIterator

public java.util.Iterator<V> descendingValueIterator(K lo,
                                                     boolean loInclusive,
                                                     K hi,
                                                     boolean hiInclusive)

entryIterator

public java.util.Iterator<java.util.Map.Entry> entryIterator(K lo,
                                                             boolean loInclusive,
                                                             K hi,
                                                             boolean hiInclusive)

keyIterator

public java.util.Iterator<K> keyIterator(K lo,
                                         boolean loInclusive,
                                         K hi,
                                         boolean hiInclusive)

valueIterator

public java.util.Iterator<V> valueIterator(K lo,
                                           boolean loInclusive,
                                           K hi,
                                           boolean hiInclusive)

findHigher

public java.util.Map.Entry<K,V> findHigher(K key,
                                           boolean inclusive)

findLower

public java.util.Map.Entry<K,V> findLower(K key,
                                          boolean inclusive)

findHigherKey

public K findHigherKey(K key,
                       boolean inclusive)

findLowerKey

public K findLowerKey(K key,
                      boolean inclusive)

forEachKey

public void forEachKey(Function1<? super K,Unit> procedure)

forEachValue

public void forEachValue(Function1<? super V,Unit> procedure)

forEach

public void forEach(java.util.function.BiConsumer<? super K,? super V> action)

isClosed

public boolean isClosed()

close

public void close()

putIfAbsentBoolean

public boolean putIfAbsentBoolean(K key,
                                  V value)

Atomically associates the specified key with the given value if it is not already associated with a value.

This is equivalent to: if(cache.containsKey(key)){}cache.put(key,value);return true;}else{return false;} * except that the action is performed atomically.

Throws:

getKeySerializer

public GroupSerializer<K> getKeySerializer()

getValueSerializer

public GroupSerializer<V> getValueSerializer()

getPageSize

public long getPageSize()

getVolume

public Volume getVolume()

getHasValues

public boolean getHasValues()