AbstractCacheRecordStore (Hazelcast Root 3.12.12 API)

java.lang.Object
- com.hazelcast.cache.impl.AbstractCacheRecordStore<R,CRM>

All Implemented Interfaces:: ICacheRecordStore, EvictionListener<Data,R>

Direct Known Subclasses:: CacheRecordStore

public abstract class AbstractCacheRecordStore<R extends CacheRecord,CRM extends SampleableCacheRecordMap<Data,R>>
extends Object
implements ICacheRecordStore, EvictionListener<Data,R>

Field Summary

Fields
Modifier and Type	Field and Description
`protected Map<CacheEventType,Set<CacheEventData>>`	`batchEvent`
`protected CacheConfig`	`cacheConfig`
`protected CacheContext`	`cacheContext`
`protected javax.cache.integration.CacheLoader`	`cacheLoader`
`protected CacheRecordFactory`	`cacheRecordFactory`
`protected AbstractCacheService`	`cacheService`
`protected javax.cache.integration.CacheWriter`	`cacheWriter`
`protected ClearExpiredRecordsTask`	`clearExpiredRecordsTask`
`protected static int`	`DEFAULT_INITIAL_CAPACITY`
`protected javax.cache.expiry.ExpiryPolicy`	`defaultExpiryPolicy`
`protected boolean`	`disablePerEntryInvalidationEvents`
`protected EventJournalConfig`	`eventJournalConfig`
`protected boolean`	`eventsBatchingEnabled`
`protected boolean`	`eventsEnabled`
`protected EvictionChecker`	`evictionChecker`
`protected EvictionConfig`	`evictionConfig`
`protected EvictionPolicyEvaluator<Data,R>`	`evictionPolicyEvaluator`
`protected SamplingEvictionStrategy<Data,R,CRM>`	`evictionStrategy`
`protected Iterator<Map.Entry<Data,R>>`	`expirationIterator`
`protected InvalidationQueue<ExpiredKey>`	`expiredKeys`
`protected boolean`	`hasEntryWithExpiration`
`protected String`	`name` the full name of the cache, including the manager scope prefix
`protected NodeEngine`	`nodeEngine`
`protected ObjectNamespace`	`objectNamespace`
`protected int`	`partitionCount`
`protected int`	`partitionId`
`protected boolean`	`persistWanReplicatedData`
`protected boolean`	`primary`
`protected CRM`	`records`
`static String`	`SOURCE_NOT_AVAILABLE`
`protected SerializationService`	`ss`
`protected CacheStatisticsImpl`	`statistics`
`protected ValueComparator`	`valueComparator`
`protected boolean`	`wanReplicationEnabled`

Fields inherited from interface com.hazelcast.internal.eviction.EvictionListener
NO_LISTENER

Constructor Summary

Constructors
Constructor and Description
`AbstractCacheRecordStore(String cacheNameWithPrefix, int partitionId, NodeEngine nodeEngine, AbstractCacheService cacheService)`

Method Summary

All Methods Instance Methods Abstract Methods Concrete Methods
Modifier and Type	Method and Description
`R`	`accessRecord(Data key, R record, javax.cache.expiry.ExpiryPolicy expiryPolicy, long now)`
`protected void`	`accumulateOrSendExpiredKeysToBackup(Data key, R record)`
`void`	`clear()` clears all internal data without publishing any events
`void`	`close(boolean onShutdown)` Close is equivalent to below operations in the given order: close resources. unregister all listeners.
`protected void`	`closeListeners()`
`protected boolean`	`compare(Object v1, Object v2)`
`boolean`	`contains(Data key)` Determines if this store contains an entry for the specified key.
`protected abstract CacheEntryProcessorEntry`	`createCacheEntryProcessorEntry(Data key, R record, long now, int completionId)`
`protected EvictionChecker`	`createCacheEvictionChecker(int size, EvictionConfig.MaxSizePolicy maxSizePolicy)` Creates an instance for checking if the maximum cache size has been reached.
`protected EvictionPolicyEvaluator<Data,R>`	`createEvictionPolicyEvaluator(EvictionConfig evictionConfig)`
`protected SamplingEvictionStrategy<Data,R,CRM>`	`createEvictionStrategy(EvictionConfig cacheEvictionConfig)`
`protected R`	`createRecord(Data keyData, Object value, long expirationTime, int completionId)`
`protected R`	`createRecord(Data key, Object value, long expiryTime, long now, boolean disableWriteThrough, int completionId, String origin)`
`protected R`	`createRecord(long expiryTime)`
`protected R`	`createRecord(Object value, long expiryTime)`
`protected abstract R`	`createRecord(Object value, long creationTime, long expiryTime)`
`protected abstract CRM`	`createRecordCacheMap()`
`protected R`	`createRecordWithExpiry(Data key, Object value, javax.cache.expiry.ExpiryPolicy expiryPolicy, long now, boolean disableWriteThrough, int completionId)`
`protected R`	`createRecordWithExpiry(Data key, Object value, javax.cache.expiry.ExpiryPolicy expiryPolicy, long now, boolean disableWriteThrough, int completionId, String origin)`
`protected R`	`createRecordWithExpiry(Data key, Object value, long expiryTime, long now, boolean disableWriteThrough, int completionId)`
`protected R`	`createRecordWithExpiry(Data key, Object value, long expiryTime, long now, boolean disableWriteThrough, int completionId, String origin)`
`protected abstract Object`	`dataToValue(Data data)`
`protected void`	`deleteAllCacheEntry(Set<Data> keys)`
`protected void`	`deleteCacheEntry(Data key)`
`protected void`	`deleteCacheEntry(Data key, CallerProvenance provenance)`
`protected boolean`	`deleteRecord(Data key, int completionId)`
`protected boolean`	`deleteRecord(Data key, int completionId, String source)`
`protected boolean`	`deleteRecord(Data key, int completionId, String source, String origin)`
`void`	`destroy()` Destroy is equivalent to below operations in the given order: clear all. close resources. unregister all listeners.
`protected void`	`destroyEventJournal()`
`void`	`destroyInternals()` Like `ICacheRecordStore.destroy()` but does not touch state on other services like event journal service.
`protected R`	`doPutRecord(Data key, R record, String source, boolean updateJournal)`
`protected R`	`doRemoveRecord(Data key, String source)`
`void`	`evictExpiredEntries(int expirationPercentage)` Do expiration operations.
`protected boolean`	`evictIfExpired(Data key, R record, long now)`
`boolean`	`evictIfRequired()` Evict cache record store if eviction is required.
`protected Object`	`extractExpiryPolicyOfRecord(CacheRecord record)`
`CacheEntryIterationResult`	`fetchEntries(int tableIndex, int size)` Starting from the provided table index, a set of entries are returned with a maximum size of `size`
`CacheKeyIterationResult`	`fetchKeys(int tableIndex, int size)` Starting from the provided table index, a set of keys are returned with a maximum size of `size`
`protected void`	`forceRemoveRecord(Data key)`
`Object`	`get(Data key, javax.cache.expiry.ExpiryPolicy expiryPolicy)` Gets the value to which the specified key is mapped, or `null` if this cache contains no mapping for the key.
`MapEntries`	`getAll(Set<Data> keySet, javax.cache.expiry.ExpiryPolicy expiryPolicy)` Gets a collection of entries from the store, returning them as `Map` of the values associated with the set of keys requested.
`Object`	`getAndPut(Data key, Object value, javax.cache.expiry.ExpiryPolicy expiryPolicy, String source, int completionId)` Associates the specified value with the specified key in this cache, returning an existing value if one existed.
`Object`	`getAndRemove(Data key, String source, int completionId)` Atomically removes the entry for a key only if it is currently mapped to some value.
`Object`	`getAndRemove(Data key, String source, int completionId, String origin)`
`Object`	`getAndReplace(Data key, Object value, javax.cache.expiry.ExpiryPolicy expiryPolicy, String source, int completionId)` Atomically replaces the value for a given key if and only if there is a value currently mapped by the key.
`CacheStatisticsImpl`	`getCacheStats()` Gets the Cache statistics associated with this `CacheService`.
`CacheConfig`	`getConfig()` Gets the configuration of the cache that this store belongs to.
`InvalidationQueue<ExpiredKey>`	`getExpiredKeysQueue()`
`protected javax.cache.expiry.ExpiryPolicy`	`getExpiryPolicy(CacheRecord record, javax.cache.expiry.ExpiryPolicy expiryPolicy)`
`Object`	`getExpiryPolicy(Data key)`
`String`	`getName()` Gets the name of the distributed object name of the cache.
`ObjectNamespace`	`getObjectNamespace()` Returns `ObjectNamespace` associated with this record store.
`int`	`getPartitionId()`
`Map<Data,CacheRecord>`	`getReadOnlyRecords()` Returns a readonly map of the internal key value store.
`CacheRecord`	`getRecord(Data key)` Gets internal record of the store by key.
`protected ValueComparator`	`getValueComparatorOf(InMemoryFormat inMemoryFormat)`
`void`	`init()` Initializes record store.
`protected void`	`initExpirationIterator()`
`void`	`instrument(NodeEngine nodeEngine)`
`protected void`	`invalidateEntry(Data key)`
`protected void`	`invalidateEntry(Data key, String source)`
`Object`	`invoke(Data key, javax.cache.processor.EntryProcessor entryProcessor, Object[] arguments, int completionId)` Invokes an `EntryProcessor` against the `Cache.Entry` specified by the provided key.
`protected boolean`	`isEventsEnabled()`
`protected boolean`	`isEvictionEnabled()`
`boolean`	`isExpirable()`
`protected boolean`	`isInvalidationEnabled()`
`protected boolean`	`isReadThrough()`
`protected boolean`	`isStatisticsEnabled()`
`boolean`	`isWanReplicationEnabled()` Determines whether wan replication is enabled or not for this record store.
`protected boolean`	`isWriteThrough()`
`Set<Data>`	`loadAll(Set<Data> keys, boolean replaceExistingValues)` Synchronously loads the specified entries into the cache using the configured `CacheLoader` for the given keys.
`protected Map<Data,Object>`	`loadAllCacheEntry(Set<Data> keys)`
`protected void`	`markExpirable(long expiryTime)` This method marks current replica as expirable and also starts expiration task if necessary.
`CacheRecord`	`merge(CacheEntryView<Data,Data> cacheEntryView, CacheMergePolicy mergePolicy, String caller, String origin, int completionId, CallerProvenance callerProvenance)` Merges the given `CacheEntryView` via the given `CacheMergePolicy`.
`CacheRecord`	`merge(SplitBrainMergeTypes.CacheMergeTypes mergingEntry, SplitBrainMergePolicy<Data,SplitBrainMergeTypes.CacheMergeTypes> mergePolicy, CallerProvenance callerProvenance)` Merges the given `SplitBrainMergeTypes.CacheMergeTypes` via the given `SplitBrainMergePolicy`.
`protected void`	`onCreateRecordError(Data key, Object value, long expiryTime, long now, boolean disableWriteThrough, int completionId, String origin, R record, Throwable error)`
`protected void`	`onDeleteRecord(Data key, R record, boolean deleted)`
`protected void`	`onDestroy()`
`void`	`onEvict(Data key, R record, boolean wasExpired)` Called when an `Evictable` entry is evicted.
`protected void`	`onGet(Data key, javax.cache.expiry.ExpiryPolicy expiryPolicy, Object value, R record)`
`protected void`	`onGetError(Data key, javax.cache.expiry.ExpiryPolicy expiryPolicy, Object value, R record, Throwable error)`
`protected void`	`onProcessExpiredEntry(Data key, R record, long expiryTime, long now, String source, String origin)`
`protected void`	`onPut(Data key, Object value, javax.cache.expiry.ExpiryPolicy expiryPolicy, String source, boolean getValue, boolean disableWriteThrough, R record, Object oldValue, boolean isExpired, boolean isNewPut, boolean isSaveSucceed)`
`protected void`	`onPutError(Data key, Object value, javax.cache.expiry.ExpiryPolicy expiryPolicy, String source, boolean getValue, boolean disableWriteThrough, R record, Object oldValue, boolean wouldBeNewPut, Throwable error)`
`protected void`	`onPutIfAbsent(Data key, Object value, javax.cache.expiry.ExpiryPolicy expiryPolicy, String source, boolean disableWriteThrough, R record, boolean isExpired, boolean isSaveSucceed)`
`protected void`	`onPutIfAbsentError(Data key, Object value, javax.cache.expiry.ExpiryPolicy expiryPolicy, String source, boolean disableWriteThrough, R record, Throwable error)`
`protected long`	`onRecordAccess(Data key, R record, javax.cache.expiry.ExpiryPolicy expiryPolicy, long now)`
`protected void`	`onRemove(Data key, Object value, String source, boolean getValue, R record, boolean removed)`
`protected void`	`onRemoveError(Data key, Object value, String source, boolean getValue, R record, boolean removed, Throwable error)`
`protected void`	`onReplace(Data key, Object oldValue, Object newValue, javax.cache.expiry.ExpiryPolicy expiryPolicy, String source, boolean getValue, R record, boolean isExpired, boolean replaced)`
`protected void`	`onReplaceError(Data key, Object oldValue, Object newValue, javax.cache.expiry.ExpiryPolicy expiryPolicy, String source, boolean getValue, R record, boolean isExpired, boolean replaced, Throwable error)`
`protected void`	`onUpdateExpiryPolicy(Data key, R record, Data oldDataExpiryPolicy)`
`protected void`	`onUpdateExpiryPolicyError(Data key, R record, Data oldDataExpiryPolicy)`
`protected void`	`onUpdateRecord(Data key, R record, Object value, Data oldDataValue)`
`protected void`	`onUpdateRecordError(Data key, R record, Object value, Data newDataValue, Data oldDataValue, Throwable error)`
`protected boolean`	`processExpiredEntry(Data key, R record, long now)`
`protected R`	`processExpiredEntry(Data key, R record, long expiryTime, long now, String source)`
`protected R`	`processExpiredEntry(Data key, R record, long expiryTime, long now, String source, String origin)`
`protected boolean`	`processExpiredEntry(Data key, R record, long now, String source)`
`protected boolean`	`processExpiredEntry(Data key, R record, long now, String source, String origin)`
`protected void`	`publishBatchedEvents(String cacheName, CacheEventType cacheEventType, int orderKey)`
`protected void`	`publishEvent(CacheEventContext cacheEventContext)`
`protected Object`	`put(Data key, Object value, javax.cache.expiry.ExpiryPolicy expiryPolicy, String source, boolean getValue, boolean disableWriteThrough, int completionId)`
`protected Object`	`put(Data key, Object value, javax.cache.expiry.ExpiryPolicy expiryPolicy, String source, boolean getValue, int completionId)`
`R`	`put(Data key, Object value, javax.cache.expiry.ExpiryPolicy expiryPolicy, String source, int completionId)` Associates the specified value with the specified key in this cache, returning an existing value if one existed.
`protected boolean`	`putIfAbsent(Data key, Object value, javax.cache.expiry.ExpiryPolicy expiryPolicy, String source, boolean disableWriteThrough, int completionId)`
`boolean`	`putIfAbsent(Data key, Object value, javax.cache.expiry.ExpiryPolicy expiryPolicy, String source, int completionId)` Removes the mapping for a key from this cache if it is present.
`void`	`putRecord(Data key, CacheRecord record, boolean updateJournal)` Associates the specified record with the specified key.
`Object`	`readThroughCache(Data key)`
`R`	`readThroughRecord(Data key, long now)`
`protected abstract Data`	`recordToData(R record)`
`protected abstract Object`	`recordToValue(R record)`
`boolean`	`remove(Data key, Object value, String source, String origin, int completionId)` Atomically removes the mapping for a key only if currently mapped to the given value.
`boolean`	`remove(Data key, String source, String origin, int completionId)`
`boolean`	`remove(Data key, String source, String origin, int completionId, CallerProvenance provenance)` Removes the mapping for a key from this cache if it is present.
`void`	`removeAll(Set<Data> keys, int completionId)` records of keys will be deleted one by one and will publish a REMOVE event for each key.
`CacheRecord`	`removeRecord(Data key)` Removes the record for a key.
`boolean`	`replace(Data key, Object value, javax.cache.expiry.ExpiryPolicy expiryPolicy, String source, int completionId)` Atomically replaces the entry for a key only if currently mapped to some value.
`boolean`	`replace(Data key, Object oldValue, Object newValue, javax.cache.expiry.ExpiryPolicy expiryPolicy, String source, int completionId)` Atomically replaces the entry for a key only if currently mapped to a given value.
`void`	`reset()` Resets the record store to it's initial state.
`void`	`sampleAndForceRemoveEntries(int entryCountToRemove)`
`boolean`	`setExpiryPolicy(Collection<Data> keys, Object expiryPolicy, String source)` Sets expiry policy for the records with given keys if and only if there is a value currently mapped by the key
`int`	`size()` Calculates the entry size of this store which reflects the partition size of the cache.
`protected Data`	`toData(Object obj)`
`Data`	`toEventData(Object obj)`
`protected abstract Data`	`toHeapData(Object obj)`
`protected Object`	`toStorageValue(Object obj)`
`protected Object`	`toValue(Object obj)`
`protected long`	`updateAccessDuration(Data key, R record, javax.cache.expiry.ExpiryPolicy expiryPolicy, long now)`
`protected void`	`updateExpiryPolicyOfRecord(Data key, R record, Object expiryPolicy)`
`protected void`	`updateGetAndPutStat(boolean isPutSucceed, boolean getValue, boolean oldValueNull, long start)`
`protected void`	`updateRecord(Data key, CacheRecord record, long expiryTime, long now, String origin)`
`protected void`	`updateRecord(Data key, R record, Object value, long expiryTime, long now, boolean disableWriteThrough, int completionId, String source, String origin)`
`protected void`	`updateRecordValue(R record, Object recordValue)`
`protected void`	`updateRecordWithExpiry(Data key, CacheRecord record, javax.cache.expiry.ExpiryPolicy expiryPolicy, long now, String source)`
`protected boolean`	`updateRecordWithExpiry(Data key, Object value, R record, javax.cache.expiry.ExpiryPolicy expiryPolicy, long now, boolean disableWriteThrough, int completionId)`
`protected boolean`	`updateRecordWithExpiry(Data key, Object value, R record, javax.cache.expiry.ExpiryPolicy expiryPolicy, long now, boolean disableWriteThrough, int completionId, String source)`
`protected boolean`	`updateRecordWithExpiry(Data key, Object value, R record, javax.cache.expiry.ExpiryPolicy expiryPolicy, long now, boolean disableWriteThrough, int completionId, String source, String origin)`
`protected boolean`	`updateRecordWithExpiry(Data key, Object value, R record, long expiryTime, long now, boolean disableWriteThrough, int completionId)`
`protected boolean`	`updateRecordWithExpiry(Data key, Object value, R record, long expiryTime, long now, boolean disableWriteThrough, int completionId, String source)`
`protected boolean`	`updateRecordWithExpiry(Data key, Object value, R record, long expiryTime, long now, boolean disableWriteThrough, int completionId, String source, String origin)`
`protected void`	`updateReplaceStat(boolean result, boolean isHit, long start)`
`protected abstract Data`	`valueToData(Object value)`
`void`	`writeThroughCache(Data key, Object value)`

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

Methods inherited from interface com.hazelcast.cache.impl.ICacheRecordStore
disposeDeferredBlocks

Field Detail

SOURCE_NOT_AVAILABLE

public static final String SOURCE_NOT_AVAILABLE

See Also:: Constant Field Values

DEFAULT_INITIAL_CAPACITY
```
protected static final int DEFAULT_INITIAL_CAPACITY
```
See Also:

Constant Field Values

partitionId
```
protected final int partitionId
```

partitionCount
```
protected final int partitionCount
```

wanReplicationEnabled

protected final boolean wanReplicationEnabled

persistWanReplicatedData

protected final boolean persistWanReplicatedData

disablePerEntryInvalidationEvents

protected final boolean disablePerEntryInvalidationEvents

name
```
protected final String name
```
the full name of the cache, including the manager scope prefix

nodeEngine
```
protected final NodeEngine nodeEngine
```

cacheConfig

protected final CacheConfig cacheConfig

ss

protected final SerializationService ss

evictionConfig

protected final EvictionConfig evictionConfig

valueComparator

protected final ValueComparator valueComparator

evictionChecker

protected final EvictionChecker evictionChecker

objectNamespace

protected final ObjectNamespace objectNamespace

cacheService

protected final AbstractCacheService cacheService

cacheRecordFactory

protected final CacheRecordFactory cacheRecordFactory

eventJournalConfig

protected final EventJournalConfig eventJournalConfig

clearExpiredRecordsTask

protected final ClearExpiredRecordsTask clearExpiredRecordsTask

evictionStrategy

protected final SamplingEvictionStrategy<Data,R extends CacheRecord,CRM extends SampleableCacheRecordMap<Data,R>> evictionStrategy

evictionPolicyEvaluator

protected final EvictionPolicyEvaluator<Data,R extends CacheRecord> evictionPolicyEvaluator

batchEvent

protected final Map<CacheEventType,Set<CacheEventData>> batchEvent

primary
```
protected boolean primary
```

eventsEnabled
```
protected boolean eventsEnabled
```

eventsBatchingEnabled

protected boolean eventsBatchingEnabled

records

protected CRM extends SampleableCacheRecordMap<Data,R> records

cacheLoader

protected javax.cache.integration.CacheLoader cacheLoader

cacheWriter

protected javax.cache.integration.CacheWriter cacheWriter

cacheContext
```
protected CacheContext cacheContext
```

statistics

protected CacheStatisticsImpl statistics

defaultExpiryPolicy

protected javax.cache.expiry.ExpiryPolicy defaultExpiryPolicy

expirationIterator

protected Iterator<Map.Entry<Data,R extends CacheRecord>> expirationIterator

expiredKeys

protected InvalidationQueue<ExpiredKey> expiredKeys

hasEntryWithExpiration

protected boolean hasEntryWithExpiration

Constructor Detail

AbstractCacheRecordStore

public AbstractCacheRecordStore(String cacheNameWithPrefix,
                                int partitionId,
                                NodeEngine nodeEngine,
                                AbstractCacheService cacheService)

Method Detail

getValueComparatorOf

protected ValueComparator getValueComparatorOf(InMemoryFormat inMemoryFormat)

instrument

public void instrument(NodeEngine nodeEngine)

init
```
public void init()
```
Description copied from interface: ICacheRecordStore

Initializes record store.

Specified by:

init in interface ICacheRecordStore

isReadThrough
```
protected boolean isReadThrough()
```

isWriteThrough
```
protected boolean isWriteThrough()
```

isStatisticsEnabled

protected boolean isStatisticsEnabled()

createRecordCacheMap

protected abstract CRM createRecordCacheMap()

createCacheEntryProcessorEntry

protected abstract CacheEntryProcessorEntry createCacheEntryProcessorEntry(Data key,
                                                                           R record,
                                                                           long now,
                                                                           int completionId)

createRecord

protected abstract R createRecord(Object value,
                                  long creationTime,
                                  long expiryTime)

valueToData

protected abstract Data valueToData(Object value)

dataToValue

protected abstract Object dataToValue(Data data)

recordToValue

protected abstract Object recordToValue(R record)

recordToData

protected abstract Data recordToData(R record)

toHeapData

protected abstract Data toHeapData(Object obj)

createCacheEvictionChecker
```
protected EvictionChecker createCacheEvictionChecker(int size,
                                                     EvictionConfig.MaxSizePolicy maxSizePolicy)
```
Creates an instance for checking if the maximum cache size has been reached. Supports only the EvictionConfig.MaxSizePolicy.ENTRY_COUNT policy. Returns null if other maxSizePolicy is used.

Parameters:

size - the maximum number of entries

maxSizePolicy - the way in which the size is interpreted, only the EvictionConfig.MaxSizePolicy.ENTRY_COUNT policy is supported.

Returns:

the instance which will check if the maximum number of entries has been reached or null if the maxSizePolicy is not EvictionConfig.MaxSizePolicy.ENTRY_COUNT

Throws:

IllegalArgumentException - if the maxSizePolicy is null

createEvictionPolicyEvaluator

protected EvictionPolicyEvaluator<Data,R> createEvictionPolicyEvaluator(EvictionConfig evictionConfig)

createEvictionStrategy

protected SamplingEvictionStrategy<Data,R,CRM> createEvictionStrategy(EvictionConfig cacheEvictionConfig)

isEvictionEnabled
```
protected boolean isEvictionEnabled()
```

isEventsEnabled
```
protected boolean isEventsEnabled()
```

isInvalidationEnabled

protected boolean isInvalidationEnabled()

evictIfRequired
```
public boolean evictIfRequired()
```
Description copied from interface: ICacheRecordStore

Evict cache record store if eviction is required.
Eviction logic is handled as specified EvictionPolicy in CacheConfig for this record store

Specified by:

evictIfRequired in interface ICacheRecordStore

Returns:

true is an entry was evicted, otherwise false

sampleAndForceRemoveEntries
```
public void sampleAndForceRemoveEntries(int entryCountToRemove)
```
Specified by:

sampleAndForceRemoveEntries in interface ICacheRecordStore

forceRemoveRecord

protected void forceRemoveRecord(Data key)

toData
```
protected Data toData(Object obj)
```

toValue
```
protected Object toValue(Object obj)
```

toStorageValue

protected Object toStorageValue(Object obj)

toEventData
```
public Data toEventData(Object obj)
```

getExpiryPolicy

protected javax.cache.expiry.ExpiryPolicy getExpiryPolicy(CacheRecord record,
                                                          javax.cache.expiry.ExpiryPolicy expiryPolicy)

evictIfExpired

protected boolean evictIfExpired(Data key,
                                 R record,
                                 long now)

processExpiredEntry

protected boolean processExpiredEntry(Data key,
                                      R record,
                                      long now)

processExpiredEntry

protected boolean processExpiredEntry(Data key,
                                      R record,
                                      long now,
                                      String source)

processExpiredEntry

protected boolean processExpiredEntry(Data key,
                                      R record,
                                      long now,
                                      String source,
                                      String origin)

processExpiredEntry

protected R processExpiredEntry(Data key,
                                R record,
                                long expiryTime,
                                long now,
                                String source)

processExpiredEntry

protected R processExpiredEntry(Data key,
                                R record,
                                long expiryTime,
                                long now,
                                String source,
                                String origin)

onProcessExpiredEntry

protected void onProcessExpiredEntry(Data key,
                                     R record,
                                     long expiryTime,
                                     long now,
                                     String source,
                                     String origin)

accumulateOrSendExpiredKeysToBackup

protected void accumulateOrSendExpiredKeysToBackup(Data key,
                                                   R record)

isExpirable
```
public boolean isExpirable()
```
Specified by:

isExpirable in interface ICacheRecordStore

accessRecord

public R accessRecord(Data key,
                      R record,
                      javax.cache.expiry.ExpiryPolicy expiryPolicy,
                      long now)

onEvict
```
public void onEvict(Data key,
                    R record,
                    boolean wasExpired)
```
Description copied from interface: EvictionListener

Called when an Evictable entry is evicted.

Specified by:

onEvict in interface EvictionListener<Data,R extends CacheRecord>

Parameters:

key - Accessor of the Evictable entry that is evicted.

record - Evictable entry that is evicted.

wasExpired - true if the entry was evicted due to expiration, false otherwise

invalidateEntry

protected void invalidateEntry(Data key,
                               String source)

invalidateEntry

protected void invalidateEntry(Data key)

updateGetAndPutStat

protected void updateGetAndPutStat(boolean isPutSucceed,
                                   boolean getValue,
                                   boolean oldValueNull,
                                   long start)

updateAccessDuration

protected long updateAccessDuration(Data key,
                                    R record,
                                    javax.cache.expiry.ExpiryPolicy expiryPolicy,
                                    long now)

onRecordAccess

protected long onRecordAccess(Data key,
                              R record,
                              javax.cache.expiry.ExpiryPolicy expiryPolicy,
                              long now)

updateReplaceStat

protected void updateReplaceStat(boolean result,
                                 boolean isHit,
                                 long start)

publishEvent

protected void publishEvent(CacheEventContext cacheEventContext)

publishBatchedEvents

protected void publishBatchedEvents(String cacheName,
                                    CacheEventType cacheEventType,
                                    int orderKey)

compare

protected boolean compare(Object v1,
                          Object v2)

createRecord

protected R createRecord(long expiryTime)

createRecord

protected R createRecord(Object value,
                         long expiryTime)

createRecord

protected R createRecord(Data keyData,
                         Object value,
                         long expirationTime,
                         int completionId)

onCreateRecordError

protected void onCreateRecordError(Data key,
                                   Object value,
                                   long expiryTime,
                                   long now,
                                   boolean disableWriteThrough,
                                   int completionId,
                                   String origin,
                                   R record,
                                   Throwable error)

createRecord

protected R createRecord(Data key,
                         Object value,
                         long expiryTime,
                         long now,
                         boolean disableWriteThrough,
                         int completionId,
                         String origin)

createRecordWithExpiry

protected R createRecordWithExpiry(Data key,
                                   Object value,
                                   long expiryTime,
                                   long now,
                                   boolean disableWriteThrough,
                                   int completionId,
                                   String origin)

createRecordWithExpiry

protected R createRecordWithExpiry(Data key,
                                   Object value,
                                   long expiryTime,
                                   long now,
                                   boolean disableWriteThrough,
                                   int completionId)

createRecordWithExpiry

protected R createRecordWithExpiry(Data key,
                                   Object value,
                                   javax.cache.expiry.ExpiryPolicy expiryPolicy,
                                   long now,
                                   boolean disableWriteThrough,
                                   int completionId)

createRecordWithExpiry

protected R createRecordWithExpiry(Data key,
                                   Object value,
                                   javax.cache.expiry.ExpiryPolicy expiryPolicy,
                                   long now,
                                   boolean disableWriteThrough,
                                   int completionId,
                                   String origin)

onUpdateRecord

protected void onUpdateRecord(Data key,
                              R record,
                              Object value,
                              Data oldDataValue)

onUpdateRecordError

protected void onUpdateRecordError(Data key,
                                   R record,
                                   Object value,
                                   Data newDataValue,
                                   Data oldDataValue,
                                   Throwable error)

onUpdateExpiryPolicy

protected void onUpdateExpiryPolicy(Data key,
                                    R record,
                                    Data oldDataExpiryPolicy)

onUpdateExpiryPolicyError

protected void onUpdateExpiryPolicyError(Data key,
                                         R record,
                                         Data oldDataExpiryPolicy)

updateRecord

protected void updateRecord(Data key,
                            CacheRecord record,
                            long expiryTime,
                            long now,
                            String origin)

updateRecord

protected void updateRecord(Data key,
                            R record,
                            Object value,
                            long expiryTime,
                            long now,
                            boolean disableWriteThrough,
                            int completionId,
                            String source,
                            String origin)

updateExpiryPolicyOfRecord

protected void updateExpiryPolicyOfRecord(Data key,
                                          R record,
                                          Object expiryPolicy)

extractExpiryPolicyOfRecord

protected Object extractExpiryPolicyOfRecord(CacheRecord record)

updateRecordValue

protected void updateRecordValue(R record,
                                 Object recordValue)

updateRecordWithExpiry

protected boolean updateRecordWithExpiry(Data key,
                                         Object value,
                                         R record,
                                         long expiryTime,
                                         long now,
                                         boolean disableWriteThrough,
                                         int completionId,
                                         String source,
                                         String origin)

updateRecordWithExpiry

protected boolean updateRecordWithExpiry(Data key,
                                         Object value,
                                         R record,
                                         long expiryTime,
                                         long now,
                                         boolean disableWriteThrough,
                                         int completionId)

updateRecordWithExpiry

protected boolean updateRecordWithExpiry(Data key,
                                         Object value,
                                         R record,
                                         long expiryTime,
                                         long now,
                                         boolean disableWriteThrough,
                                         int completionId,
                                         String source)

updateRecordWithExpiry

protected boolean updateRecordWithExpiry(Data key,
                                         Object value,
                                         R record,
                                         javax.cache.expiry.ExpiryPolicy expiryPolicy,
                                         long now,
                                         boolean disableWriteThrough,
                                         int completionId)

updateRecordWithExpiry

protected boolean updateRecordWithExpiry(Data key,
                                         Object value,
                                         R record,
                                         javax.cache.expiry.ExpiryPolicy expiryPolicy,
                                         long now,
                                         boolean disableWriteThrough,
                                         int completionId,
                                         String source)

updateRecordWithExpiry

protected boolean updateRecordWithExpiry(Data key,
                                         Object value,
                                         R record,
                                         javax.cache.expiry.ExpiryPolicy expiryPolicy,
                                         long now,
                                         boolean disableWriteThrough,
                                         int completionId,
                                         String source,
                                         String origin)

updateRecordWithExpiry

protected void updateRecordWithExpiry(Data key,
                                      CacheRecord record,
                                      javax.cache.expiry.ExpiryPolicy expiryPolicy,
                                      long now,
                                      String source)

onDeleteRecord

protected void onDeleteRecord(Data key,
                              R record,
                              boolean deleted)

deleteRecord

protected boolean deleteRecord(Data key,
                               int completionId)

deleteRecord

protected boolean deleteRecord(Data key,
                               int completionId,
                               String source)

deleteRecord

protected boolean deleteRecord(Data key,
                               int completionId,
                               String source,
                               String origin)

readThroughRecord

public R readThroughRecord(Data key,
                           long now)

readThroughCache

public Object readThroughCache(Data key)
                        throws javax.cache.integration.CacheLoaderException

Throws:: javax.cache.integration.CacheLoaderException

writeThroughCache

public void writeThroughCache(Data key,
                              Object value)
                       throws javax.cache.integration.CacheWriterException

Throws:: javax.cache.integration.CacheWriterException

deleteCacheEntry

protected void deleteCacheEntry(Data key)

deleteCacheEntry

protected void deleteCacheEntry(Data key,
                                CallerProvenance provenance)

deleteAllCacheEntry

protected void deleteAllCacheEntry(Set<Data> keys)

loadAllCacheEntry

protected Map<Data,Object> loadAllCacheEntry(Set<Data> keys)

getRecord
```
public CacheRecord getRecord(Data key)
```
Description copied from interface: ICacheRecordStore

Gets internal record of the store by key.

Specified by:

getRecord in interface ICacheRecordStore

Parameters:

key - the key to the entry.

Returns:

CacheRecord instance mapped.

putRecord
```
public void putRecord(Data key,
                      CacheRecord record,
                      boolean updateJournal)
```
Description copied from interface: ICacheRecordStore

Associates the specified record with the specified key. This is simply a put operation on the internal map data without any CacheLoad. It also DOES trigger eviction!

Specified by:

putRecord in interface ICacheRecordStore

Parameters:

key - the key to the entry.

record - the value to be associated with the specified key.

updateJournal - when true an event is appended to related event-journal

doPutRecord

protected R doPutRecord(Data key,
                        R record,
                        String source,
                        boolean updateJournal)

removeRecord
```
public CacheRecord removeRecord(Data key)
```
Description copied from interface: ICacheRecordStore

Removes the record for a key.

Specified by:

removeRecord in interface ICacheRecordStore

Parameters:

key - the key to the entry.

Returns:

the removed record if one exists.

doRemoveRecord

protected R doRemoveRecord(Data key,
                           String source)

onGet

protected void onGet(Data key,
                     javax.cache.expiry.ExpiryPolicy expiryPolicy,
                     Object value,
                     R record)

onGetError

protected void onGetError(Data key,
                          javax.cache.expiry.ExpiryPolicy expiryPolicy,
                          Object value,
                          R record,
                          Throwable error)

get
```
public Object get(Data key,
                  javax.cache.expiry.ExpiryPolicy expiryPolicy)
```
Description copied from interface: ICacheRecordStore

Gets the value to which the specified key is mapped, or null if this cache contains no mapping for the key.
If the cache is configured to use read-through, and get would return null because the entry is missing from the cache, the Cache's CacheLoader is called in an attempt to load the entry.

Specified by:

get in interface ICacheRecordStore

Parameters:

key - the key whose associated value is to be returned.

expiryPolicy - custom expiry policy or null to use configured default value.

Returns:

the element, or null, if it does not exist.

evictExpiredEntries
```
public void evictExpiredEntries(int expirationPercentage)
```
Description copied from interface: ICacheRecordStore

Do expiration operations.

Specified by:

evictExpiredEntries in interface ICacheRecordStore

Parameters:

expirationPercentage - of max expirables according to the record store size.

initExpirationIterator

protected void initExpirationIterator()

contains
```
public boolean contains(Data key)
```
Description copied from interface: ICacheRecordStore

Determines if this store contains an entry for the specified key.
More formally, returns true if and only if this store contains a mapping for a key k such that key.equals(k) (There can be at most one such mapping.)

Specified by:

contains in interface ICacheRecordStore

Parameters:

key - key whose presence in this store is to be tested.

Returns:

true if this map contains a mapping for the specified key.

onPut

protected void onPut(Data key,
                     Object value,
                     javax.cache.expiry.ExpiryPolicy expiryPolicy,
                     String source,
                     boolean getValue,
                     boolean disableWriteThrough,
                     R record,
                     Object oldValue,
                     boolean isExpired,
                     boolean isNewPut,
                     boolean isSaveSucceed)

onPutError

protected void onPutError(Data key,
                          Object value,
                          javax.cache.expiry.ExpiryPolicy expiryPolicy,
                          String source,
                          boolean getValue,
                          boolean disableWriteThrough,
                          R record,
                          Object oldValue,
                          boolean wouldBeNewPut,
                          Throwable error)

put

protected Object put(Data key,
                     Object value,
                     javax.cache.expiry.ExpiryPolicy expiryPolicy,
                     String source,
                     boolean getValue,
                     boolean disableWriteThrough,
                     int completionId)

put

protected Object put(Data key,
                     Object value,
                     javax.cache.expiry.ExpiryPolicy expiryPolicy,
                     String source,
                     boolean getValue,
                     int completionId)

put
```
public R put(Data key,
             Object value,
             javax.cache.expiry.ExpiryPolicy expiryPolicy,
             String source,
             int completionId)
```
Description copied from interface: ICacheRecordStore

Associates the specified value with the specified key in this cache, returning an existing value if one existed.
If the cache previously contained a mapping for the key, the old value is replaced by the specified value. (A cache c is said to contain a mapping for a key k if and only if c.contains(k) would return true.)
The previous value is returned, or null if there was no value associated with the key previously.

Specified by:

put in interface ICacheRecordStore

Parameters:

key - key with which the specified value is to be associated.

value - value to be associated with the specified key.

expiryPolicy - custom expiry policy or null to use configured default value.

source - UUID of the calling node or client.

Returns:

the stored CacheRecord (added as new record or updated). null if record has expired.

getAndPut
```
public Object getAndPut(Data key,
                        Object value,
                        javax.cache.expiry.ExpiryPolicy expiryPolicy,
                        String source,
                        int completionId)
```
Description copied from interface: ICacheRecordStore

Associates the specified value with the specified key in this cache, returning an existing value if one existed.
If the cache previously contained a mapping for the key, the old value is replaced by the specified value. (A cache c is said to contain a mapping for a key k if and only if c.contains(k) would return true.)
The previous value is returned, or null if there was no value associated with the key previously.

Specified by:

getAndPut in interface ICacheRecordStore

Parameters:

key - key with which the specified value is to be associated.

value - value to be associated with the specified key.

expiryPolicy - custom expiry policy or null to use configured default value.

source - UUID of the calling node or client.

Returns:

the value associated with the key at the start of the operation or null if none was associated.

onPutIfAbsent

protected void onPutIfAbsent(Data key,
                             Object value,
                             javax.cache.expiry.ExpiryPolicy expiryPolicy,
                             String source,
                             boolean disableWriteThrough,
                             R record,
                             boolean isExpired,
                             boolean isSaveSucceed)

onPutIfAbsentError

protected void onPutIfAbsentError(Data key,
                                  Object value,
                                  javax.cache.expiry.ExpiryPolicy expiryPolicy,
                                  String source,
                                  boolean disableWriteThrough,
                                  R record,
                                  Throwable error)

putIfAbsent

protected boolean putIfAbsent(Data key,
                              Object value,
                              javax.cache.expiry.ExpiryPolicy expiryPolicy,
                              String source,
                              boolean disableWriteThrough,
                              int completionId)

putIfAbsent
```
public boolean putIfAbsent(Data key,
                           Object value,
                           javax.cache.expiry.ExpiryPolicy expiryPolicy,
                           String source,
                           int completionId)
```
Description copied from interface: ICacheRecordStore

Removes the mapping for a key from this cache if it is present.
More formally, if this cache contains a mapping from key k to value v such that (key==null ? k==null : key.equals(k)), that mapping is removed. (The cache can contain at most one such mapping.)

Returns true if this cache previously associated the key, or false if the cache contained no mapping for the key.
The cache will not contain a mapping for the specified key once the call returns.

Specified by:

putIfAbsent in interface ICacheRecordStore

Parameters:

key - key with which the specified value is to be associated.

value - value to be associated with the specified key.

expiryPolicy - custom expiry policy or null to use configured default value.

source - UUID of the calling node or client.

Returns:

true if a value was set..

onReplace

protected void onReplace(Data key,
                         Object oldValue,
                         Object newValue,
                         javax.cache.expiry.ExpiryPolicy expiryPolicy,
                         String source,
                         boolean getValue,
                         R record,
                         boolean isExpired,
                         boolean replaced)

onReplaceError

protected void onReplaceError(Data key,
                              Object oldValue,
                              Object newValue,
                              javax.cache.expiry.ExpiryPolicy expiryPolicy,
                              String source,
                              boolean getValue,
                              R record,
                              boolean isExpired,
                              boolean replaced,
                              Throwable error)

replace
```
public boolean replace(Data key,
                       Object value,
                       javax.cache.expiry.ExpiryPolicy expiryPolicy,
                       String source,
                       int completionId)
```
Description copied from interface: ICacheRecordStore
Atomically replaces the entry for a key only if currently mapped to some 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.
Specified by:

replace in interface ICacheRecordStore

Parameters:

key - the key with which the specified value is associated.

value - the value to be associated with the specified key.

expiryPolicy - custom expiry policy or null to use configured default value.

source - UUID of the calling node or client.

Returns:

true if the value was replaced.

replace
```
public boolean replace(Data key,
                       Object oldValue,
                       Object newValue,
                       javax.cache.expiry.ExpiryPolicy expiryPolicy,
                       String source,
                       int completionId)
```
Description copied from interface: ICacheRecordStore
Atomically replaces the entry for a key only if currently mapped to a given value.
This is equivalent to:
```
 if (cache.containsKey(key) && equals(cache.get(key), oldValue)) {
  cache.put(key, newValue);
 return true;
 } else {
  return false;
 }
 
```
except that the action is performed atomically.
Specified by:

replace in interface ICacheRecordStore

Parameters:

key - key with which the specified value is associated.

oldValue - value expected to be associated with the specified key.

newValue - value to be associated with the specified key.

expiryPolicy - custom expiry policy or null to use configured default value.

source - UUID of the calling node or client.

Returns:

true if the value was replaced.

getAndReplace
```
public Object getAndReplace(Data key,
                            Object value,
                            javax.cache.expiry.ExpiryPolicy expiryPolicy,
                            String source,
                            int completionId)
```
Description copied from interface: ICacheRecordStore
Atomically replaces the value for a given key if and only if there is a value currently mapped by the key.
This is equivalent to
```
 if (cache.containsKey(key)) {
   V oldValue = cache.get(key);
   cache.put(key, value);
   return oldValue;
 } else {
   return null;
 }
 
```
except that the action is performed atomically.
Specified by:

getAndReplace in interface ICacheRecordStore

Parameters:

key - key with which the specified value is associated.

value - value to be associated with the specified key.

expiryPolicy - custom expiry policy or null to use configured default value.

source - uuid of the calling node or client.

Returns:

the previous value associated with the specified key, or null if there was no mapping for the key.

setExpiryPolicy
```
public boolean setExpiryPolicy(Collection<Data> keys,
                               Object expiryPolicy,
                               String source)
```
Description copied from interface: ICacheRecordStore

Sets expiry policy for the records with given keys if and only if there is a value currently mapped by the key

Specified by:

setExpiryPolicy in interface ICacheRecordStore

Parameters:

keys - keys for the entries

expiryPolicy - custom expiry policy or null to use configured default value

getExpiryPolicy
```
public Object getExpiryPolicy(Data key)
```
Specified by:

getExpiryPolicy in interface ICacheRecordStore

onRemove

protected void onRemove(Data key,
                        Object value,
                        String source,
                        boolean getValue,
                        R record,
                        boolean removed)

onRemoveError

protected void onRemoveError(Data key,
                             Object value,
                             String source,
                             boolean getValue,
                             R record,
                             boolean removed,
                             Throwable error)

remove

public boolean remove(Data key,
                      String source,
                      String origin,
                      int completionId)

Specified by:: remove in interface ICacheRecordStore

remove
```
public boolean remove(Data key,
                      String source,
                      String origin,
                      int completionId,
                      CallerProvenance provenance)
```
Description copied from interface: ICacheRecordStore

Removes the mapping for a key from this cache if it is present.
More formally, if this cache contains a mapping from key k to value v such that (key==null ? k==null : key.equals(k)), that mapping is removed. (The cache can contain at most one such mapping.)

Returns true if this cache previously associated the key, or false if the cache contained no mapping for the key.
The cache will not contain a mapping for the specified key once the call returns.

Specified by:

remove in interface ICacheRecordStore

Parameters:

key - key whose mapping is to be removed from the cache.

source - UUID of the calling node or client.

origin - Source of the call

completionId - User generated id which shall be received as a field of the cache event upon completion of the request in the cluster.

provenance - caller operation provenance

Returns:

returns false if there was no matching key.

getExpiredKeysQueue
```
public InvalidationQueue<ExpiredKey> getExpiredKeysQueue()
```
Specified by:

getExpiredKeysQueue in interface ICacheRecordStore

remove
```
public boolean remove(Data key,
                      Object value,
                      String source,
                      String origin,
                      int completionId)
```
Description copied from interface: ICacheRecordStore
Atomically removes the mapping for a key only if currently mapped to the given value.
This is equivalent to:
```
 if (cache.containsKey(key) && equals(cache.get(key), oldValue) {
   cache.remove(key);
   return true;
 } else {
   return false;
 }
 
```
except that the action is performed atomically.
Specified by:

remove in interface ICacheRecordStore

Parameters:

key - key whose mapping is to be removed from the cache.

value - value expected to be associated with the specified key.

source - UUID of the calling node or client.

origin - Source of the call

completionId - User generated id which shall be received as a field of the cache event upon completion of the request in the cluster.

Returns:

returns false if there was no matching key.

markExpirable
```
protected void markExpirable(long expiryTime)
```
This method marks current replica as expirable and also starts expiration task if necessary. The expiration task runs on only primary replicas. Expiration on backup replicas are dictated by primary replicas. However, it is still important to mark a backup replica as expirable because it might be promoted to be the primary in a later time.

Parameters:

expiryTime -

getAndRemove
```
public Object getAndRemove(Data key,
                           String source,
                           int completionId)
```
Description copied from interface: ICacheRecordStore
Atomically removes the entry for a key only if it is currently mapped to some value.
This is equivalent to:
```
 if (cache.containsKey(key)) {
   V oldValue = cache.get(key);
   cache.remove(key);
   return oldValue;
 } else {
   return null;
 }
 
```
except that the action is performed atomically.
Specified by:

getAndRemove in interface ICacheRecordStore

Parameters:

key - key with which the specified value is associated.

source - UUID of the calling node or client.

Returns:

the value if one existed or null if no mapping existed for this key.

getAndRemove

public Object getAndRemove(Data key,
                           String source,
                           int completionId,
                           String origin)

getAll
```
public MapEntries getAll(Set<Data> keySet,
                         javax.cache.expiry.ExpiryPolicy expiryPolicy)
```
Description copied from interface: ICacheRecordStore

Gets a collection of entries from the store, returning them as Map of the values associated with the set of keys requested.
If the cache is configured read-through, and a get for a key would return null because an entry is missing from the cache, the Cache's CacheLoader is called in an attempt to load the entry. If an entry cannot be loaded for a given key, the key will not be present in the returned Map.

Specified by:

getAll in interface ICacheRecordStore

Parameters:

keySet - keys whose associated values are to be returned.

expiryPolicy - custom expiry policy or null to use configured default value.

Returns:

A simple wrapper for map of entries that were found for the given keys. Keys not found in the cache are not in the result.

removeAll
```
public void removeAll(Set<Data> keys,
                      int completionId)
```
Description copied from interface: ICacheRecordStore

records of keys will be deleted one by one and will publish a REMOVE event for each key.

Specified by:

removeAll in interface ICacheRecordStore

Parameters:

keys - set of keys to be cleaned.

loadAll
```
public Set<Data> loadAll(Set<Data> keys,
                         boolean replaceExistingValues)
```
Description copied from interface: ICacheRecordStore

Synchronously loads the specified entries into the cache using the configured CacheLoader for the given keys.
If an entry for a key already exists in the cache, a value will be loaded if and only if replaceExistingValues is true. If no loader is configured for the cache, no objects will be loaded.

Specified by:

loadAll in interface ICacheRecordStore

Parameters:

keys - the keys to be loaded.

replaceExistingValues - when true, existing values in the cache will be replaced by those loaded from a CacheLoader.

Returns:

Set of keys which are successfully loaded.

merge
```
public CacheRecord merge(SplitBrainMergeTypes.CacheMergeTypes mergingEntry,
                         SplitBrainMergePolicy<Data,SplitBrainMergeTypes.CacheMergeTypes> mergePolicy,
                         CallerProvenance callerProvenance)
```
Description copied from interface: ICacheRecordStore

Merges the given SplitBrainMergeTypes.CacheMergeTypes via the given SplitBrainMergePolicy.

Specified by:

merge in interface ICacheRecordStore

Parameters:

mergingEntry - the SplitBrainMergeTypes.CacheMergeTypes instance to merge

mergePolicy - the SplitBrainMergePolicy instance to apply

Returns:

the used CacheRecord if merge is applied, otherwise null

merge
```
public CacheRecord merge(CacheEntryView<Data,Data> cacheEntryView,
                         CacheMergePolicy mergePolicy,
                         String caller,
                         String origin,
                         int completionId,
                         CallerProvenance callerProvenance)
```
Description copied from interface: ICacheRecordStore

Merges the given CacheEntryView via the given CacheMergePolicy.

Specified by:

merge in interface ICacheRecordStore

Parameters:

cacheEntryView - the CacheEntryView instance to merge

mergePolicy - the CacheMergePolicy instance to apply

caller - the UUID of the caller

origin - source of the call

completionId - User generated id which shall be received as a field of the cache event upon completion of the request in the cluster.

Returns:

the used CacheRecord if merge is applied, otherwise null

fetchKeys
```
public CacheKeyIterationResult fetchKeys(int tableIndex,
                                         int size)
```
Description copied from interface: ICacheRecordStore

Starting from the provided table index, a set of keys are returned with a maximum size of size

Specified by:

fetchKeys in interface ICacheRecordStore

Parameters:

tableIndex - initial table index.

size - maximum key set size.

Returns:

CacheKeyIterationResult which wraps keys and last tableIndex.

fetchEntries
```
public CacheEntryIterationResult fetchEntries(int tableIndex,
                                              int size)
```
Description copied from interface: ICacheRecordStore

Starting from the provided table index, a set of entries are returned with a maximum size of size

Specified by:

fetchEntries in interface ICacheRecordStore

Parameters:

tableIndex - initial table index.

size - maximum entry set size.

Returns:

CacheEntryIterationResult which wraps entries and last tableIndex.

invoke
```
public Object invoke(Data key,
                     javax.cache.processor.EntryProcessor entryProcessor,
                     Object[] arguments,
                     int completionId)
```
Description copied from interface: ICacheRecordStore

Invokes an EntryProcessor against the Cache.Entry specified by the provided key. If an Cache.Entry does not exist for the specified key, an attempt is made to load it (if a loader is configured) or a surrogate Cache.Entry, consisting of the key with a null value is used instead.

Specified by:

invoke in interface ICacheRecordStore

Parameters:

key - the key of the entry.

entryProcessor - the EntryProcessor to be invoked.

arguments - additional arguments to be passed to the EntryProcessor.

Returns:

the result of the processing, if any, defined by the EntryProcessor implementation.

size
```
public int size()
```
Description copied from interface: ICacheRecordStore

Calculates the entry size of this store which reflects the partition size of the cache.

Specified by:

size in interface ICacheRecordStore

Returns:

partition size of the cache.

getCacheStats
```
public CacheStatisticsImpl getCacheStats()
```
Description copied from interface: ICacheRecordStore

Gets the Cache statistics associated with this CacheService.

Specified by:

getCacheStats in interface ICacheRecordStore

Returns:

CacheStatisticsImpl cache statistics.

getConfig
```
public CacheConfig getConfig()
```
Description copied from interface: ICacheRecordStore

Gets the configuration of the cache that this store belongs to.

Specified by:

getConfig in interface ICacheRecordStore

Returns:

CacheConfig

getName
```
public String getName()
```
Gets the name of the distributed object name of the cache.

Specified by:

getName in interface ICacheRecordStore

Returns:

the full name of the cache, including the manager scope prefix

getReadOnlyRecords
```
public Map<Data,CacheRecord> getReadOnlyRecords()
```
Description copied from interface: ICacheRecordStore

Returns a readonly map of the internal key value store.

Specified by:

getReadOnlyRecords in interface ICacheRecordStore

Returns:

readonly map of the internal key value store.

clear
```
public void clear()
```
Description copied from interface: ICacheRecordStore

clears all internal data without publishing any events

Specified by:

clear in interface ICacheRecordStore

destroyEventJournal
```
protected void destroyEventJournal()
```

reset
```
public void reset()
```
Description copied from interface: ICacheRecordStore

Resets the record store to it's initial state. Used in replication operations.

Specified by:

reset in interface ICacheRecordStore

close
```
public void close(boolean onShutdown)
```
Description copied from interface: ICacheRecordStore
Close is equivalent to below operations in the given order:
- close resources.
- unregister all listeners.
Specified by:

close in interface ICacheRecordStore

Parameters:

onShutdown - true if close is called during CacheService shutdown, false otherwise.

See Also:

ICacheRecordStore.clear(), ICacheRecordStore.destroy()

destroy
```
public void destroy()
```
Description copied from interface: ICacheRecordStore
Destroy is equivalent to below operations in the given order:
- clear all.
- close resources.
- unregister all listeners.
Specified by:

destroy in interface ICacheRecordStore

See Also:

ICacheRecordStore.clear(), ICacheRecordStore.close(boolean)

destroyInternals
```
public void destroyInternals()
```
Description copied from interface: ICacheRecordStore

Like ICacheRecordStore.destroy() but does not touch state on other services like event journal service.

Specified by:

destroyInternals in interface ICacheRecordStore

onDestroy
```
protected void onDestroy()
```

closeListeners
```
protected void closeListeners()
```

isWanReplicationEnabled
```
public boolean isWanReplicationEnabled()
```
Description copied from interface: ICacheRecordStore

Determines whether wan replication is enabled or not for this record store.

Specified by:

isWanReplicationEnabled in interface ICacheRecordStore

Returns:

true if wan replication is enabled for this record store, false otherwise

getObjectNamespace
```
public ObjectNamespace getObjectNamespace()
```
Description copied from interface: ICacheRecordStore

Returns ObjectNamespace associated with this record store.

Specified by:

getObjectNamespace in interface ICacheRecordStore

Returns:

ObjectNamespace associated with this record store.

getPartitionId
```
public int getPartitionId()
```
Specified by:

getPartitionId in interface ICacheRecordStore

Returns:

partition ID of this store

Class AbstractCacheRecordStore<R extends CacheRecord,CRM extends SampleableCacheRecordMap<Data,R>>

Field Summary

Fields inherited from interface com.hazelcast.internal.eviction.EvictionListener

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Methods inherited from interface com.hazelcast.cache.impl.ICacheRecordStore

Field Detail

SOURCE_NOT_AVAILABLE

DEFAULT_INITIAL_CAPACITY

partitionId

partitionCount

wanReplicationEnabled

persistWanReplicatedData

disablePerEntryInvalidationEvents

name

nodeEngine

cacheConfig

ss

evictionConfig

valueComparator

evictionChecker

objectNamespace

cacheService

cacheRecordFactory

eventJournalConfig

clearExpiredRecordsTask

evictionStrategy

evictionPolicyEvaluator

batchEvent

primary

eventsEnabled

eventsBatchingEnabled

records

cacheLoader

cacheWriter

cacheContext

statistics

defaultExpiryPolicy

expirationIterator

expiredKeys

hasEntryWithExpiration

Constructor Detail

AbstractCacheRecordStore

Method Detail

getValueComparatorOf

instrument

init

isReadThrough

isWriteThrough

isStatisticsEnabled

createRecordCacheMap

createCacheEntryProcessorEntry

createRecord

valueToData

dataToValue

recordToValue

recordToData

toHeapData

createCacheEvictionChecker

createEvictionPolicyEvaluator

createEvictionStrategy

isEvictionEnabled

isEventsEnabled

isInvalidationEnabled

evictIfRequired

sampleAndForceRemoveEntries

forceRemoveRecord

toData

toValue

toStorageValue

toEventData

getExpiryPolicy

evictIfExpired

processExpiredEntry

processExpiredEntry

processExpiredEntry

processExpiredEntry

processExpiredEntry

onProcessExpiredEntry