DefaultRecordStore (hazelcast-client-protocol 1.0.0 API)

java.lang.Object
- com.hazelcast.map.impl.recordstore.DefaultRecordStore

All Implemented Interfaces:

RecordStore<Record>
```
public class DefaultRecordStore
extends Object
```
Default implementation of record-store.

Field Summary

Fields
Modifier and Type	Field and Description
`protected InMemoryFormat`	`inMemoryFormat`
`protected MapKeyLoader`	`keyLoader`
`protected Collection<Future>`	`loadingFutures`
`protected LockStore`	`lockStore`
`protected ILogger`	`logger`
`protected MapContainer`	`mapContainer`
`protected MapDataStore<Data,Object>`	`mapDataStore`
`protected MapServiceContext`	`mapServiceContext`
`protected MapStoreContext`	`mapStoreContext`
`protected String`	`name`
`protected int`	`partitionId`
`protected RecordFactory`	`recordFactory`
`protected com.hazelcast.map.impl.recordstore.RecordStoreLoader`	`recordStoreLoader`
`protected SerializationService`	`serializationService`
`protected Storage<Data,Record>`	`storage`

Fields inherited from interface com.hazelcast.map.impl.recordstore.RecordStore
DEFAULT_TTL

Constructor Summary

Constructors
Constructor and Description
`DefaultRecordStore(MapContainer mapContainer, int partitionId, MapKeyLoader keyLoader, ILogger logger)`

Method Summary

Methods
Modifier and Type	Method and Description
`protected void`	`accessRecord(Record record)`
`protected void`	`accessRecord(Record record, long now)`
`protected void`	`addMapEntrySet(Map<Object,Object> entries, MapEntries mapEntries)`
`protected void`	`addMapEntrySet(Object key, Object value, MapEntries mapEntries)`
`boolean`	`canAcquireLock(Data key, String caller, long threadId)`
`void`	`checkIfLoaded()`
`int`	`clear()`
`void`	`clearPartition(boolean onShutdown)` Clears internal partition data.
`boolean`	`containsKey(Data key)`
`boolean`	`containsValue(Object value)`
`protected Object`	`copyToHeap(Object value)`
`protected LockStore`	`createLockStore()`
`Record`	`createRecord(Object value, long ttlMillis, long now)`
`protected com.hazelcast.map.impl.recordstore.RecordStoreLoader`	`createRecordStoreLoader(MapStoreContext mapStoreContext)`
`Storage`	`createStorage(RecordFactory recordFactory, InMemoryFormat memoryFormat)`
`boolean`	`delete(Data key)`
`void`	`destroy()`
`void`	`disposeDeferredBlocks()` This can be used to release unused resources.
`void`	`doPostEvictionOperations(Data key, Object value, boolean isExpired)` - Sends eviction event.
`Object`	`evict(Data key, boolean backup)`
`int`	`evictAll(boolean backup)` Evicts all keys except locked ones.
`void`	`evictEntries(long now)`
`void`	`evictExpiredEntries(int percentage, boolean backup)` Do expiration operations.
`boolean`	`extendLock(Data key, String caller, long threadId, long ttl)`
`protected void`	`flush(Collection<Record> recordsToBeFlushed, boolean backup)` Flushes evicted records to map store.
`boolean`	`forceUnlock(Data dataKey)`
`Object`	`get(Data key, boolean backup)` Gets record from `RecordStore`.
`MapEntries`	`getAll(Set<Data> keys)`
`long`	`getHeapCost()`
`protected List<Data>`	`getKeysFromRecords(Collection<Record> clearableRecords)`
`String`	`getLockOwnerInfo(Data key)`
`MapContainer`	`getMapContainer()`
`MapDataStore<Data,Object>`	`getMapDataStore()`
`String`	`getName()`
`protected Collection<Record>`	`getNotLockedRecords()`
`protected long`	`getNow()`
`protected Record`	`getOrNullIfExpired(Record record, long now, boolean backup)` Check if record is reachable according to ttl or idle times.
`int`	`getPartitionId()`
`Record`	`getRecord(Data key)`
`Record`	`getRecordOrNull(Data key)` Returns live record or null if record is already expired.
`protected Record`	`getRecordOrNull(Data key, long now, boolean backup)`
`Storage<Data,? extends Record>`	`getStorage()`
`void`	`init()` Initialize the recordStore after creation
`boolean`	`isEmpty()`
`boolean`	`isEvictionEnabled()`
`boolean`	`isExpirable()`
`boolean`	`isExpired(Record record, long now, boolean backup)` Checks whether a record is expired or not.
`protected boolean`	`isKeyAndValueLoadable(Data key, Object value)`
`boolean`	`isLoaded()`
`boolean`	`isLocked(Data dataKey)`
`boolean`	`isTransactionallyLocked(Data key)`
`Iterator<Record>`	`iterator()` Iterates over record store entries.
`Iterator<Record>`	`iterator(long now, boolean backup)` Iterates over record store entries by respecting expiration.
`Set<Data>`	`keySet()`
`void`	`loadAll(boolean replaceExistingValues)` Loads all keys and values
`void`	`loadAllFromStore(List<Data> keys, boolean replaceExistingValues)` Loads all given keys from defined map store.
`Iterator<Record>`	`loadAwareIterator(long now, boolean backup)` Iterates over record store entries but first waits map store to load.
`protected Map`	`loadEntries(Set<Data> keys)`
`Record`	`loadRecordOrNull(Data key, boolean backup)`
`protected void`	`markRecordStoreExpirable(long ttl)`
`void`	`maybeDoInitialLoad()` Performs initial loading from a MapLoader if it has not been done before
`boolean`	`merge(Data key, EntryView mergingEntry, MapMergePolicy mergePolicy)`
`protected void`	`mergeRecordExpiration(Record record, EntryView mergingEntry)`
`void`	`onKeyLoad(ExecutionCallback<Boolean> callback)` Register a callback for when key loading is complete
`protected void`	`onStore(Record record)`
`Object`	`put(Data key, Object value, long ttl)`
`Record`	`putBackup(Data key, Object value)`
`Record`	`putBackup(Data key, Object value, long ttl, boolean putTransient)`
`Object`	`putFromLoad(Data key, Object value)` Puts key-value pair to map which is the result of a load from map store operation.
`Object`	`putFromLoad(Data key, Object value, long ttl)` Puts key-value pair to map which is the result of a load from map store operation.
`Object`	`putFromLoadBackup(Data key, Object value)` Puts key-value pair to map which is the result of a load from map store operation on backup.
`Object`	`putIfAbsent(Data key, Object value, long ttl)`
`protected Object`	`putInternal(Data key, Object value, long ttl, boolean loadFromStore)`
`void`	`putRecord(Data key, Record record)` Puts a data key and a record value to record-store.
`void`	`putTransient(Data key, Object value, long ttl)`
`Data`	`readBackupData(Data key)` Called when `MapConfig.isReadBackupData()` is `true` from `MapProxySupport.getInternal(com.hazelcast.nio.serialization.Data)` Returns corresponding value for key as `Data`.
`Object`	`remove(Data key)`
`boolean`	`remove(Data key, Object testValue)`
`void`	`removeBackup(Data key)` Similar to `RecordStore.remove(com.hazelcast.nio.serialization.Data)` except removeBackup doesn't touch mapstore since it does not return previous value.
`protected void`	`removeIndex(Collection<Record> records)`
`protected void`	`removeIndex(Record record)`
`protected Object`	`removeRecord(Data key, Record record, long now)`
`protected int`	`removeRecords(Collection<Record> recordsToRemove)`
`Object`	`replace(Data key, Object update)`
`boolean`	`replace(Data key, Object expect, Object update)` Sets the value to the given updated value if `RecordFactory.isEquals(java.lang.Object, java.lang.Object)` comparison of current value and expected value is `true`.
`void`	`reset()` Resets the record store to it's initial state.
`protected void`	`resetAccessSequenceNumber()`
`protected void`	`saveIndex(Record record, Object oldValue)`
`boolean`	`set(Data dataKey, Object value, long ttl)` Returns `true` if key doesn't exist previously, otherwise returns `false`.
`void`	`setSizeEstimator(SizeEstimator sizeEstimator)`
`protected boolean`	`shouldEvict(long now)`
`int`	`size()` Size may not give precise size at a specific moment due to the expiration logic.
`void`	`softFlush()`
`void`	`startLoading()` Starts mapLoader
`protected Data`	`toData(Object value)`
`boolean`	`txnLock(Data key, String caller, long threadId, long referenceId, long ttl)`
`boolean`	`unlock(Data key, String caller, long threadId, long referenceId)`
`void`	`updateLoadStatus(boolean lastBatch, Throwable exception)`
`protected void`	`updateRecord(Data key, Record record, Object value, long now)`

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Field Detail

logger
```
protected final ILogger logger
```

lockStore
```
protected final LockStore lockStore
```

recordStoreLoader

protected final com.hazelcast.map.impl.recordstore.RecordStoreLoader recordStoreLoader

keyLoader
```
protected final MapKeyLoader keyLoader
```

loadingFutures

protected final Collection<Future> loadingFutures

recordFactory

protected final RecordFactory recordFactory

name
```
protected final String name
```

mapContainer

protected final MapContainer mapContainer

mapServiceContext

protected final MapServiceContext mapServiceContext

serializationService

protected final SerializationService serializationService

mapDataStore

protected final MapDataStore<Data,Object> mapDataStore

mapStoreContext

protected final MapStoreContext mapStoreContext

partitionId
```
protected final int partitionId
```

inMemoryFormat

protected final InMemoryFormat inMemoryFormat

storage
```
protected Storage<Data,Record> storage
```

Constructor Detail

DefaultRecordStore

public DefaultRecordStore(MapContainer mapContainer,
                  int partitionId,
                  MapKeyLoader keyLoader,
                  ILogger logger)

Method Detail
- startLoading
```
public void startLoading()
```
  Description copied from interface: RecordStore
  
  Starts mapLoader
- isLoaded
```
public boolean isLoaded()
```
- loadAll
```
public void loadAll(boolean replaceExistingValues)
```
  Description copied from interface: RecordStore
  
  Loads all keys and values
  
  Parameters:
  replaceExistingValues - true if need to replace existing values otherwise false
- loadAllFromStore
```
public void loadAllFromStore(List<Data> keys,
                    boolean replaceExistingValues)
```
  Description copied from interface: RecordStore
  
  Loads all given keys from defined map store.
  
  Parameters:
  keys - keys to be loaded.
  replaceExistingValues - true if need to replace existing values otherwise false
- updateLoadStatus
```
public void updateLoadStatus(boolean lastBatch,
                    Throwable exception)
```
- maybeDoInitialLoad
```
public void maybeDoInitialLoad()
```
  Description copied from interface: RecordStore
  
  Performs initial loading from a MapLoader if it has not been done before
- destroy
```
public void destroy()
```
- onKeyLoad
```
public void onKeyLoad(ExecutionCallback<Boolean> callback)
```
  Description copied from interface: RecordStore
  
  Register a callback for when key loading is complete
- checkIfLoaded
```
public void checkIfLoaded()
```
- softFlush
```
public void softFlush()
```
  See Also:
  MapDataStore.softFlush()
- flush
```
protected void flush(Collection<Record> recordsToBeFlushed,
         boolean backup)
```
  Flushes evicted records to map store.
  
  Parameters:
  recordsToBeFlushed - records to be flushed to map-store.
  backup - true if backup, false otherwise.
- getRecord
```
public Record getRecord(Data key)
```
- putRecord
```
public void putRecord(Data key,
             Record record)
```
  Description copied from interface: RecordStore
  
  Puts a data key and a record value to record-store. Used in replication operations.
  
  Parameters:
  key - the data key to put record store.
  record - the value for record store.
  See Also:
  MapReplicationOperation
- putBackup
```
public Record putBackup(Data key,
               Object value)
```
- putBackup
```
public Record putBackup(Data key,
               Object value,
               long ttl,
               boolean putTransient)
```
  Parameters:
  key - the key to be processed.
  value - the value to be processed.
  ttl - milliseconds. Check out MapProxySupport.putInternal(com.hazelcast.nio.serialization.Data, com.hazelcast.nio.serialization.Data, long, java.util.concurrent.TimeUnit)
  putTransient - true if putting transient entry, otherwise false
  
  Returns:
  previous record if exists otherwise null.
- iterator
```
public Iterator<Record> iterator()
```
  Description copied from interface: RecordStore
  
  Iterates over record store entries.
  
  Returns:
  read only iterator for map values.
- iterator
```
public Iterator<Record> iterator(long now,
                        boolean backup)
```
  Description copied from interface: RecordStore
  
  Iterates over record store entries by respecting expiration.
  
  Returns:
  read only iterator for map values.
- loadAwareIterator
```
public Iterator<Record> loadAwareIterator(long now,
                                 boolean backup)
```
  Description copied from interface: RecordStore
  
  Iterates over record store entries but first waits map store to load. If an operation needs to wait a data source load like query operations IMap.keySet(com.hazelcast.query.Predicate), this method can be used to return a read-only iterator.
  
  Parameters:
  now - current time in millis
  backup - true if a backup partition, otherwise false.
  
  Returns:
  read only iterator for map values.
- clearPartition
```
public void clearPartition(boolean onShutdown)
```
  Description copied from interface: RecordStore
  
  Clears internal partition data.
  
  Parameters:
  onShutdown - true if close is called during MapService shutdown, false otherwise.
- size
```
public int size()
```
  Size may not give precise size at a specific moment due to the expiration logic. But eventually, it should be correct.
  
  Returns:
  record store size.
- isEmpty
```
public boolean isEmpty()
```
- containsValue
```
public boolean containsValue(Object value)
```
- txnLock
```
public boolean txnLock(Data key,
              String caller,
              long threadId,
              long referenceId,
              long ttl)
```
- extendLock
```
public boolean extendLock(Data key,
                 String caller,
                 long threadId,
                 long ttl)
```
- unlock
```
public boolean unlock(Data key,
             String caller,
             long threadId,
             long referenceId)
```
- forceUnlock
```
public boolean forceUnlock(Data dataKey)
```
- isLocked
```
public boolean isLocked(Data dataKey)
```
- isTransactionallyLocked
```
public boolean isTransactionallyLocked(Data key)
```
- canAcquireLock
```
public boolean canAcquireLock(Data key,
                     String caller,
                     long threadId)
```
- getLockOwnerInfo
```
public String getLockOwnerInfo(Data key)
```
- loadRecordOrNull
```
public Record loadRecordOrNull(Data key,
                      boolean backup)
```
- keySet
```
public Set<Data> keySet()
```
- clear
```
public int clear()
```
- getKeysFromRecords
```
protected List<Data> getKeysFromRecords(Collection<Record> clearableRecords)
```
- removeRecords
```
protected int removeRecords(Collection<Record> recordsToRemove)
```
- getNotLockedRecords
```
protected Collection<Record> getNotLockedRecords()
```
- reset
```
public void reset()
```
  Resets the record store to it's initial state.
- evict
```
public Object evict(Data key,
           boolean backup)
```
- evictAll
```
public int evictAll(boolean backup)
```
  Description copied from interface: RecordStore
  
  Evicts all keys except locked ones.
  
  Parameters:
  backup - true if a backup partition, otherwise false.
  
  Returns:
  number of evicted entries.
- removeBackup
```
public void removeBackup(Data key)
```
  Description copied from interface: RecordStore
  
  Similar to RecordStore.remove(com.hazelcast.nio.serialization.Data) except removeBackup doesn't touch mapstore since it does not return previous value.
- remove
```
public Object remove(Data key)
```
- remove
```
public boolean remove(Data key,
             Object testValue)
```
- delete
```
public boolean delete(Data key)
```
- get
```
public Object get(Data key,
         boolean backup)
```
  Description copied from interface: RecordStore
  
  Gets record from RecordStore. Loads missing keys from map store.
  
  Parameters:
  key - key.
  backup - true if a backup partition, otherwise false.
  
  Returns:
  value of an entry in RecordStore
- readBackupData
```
public Data readBackupData(Data key)
```
  Description copied from interface: RecordStore
  
  Called when MapConfig.isReadBackupData() is true from MapProxySupport.getInternal(com.hazelcast.nio.serialization.Data)
  Returns corresponding value for key as Data. This adds an extra serialization step. For the reason of this behaviour please see issue 1292 on github.
  
  Parameters:
  key - key to be accessed
  
  Returns:
  value as Data independent of InMemoryFormat
- getAll
```
public MapEntries getAll(Set<Data> keys)
```
- loadEntries
```
protected Map loadEntries(Set<Data> keys)
```
- addMapEntrySet
```
protected void addMapEntrySet(Object key,
                  Object value,
                  MapEntries mapEntries)
```
- addMapEntrySet
```
protected void addMapEntrySet(Map<Object,Object> entries,
                  MapEntries mapEntries)
```
- containsKey
```
public boolean containsKey(Data key)
```
- put
```
public Object put(Data key,
         Object value,
         long ttl)
```
- putInternal
```
protected Object putInternal(Data key,
                 Object value,
                 long ttl,
                 boolean loadFromStore)
```
- merge
```
public boolean merge(Data key,
            EntryView mergingEntry,
            MapMergePolicy mergePolicy)
```
- replace
```
public Object replace(Data key,
             Object update)
```
- replace
```
public boolean replace(Data key,
              Object expect,
              Object update)
```
  Description copied from interface: RecordStore
  
  Sets the value to the given updated value if RecordFactory.isEquals(java.lang.Object, java.lang.Object) comparison of current value and expected value is true.
  
  Parameters:
  key - key which's value is requested to be replaced.
  expect - the expected value
  update - the new value
  
  Returns:
  true if successful. False return indicates that the actual value was not equal to the expected value.
- putTransient
```
public void putTransient(Data key,
                Object value,
                long ttl)
```
- putFromLoad
```
public Object putFromLoad(Data key,
                 Object value)
```
  Description copied from interface: RecordStore
  
  Puts key-value pair to map which is the result of a load from map store operation.
  
  Parameters:
  key - key to put.
  value - to put.
  
  Returns:
  the previous value associated with key, or null if there was no mapping for key.
  See Also:
  PutFromLoadAllOperation
- putFromLoadBackup
```
public Object putFromLoadBackup(Data key,
                       Object value)
```
  Description copied from interface: RecordStore
  
  Puts key-value pair to map which is the result of a load from map store operation on backup.
  
  Parameters:
  key - key to put.
  value - to put.
  
  Returns:
  the previous value associated with key, or null if there was no mapping for key.
  See Also:
  PutFromLoadAllBackupOperation
- putFromLoad
```
public Object putFromLoad(Data key,
                 Object value,
                 long ttl)
```
  Description copied from interface: RecordStore
  
  Puts key-value pair to map which is the result of a load from map store operation.
  
  Parameters:
  key - key to put.
  value - to put.
  ttl - time to live seconds.
  
  Returns:
  the previous value associated with key, or null if there was no mapping for key.
  See Also:
  PutAllOperation
- isKeyAndValueLoadable
```
protected boolean isKeyAndValueLoadable(Data key,
                            Object value)
```
- set
```
public boolean set(Data dataKey,
          Object value,
          long ttl)
```
  Description copied from interface: RecordStore
  
  Returns true if key doesn't exist previously, otherwise returns false.
  
  See Also:
  IMap.set(Object, Object)
- putIfAbsent
```
public Object putIfAbsent(Data key,
                 Object value,
                 long ttl)
```
- getMapDataStore
```
public MapDataStore<Data,Object> getMapDataStore()
```
- removeRecord
```
protected Object removeRecord(Data key,
                  Record record,
                  long now)
```
- getRecordOrNull
```
public Record getRecordOrNull(Data key)
```
  Description copied from interface: RecordStore
  
  Returns live record or null if record is already expired. Does not load missing keys from a map store.
  
  Parameters:
  key - key to be accessed
  
  Returns:
  live record or null
  See Also:
  RecordStore.get(com.hazelcast.nio.serialization.Data, boolean)
- getRecordOrNull
```
protected Record getRecordOrNull(Data key,
                     long now,
                     boolean backup)
```
- onStore
```
protected void onStore(Record record)
```
- isEvictionEnabled
```
public boolean isEvictionEnabled()
```
- evictExpiredEntries
```
public void evictExpiredEntries(int percentage,
                       boolean backup)
```
  Description copied from interface: RecordStore
  
  Do expiration operations.
  
  Parameters:
  percentage - of max expirables according to the record store size.
  backup - true if a backup partition, otherwise false.
- isExpirable
```
public boolean isExpirable()
```
  Returns:
  true if record store has at least one candidate entry for expiration else return false.
- resetAccessSequenceNumber
```
protected void resetAccessSequenceNumber()
```
- evictEntries
```
public void evictEntries(long now)
```
- shouldEvict
```
protected boolean shouldEvict(long now)
```
- markRecordStoreExpirable
```
protected void markRecordStoreExpirable(long ttl)
```
- getOrNullIfExpired
```
protected Record getOrNullIfExpired(Record record,
                        long now,
                        boolean backup)
```
  Check if record is reachable according to ttl or idle times. If not reachable return null.
  
  Parameters:
  record - Record
  
  Returns:
  null if evictable.
- isExpired
```
public boolean isExpired(Record record,
                long now,
                boolean backup)
```
  Description copied from interface: RecordStore
  
  Checks whether a record is expired or not.
  
  Parameters:
  record - the record from record-store.
  now - current time in millis
  backup - true if a backup partition, otherwise false.
  
  Returns:
  true if the record is expired, false otherwise.
- doPostEvictionOperations
```
public void doPostEvictionOperations(Data key,
                            Object value,
                            boolean isExpired)
```
  - Sends eviction event. - Invalidates near cache.
  
  Parameters:
  key - the key to be processed.
  value - the value to be processed.
- accessRecord
```
protected void accessRecord(Record record,
                long now)
```
- mergeRecordExpiration
```
protected void mergeRecordExpiration(Record record,
                         EntryView mergingEntry)
```
- init
```
public void init()
```
  Description copied from interface: RecordStore
  
  Initialize the recordStore after creation
  
  Specified by:
  
  init in interface RecordStore<Record>
- createRecord
```
public Record createRecord(Object value,
                  long ttlMillis,
                  long now)
```
  Specified by:
  
  createRecord in interface RecordStore<Record>
- createStorage
```
public Storage createStorage(RecordFactory recordFactory,
                    InMemoryFormat memoryFormat)
```
  Specified by:
  
  createStorage in interface RecordStore<Record>
- getName
```
public String getName()
```
  Specified by:
  
  getName in interface RecordStore<Record>
- getMapContainer
```
public MapContainer getMapContainer()
```
  Specified by:
  
  getMapContainer in interface RecordStore<Record>
- getHeapCost
```
public long getHeapCost()
```
  Specified by:
  
  getHeapCost in interface RecordStore<Record>
- getNow
```
protected long getNow()
```
- accessRecord
```
protected void accessRecord(Record record)
```
- updateRecord
```
protected void updateRecord(Data key,
                Record record,
                Object value,
                long now)
```
- getPartitionId
```
public int getPartitionId()
```
  Specified by:
  
  getPartitionId in interface RecordStore<Record>
- saveIndex
```
protected void saveIndex(Record record,
             Object oldValue)
```
- removeIndex
```
protected void removeIndex(Record record)
```
- copyToHeap
```
protected Object copyToHeap(Object value)
```
- removeIndex
```
protected void removeIndex(Collection<Record> records)
```
- createLockStore
```
protected LockStore createLockStore()
```
- createRecordStoreLoader
```
protected com.hazelcast.map.impl.recordstore.RecordStoreLoader createRecordStoreLoader(MapStoreContext mapStoreContext)
```
- toData
```
protected Data toData(Object value)
```
- setSizeEstimator
```
public void setSizeEstimator(SizeEstimator sizeEstimator)
```
- disposeDeferredBlocks
```
public void disposeDeferredBlocks()
```
  Description copied from interface: RecordStore
  
  This can be used to release unused resources.
  
  Specified by:
  
  disposeDeferredBlocks in interface RecordStore<Record>
- getStorage
```
public Storage<Data,? extends Record> getStorage()
```
  Specified by:
  
  getStorage in interface RecordStore<Record>

Class DefaultRecordStore

Field Summary

Fields inherited from interface com.hazelcast.map.impl.recordstore.RecordStore

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

logger

lockStore

recordStoreLoader

keyLoader

loadingFutures

recordFactory

name

mapContainer

mapServiceContext

serializationService

mapDataStore

mapStoreContext

partitionId

inMemoryFormat

storage

Constructor Detail

DefaultRecordStore

Method Detail

startLoading

isLoaded

loadAll

loadAllFromStore

updateLoadStatus

maybeDoInitialLoad

destroy

onKeyLoad

checkIfLoaded

softFlush

flush

getRecord

putRecord

putBackup

putBackup

iterator

iterator

loadAwareIterator

clearPartition

size

isEmpty

containsValue

txnLock

extendLock

unlock

forceUnlock

isLocked

isTransactionallyLocked

canAcquireLock

getLockOwnerInfo

loadRecordOrNull

keySet

clear

getKeysFromRecords

removeRecords

getNotLockedRecords

reset

evict

evictAll

removeBackup

remove

remove

delete

get

readBackupData

getAll

loadEntries

addMapEntrySet

addMapEntrySet

containsKey

put

putInternal

merge

replace

replace