AbstractConcurrentOffHeapMap (Terracotta Off-Heap Store 2.5.6 API)

java.lang.Object
- java.util.AbstractMap<K,V>
- - org.terracotta.offheapstore.concurrent.AbstractConcurrentOffHeapMap<K,V>

Type Parameters:

K - the type of keys maintained by this map

V - the type of mapped values

All Implemented Interfaces:

ConcurrentMap<K,V>, Map<K,V>, ConcurrentMapInternals, HashingMap<K,V>, MapInternals

Direct Known Subclasses:

AbstractConcurrentOffHeapCache, AbstractPersistentConcurrentOffHeapMap, ConcurrentOffHeapHashMap, ConcurrentWriteLockedOffHeapHashMap
```
public abstract class AbstractConcurrentOffHeapMap<K,V>
extends AbstractMap<K,V>
implements ConcurrentMap<K,V>, ConcurrentMapInternals, HashingMap<K,V>
```
An abstract concurrent (striped) off-heap map.
This is an n-way hashcode striped map implementation. Subclasses must provide a Factory instance at construction time from which the required number of segments are created.

Author:

Chris Dennis

Nested Class Summary

Nested Classes
Modifier and Type Class and Description

protected class AbstractConcurrentOffHeapMap.AggregateIterator<T>
- Nested classes/interfaces inherited from class java.util.AbstractMap
  AbstractMap.SimpleEntry<K,V>, AbstractMap.SimpleImmutableEntry<K,V>
- Nested classes/interfaces inherited from interface java.util.Map
  Map.Entry<K,V>

Nested Classes
Modifier and Type	Class and Description
`protected class`	`AbstractConcurrentOffHeapMap.AggregateIterator<T>`

Field Summary

Fields
Modifier and Type Field and Description

protected Segment<K,V>[] segments

Fields
Modifier and Type	Field and Description
`protected Segment<K,V>[]`	`segments`

Constructor Summary

Constructors
Constructor and Description
`AbstractConcurrentOffHeapMap(Factory<? extends Segment<K,V>> segmentFactory)` Create a concurrent map using a default number of segments.
`AbstractConcurrentOffHeapMap(Factory<? extends Segment<K,V>> segmentFactory, int concurrency)` Create a concurrent map with a defined number of segments.

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`void`	`clear()`
`MetadataTuple<V>`	`computeIfAbsentWithMetadata(K key, Function<? super K,? extends MetadataTuple<V>> mappingFunction)`
`MetadataTuple<V>`	`computeIfPresentWithMetadata(K key, BiFunction<? super K,? super MetadataTuple<V>,? extends MetadataTuple<V>> remappingFunction)`
`MetadataTuple<V>`	`computeWithMetadata(K key, BiFunction<? super K,? super MetadataTuple<V>,? extends MetadataTuple<V>> remappingFunction)`
`boolean`	`containsKey(Object key)`
`boolean`	`containsValue(Object value)`
`void`	`destroy()`
`Set<Map.Entry<K,V>>`	`entrySet()`
`V`	`fill(K key, V value)` See `OffHeapHashMap.fill(Object, Object)` for a detailed description.
`V`	`fill(K key, V value, int metadata)`
`V`	`get(Object key)`
`long`	`getAllocatedMemory()`
`Integer`	`getAndSetMetadata(K key, int mask, int values)`
`protected int`	`getConcurrency()`
`long`	`getDataAllocatedMemory()`
`long`	`getDataOccupiedMemory()`
`long`	`getDataSize()`
`long`	`getDataVitalMemory()`
`int`	`getIndexFor(int hash)`
`Integer`	`getMetadata(K key, int mask)`
`long`	`getOccupiedMemory()`
`long`	`getRemovedSlotCount()`
`int`	`getReprobeLength()`
`List<MapInternals>`	`getSegmentInternals()`
`List<Segment<K,V>>`	`getSegments()`
`long`	`getSize()`
`long`	`getTableCapacity()`
`long`	`getUsedSlotCount()`
`V`	`getValueAndSetMetadata(K key, int mask, int values)`
`long`	`getVitalMemory()`
`boolean`	`handleOversizeMappingException(int hash)`
`Set<K>`	`keySet()`
`V`	`put(K key, V value)`
`V`	`put(K key, V value, int metadata)`
`V`	`putIfAbsent(K key, V value)`
`protected void`	`readLockAll()`
`protected void`	`readUnlockAll()`
`V`	`remove(Object key)`
`boolean`	`remove(Object key, Object value)`
`Map<K,V>`	`removeAllWithHash(int keyHash)` Remove all keys having a specific hashcode.
`boolean`	`removeNoReturn(Object key)`
`V`	`replace(K key, V value)`
`boolean`	`replace(K key, V oldValue, V newValue)`
`protected Segment<K,V>`	`segmentFor(int hash)`
`protected Segment<K,V>`	`segmentFor(Object key)`
`int`	`size()`
`Collection<V>`	`values()`
`void`	`writeLockAll()`
`void`	`writeUnlockAll()`

Methods inherited from class java.util.AbstractMap
clone, equals, hashCode, isEmpty, 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, isEmpty, putAll

- Field Detail
  - segments
```
protected final Segment<K,V>[] segments
```
- Constructor Detail
  - AbstractConcurrentOffHeapMap
```
public AbstractConcurrentOffHeapMap(Factory<? extends Segment<K,V>> segmentFactory)
```
    Create a concurrent map using a default number of segments.
    
    Parameters:
    
    segmentFactory - factory used to create the map segments
  - AbstractConcurrentOffHeapMap
```
public AbstractConcurrentOffHeapMap(Factory<? extends Segment<K,V>> segmentFactory,
                                    int concurrency)
```
    Create a concurrent map with a defined number of segments.
    
    Parameters:
    
    segmentFactory - factory used to create the map segments
    
    concurrency - number of segments in the map
    
    Throws:
    
    IllegalArgumentException - if the supplied number of segments is negative
- Method Detail
  - segmentFor
```
protected Segment<K,V> segmentFor(Object key)
```
  - segmentFor
```
protected Segment<K,V> segmentFor(int hash)
```
  - getIndexFor
```
public int getIndexFor(int hash)
```
  - getSegments
```
public List<Segment<K,V>> getSegments()
```
  - getConcurrency
```
protected int getConcurrency()
```
  - size
```
public int size()
```
    Specified by:
    
    size in interface Map<K,V>
    
    Overrides:
    
    size in class AbstractMap<K,V>
  - containsKey
```
public boolean containsKey(Object key)
```
    Specified by:
    
    containsKey in interface Map<K,V>
    
    Overrides:
    
    containsKey in class AbstractMap<K,V>
  - containsValue
```
public boolean containsValue(Object value)
```
    Specified by:
    
    containsValue in interface Map<K,V>
    
    Overrides:
    
    containsValue in class AbstractMap<K,V>
  - get
```
public V get(Object key)
```
    Specified by:
    
    get in interface Map<K,V>
    
    Overrides:
    
    get in class AbstractMap<K,V>
  - put
```
public V put(K key,
             V value)
```
    Specified by:
    
    put in interface Map<K,V>
    
    Overrides:
    
    put in class AbstractMap<K,V>
  - put
```
public V put(K key,
             V value,
             int metadata)
```
  - fill
```
public V fill(K key,
              V value)
```
    See OffHeapHashMap.fill(Object, Object) for a detailed description.
    
    Parameters:
    
    key - key with which the specified value is to be associated
    
    value - value to be associated with the specified key
    
    Returns:
    
    the previous value associated with key, or null if there was no mapping for key (irrespective of whether the value was successfully installed).
  - fill
```
public V fill(K key,
              V value,
              int metadata)
```
  - remove
```
public V remove(Object key)
```
    Specified by:
    
    remove in interface Map<K,V>
    
    Overrides:
    
    remove in class AbstractMap<K,V>
  - removeNoReturn
```
public boolean removeNoReturn(Object key)
```
  - getMetadata
```
public Integer getMetadata(K key,
                           int mask)
                    throws IllegalArgumentException
```
    Throws:
    
    IllegalArgumentException
  - getAndSetMetadata
```
public Integer getAndSetMetadata(K key,
                                 int mask,
                                 int values)
                          throws IllegalArgumentException
```
    Throws:
    
    IllegalArgumentException
  - getValueAndSetMetadata
```
public V getValueAndSetMetadata(K key,
                                int mask,
                                int values)
```
  - clear
```
public void clear()
```
    Specified by:
    
    clear in interface Map<K,V>
    
    Overrides:
    
    clear in class AbstractMap<K,V>
  - destroy
```
public void destroy()
```
  - putIfAbsent
```
public V putIfAbsent(K key,
                     V value)
```
    Specified by:
    
    putIfAbsent in interface ConcurrentMap<K,V>
    
    Specified by:
    
    putIfAbsent in interface Map<K,V>
  - remove
```
public boolean remove(Object key,
                      Object value)
```
    Specified by:
    
    remove in interface ConcurrentMap<K,V>
    
    Specified by:
    
    remove in interface Map<K,V>
  - replace
```
public boolean replace(K key,
                       V oldValue,
                       V newValue)
```
    Specified by:
    
    replace in interface ConcurrentMap<K,V>
    
    Specified by:
    
    replace in interface Map<K,V>
  - replace
```
public V replace(K key,
                 V value)
```
    Specified by:
    
    replace in interface ConcurrentMap<K,V>
    
    Specified by:
    
    replace in interface Map<K,V>
  - keySet
```
public Set<K> keySet()
```
    Specified by:
    
    keySet in interface Map<K,V>
    
    Overrides:
    
    keySet in class AbstractMap<K,V>
  - values
```
public Collection<V> values()
```
    Specified by:
    
    values in interface Map<K,V>
    
    Overrides:
    
    values in class AbstractMap<K,V>
  - entrySet
```
public Set<Map.Entry<K,V>> entrySet()
```
    Specified by:
    
    entrySet in interface Map<K,V>
    
    Specified by:
    
    entrySet in class AbstractMap<K,V>
  - readLockAll
```
protected void readLockAll()
```
  - readUnlockAll
```
protected void readUnlockAll()
```
  - writeLockAll
```
public final void writeLockAll()
```
  - writeUnlockAll
```
public final void writeUnlockAll()
```
  - getSegmentInternals
```
public List<MapInternals> getSegmentInternals()
```
    Specified by:
    
    getSegmentInternals in interface ConcurrentMapInternals
  - getSize
```
public long getSize()
```
    Specified by:
    
    getSize in interface MapInternals
  - getTableCapacity
```
public long getTableCapacity()
```
    Specified by:
    
    getTableCapacity in interface MapInternals
  - getUsedSlotCount
```
public long getUsedSlotCount()
```
    Specified by:
    
    getUsedSlotCount in interface MapInternals
  - getRemovedSlotCount
```
public long getRemovedSlotCount()
```
    Specified by:
    
    getRemovedSlotCount in interface MapInternals
  - getReprobeLength
```
public int getReprobeLength()
```
    Specified by:
    
    getReprobeLength in interface MapInternals
  - getAllocatedMemory
```
public long getAllocatedMemory()
```
    Specified by:
    
    getAllocatedMemory in interface MapInternals
  - getOccupiedMemory
```
public long getOccupiedMemory()
```
    Specified by:
    
    getOccupiedMemory in interface MapInternals
  - getVitalMemory
```
public long getVitalMemory()
```
    Specified by:
    
    getVitalMemory in interface MapInternals
  - getDataAllocatedMemory
```
public long getDataAllocatedMemory()
```
    Specified by:
    
    getDataAllocatedMemory in interface MapInternals
  - getDataOccupiedMemory
```
public long getDataOccupiedMemory()
```
    Specified by:
    
    getDataOccupiedMemory in interface MapInternals
  - getDataVitalMemory
```
public long getDataVitalMemory()
```
    Specified by:
    
    getDataVitalMemory in interface MapInternals
  - getDataSize
```
public long getDataSize()
```
    Specified by:
    
    getDataSize in interface MapInternals
  - handleOversizeMappingException
```
public final boolean handleOversizeMappingException(int hash)
```
  - computeWithMetadata
```
public MetadataTuple<V> computeWithMetadata(K key,
                                            BiFunction<? super K,? super MetadataTuple<V>,? extends MetadataTuple<V>> remappingFunction)
```
  - computeIfAbsentWithMetadata
```
public MetadataTuple<V> computeIfAbsentWithMetadata(K key,
                                                    Function<? super K,? extends MetadataTuple<V>> mappingFunction)
```
  - computeIfPresentWithMetadata
```
public MetadataTuple<V> computeIfPresentWithMetadata(K key,
                                                     BiFunction<? super K,? super MetadataTuple<V>,? extends MetadataTuple<V>> remappingFunction)
```
  - removeAllWithHash
```
public Map<K,V> removeAllWithHash(int keyHash)
```
    Description copied from interface: HashingMap
    
    Remove all keys having a specific hashcode.
    
    Specified by:
    
    removeAllWithHash in interface HashingMap<K,V>
    
    Parameters:
    
    keyHash - the hashcode of the keys to be removed.
    
    Returns:
    
    a Map containing the removed mappings.

Class AbstractConcurrentOffHeapMap<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

segments

Constructor Detail

AbstractConcurrentOffHeapMap

AbstractConcurrentOffHeapMap

Method Detail

segmentFor

segmentFor

getIndexFor

getSegments

getConcurrency

size

containsKey

containsValue

get

put

put

fill

fill

remove

removeNoReturn

getMetadata

getAndSetMetadata

getValueAndSetMetadata

clear

destroy

putIfAbsent

remove

replace

replace

keySet

values

entrySet

readLockAll

readUnlockAll

writeLockAll

writeUnlockAll

getSegmentInternals

getSize

getTableCapacity

getUsedSlotCount

getRemovedSlotCount

getReprobeLength

getAllocatedMemory

getOccupiedMemory

getVitalMemory

getDataAllocatedMemory

getDataOccupiedMemory

getDataVitalMemory

getDataSize

handleOversizeMappingException

computeWithMetadata

computeIfAbsentWithMetadata

computeIfPresentWithMetadata

removeAllWithHash