AbstractCacheRecordStore (Hazelcast Root 3.8.5 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>

Nested Class Summary

Nested Classes
Modifier and Type Class and Description

protected class AbstractCacheRecordStore.MaxSizeEvictionChecker

Nested Classes
Modifier and Type	Class and Description
`protected class`	`AbstractCacheRecordStore.MaxSizeEvictionChecker`

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 AbstractCacheService`	`cacheService`
`protected javax.cache.integration.CacheWriter`	`cacheWriter`
`protected static int`	`DEFAULT_INITIAL_CAPACITY`
`protected javax.cache.expiry.ExpiryPolicy`	`defaultExpiryPolicy`
`protected boolean`	`disablePerEntryInvalidationEvents`
`protected boolean`	`eventsBatchingEnabled`
`protected boolean`	`eventsEnabled`
`protected EvictionChecker`	`evictionChecker`
`protected EvictionConfig`	`evictionConfig`
`protected EvictionPolicyEvaluator<Data,R>`	`evictionPolicyEvaluator`
`protected EvictionStrategy<Data,R,CRM>`	`evictionStrategy`
`protected MaxSizeChecker`	`maxSizeChecker`
`protected String`	`name`
`protected NodeEngine`	`nodeEngine`
`protected int`	`partitionCount`
`protected int`	`partitionId`
`protected boolean`	`primary`
`protected CRM`	`records`
`static String`	`SOURCE_NOT_AVAILABLE`
`protected CacheStatisticsImpl`	`statistics`
`protected boolean`	`wanReplicationEnabled`

Fields inherited from interface com.hazelcast.cache.impl.ICacheRecordStore
UNIT_PERCENTAGE

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

Constructor Summary

Constructors
Constructor and Description
`AbstractCacheRecordStore(String name, 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)`
`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 MaxSizeChecker`	`createCacheMaxSizeChecker(int size, EvictionConfig.MaxSizePolicy maxSizePolicy)` Creates an instance for checking if the maximum cache size has been reached.
`protected EvictionChecker`	`createEvictionChecker(EvictionConfig cacheEvictionConfig)`
`protected EvictionPolicyEvaluator<Data,R>`	`createEvictionPolicyEvaluator(EvictionConfig evictionConfig)`
`protected EvictionStrategy<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 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.
`R`	`doPutRecord(Data key, R record)`
`protected R`	`doPutRecord(Data key, R record, String source)`
`protected R`	`doRemoveRecord(Data key)`
`protected R`	`doRemoveRecord(Data key, String source)`
`int`	`evictIfRequired()` Evict cache record store if eviction is required.
`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`
`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.
`protected javax.cache.expiry.ExpiryPolicy`	`getExpiryPolicy(javax.cache.expiry.ExpiryPolicy expiryPolicy)`
`String`	`getName()` Gets the name of the distributed object name of the cache.
`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.
`void`	`init()` Initializes record store.
`void`	`instrument(NodeEngine nodeEngine)`
`protected void`	`invalidateAllEntries()`
`protected void`	`invalidateAllEntries(String source)`
`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()`
`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`	`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, Data dataValue, boolean deleted)`
`protected void`	`onDeleteRecordError(Data key, R record, Data dataValue, boolean deleted, Throwable error)`
`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`	`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)` 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, int completionId)` Atomically removes the mapping for a key only if currently mapped to the given value.
`boolean`	`remove(Data key, Object value, String source, int completionId, String origin)`
`boolean`	`remove(Data key, String source, int completionId)` Removes the mapping for a key from this cache if it is present.
`boolean`	`remove(Data key, String source, int completionId, String origin)`
`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.
`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`	`updateGetAndPutStat(boolean isPutSucceed, boolean getValue, boolean oldValueNull, long start)`
`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 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

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

name
```
protected final String name
```

partitionId
```
protected final int partitionId
```

partitionCount
```
protected final int partitionCount
```

nodeEngine
```
protected final NodeEngine nodeEngine
```

cacheService

protected final AbstractCacheService cacheService

cacheConfig

protected final CacheConfig cacheConfig

evictionConfig

protected final EvictionConfig evictionConfig

batchEvent

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

maxSizeChecker

protected final MaxSizeChecker maxSizeChecker

evictionPolicyEvaluator

protected final EvictionPolicyEvaluator<Data,R extends CacheRecord> evictionPolicyEvaluator

evictionChecker

protected final EvictionChecker evictionChecker

evictionStrategy

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

wanReplicationEnabled

protected final boolean wanReplicationEnabled

disablePerEntryInvalidationEvents

protected final boolean disablePerEntryInvalidationEvents

records

protected CRM extends SampleableCacheRecordMap<Data,R> records

cacheContext
```
protected CacheContext cacheContext
```

statistics

protected CacheStatisticsImpl statistics

cacheLoader

protected javax.cache.integration.CacheLoader cacheLoader

cacheWriter

protected javax.cache.integration.CacheWriter cacheWriter

eventsEnabled
```
protected boolean eventsEnabled
```

eventsBatchingEnabled

protected boolean eventsBatchingEnabled

defaultExpiryPolicy

protected javax.cache.expiry.ExpiryPolicy defaultExpiryPolicy

primary
```
protected boolean primary
```

Constructor Detail

AbstractCacheRecordStore

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

Method Detail

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)

createCacheMaxSizeChecker
```
protected MaxSizeChecker createCacheMaxSizeChecker(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)

createEvictionChecker

protected EvictionChecker createEvictionChecker(EvictionConfig cacheEvictionConfig)

createEvictionStrategy

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

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

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

isInvalidationEnabled

protected boolean isInvalidationEnabled()

evictIfRequired
```
public int 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:

the number of evicted records.

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(javax.cache.expiry.ExpiryPolicy expiryPolicy)

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)

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)

invalidateAllEntries
```
protected void invalidateAllEntries()
```

invalidateAllEntries

protected void invalidateAllEntries(String source)

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)

updateRecord

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

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)

onDeleteRecord

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

onDeleteRecordError

protected void onDeleteRecordError(Data key,
                                   R record,
                                   Data dataValue,
                                   boolean deleted,
                                   Throwable error)

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)

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)
```
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.

doPutRecord

public final R doPutRecord(Data key,
                           R record)

doPutRecord

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

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)
```

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.

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.

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,
                      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:

remove in interface ICacheRecordStore

Parameters:

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

source - uuid of the calling node or client.

Returns:

returns false if there was no matching key.

remove

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

remove
```
public boolean remove(Data key,
                      Object value,
                      String source,
                      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.

Returns:

returns false if there was no matching key.

remove

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

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.

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()
```
Description copied from interface: ICacheRecordStore

Gets the name of the distributed object name of the cache.

Specified by:

getName in interface ICacheRecordStore

Returns:

name.

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

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)

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

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

Nested Class Summary

Field Summary

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

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

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

SOURCE_NOT_AVAILABLE

DEFAULT_INITIAL_CAPACITY

name

partitionId

partitionCount

nodeEngine

cacheService

cacheConfig

evictionConfig

batchEvent

maxSizeChecker

evictionPolicyEvaluator

evictionChecker

evictionStrategy

wanReplicationEnabled

disablePerEntryInvalidationEvents

records

cacheContext

statistics

cacheLoader

cacheWriter

eventsEnabled

eventsBatchingEnabled

defaultExpiryPolicy

primary

Constructor Detail

AbstractCacheRecordStore

Method Detail

instrument

init

isReadThrough

isWriteThrough

isStatisticsEnabled

createRecordCacheMap

createCacheEntryProcessorEntry

createRecord

valueToData

dataToValue

recordToValue

recordToData

toHeapData

createCacheMaxSizeChecker

createEvictionPolicyEvaluator

createEvictionChecker

createEvictionStrategy

isEvictionEnabled

isEventsEnabled

isInvalidationEnabled

evictIfRequired

toData

toValue

toStorageValue

toEventData

getExpiryPolicy

processExpiredEntry

processExpiredEntry

processExpiredEntry

processExpiredEntry

processExpiredEntry

onProcessExpiredEntry

accessRecord

onEvict

invalidateEntry

invalidateEntry

invalidateAllEntries

invalidateAllEntries

updateGetAndPutStat

updateAccessDuration

onRecordAccess

updateReplaceStat

publishEvent