NearCachedClientCacheProxy (Hazelcast Root 3.12.12 API)

java.lang.Object
- com.hazelcast.client.spi.ClientProxy
- - com.hazelcast.client.cache.impl.ClientCacheProxy<K,V>
  - - com.hazelcast.client.cache.impl.NearCachedClientCacheProxy<K,V>

Type Parameters:

K - the type of key.

V - the type of value.

All Implemented Interfaces:

ICache<K,V>, CacheSyncListenerCompleter, ICacheInternal<K,V>, DistributedObject, PrefixedDistributedObject, EventJournalReader<EventJournalCacheEvent<K,V>>, Closeable, AutoCloseable, Iterable<javax.cache.Cache.Entry<K,V>>, javax.cache.Cache<K,V>
```
public class NearCachedClientCacheProxy<K,V>
extends ClientCacheProxy<K,V>
```
An ICacheInternal implementation which handles Near Cache specific behaviour of methods.

Nested Class Summary
- Nested classes/interfaces inherited from interface javax.cache.Cache
  javax.cache.Cache.Entry<K,V>

Field Summary

Fields
Modifier and Type	Field and Description
`protected CacheConfig<K,V>`	`cacheConfig`
`protected AtomicReference<HazelcastClientCacheManager>`	`cacheManagerRef`
`protected ILogger`	`logger`
`protected String`	`name`
`protected String`	`nameWithPrefix`
`protected int`	`partitionCount`

Method Summary

All Methods Static Methods Instance Methods Concrete Methods Deprecated Methods
Modifier and Type	Method and Description
`protected static <T> void`	`addCallback(ClientDelegatingFuture<T> delegatingFuture, ExecutionCallback<T> callback)`
`protected void`	`addListenerLocally(String regId, javax.cache.configuration.CacheEntryListenerConfiguration<K,V> cacheEntryListenerConfiguration, CacheEventListenerAdaptor<K,V> adaptor)`
`String`	`addNearCacheInvalidationListener(EventHandler eventHandler)`
`void`	`clear()`
`protected void`	`clearInternal()`
`void`	`close()`
`protected void`	`closeListeners()`
`protected boolean`	`containsKeyInternal(Object key)`
`void`	`countDownCompletionLatch(int countDownLatchId)`
`protected EventHandler`	`createHandler(CacheEventListenerAdaptor<K,V> adaptor)`
`protected void`	`deregisterCompletionLatch(Integer countDownLatchId)`
`V`	`get(K key, javax.cache.expiry.ExpiryPolicy expiryPolicy)` Retrieves the mapped value of the given key using a custom `ExpiryPolicy`.
`Map<K,V>`	`getAll(Set<? extends K> keys, javax.cache.expiry.ExpiryPolicy expiryPolicy)` Gets a collection of entries from the cache with custom expiry policy, returning them as `Map` of the values associated with the set of keys requested.
`protected void`	`getAllInternal(Set<? extends K> keys, Collection<Data> dataKeys, javax.cache.expiry.ExpiryPolicy expiryPolicy, List<Object> resultingKeyValuePairs, long startNanos)`
`V`	`getAndPut(K key, V value, javax.cache.expiry.ExpiryPolicy expiryPolicy)` Associates the specified value with the specified key in this cache using a custom `ExpiryPolicy`, returning an existing value if one existed.
`ICompletableFuture<V>`	`getAndPutAsync(K key, V value)` Asynchronously associates the specified value with the specified key in this cache, returning an existing value if one existed.
`ICompletableFuture<V>`	`getAndPutAsync(K key, V value, javax.cache.expiry.ExpiryPolicy expiryPolicy)` Asynchronously associates the specified value with the specified key in this cache, returning an existing value if one existed using a custom `ExpiryPolicy`.
`ICompletableFuture<V>`	`getAndRemoveAsync(K key)` Asynchronously removes the entry for a key and returns the previously assigned value or null if no value was assigned.
`protected <T> ICompletableFuture<T>`	`getAndRemoveAsyncInternal(K key)`
`protected <T> ClientDelegatingFuture<T>`	`getAndRemoveSyncInternal(K key)`
`V`	`getAndReplace(K key, V value, javax.cache.expiry.ExpiryPolicy expiryPolicy)` Atomically replaces the assigned value of the given key by the specified value using a custom `ExpiryPolicy` and returns the previously assigned value.
`ICompletableFuture<V>`	`getAndReplaceAsync(K key, V value)` Asynchronously replaces the assigned value of the given key by the specified value and returns the previously assigned value.
`ICompletableFuture<V>`	`getAndReplaceAsync(K key, V value, javax.cache.expiry.ExpiryPolicy expiryPolicy)` Asynchronously replaces the assigned value of the given key by the specified value using a custom `ExpiryPolicy` and returns the previously assigned value.
`ICompletableFuture<V>`	`getAsync(K key)` Asynchronously retrieves the mapped value of the given key using a custom `ExpiryPolicy`.
`ICompletableFuture<V>`	`getAsync(K key, javax.cache.expiry.ExpiryPolicy expiryPolicy)` Asynchronously gets an entry from cache using a custom `ExpiryPolicy`.
`protected InternalCompletableFuture<V>`	`getAsyncInternal(Object key, javax.cache.expiry.ExpiryPolicy expiryPolicy, ExecutionCallback<V> callback)`
`protected String`	`getDistributedObjectName()`
`protected String`	`getListenerIdLocal(javax.cache.configuration.CacheEntryListenerConfiguration<K,V> cacheEntryListenerConfiguration)`
`CacheStatistics`	`getLocalCacheStatistics()` Directly access local Cache Statistics.
`String`	`getNameWithPrefix()` Deprecated. use #getPrefixedName instead
`NearCache`	`getNearCache()`
`String`	`getPrefixedName()` Returns the unique prefixed name for this DistributedObject.
`protected <T> T`	`getSafely(Future<T> future)`
`protected V`	`getSyncInternal(Object key, javax.cache.expiry.ExpiryPolicy expiryPolicy)`
`protected void`	`injectDependencies(Object obj)`
`protected <T> T`	`invoke(ClientMessage clientMessage)`
`protected ClientMessage`	`invoke(ClientMessage clientMessage, Data keyData)`
`protected ClientInvocationFuture`	`invoke(ClientMessage req, Data keyData, int completionId)`
`protected ClientInvocationFuture`	`invoke(ClientMessage req, int partitionId, int completionId)`
`protected Object`	`invokeInternal(Object key, Data epData, Object[] arguments)`
`boolean`	`isClosed()`
`boolean`	`isDestroyed()` Determines whether this Cache instance has been destroyed.
`protected void`	`loadAllInternal(Set<? extends K> keys, List<Data> dataKeys, boolean replaceExistingValues, javax.cache.integration.CompletionListener completionListener)`
`protected <T> ClientDelegatingFuture<T>`	`newDelegatingFuture(ClientInvocationFuture future, ClientMessageDecoder decoder)`
`protected <T> ClientDelegatingFuture<T>`	`newDelegatingFuture(ClientInvocationFuture future, ClientMessageDecoder decoder, boolean deserializeResponse)`
`protected com.hazelcast.client.cache.impl.OneShotExecutionCallback<V>`	`newStatsCallbackOrNull(boolean isGet)`
`protected int`	`nextCompletionId()`
`protected void`	`onDestroy()` Called before proxy is destroyed.
`protected <T> void`	`onGetAndRemoveAsyncInternal(K key, Data keyData, ClientDelegatingFuture<T> delegatingFuture, ExecutionCallback<T> callback)`
`protected void`	`onInitialize()` Called when proxy is created.
`protected void`	`onPutIfAbsentAsyncInternal(K key, V value, Data keyData, Data valueData, ClientDelegatingFuture<Boolean> delegatingFuture, ExecutionCallback<Boolean> callback)`
`protected void`	`onPutIfAbsentSyncInternal(K key, V value, Data keyData, Data valueData)`
`protected void`	`onPutSyncInternal(K key, V value, Data keyData, Data valueData)`
`protected void`	`onRemoveAsyncInternal(Object key, Data keyData, ClientDelegatingFuture future, ExecutionCallback callback)`
`void`	`onRemoveSyncInternal(Object key, Data keyData)`
`protected <T> void`	`onReplaceAndGetAsync(K key, V value, Data keyData, Data valueData, ClientDelegatingFuture<T> delegatingFuture, ExecutionCallback<T> callback)`
`protected <T> void`	`onReplaceInternalAsync(K key, V value, Data keyData, Data valueData, ClientDelegatingFuture<T> delegatingFuture, ExecutionCallback<T> callback)`
`void`	`open()` Opens cache if available (not destroyed).
`protected void`	`postDestroy()` Called after proxy is destroyed.
`protected boolean`	`preDestroy()` Called before proxy is destroyed and determines whether destroy should be done.
`void`	`put(K key, V value, javax.cache.expiry.ExpiryPolicy expiryPolicy)` Associates the specified value with the specified key in the cache using a custom `ExpiryPolicy`.
`void`	`putAll(Map<? extends K,? extends V> map, javax.cache.expiry.ExpiryPolicy expiryPolicy)` Copies all of the entries from the given map to the cache using a custom `ExpiryPolicy`.
`protected void`	`putAllInternal(Map<? extends K,? extends V> map, javax.cache.expiry.ExpiryPolicy expiryPolicy, Map<Object,Data> keyMap, List<Map.Entry<Data,Data>>[] entriesPerPartition, long startNanos)`
`ICompletableFuture<Void>`	`putAsync(K key, V value)` Asynchronously associates the specified value with the specified key in the cache.
`ICompletableFuture<Void>`	`putAsync(K key, V value, javax.cache.expiry.ExpiryPolicy expiryPolicy)` Asynchronously associates the specified value with the specified key in the cache using a custom `ExpiryPolicy`.
`protected ClientDelegatingFuture`	`putAsyncInternal(K key, V value, javax.cache.expiry.ExpiryPolicy expiryPolicy, boolean isGet, boolean withCompletionEvent, com.hazelcast.client.cache.impl.OneShotExecutionCallback<V> callback)`
`boolean`	`putIfAbsent(K key, V value, javax.cache.expiry.ExpiryPolicy expiryPolicy)` Associates the specified key with the given value if and only if there is not yet a mapping defined for the specified key.
`ICompletableFuture<Boolean>`	`putIfAbsentAsync(K key, V value)` Asynchronously associates the specified key with the given value if and only if there is not yet a mapping defined for the specified key.
`ICompletableFuture<Boolean>`	`putIfAbsentAsync(K key, V value, javax.cache.expiry.ExpiryPolicy expiryPolicy)` Asynchronously associates the specified key with the given value if and only if there is not yet a mapping defined for the specified key.
`protected Object`	`putIfAbsentInternal(K key, V value, javax.cache.expiry.ExpiryPolicy expiryPolicy, boolean withCompletionEvent, boolean async)`
`protected V`	`putSyncInternal(K key, V value, javax.cache.expiry.ExpiryPolicy expiryPolicy, boolean isGet)`
`protected Integer`	`registerCompletionLatch(Integer countDownLatchId, int count)`
`void`	`removeAll()`
`protected void`	`removeAllInternal()`
`protected void`	`removeAllKeysInternal(Set<? extends K> keys, Collection<Data> dataKeys, long startNanos)`
`ICompletableFuture<Boolean>`	`removeAsync(K key)` Asynchronously removes the mapping for a key from this cache if it is present.
`ICompletableFuture<Boolean>`	`removeAsync(K key, V oldValue)` Asynchronously removes the mapping for the given key if and only if the currently mapped value equals to the value of `oldValue`.
`protected Object`	`removeAsyncInternal(K key, V oldValue, boolean hasOldValue, boolean withCompletionEvent, boolean async)`
`protected String`	`removeListenerLocally(javax.cache.configuration.CacheEntryListenerConfiguration<K,V> cacheEntryListenerConfiguration)`
`boolean`	`replace(K key, V value, javax.cache.expiry.ExpiryPolicy expiryPolicy)` Atomically replaces the assigned value of the given key by the specified value using a custom `ExpiryPolicy`.
`boolean`	`replace(K key, V oldValue, V newValue, javax.cache.expiry.ExpiryPolicy expiryPolicy)` Atomically replaces the currently assigned value for the given key with the specified `newValue` if and only if the currently assigned value equals the value of `oldValue` using a custom `ExpiryPolicy`.
`protected <T> ICompletableFuture<T>`	`replaceAndGetAsyncInternal(K key, V oldValue, V newValue, javax.cache.expiry.ExpiryPolicy expiryPolicy, boolean hasOldValue, boolean withCompletionEvent, boolean async)`
`ICompletableFuture<Boolean>`	`replaceAsync(K key, V value)` Asynchronously replaces the assigned value of the given key by the specified value.
`ICompletableFuture<Boolean>`	`replaceAsync(K key, V value, javax.cache.expiry.ExpiryPolicy expiryPolicy)` Asynchronously replaces the assigned value of the given key by the specified value using a custom `ExpiryPolicy`.
`ICompletableFuture<Boolean>`	`replaceAsync(K key, V oldValue, V newValue)` Asynchronously replaces the currently assigned value for the given key with the specified `newValue` if and only if the currently assigned value equals the value of `oldValue`.
`ICompletableFuture<Boolean>`	`replaceAsync(K key, V oldValue, V newValue, javax.cache.expiry.ExpiryPolicy expiryPolicy)` Asynchronously replaces the currently assigned value for the given key with the specified `newValue` if and only if the currently assigned value equals the value of `oldValue` using a custom `ExpiryPolicy`.
`protected <T> ICompletableFuture<T>`	`replaceAsyncInternal(K key, V oldValue, V newValue, javax.cache.expiry.ExpiryPolicy expiryPolicy, boolean hasOldValue, boolean withCompletionEvent, boolean async)`
`protected boolean`	`replaceSyncInternal(K key, V oldValue, V newValue, javax.cache.expiry.ExpiryPolicy expiryPolicy, boolean hasOldValue)`
`void`	`resetCacheManager()` Reset cache manager of this cache proxy to `null`.
`void`	`setCacheManager(HazelcastCacheManager cacheManager)` Sets relevant `HazelcastCacheManager` to client/server.
`boolean`	`setExpiryPolicy(K key, javax.cache.expiry.ExpiryPolicy expiryPolicy)` Associates the specified key with the given `ExpiryPolicy`.
`void`	`setExpiryPolicy(Set<? extends K> keys, javax.cache.expiry.ExpiryPolicy policy)` Associates the specified key with the given `ExpiryPolicy`.
`protected boolean`	`setExpiryPolicyInternal(K key, javax.cache.expiry.ExpiryPolicy expiryPolicy)`
`void`	`setExpiryPolicyInternal(Set<? extends K> keys, javax.cache.expiry.ExpiryPolicy expiryPolicy)`
`protected void`	`setExpiryPolicyInternal(Set<? extends K> keys, javax.cache.expiry.ExpiryPolicy policy, Set<Data> serializedKeys)`
`int`	`size()` Total entry count.
`protected void`	`submitLoadAllTask(ClientMessage request, javax.cache.integration.CompletionListener completionListener, List<Data> binaryKeys)`
`protected void`	`waitCompletionLatch(Integer countDownLatchId, ICompletableFuture future)`
`protected ClientDelegatingFuture<V>`	`wrapPutAsyncFuture(K key, V value, Data keyData, Data valueData, ClientInvocationFuture invocationFuture, com.hazelcast.client.cache.impl.OneShotExecutionCallback<V> callback)`

Methods inherited from class com.hazelcast.client.cache.impl.ClientCacheProxy
addPartitionLostListener, containsKey, deregisterCacheEntryListener, get, getAll, getAndPut, getAndRemove, getAndReplace, getCacheManager, getConfiguration, invoke, invokeAll, iterator, iterator, iterator, loadAll, onLoadAll, put, putAll, putIfAbsent, readFromEventJournal, registerCacheEntryListener, registerCacheEntryListener, remove, remove, removeAll, removePartitionLostListener, replace, replace, subscribeToEventJournal, unwrap, updateCacheListenerConfigOnOtherNodes

Methods inherited from class com.hazelcast.client.spi.ClientProxy
deregisterListener, destroy, destroyLocally, destroyRemotely, equals, getClient, getConnectedServerVersion, getContext, getId, getName, getPartitionKey, getSerializationService, getServiceName, hashCode, invoke, invokeOnAddress, invokeOnPartition, invokeOnPartitionInterruptibly, onShutdown, registerListener, setContext, toData, toObject

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

Methods inherited from interface com.hazelcast.cache.ICache
destroy

Methods inherited from interface javax.cache.Cache
getName

Methods inherited from interface java.lang.Iterable
forEach, spliterator

Methods inherited from interface com.hazelcast.core.DistributedObject
getName, getPartitionKey, getServiceName

- Field Detail
  - cacheManagerRef
```
protected final AtomicReference<HazelcastClientCacheManager> cacheManagerRef
```
  - partitionCount
```
protected int partitionCount
```
  - name
```
protected final String name
```
  - nameWithPrefix
```
protected final String nameWithPrefix
```
  - cacheConfig
```
protected final CacheConfig<K,V> cacheConfig
```
  - logger
```
protected ILogger logger
```
- Method Detail
  - getNearCache
```
public NearCache getNearCache()
```
  - onInitialize
```
protected void onInitialize()
```
    Description copied from class: ClientProxy
    
    Called when proxy is created. Overriding implementations can add initialization specific logic into this method like registering a listener, creating a cleanup task etc.
    
    Overrides:
    
    onInitialize in class ClientCacheProxy<K,V>
  - getSyncInternal
```
protected V getSyncInternal(Object key,
                            javax.cache.expiry.ExpiryPolicy expiryPolicy)
```
  - getAsyncInternal
```
protected InternalCompletableFuture<V> getAsyncInternal(Object key,
                                                        javax.cache.expiry.ExpiryPolicy expiryPolicy,
                                                        ExecutionCallback<V> callback)
```
  - onPutSyncInternal
```
protected void onPutSyncInternal(K key,
                                 V value,
                                 Data keyData,
                                 Data valueData)
```
  - onPutIfAbsentSyncInternal
```
protected void onPutIfAbsentSyncInternal(K key,
                                         V value,
                                         Data keyData,
                                         Data valueData)
```
  - onPutIfAbsentAsyncInternal
```
protected void onPutIfAbsentAsyncInternal(K key,
                                          V value,
                                          Data keyData,
                                          Data valueData,
                                          ClientDelegatingFuture<Boolean> delegatingFuture,
                                          ExecutionCallback<Boolean> callback)
```
  - wrapPutAsyncFuture
```
protected ClientDelegatingFuture<V> wrapPutAsyncFuture(K key,
                                                       V value,
                                                       Data keyData,
                                                       Data valueData,
                                                       ClientInvocationFuture invocationFuture,
                                                       com.hazelcast.client.cache.impl.OneShotExecutionCallback<V> callback)
```
  - onGetAndRemoveAsyncInternal
```
protected <T> void onGetAndRemoveAsyncInternal(K key,
                                               Data keyData,
                                               ClientDelegatingFuture<T> delegatingFuture,
                                               ExecutionCallback<T> callback)
```
  - onReplaceInternalAsync
```
protected <T> void onReplaceInternalAsync(K key,
                                          V value,
                                          Data keyData,
                                          Data valueData,
                                          ClientDelegatingFuture<T> delegatingFuture,
                                          ExecutionCallback<T> callback)
```
  - onReplaceAndGetAsync
```
protected <T> void onReplaceAndGetAsync(K key,
                                        V value,
                                        Data keyData,
                                        Data valueData,
                                        ClientDelegatingFuture<T> delegatingFuture,
                                        ExecutionCallback<T> callback)
```
  - getAllInternal
```
protected void getAllInternal(Set<? extends K> keys,
                              Collection<Data> dataKeys,
                              javax.cache.expiry.ExpiryPolicy expiryPolicy,
                              List<Object> resultingKeyValuePairs,
                              long startNanos)
```
  - setExpiryPolicyInternal
```
public void setExpiryPolicyInternal(Set<? extends K> keys,
                                    javax.cache.expiry.ExpiryPolicy expiryPolicy)
```
  - setExpiryPolicyInternal
```
protected boolean setExpiryPolicyInternal(K key,
                                          javax.cache.expiry.ExpiryPolicy expiryPolicy)
```
  - putAllInternal
```
protected void putAllInternal(Map<? extends K,? extends V> map,
                              javax.cache.expiry.ExpiryPolicy expiryPolicy,
                              Map<Object,Data> keyMap,
                              List<Map.Entry<Data,Data>>[] entriesPerPartition,
                              long startNanos)
```
  - containsKeyInternal
```
protected boolean containsKeyInternal(Object key)
```
    Overrides:
    
    containsKeyInternal in class ClientCacheProxy<K,V>
  - loadAllInternal
```
protected void loadAllInternal(Set<? extends K> keys,
                               List<Data> dataKeys,
                               boolean replaceExistingValues,
                               javax.cache.integration.CompletionListener completionListener)
```
    Overrides:
    
    loadAllInternal in class ClientCacheProxy<K,V>
  - removeAllKeysInternal
```
protected void removeAllKeysInternal(Set<? extends K> keys,
                                     Collection<Data> dataKeys,
                                     long startNanos)
```
  - onRemoveSyncInternal
```
public void onRemoveSyncInternal(Object key,
                                 Data keyData)
```
  - onRemoveAsyncInternal
```
protected void onRemoveAsyncInternal(Object key,
                                     Data keyData,
                                     ClientDelegatingFuture future,
                                     ExecutionCallback callback)
```
  - removeAll
```
public void removeAll()
```
    Specified by:
    
    removeAll in interface javax.cache.Cache<K,V>
    
    Overrides:
    
    removeAll in class ClientCacheProxy<K,V>
  - clear
```
public void clear()
```
    Specified by:
    
    clear in interface javax.cache.Cache<K,V>
    
    Overrides:
    
    clear in class ClientCacheProxy<K,V>
  - invokeInternal
```
protected Object invokeInternal(Object key,
                                Data epData,
                                Object[] arguments)
```
    Overrides:
    
    invokeInternal in class ClientCacheProxy<K,V>
  - close
```
public void close()
```
    Specified by:
    
    close in interface Closeable
    
    Specified by:
    
    close in interface AutoCloseable
    
    Specified by:
    
    close in interface javax.cache.Cache<K,V>
  - postDestroy
```
protected void postDestroy()
```
    Description copied from class: ClientProxy
    
    Called after proxy is destroyed.
  - addNearCacheInvalidationListener
```
public String addNearCacheInvalidationListener(EventHandler eventHandler)
```
  - getAsync
```
public ICompletableFuture<V> getAsync(K key)
```
    Description copied from interface: ICache
    
    Asynchronously retrieves the mapped value of the given key using a custom ExpiryPolicy. If no mapping exists null is returned.
    If the cache is configured for read-through operation mode, the underlying configured CacheLoader might be called to retrieve the value of the key from any kind of external resource.
    The resulting ICompletableFuture instance may throw a ClassCastException as the operations result if the Cache is configured to perform runtime-type-checking, and the key or value types are incompatible with those that have been configured for the Cache.
    
    Parameters:
    
    key - The key whose associated value is to be returned.
    
    Returns:
    
    ICompletableFuture retrieve the value assigned to the given key.
    
    See Also:
    
    javax.cache.Cache#get(K), ICompletableFuture
  - getAsync
```
public ICompletableFuture<V> getAsync(K key,
                                      javax.cache.expiry.ExpiryPolicy expiryPolicy)
```
    Description copied from interface: ICache
    
    Asynchronously gets an entry from cache using a custom ExpiryPolicy.
    If the cache is configured for read-through operation mode, the underlying configured CacheLoader might be called to retrieve the value of the key from any kind of external resource.
    The resulting ICompletableFuture instance may throw a ClassCastException as the operations result if the Cache is configured to perform runtime-type-checking, and the key or value types are incompatible with those that have been configured for the Cache.
    
    Parameters:
    
    key - The key whose associated value is to be returned.
    
    expiryPolicy - The custom expiry policy for this operation, a null value is equivalent to ICache.getAsync(Object).
    
    Returns:
    
    ICompletableFuture retrieve the value assigned to the given key.
    
    See Also:
    
    javax.cache.Cache#get(K), ICompletableFuture
  - putAsync
```
public ICompletableFuture<Void> putAsync(K key,
                                         V value)
```
    Description copied from interface: ICache
    
    Asynchronously associates the specified value with the specified key in the cache.
    In case a previous assignment already exists, the previous value is overridden by the new given value.
    If the cache is configured for write-through operation mode, the underlying configured CacheWriter might be called to store the value of the key to any kind of external resource.
    
    Parameters:
    
    key - The key whose associated value is to be returned.
    
    value - The value to be associated with the specified key.
    
    Returns:
    
    ICompletableFuture notify when the operation succeeds.
    
    See Also:
    
    javax.cache.Cache#put(K, V), ICompletableFuture
  - putAsync
```
public ICompletableFuture<Void> putAsync(K key,
                                         V value,
                                         javax.cache.expiry.ExpiryPolicy expiryPolicy)
```
    Description copied from interface: ICache
    
    Asynchronously associates the specified value with the specified key in the cache using a custom ExpiryPolicy.
    In case a previous assignment already exists, the previous value is overridden by the new given value.
    If the cache is configured for write-through operation mode, the underlying configured CacheWriter might be called to store the value of the key to any kind of external resource.
    
    Parameters:
    
    key - The key whose associated value is to be returned.
    
    value - The value to be associated with the specified key.
    
    expiryPolicy - The custom expiry policy for this operation, a null value is equivalent to ICache.putAsync(Object, Object).
    
    Returns:
    
    ICompletableFuture notify when the operation succeeds.
    
    See Also:
    
    javax.cache.Cache#put(K, V), ICompletableFuture
  - putIfAbsentAsync
```
public ICompletableFuture<Boolean> putIfAbsentAsync(K key,
                                                    V value)
```
    Description copied from interface: ICache
    Asynchronously associates the specified key with the given value if and only if there is not yet a mapping defined for the specified key.
    This is equivalent to:
```
   if (!cache.containsKey(key)) {}
     cache.put(key, value);
     return true;
   } else {
     return false;
   }
 
```
    except that the action is performed atomically.
    If the cache is configured for write-through operation mode, the underlying configured CacheWriter might be called to store the value of the key to any kind of external resource.
    Parameters:
    
    key - The key that is associated with the specified value.
    
    value - The value to which the specified key is associated.
    
    Returns:
    
    ICompletableFuture notify if a previous value was assigned with the key
    
    See Also:
    
    javax.cache.Cache#putIfAbsent(K, V), ICompletableFuture
  - putIfAbsentAsync
```
public ICompletableFuture<Boolean> putIfAbsentAsync(K key,
                                                    V value,
                                                    javax.cache.expiry.ExpiryPolicy expiryPolicy)
```
    Description copied from interface: ICache
    Asynchronously associates the specified key with the given value if and only if there is not yet a mapping defined for the specified key. using a custom ExpiryPolicy.
    This is equivalent to:
```
   if (!cache.containsKey(key)) {}
     cache.put(key, value);
     return true;
   } else {
     return false;
   }
 
```
    except that the action is performed atomically.
    If the cache is configured for write-through operation mode, the underlying configured CacheWriter might be called to store the value of the key to any kind of external resource.
    Parameters:
    
    key - The key that is associated with the specified value.
    
    value - The value to which the specified key is associated.
    
    expiryPolicy - custom expiry policy for this operation, a null value is equivalent to ICache.putIfAbsentAsync(Object, Object)
    
    Returns:
    
    ICompletableFuture notify if a previous value was assigned with the key
    
    See Also:
    
    javax.cache.Cache#putIfAbsent(K, V), ICompletableFuture
  - getAndPutAsync
```
public ICompletableFuture<V> getAndPutAsync(K key,
                                            V value)
```
    Description copied from interface: ICache
    
    Asynchronously associates the specified value with the specified key in this cache, returning an existing value if one existed.
    In case a previous assignment already exists, the previous value is overridden by the new given value and the previous value is returned to the caller. This is equivalent to the Map.put(Object, Object) operation.
    If the cache is configured for write-through operation mode, the underlying configured CacheWriter might be called to store the value of the key to any kind of external resource.
    
    Parameters:
    
    key - The key whose associated value is to be returned.
    
    value - The value that is associated with the specified key.
    
    Returns:
    
    ICompletableFuture retrieve a possible previously assigned value for the given key.
    
    See Also:
    
    javax.cache.Cache#getAndPut(K, V), ICompletableFuture
  - getAndPutAsync
```
public ICompletableFuture<V> getAndPutAsync(K key,
                                            V value,
                                            javax.cache.expiry.ExpiryPolicy expiryPolicy)
```
    Description copied from interface: ICache
    
    Asynchronously associates the specified value with the specified key in this cache, returning an existing value if one existed using a custom ExpiryPolicy.
    In case a previous assignment already exists, the previous value is overridden by the new given value and the previous value is returned to the caller. This is equivalent to the Map.put(Object, Object) operation.
    If the cache is configured for write-through operation mode, the underlying configured CacheWriter might be called to store the value of the key to any kind of external resource.
    
    Parameters:
    
    key - The key whose associated value is to be returned.
    
    value - The value to associate with the specified key.
    
    expiryPolicy - The custom expiry policy for this operation, a null value is equivalent to ICache.getAndPutAsync(Object, Object).
    
    Returns:
    
    ICompletableFuture retrieve a possible previously assigned value for the given key.
    
    See Also:
    
    javax.cache.Cache#getAndPut(K, V), ICompletableFuture
  - removeAsync
```
public ICompletableFuture<Boolean> removeAsync(K key)
```
    Description copied from interface: ICache
    
    Asynchronously removes the mapping for a key from this cache if it is present.
    If the cache is configured for write-through operation mode, the underlying configured CacheWriter might be called to store the value of the key to any kind of external resource.
    The resulting ICompletableFuture instance may throw a ClassCastException as the operations result if the Cache is configured to perform runtime-type-checking, and the key or value types are incompatible with those that have been configured for the Cache.
    
    Parameters:
    
    key - The key whose mapping is to be removed.
    
    Returns:
    
    ICompletableFuture notify if mapping could be removed or not.
    
    See Also:
    
    javax.cache.Cache#remove(K), ICompletableFuture
  - removeAsync
```
public ICompletableFuture<Boolean> removeAsync(K key,
                                               V oldValue)
```
    Description copied from interface: ICache
    Asynchronously removes the mapping for the given key if and only if the currently mapped value equals to the value of oldValue.
    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.
    If the cache is configured for write-through operation mode, the underlying configured CacheWriter might be called to store the value of the key to any kind of external resource.
    The resulting ICompletableFuture instance may throw a ClassCastException as the operations result if the Cache is configured to perform runtime-type-checking, and the key or value types are incompatible with those that have been configured for the Cache.
    Parameters:
    
    key - The key whose mapping is to be removed if the mapped value is oldValue.
    
    oldValue - The value expected to be associated with the specified key.
    
    Returns:
    
    ICompletableFuture notify if mapping could be removed or not.
    
    See Also:
    
    javax.cache.Cache#remove(K, V), ICompletableFuture
  - getAndRemoveAsync
```
public ICompletableFuture<V> getAndRemoveAsync(K key)
```
    Description copied from interface: ICache
    
    Asynchronously removes the entry for a key and returns the previously assigned value or null if no value was assigned.
    If the cache is configured for write-through operation mode, the underlying configured CacheWriter might be called to store the value of the key to any kind of external resource.
    The resulting ICompletableFuture instance may throw a ClassCastException as the operations result if the Cache is configured to perform runtime-type-checking, and the key or value types are incompatible with those that have been configured for the Cache.
    
    Parameters:
    
    key - The key to be removed and whose associated value is to be returned.
    
    Returns:
    
    ICompletableFuture retrieve a possible previously assigned value for the removed key.
    
    See Also:
    
    javax.cache.Cache#getAndRemove(K), ICompletableFuture
  - replaceAsync
```
public ICompletableFuture<Boolean> replaceAsync(K key,
                                                V value)
```
    Description copied from interface: ICache
    
    Asynchronously replaces the assigned value of the given key by the specified value.
    If the cache is configured for write-through operation mode, the underlying configured CacheWriter might be called to store the value of the key to any kind of external resource.
    
    Parameters:
    
    key - The key whose associated value is to be replaced.
    
    value - The new value to be associated with the specified key.
    
    Returns:
    
    ICompletableFuture notify if the operation succeeds or not.
    
    See Also:
    
    javax.cache.Cache#replace(K, V), ICompletableFuture
  - replaceAsync
```
public ICompletableFuture<Boolean> replaceAsync(K key,
                                                V value,
                                                javax.cache.expiry.ExpiryPolicy expiryPolicy)
```
    Description copied from interface: ICache
    
    Asynchronously replaces the assigned value of the given key by the specified value using a custom ExpiryPolicy.
    If the cache is configured for write-through operation mode, the underlying configured CacheWriter might be called to store the value of the key to any kind of external resource.
    
    Parameters:
    
    key - The key whose assigned value is replaced by the specified value.
    
    value - The specified value to be associated with the given key.
    
    expiryPolicy - The custom expiry policy for this operation, a null value is equivalent to ICache.replaceAsync(Object, Object)
    
    Returns:
    
    ICompletableFuture notify if the operation succeeds or not.
    
    See Also:
    
    javax.cache.Cache#replace(K, V), ICompletableFuture
  - replaceAsync
```
public ICompletableFuture<Boolean> replaceAsync(K key,
                                                V oldValue,
                                                V newValue)
```
    Description copied from interface: ICache
    Asynchronously replaces the currently assigned value for the given key with the specified newValue if and only if the currently assigned value equals the value of oldValue.
    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.
    If the cache is configured for write-through operation mode, the underlying configured CacheWriter might be called to store the value of the key to any kind of external resource.
    The resulting ICompletableFuture instance may throw a ClassCastException as the operations result if the Cache is configured to perform runtime-type-checking, and the key or value types are incompatible with those that have been configured for the Cache.
    Parameters:
    
    key - The key that will have its assigned value replaced.
    
    oldValue - The old value expected to be associated with the specified key.
    
    newValue - The new value to be associated with the specified key.
    
    Returns:
    
    ICompletableFuture notify if the operation succeeds or not.
    
    See Also:
    
    javax.cache.Cache#replace(K, V, V), ICompletableFuture
  - replaceAsync
```
public ICompletableFuture<Boolean> replaceAsync(K key,
                                                V oldValue,
                                                V newValue,
                                                javax.cache.expiry.ExpiryPolicy expiryPolicy)
```
    Description copied from interface: ICache
    Asynchronously replaces the currently assigned value for the given key with the specified newValue if and only if the currently assigned value equals the value of oldValue using a custom ExpiryPolicy.
    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.
    If the cache is configured for write-through operation mode, the underlying configured CacheWriter might be called to store the value of the key to any kind of external resource.
    The resulting ICompletableFuture instance may throw a ClassCastException as the operations result if the Cache is configured to perform runtime-type-checking, and the key or value types are incompatible with those that have been configured for the Cache.
    Parameters:
    
    key - The key that will have its assigned value replaced.
    
    oldValue - The old value expected to be associated with the specified key.
    
    newValue - The new value to be associated with the specified key.
    
    expiryPolicy - The custom expiry policy for this operation, a null value is equivalent to ICache.replaceAsync(Object, Object, Object).
    
    Returns:
    
    ICompletableFuture to get notified if the operation succeed or not.
    
    See Also:
    
    javax.cache.Cache#replace(K, V, V), ICompletableFuture
  - getAndReplaceAsync
```
public ICompletableFuture<V> getAndReplaceAsync(K key,
                                                V value)
```
    Description copied from interface: ICache
    
    Asynchronously replaces the assigned value of the given key by the specified value and returns the previously assigned value.
    If the cache is configured for write-through operation mode, the underlying configured CacheWriter might be called to store the value of the key to any kind of external resource.
    
    Parameters:
    
    key - The key whose value is replaced.
    
    value - The new value to be associated with the specified key.
    
    Returns:
    
    ICompletableFuture to retrieve a possible previously assigned value for the given key.
    
    See Also:
    
    javax.cache.Cache#getAndReplace(K, V), ICompletableFuture
  - getAndReplaceAsync
```
public ICompletableFuture<V> getAndReplaceAsync(K key,
                                                V value,
                                                javax.cache.expiry.ExpiryPolicy expiryPolicy)
```
    Description copied from interface: ICache
    
    Asynchronously replaces the assigned value of the given key by the specified value using a custom ExpiryPolicy and returns the previously assigned value.
    If the cache is configured for write-through operation mode, the underlying configured CacheWriter might be called to store the value of the key to any kind of external resource.
    
    Parameters:
    
    key - The key whose value is replaced.
    
    value - The new value to be associated with the specified key.
    
    expiryPolicy - The custom expiry policy for this operation, a null value is equivalent to Cache.getAndReplace(Object, Object)
    
    Returns:
    
    ICompletableFuture to retrieve a possible previously assigned value for the given key.
    
    See Also:
    
    javax.cache.Cache#getAndReplace(K, V), ICompletableFuture
  - get
```
public V get(K key,
             javax.cache.expiry.ExpiryPolicy expiryPolicy)
```
    Description copied from interface: ICache
    
    Retrieves the mapped value of the given key using a custom ExpiryPolicy. If no mapping exists null is returned.
    If the cache is configured for read-through operation mode, the underlying configured CacheLoader might be called to retrieve the value of the key from any kind of external resource.
    
    Parameters:
    
    key - The key whose mapped value is to be returned.
    
    expiryPolicy - The custom expiry policy for this operation, a null value is equivalent to Cache.get(Object).
    
    Returns:
    
    The value assigned to the given key, or null if not assigned.
    
    See Also:
    
    javax.cache.Cache#get(K)
  - getAll
```
public Map<K,V> getAll(Set<? extends K> keys,
                       javax.cache.expiry.ExpiryPolicy expiryPolicy)
```
    Description copied from interface: ICache
    
    Gets a collection of entries from the cache with custom expiry policy, returning them as Map of the values associated with the set of keys requested.
    If the cache is configured for read-through operation mode, the underlying configured CacheLoader might be called to retrieve the values of the keys from any kind of external resource.
    
    Parameters:
    
    keys - The keys whose associated values are to be returned.
    
    expiryPolicy - The custom expiry policy for this operation, a null value is equivalent to Cache.getAll(java.util.Set).
    
    Returns:
    
    A map of entries that were found for the given keys. Keys not found in the cache are not in the returned map.
    
    See Also:
    
    Cache.getAll(java.util.Set)
  - put
```
public void put(K key,
                V value,
                javax.cache.expiry.ExpiryPolicy expiryPolicy)
```
    Description copied from interface: ICache
    
    Associates the specified value with the specified key in the cache using a custom ExpiryPolicy.
    
    Parameters:
    
    key - The key that has the specified value associated with it.
    
    value - The value to be associated with the key.
    
    expiryPolicy - The custom expiry policy for this operation, a null value is equivalent to Cache.put(Object, Object).
    
    See Also:
    
    javax.cache.Cache#put(K, V)
  - getAndPut
```
public V getAndPut(K key,
                   V value,
                   javax.cache.expiry.ExpiryPolicy expiryPolicy)
```
    Description copied from interface: ICache
    
    Associates the specified value with the specified key in this cache using a custom ExpiryPolicy, returning an existing value if one existed.
    
    Parameters:
    
    key - The key that has the specified value associated with it.
    
    value - The value to be associated with the key.
    
    expiryPolicy - The custom expiry policy for this operation, a null value is equivalent to Cache.getAndPut(Object, Object).
    
    Returns:
    
    The value previously assigned to the given key, or null if not assigned.
    
    See Also:
    
    javax.cache.Cache#getAndPut(K, V)
  - putAll
```
public void putAll(Map<? extends K,? extends V> map,
                   javax.cache.expiry.ExpiryPolicy expiryPolicy)
```
    Description copied from interface: ICache
    
    Copies all of the entries from the given map to the cache using a custom ExpiryPolicy.
    Puts of single entries happen atomically but there is no transactional guarantee over the complete putAll operation. If other concurrent operations modify or remove all or single values of the provided map, the result is undefined.
    If the cache is configured for write-through operation mode, the underlying configured CacheWriter might be called to store the values of the keys to any kind of external resource.
    
    Parameters:
    
    map - The mappings to be stored in this cache.
    
    expiryPolicy - The custom expiry policy for this operation, a null value is equivalent to Cache.putAll(java.util.Map).
    
    See Also:
    
    Cache.putAll(java.util.Map)
  - setExpiryPolicy
```
public void setExpiryPolicy(Set<? extends K> keys,
                            javax.cache.expiry.ExpiryPolicy policy)
```
    Description copied from interface: ICache
    
    Associates the specified key with the given ExpiryPolicy. expiryPolicy takes precedence for these particular keys against any cache wide expiry policy. If some keys in keys do not exist or are already expired, this call has no effect for those. Note: New time-to-live duration is calculated using newly added entry policy's getExpiryForUpdate method immediately after this operation succeeds.
    
    Parameters:
    
    keys - The keys that are associated with the specified expiry policy.
    
    policy - custom expiry policy for this operation
  - setExpiryPolicy
```
public boolean setExpiryPolicy(K key,
                               javax.cache.expiry.ExpiryPolicy expiryPolicy)
```
    Description copied from interface: ICache
    
    Associates the specified key with the given ExpiryPolicy. expiryPolicy takes precedence for this particular key against any cache wide expiry policy. If key does not exist or is already expired, this call makes no changes to entries stored in this cache. Note: New time-to-live duration is calculated using newly added entry policy's getExpiryForUpdate method immediately after this operation succeeds.
    
    Parameters:
    
    key - The key that is associated with the specified expiry policy.
    
    expiryPolicy - custom expiry policy for this operation
    
    Returns:
    
    true if the entry exists and its expiry policy is changed, false otherwise
  - setExpiryPolicyInternal
```
protected void setExpiryPolicyInternal(Set<? extends K> keys,
                                       javax.cache.expiry.ExpiryPolicy policy,
                                       Set<Data> serializedKeys)
```
  - putIfAbsent
```
public boolean putIfAbsent(K key,
                           V value,
                           javax.cache.expiry.ExpiryPolicy expiryPolicy)
```
    Description copied from interface: ICache
    Associates the specified key with the given value if and only if there is not yet a mapping defined for the specified key.
    This is equivalent to:
```
   if (!cache.containsKey(key)) {}
     cache.put(key, value);
     return true;
   } else {
     return false;
   }
 
```
    except that the action is performed atomically.
    If the cache is configured for write-through operation mode, the underlying configured CacheWriter might be called to store the value of the key to any kind of external resource.
    Parameters:
    
    key - The key that is associated with the specified value.
    
    value - The value that has the specified key associated with it.
    
    expiryPolicy - The custom expiry policy for this operation, a null value is equivalent to Cache.putIfAbsent(Object, Object).
    
    Returns:
    
    true if a value was set, false otherwise.
    
    See Also:
    
    javax.cache.Cache#putIfAbsent(K, V)
  - replace
```
public boolean replace(K key,
                       V oldValue,
                       V newValue,
                       javax.cache.expiry.ExpiryPolicy expiryPolicy)
```
    Description copied from interface: ICache
    Atomically replaces the currently assigned value for the given key with the specified newValue if and only if the currently assigned value equals the value of oldValue using a custom ExpiryPolicy.
    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.
    If the cache is configured for write-through operation mode, the underlying configured CacheWriter might be called to store the value of the key to any kind of external resource.
    Parameters:
    
    key - The key with the value to be replaced.
    
    oldValue - The old value expected to be associated with the specified key.
    
    newValue - The new value to be associated with the specified key.
    
    expiryPolicy - The custom expiry policy for this operation, a null value is equivalent to Cache.replace(Object, Object, Object).
    
    Returns:
    
    true if a value was replaced, false otherwise.
    
    See Also:
    
    javax.cache.Cache#replace(K, V, V)
  - replace
```
public boolean replace(K key,
                       V value,
                       javax.cache.expiry.ExpiryPolicy expiryPolicy)
```
    Description copied from interface: ICache
    
    Atomically replaces the assigned value of the given key by the specified value using a custom ExpiryPolicy.
    If the cache is configured for write-through operation mode, the underlying configured CacheWriter might be called to store the value of the key to any kind of external resource.
    
    Parameters:
    
    key - The key whose value is replaced.
    
    value - The new value to be associated with the specified key.
    
    expiryPolicy - The custom expiry policy for this operation, a null value is equivalent to Cache.replace(Object, Object)
    
    Returns:
    
    true if a value was replaced, false otherwise.
    
    See Also:
    
    javax.cache.Cache#replace(K, V)
  - getAndReplace
```
public V getAndReplace(K key,
                       V value,
                       javax.cache.expiry.ExpiryPolicy expiryPolicy)
```
    Description copied from interface: ICache
    
    Atomically replaces the assigned value of the given key by the specified value using a custom ExpiryPolicy and returns the previously assigned value.
    If the cache is configured for write-through operation mode, the underlying configured CacheWriter might be called to store the value of the key to any kind of external resource.
    
    Parameters:
    
    key - The key whose value is replaced.
    
    value - The new value to be associated with the specified key.
    
    expiryPolicy - The custom expiry policy for this operation, a null value is equivalent to Cache.getAndReplace(Object, Object).
    
    Returns:
    
    The old value previously assigned to the given key.
    
    See Also:
    
    javax.cache.Cache#getAndReplace(K, V)
  - size
```
public int size()
```
    Description copied from interface: ICache
    
    Total entry count. If the cache contains more than Integer.MAX_VALUE elements, returns Integer.MAX_VALUE.
    
    Returns:
    
    total entry count
  - getLocalCacheStatistics
```
public CacheStatistics getLocalCacheStatistics()
```
    Description copied from interface: ICache
    
    Directly access local Cache Statistics.
    
    Returns:
    
    CacheStatistics instance or an empty statistics if not enabled.
  - setCacheManager
```
public void setCacheManager(HazelcastCacheManager cacheManager)
```
    Description copied from interface: ICacheInternal
    
    Sets relevant HazelcastCacheManager to client/server.
    
    Specified by:
    
    setCacheManager in interface ICacheInternal<K,V>
    
    Parameters:
    
    cacheManager - client or server HazelcastCacheManager
  - resetCacheManager
```
public void resetCacheManager()
```
    Description copied from interface: ICacheInternal
    
    Reset cache manager of this cache proxy to null. Whenever a Cache is not managed any more (for example after Cache.close() has been called), its CacheManager should be reset.
    
    Specified by:
    
    resetCacheManager in interface ICacheInternal<K,V>
  - onDestroy
```
protected void onDestroy()
```
    Description copied from class: ClientProxy
    
    Called before proxy is destroyed. Overriding implementations should clean/release resources created during initialization.
    
    Overrides:
    
    onDestroy in class ClientProxy
  - invoke
```
protected ClientInvocationFuture invoke(ClientMessage req,
                                        int partitionId,
                                        int completionId)
```
  - invoke
```
protected ClientInvocationFuture invoke(ClientMessage req,
                                        Data keyData,
                                        int completionId)
```
  - getSafely
```
protected <T> T getSafely(Future<T> future)
```
  - getAndRemoveAsyncInternal
```
protected <T> ICompletableFuture<T> getAndRemoveAsyncInternal(K key)
```
  - getAndRemoveSyncInternal
```
protected <T> ClientDelegatingFuture<T> getAndRemoveSyncInternal(K key)
```
  - removeAsyncInternal
```
protected Object removeAsyncInternal(K key,
                                     V oldValue,
                                     boolean hasOldValue,
                                     boolean withCompletionEvent,
                                     boolean async)
```
  - replaceSyncInternal
```
protected boolean replaceSyncInternal(K key,
                                      V oldValue,
                                      V newValue,
                                      javax.cache.expiry.ExpiryPolicy expiryPolicy,
                                      boolean hasOldValue)
```
  - replaceAsyncInternal
```
protected <T> ICompletableFuture<T> replaceAsyncInternal(K key,
                                                         V oldValue,
                                                         V newValue,
                                                         javax.cache.expiry.ExpiryPolicy expiryPolicy,
                                                         boolean hasOldValue,
                                                         boolean withCompletionEvent,
                                                         boolean async)
```
  - replaceAndGetAsyncInternal
```
protected <T> ICompletableFuture<T> replaceAndGetAsyncInternal(K key,
                                                               V oldValue,
                                                               V newValue,
                                                               javax.cache.expiry.ExpiryPolicy expiryPolicy,
                                                               boolean hasOldValue,
                                                               boolean withCompletionEvent,
                                                               boolean async)
```
  - addCallback
```
protected static <T> void addCallback(ClientDelegatingFuture<T> delegatingFuture,
                                      ExecutionCallback<T> callback)
```
  - putSyncInternal
```
protected V putSyncInternal(K key,
                            V value,
                            javax.cache.expiry.ExpiryPolicy expiryPolicy,
                            boolean isGet)
```
  - putAsyncInternal
```
protected ClientDelegatingFuture putAsyncInternal(K key,
                                                  V value,
                                                  javax.cache.expiry.ExpiryPolicy expiryPolicy,
                                                  boolean isGet,
                                                  boolean withCompletionEvent,
                                                  com.hazelcast.client.cache.impl.OneShotExecutionCallback<V> callback)
```
  - newStatsCallbackOrNull
```
protected com.hazelcast.client.cache.impl.OneShotExecutionCallback<V> newStatsCallbackOrNull(boolean isGet)
```
  - putIfAbsentInternal
```
protected Object putIfAbsentInternal(K key,
                                     V value,
                                     javax.cache.expiry.ExpiryPolicy expiryPolicy,
                                     boolean withCompletionEvent,
                                     boolean async)
```
  - removeAllInternal
```
protected void removeAllInternal()
```
  - clearInternal
```
protected void clearInternal()
```
  - addListenerLocally
```
protected void addListenerLocally(String regId,
                                  javax.cache.configuration.CacheEntryListenerConfiguration<K,V> cacheEntryListenerConfiguration,
                                  CacheEventListenerAdaptor<K,V> adaptor)
```
  - removeListenerLocally
```
protected String removeListenerLocally(javax.cache.configuration.CacheEntryListenerConfiguration<K,V> cacheEntryListenerConfiguration)
```
  - getListenerIdLocal
```
protected String getListenerIdLocal(javax.cache.configuration.CacheEntryListenerConfiguration<K,V> cacheEntryListenerConfiguration)
```
  - closeListeners
```
protected void closeListeners()
```
  - countDownCompletionLatch
```
public void countDownCompletionLatch(int countDownLatchId)
```
    Specified by:
    
    countDownCompletionLatch in interface CacheSyncListenerCompleter
  - registerCompletionLatch
```
protected Integer registerCompletionLatch(Integer countDownLatchId,
                                          int count)
```
  - deregisterCompletionLatch
```
protected void deregisterCompletionLatch(Integer countDownLatchId)
```
  - waitCompletionLatch
```
protected void waitCompletionLatch(Integer countDownLatchId,
                                   ICompletableFuture future)
                            throws ExecutionException
```
    Throws:
    
    ExecutionException
  - createHandler
```
protected EventHandler createHandler(CacheEventListenerAdaptor<K,V> adaptor)
```
  - injectDependencies
```
protected void injectDependencies(Object obj)
```
  - getDistributedObjectName
```
protected String getDistributedObjectName()
```
    Overrides:
    
    getDistributedObjectName in class ClientProxy
  - nextCompletionId
```
protected int nextCompletionId()
```
  - preDestroy
```
protected boolean preDestroy()
```
    Description copied from class: ClientProxy
    
    Called before proxy is destroyed and determines whether destroy should be done.
    
    Overrides:
    
    preDestroy in class ClientProxy
    
    Returns:
    
    true if destroy should be done, otherwise false
  - isClosed
```
public boolean isClosed()
```
    Specified by:
    
    isClosed in interface javax.cache.Cache<K,V>
  - isDestroyed
```
public boolean isDestroyed()
```
    Description copied from interface: ICache
    
    Determines whether this Cache instance has been destroyed.
    
    Specified by:
    
    isDestroyed in interface ICache<K,V>
    
    Returns:
    
    true if this Cache instance is destroyed; false if it is still open.
  - open
```
public void open()
```
    Description copied from interface: ICacheInternal
    
    Opens cache if available (not destroyed). If cache is already open, does nothing.
    
    Specified by:
    
    open in interface ICacheInternal<K,V>
  - getPrefixedName
```
public String getPrefixedName()
```
    Description copied from interface: PrefixedDistributedObject
    
    Returns the unique prefixed name for this DistributedObject. The returned value will never be null.
    
    Specified by:
    
    getPrefixedName in interface PrefixedDistributedObject
    
    Returns:
    
    the unique prefixed name for this object.
  - getNameWithPrefix
```
@Deprecated
public String getNameWithPrefix()
```
    Deprecated. use #getPrefixedName instead
    
    Gets the full cache name with prefixes.
    
    Returns:
    
    the full cache name with prefixes
  - invoke
```
protected <T> T invoke(ClientMessage clientMessage)
```
    Overrides:
    
    invoke in class ClientProxy
  - invoke
```
protected ClientMessage invoke(ClientMessage clientMessage,
                               Data keyData)
```
  - submitLoadAllTask
```
protected void submitLoadAllTask(ClientMessage request,
                                 javax.cache.integration.CompletionListener completionListener,
                                 List<Data> binaryKeys)
```
  - newDelegatingFuture
```
protected <T> ClientDelegatingFuture<T> newDelegatingFuture(ClientInvocationFuture future,
                                                            ClientMessageDecoder decoder)
```
  - newDelegatingFuture
```
protected <T> ClientDelegatingFuture<T> newDelegatingFuture(ClientInvocationFuture future,
                                                            ClientMessageDecoder decoder,
                                                            boolean deserializeResponse)
```

Class NearCachedClientCacheProxy<K,V>

Nested Class Summary

Nested classes/interfaces inherited from interface javax.cache.Cache

Field Summary

Method Summary

Methods inherited from class com.hazelcast.client.cache.impl.ClientCacheProxy

Methods inherited from class com.hazelcast.client.spi.ClientProxy

Methods inherited from class java.lang.Object

Methods inherited from interface com.hazelcast.cache.ICache

Methods inherited from interface javax.cache.Cache

Methods inherited from interface java.lang.Iterable

Methods inherited from interface com.hazelcast.core.DistributedObject

Field Detail

cacheManagerRef

partitionCount

name

nameWithPrefix

cacheConfig

logger

Method Detail

getNearCache

onInitialize

getSyncInternal

getAsyncInternal

onPutSyncInternal

onPutIfAbsentSyncInternal

onPutIfAbsentAsyncInternal

wrapPutAsyncFuture

onGetAndRemoveAsyncInternal

onReplaceInternalAsync

onReplaceAndGetAsync

getAllInternal

setExpiryPolicyInternal

setExpiryPolicyInternal

putAllInternal

containsKeyInternal

loadAllInternal

removeAllKeysInternal

onRemoveSyncInternal

onRemoveAsyncInternal

removeAll

clear

invokeInternal

close

postDestroy

addNearCacheInvalidationListener

getAsync

getAsync

putAsync

putAsync

putIfAbsentAsync

putIfAbsentAsync

getAndPutAsync

getAndPutAsync

removeAsync

removeAsync

getAndRemoveAsync

replaceAsync

replaceAsync

replaceAsync

replaceAsync

getAndReplaceAsync

getAndReplaceAsync

get

getAll

put

getAndPut

putAll

setExpiryPolicy

setExpiryPolicy

setExpiryPolicyInternal

putIfAbsent

replace

replace

getAndReplace

size

getLocalCacheStatistics

setCacheManager

resetCacheManager

onDestroy