ClientCacheProxy (Hazelcast Root 3.3.5 API)

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

Type Parameters:
K - key type
V - value type

All Implemented Interfaces:

ICache<K,V>, Closeable, AutoCloseable, Iterable<javax.cache.Cache.Entry<K,V>>, javax.cache.Cache<K,V>
```
public class ClientCacheProxy<K,V>
extends Object
```
ICache implementation for client This proxy is the implementation of ICache and javax.cache.Cache which is returned by HazelcastClientCacheManager. Represent a cache on client. This implementation is a thin proxy implementation using hazelcast client infrastructure

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 ClientContext`	`clientContext`
`protected ILogger`	`logger`
`protected String`	`name`
`protected String`	`nameWithPrefix`
`protected IClientNearCache<Data,Object>`	`nearCache`

Constructor Summary

Constructors
Constructor and Description
`ClientCacheProxy(CacheConfig<K,V> cacheConfig, ClientContext clientContext, HazelcastClientCacheManager cacheManager)`

Method Summary

Methods
Modifier and Type	Method and Description
`protected void`	`addListenerLocally(String regId, javax.cache.configuration.CacheEntryListenerConfiguration<K,V> cacheEntryListenerConfiguration)`
`void`	`clear()`
`void`	`close()`
`protected void`	`closeCacheLoader()`
`protected void`	`closeListeners()`
`boolean`	`containsKey(K key)`
`protected void`	`countDownCompletionLatch(int id)`
`protected ICompletableFuture`	`createCompletedFuture(Object value)`
`protected EventHandler<Object>`	`createHandler(CacheEventListenerAdaptor adaptor)`
`void`	`deregisterAllCacheEntryListener(Collection<String> listenerRegistrations)`
`void`	`deregisterCacheEntryListener(javax.cache.configuration.CacheEntryListenerConfiguration<K,V> cacheEntryListenerConfiguration)`
`protected void`	`deregisterCompletionLatch(Integer countDownLatchId)`
`protected void`	`deregisterCompletionListener()`
`void`	`destroy()`
`protected void`	`ensureOpen()`
`V`	`get(K key)`
`V`	`get(K key, javax.cache.expiry.ExpiryPolicy expiryPolicy)` Get with custom expiry policy
`Map<K,V>`	`getAll(Set<? extends K> keys)`
`Map<K,V>`	`getAll(Set<? extends K> keys, javax.cache.expiry.ExpiryPolicy expiryPolicy)` getAll with custom expiry policy
`V`	`getAndPut(K key, V value)`
`V`	`getAndPut(K key, V value, javax.cache.expiry.ExpiryPolicy expiryPolicy)` getAndPut with custom expiry policy
`Future<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.
`Future<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 expiry policy
`V`	`getAndRemove(K key)`
`Future<V>`	`getAndRemoveAsync(K key)` Asynchronously removes the entry for a key returning the removed value if one existed.
`V`	`getAndReplace(K key, V value)`
`V`	`getAndReplace(K key, V value, javax.cache.expiry.ExpiryPolicy expiryPolicy)` getAndReplace with custom expiry policy
`Future<V>`	`getAndReplaceAsync(K key, V value)` Asynchronously replaces the entry for a key only if currently mapped to some
`Future<V>`	`getAndReplaceAsync(K key, V value, javax.cache.expiry.ExpiryPolicy expiryPolicy)` Asynchronously replaces the entry for a key only if currently mapped to some using custom expiry policy
`ICompletableFuture<V>`	`getAsync(K key)` Asynchronously get an entry from cache
`ICompletableFuture<V>`	`getAsync(K key, javax.cache.expiry.ExpiryPolicy expiryPolicy)` Asynchronously get an entry from cache with a provided expiry policy
`javax.cache.CacheManager`	`getCacheManager()`
`<C extends javax.cache.configuration.Configuration<K,V>> C`	`getConfiguration(Class<C> clazz)`
`CacheStatistics`	`getLocalCacheStatistics()` Directly access to local Cache Statistics
`String`	`getName()`
`String`	`getNameWithPrefix()`
`protected <T> T`	`getSafely(Future<T> future)`
`protected void`	`invalidateNearCache(Data key)`
`protected <T> T`	`invoke(ClientRequest req)`
`protected <T> ICompletableFuture<T>`	`invoke(ClientRequest req, Data keyData, boolean completionOperation)`
`<T> T`	`invoke(K key, javax.cache.processor.EntryProcessor<K,V,T> entryProcessor, Object... arguments)`
`<T> Map<K,javax.cache.processor.EntryProcessorResult<T>>`	`invokeAll(Set<? extends K> keys, javax.cache.processor.EntryProcessor<K,V,T> entryProcessor, Object... arguments)`
`boolean`	`isClosed()`
`Iterator<javax.cache.Cache.Entry<K,V>>`	`iterator()`
`void`	`loadAll(Set<? extends K> keys, boolean replaceExistingValues, javax.cache.integration.CompletionListener completionListener)`
`void`	`put(K key, V value)`
`void`	`put(K key, V value, javax.cache.expiry.ExpiryPolicy expiryPolicy)` put with custom expiry policy
`void`	`putAll(Map<? extends K,? extends V> map)`
`void`	`putAll(Map<? extends K,? extends V> map, javax.cache.expiry.ExpiryPolicy expiryPolicy)` putAll with custom expiry policy
`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 expiry policy
`protected <T> ICompletableFuture<T>`	`putAsyncInternal(K key, V value, javax.cache.expiry.ExpiryPolicy expiryPolicy, boolean isGet, boolean withCompletionEvent)`
`boolean`	`putIfAbsent(K key, V value)`
`boolean`	`putIfAbsent(K key, V value, javax.cache.expiry.ExpiryPolicy expiryPolicy)` putIfAbsent with custom expiry policy
`ICompletableFuture<Boolean>`	`putIfAbsentAsync(K key, V value, javax.cache.expiry.ExpiryPolicy expiryPolicy)` Asynchronously associates the specified value with the specified key in the cache if not already exist using a custom expiry policy
`protected ICompletableFuture<Boolean>`	`putIfAbsentAsyncInternal(K key, V value, javax.cache.expiry.ExpiryPolicy expiryPolicy, boolean withCompletionEvent)`
`void`	`registerCacheEntryListener(javax.cache.configuration.CacheEntryListenerConfiguration<K,V> cacheEntryListenerConfiguration)`
`protected Integer`	`registerCompletionLatch(int count)`
`protected void`	`registerCompletionListener()`
`boolean`	`remove(K key)`
`boolean`	`remove(K key, V oldValue)`
`void`	`removeAll()`
`void`	`removeAll(Set<? extends K> keys)`
`protected void`	`removeAllInternal(Set<? extends K> keys, boolean isRemoveAll)`
`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 a key only if currently mapped to the given value.
`protected <T> ICompletableFuture<T>`	`removeAsyncInternal(K key, V oldValue, boolean hasOldValue, boolean isGet, boolean withCompletionEvent)`
`protected String`	`removeListenerLocally(javax.cache.configuration.CacheEntryListenerConfiguration<K,V> cacheEntryListenerConfiguration)`
`boolean`	`replace(K key, V value)`
`boolean`	`replace(K key, V value, javax.cache.expiry.ExpiryPolicy expiryPolicy)` replace with custom expiry policy
`boolean`	`replace(K key, V oldValue, V newValue)`
`boolean`	`replace(K key, V oldValue, V newValue, javax.cache.expiry.ExpiryPolicy expiryPolicy)` replace with custom expiry policy
`Future<Boolean>`	`replaceAsync(K key, V value)` Asynchronously replaces the entry for a key
`Future<Boolean>`	`replaceAsync(K key, V value, javax.cache.expiry.ExpiryPolicy expiryPolicy)` Asynchronously replaces the entry for a key only if currently mapped to some value.
`Future<Boolean>`	`replaceAsync(K key, V oldValue, V newValue)` Asynchronously replaces the entry for a key only if currently mapped to a given value.
`Future<Boolean>`	`replaceAsync(K key, V oldValue, V newValue, javax.cache.expiry.ExpiryPolicy expiryPolicy)` Asynchronously replaces the entry for a key only if currently mapped to a given value using custom expiry policy
`protected <T> ICompletableFuture<T>`	`replaceAsyncInternal(K key, V oldValue, V newValue, javax.cache.expiry.ExpiryPolicy expiryPolicy, boolean hasOldValue, boolean isGet, boolean withCompletionEvent)`
`int`	`size()` total entry count
`protected void`	`storeInNearCache(Data key, Data valueData, V value)`
`protected void`	`submitLoadAllTask(CacheLoadAllRequest request, javax.cache.integration.CompletionListener completionListener)`
`protected Data`	`toData(Object o)`
`protected <T> T`	`toObject(Object data)`
`<T> T`	`unwrap(Class<T> clazz)`
`protected void`	`updateCacheListenerConfigOnOtherNodes(javax.cache.configuration.CacheEntryListenerConfiguration<K,V> cacheEntryListenerConfiguration, boolean isRegister)`
`protected void`	`validateCacheLoader(javax.cache.integration.CompletionListener completionListener)`
`protected void`	`waitCompletionLatch(Integer countDownLatchId)`
`protected void`	`waitCompletionLatch(Integer countDownLatchId, int offset)`

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

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

Methods inherited from interface javax.cache.Cache
close, isClosed

- Field Detail
  - logger
```
protected final ILogger logger
```
  - nearCache
```
protected final IClientNearCache<Data,Object> nearCache
```
  - clientContext
```
protected final ClientContext clientContext
```
  - cacheConfig
```
protected final CacheConfig<K,V> cacheConfig
```
  - name
```
protected final String name
```
  - nameWithPrefix
```
protected final String nameWithPrefix
```
- Constructor Detail
  - ClientCacheProxy
```
public ClientCacheProxy(CacheConfig<K,V> cacheConfig,
                ClientContext clientContext,
                HazelcastClientCacheManager cacheManager)
```
- Method Detail
  - get
```
public V get(K key)
```
  - getAll
```
public Map<K,V> getAll(Set<? extends K> keys)
```
  - containsKey
```
public boolean containsKey(K key)
```
  - loadAll
```
public void loadAll(Set<? extends K> keys,
           boolean replaceExistingValues,
           javax.cache.integration.CompletionListener completionListener)
```
  - put
```
public void put(K key,
       V value)
```
  - getAndPut
```
public V getAndPut(K key,
          V value)
```
  - putAll
```
public void putAll(Map<? extends K,? extends V> map)
```
  - putIfAbsent
```
public boolean putIfAbsent(K key,
                  V value)
```
  - remove
```
public boolean remove(K key)
```
  - remove
```
public boolean remove(K key,
             V oldValue)
```
  - getAndRemove
```
public V getAndRemove(K key)
```
  - replace
```
public boolean replace(K key,
              V oldValue,
              V newValue)
```
  - replace
```
public boolean replace(K key,
              V value)
```
  - getAndReplace
```
public V getAndReplace(K key,
              V value)
```
  - removeAll
```
public void removeAll(Set<? extends K> keys)
```
  - removeAll
```
public void removeAll()
```
  - clear
```
public void clear()
```
  - getConfiguration
```
public <C extends javax.cache.configuration.Configuration<K,V>> C getConfiguration(Class<C> clazz)
```
  - invoke
```
public <T> T invoke(K key,
           javax.cache.processor.EntryProcessor<K,V,T> entryProcessor,
           Object... arguments)
         throws javax.cache.processor.EntryProcessorException
```
    Throws:
    
    javax.cache.processor.EntryProcessorException
  - invokeAll
```
public <T> Map<K,javax.cache.processor.EntryProcessorResult<T>> invokeAll(Set<? extends K> keys,
                                                                 javax.cache.processor.EntryProcessor<K,V,T> entryProcessor,
                                                                 Object... arguments)
```
  - getName
```
public String getName()
```
  - getCacheManager
```
public javax.cache.CacheManager getCacheManager()
```
  - unwrap
```
public <T> T unwrap(Class<T> clazz)
```
  - registerCacheEntryListener
```
public void registerCacheEntryListener(javax.cache.configuration.CacheEntryListenerConfiguration<K,V> cacheEntryListenerConfiguration)
```
  - deregisterCacheEntryListener
```
public void deregisterCacheEntryListener(javax.cache.configuration.CacheEntryListenerConfiguration<K,V> cacheEntryListenerConfiguration)
```
  - updateCacheListenerConfigOnOtherNodes
```
protected void updateCacheListenerConfigOnOtherNodes(javax.cache.configuration.CacheEntryListenerConfiguration<K,V> cacheEntryListenerConfiguration,
                                         boolean isRegister)
```
  - iterator
```
public Iterator<javax.cache.Cache.Entry<K,V>> iterator()
```
  - getAsync
```
public ICompletableFuture<V> getAsync(K key)
```
    Description copied from interface: ICache
    
    Asynchronously get an entry from cache
    
    Specified by:
    
    getAsync in interface ICache<K,V>
    
    Parameters:
    key - the key whose associated value is to be returned
    
    Returns:
    Future from which the value of the key can be retrieved.
    See Also:
    javax.cache.Cache#get(K), Future
  - getAsync
```
public ICompletableFuture<V> getAsync(K key,
                             javax.cache.expiry.ExpiryPolicy expiryPolicy)
```
    Description copied from interface: ICache
    
    Asynchronously get an entry from cache with a provided expiry policy
    
    Specified by:
    
    getAsync in interface ICache<K,V>
    
    Parameters:
    key - the key whose associated value is to be returned
    expiryPolicy - custom expiry policy for this operation
    
    Returns:
    Future from which the value of the key can be retrieved.
    See Also:
    javax.cache.Cache#get(K), Future
  - 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.
    
    Specified by:
    
    putAsync in interface ICache<K,V>
    
    Parameters:
    key - the key whose associated value is to be returned
    value - value to be associated with the specified key
    
    Returns:
    Future
    See Also:
    javax.cache.Cache#put(K,V), Future
  - 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 expiry policy
    
    Specified by:
    
    putAsync in interface ICache<K,V>
    
    Parameters:
    key - the key whose associated value is to be returned
    value - value to be associated with the specified key
    expiryPolicy - custom expiry Policy for this operation
    
    Returns:
    Future
    See Also:
    javax.cache.Cache#put(K,V), Future
  - putIfAbsentAsync
```
public ICompletableFuture<Boolean> putIfAbsentAsync(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 if not already exist using a custom expiry policy
    
    Specified by:
    
    putIfAbsentAsync in interface ICache<K,V>
    
    Parameters:
    key - key with which the specified value is to be associated
    value - value to be associated with the specified key
    
    Returns:
    See Also:
    javax.cache.Cache#putIfAbsent(K,V), Future
  - getAndPutAsync
```
public Future<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.
    
    Specified by:
    
    getAndPutAsync in interface ICache<K,V>
    
    Parameters:
    key - the key whose associated value is to be returned
    value - value to be associated with the specified key
    
    Returns:
    Future
    See Also:
    javax.cache.Cache#getAndPut(K,V), Future
  - getAndPutAsync
```
public Future<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 expiry policy
    
    Specified by:
    
    getAndPutAsync in interface ICache<K,V>
    
    Parameters:
    key - the key whose associated value is to be returned
    value - value to be associated with the specified key
    expiryPolicy - custom expiry Policy for this operation
    
    Returns:
    Future
    See Also:
    javax.cache.Cache#getAndPut(K,V), Future
  - 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.
    
    Specified by:
    
    removeAsync in interface ICache<K,V>
    
    Parameters:
    key - the key whose associated value is to be returned
    
    Returns:
    Future
    See Also:
    javax.cache.Cache#remove(K), Future
  - removeAsync
```
public ICompletableFuture<Boolean> removeAsync(K key,
                                      V oldValue)
```
    Description copied from interface: ICache
    
    Asynchronously removes the mapping for a key only if currently mapped to the given value.
    
    Specified by:
    
    removeAsync in interface ICache<K,V>
    
    Parameters:
    key - the key whose associated value is to be returned
    oldValue - value expected to be associated with the specified key
    
    Returns:
    Future
    See Also:
    javax.cache.Cache#remove(K,V), Future
  - getAndRemoveAsync
```
public Future<V> getAndRemoveAsync(K key)
```
    Description copied from interface: ICache
    
    Asynchronously removes the entry for a key returning the removed value if one existed.
    
    Specified by:
    
    getAndRemoveAsync in interface ICache<K,V>
    
    Parameters:
    key - the key whose associated value is to be returned
    
    Returns:
    Future
    See Also:
    javax.cache.Cache#getAndRemove(K), Future
  - replaceAsync
```
public Future<Boolean> replaceAsync(K key,
                           V value)
```
    Description copied from interface: ICache
    
    Asynchronously replaces the entry for a key
    
    Specified by:
    
    replaceAsync in interface ICache<K,V>
    
    Parameters:
    key - the key whose associated value is to be returned
    value - value to be associated with the specified key
    
    Returns:
    Future
    See Also:
    javax.cache.Cache#replace(K,V), Future
  - replaceAsync
```
public Future<Boolean> replaceAsync(K key,
                           V value,
                           javax.cache.expiry.ExpiryPolicy expiryPolicy)
```
    Description copied from interface: ICache
    
    Asynchronously replaces the entry for a key only if currently mapped to some value.
    
    Specified by:
    
    replaceAsync in interface ICache<K,V>
    
    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 for this operation
    
    Returns:
    See Also:
    javax.cache.Cache#replace(K,V), Future
  - replaceAsync
```
public Future<Boolean> replaceAsync(K key,
                           V oldValue,
                           V newValue)
```
    Description copied from interface: ICache
    
    Asynchronously replaces the entry for a key only if currently mapped to a given value.
    
    Specified by:
    
    replaceAsync in interface ICache<K,V>
    
    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
    
    Returns:
    See Also:
    javax.cache.Cache#replace(K,V,V), Future
  - replaceAsync
```
public Future<Boolean> replaceAsync(K key,
                           V oldValue,
                           V newValue,
                           javax.cache.expiry.ExpiryPolicy expiryPolicy)
```
    Description copied from interface: ICache
    
    Asynchronously replaces the entry for a key only if currently mapped to a given value using custom expiry policy
    
    Specified by:
    
    replaceAsync in interface ICache<K,V>
    
    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 for this operation
    
    Returns:
    See Also:
    javax.cache.Cache#replace(K,V,V), Future
  - getAndReplaceAsync
```
public Future<V> getAndReplaceAsync(K key,
                           V value)
```
    Description copied from interface: ICache
    
    Asynchronously replaces the entry for a key only if currently mapped to some
    
    Specified by:
    
    getAndReplaceAsync in interface ICache<K,V>
    
    Parameters:
    key - the key with which the specified value is associated
    value - the value to be associated with the specified key
    
    Returns:
    See Also:
    javax.cache.Cache#getAndReplace(K,V), Future
  - getAndReplaceAsync
```
public Future<V> getAndReplaceAsync(K key,
                           V value,
                           javax.cache.expiry.ExpiryPolicy expiryPolicy)
```
    Description copied from interface: ICache
    
    Asynchronously replaces the entry for a key only if currently mapped to some using custom expiry policy
    
    Specified by:
    
    getAndReplaceAsync in interface ICache<K,V>
    
    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 for this operation
    
    Returns:
    See Also:
    javax.cache.Cache#getAndReplace(K,V), Future
  - get
```
public V get(K key,
    javax.cache.expiry.ExpiryPolicy expiryPolicy)
```
    Description copied from interface: ICache
    
    Get with custom expiry policy
    
    Specified by:
    
    get in interface ICache<K,V>
    
    Parameters:
    key - the key whose associated value is to be returned
    
    Returns:
    See Also:
    javax.cache.Cache#get(K), Future
  - getAll
```
public Map<K,V> getAll(Set<? extends K> keys,
              javax.cache.expiry.ExpiryPolicy expiryPolicy)
```
    Description copied from interface: ICache
    
    getAll with custom expiry policy
    
    Specified by:
    
    getAll in interface ICache<K,V>
    
    Parameters:
    keys - The keys whose associated values are to be returned.
    
    Returns:
    See Also:
    Cache.getAll(java.util.Set), Future
  - put
```
public void put(K key,
       V value,
       javax.cache.expiry.ExpiryPolicy expiryPolicy)
```
    Description copied from interface: ICache
    
    put with custom expiry policy
    
    Specified by:
    
    put in interface ICache<K,V>
    
    Parameters:
    key - key with which the specified value is to be associated
    value - value to be associated with the specified key
    See Also:
    javax.cache.Cache#put(K,V), Future
  - getAndPut
```
public V getAndPut(K key,
          V value,
          javax.cache.expiry.ExpiryPolicy expiryPolicy)
```
    Description copied from interface: ICache
    
    getAndPut with custom expiry policy
    
    Specified by:
    
    getAndPut in interface ICache<K,V>
    
    Parameters:
    key - key with which the specified value is to be associated
    value - value to be associated with the specified key
    
    Returns:
    See Also:
    javax.cache.Cache#getAndPut(K,V), Future
  - putAll
```
public void putAll(Map<? extends K,? extends V> map,
          javax.cache.expiry.ExpiryPolicy expiryPolicy)
```
    Description copied from interface: ICache
    
    putAll with custom expiry policy
    
    Specified by:
    
    putAll in interface ICache<K,V>
    
    Parameters:
    map - mappings to be stored in this cache
    See Also:
    Cache.putAll(java.util.Map), Future
  - putIfAbsent
```
public boolean putIfAbsent(K key,
                  V value,
                  javax.cache.expiry.ExpiryPolicy expiryPolicy)
```
    Description copied from interface: ICache
    
    putIfAbsent with custom expiry policy
    
    Specified by:
    
    putIfAbsent in interface ICache<K,V>
    
    Parameters:
    key - key with which the specified value is to be associated
    value - value to be associated with the specified key
    
    Returns:
    See Also:
    javax.cache.Cache#putIfAbsent(K,V), Future
  - replace
```
public boolean replace(K key,
              V oldValue,
              V newValue,
              javax.cache.expiry.ExpiryPolicy expiryPolicy)
```
    Description copied from interface: ICache
    
    replace with custom expiry policy
    
    Specified by:
    
    replace in interface ICache<K,V>
    
    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
    
    Returns:
    See Also:
    javax.cache.Cache#replace(K,V,V), Future
  - replace
```
public boolean replace(K key,
              V value,
              javax.cache.expiry.ExpiryPolicy expiryPolicy)
```
    Description copied from interface: ICache
    
    replace with custom expiry policy
    
    Specified by:
    
    replace in interface ICache<K,V>
    
    Parameters:
    key - the key with which the specified value is associated
    value - the value to be associated with the specified key
    
    Returns:
  - getAndReplace
```
public V getAndReplace(K key,
              V value,
              javax.cache.expiry.ExpiryPolicy expiryPolicy)
```
    Description copied from interface: ICache
    
    getAndReplace with custom expiry policy
    
    Specified by:
    
    getAndReplace in interface ICache<K,V>
    
    Parameters:
    key - key with which the specified value is associated
    value - value to be associated with the specified key
    
    Returns:
    See Also:
    javax.cache.Cache#getAndReplace(K,V), Future
  - size
```
public int size()
```
    Description copied from interface: ICache
    
    total entry count
    
    Specified by:
    
    size in interface ICache<K,V>
    
    Returns:
    total entry count
  - getLocalCacheStatistics
```
public CacheStatistics getLocalCacheStatistics()
```
    Description copied from interface: ICache
    
    Directly access to local Cache Statistics
    
    Specified by:
    
    getLocalCacheStatistics in interface ICache<K,V>
    
    Returns:
    CacheStatistics
  - invoke
```
protected <T> ICompletableFuture<T> invoke(ClientRequest req,
                               Data keyData,
                               boolean completionOperation)
```
  - getSafely
```
protected <T> T getSafely(Future<T> future)
```
  - removeAsyncInternal
```
protected <T> ICompletableFuture<T> removeAsyncInternal(K key,
                                            V oldValue,
                                            boolean hasOldValue,
                                            boolean isGet,
                                            boolean withCompletionEvent)
```
  - replaceAsyncInternal
```
protected <T> ICompletableFuture<T> replaceAsyncInternal(K key,
                                             V oldValue,
                                             V newValue,
                                             javax.cache.expiry.ExpiryPolicy expiryPolicy,
                                             boolean hasOldValue,
                                             boolean isGet,
                                             boolean withCompletionEvent)
```
  - putAsyncInternal
```
protected <T> ICompletableFuture<T> putAsyncInternal(K key,
                                         V value,
                                         javax.cache.expiry.ExpiryPolicy expiryPolicy,
                                         boolean isGet,
                                         boolean withCompletionEvent)
```
  - putIfAbsentAsyncInternal
```
protected ICompletableFuture<Boolean> putIfAbsentAsyncInternal(K key,
                                                   V value,
                                                   javax.cache.expiry.ExpiryPolicy expiryPolicy,
                                                   boolean withCompletionEvent)
```
  - removeAllInternal
```
protected void removeAllInternal(Set<? extends K> keys,
                     boolean isRemoveAll)
```
  - storeInNearCache
```
protected void storeInNearCache(Data key,
                    Data valueData,
                    V value)
```
  - invalidateNearCache
```
protected void invalidateNearCache(Data key)
```
  - addListenerLocally
```
protected void addListenerLocally(String regId,
                      javax.cache.configuration.CacheEntryListenerConfiguration<K,V> cacheEntryListenerConfiguration)
```
  - removeListenerLocally
```
protected String removeListenerLocally(javax.cache.configuration.CacheEntryListenerConfiguration<K,V> cacheEntryListenerConfiguration)
```
  - deregisterAllCacheEntryListener
```
public void deregisterAllCacheEntryListener(Collection<String> listenerRegistrations)
```
  - closeListeners
```
protected void closeListeners()
```
  - countDownCompletionLatch
```
protected void countDownCompletionLatch(int id)
```
  - registerCompletionLatch
```
protected Integer registerCompletionLatch(int count)
```
  - deregisterCompletionLatch
```
protected void deregisterCompletionLatch(Integer countDownLatchId)
```
  - waitCompletionLatch
```
protected void waitCompletionLatch(Integer countDownLatchId)
```
  - waitCompletionLatch
```
protected void waitCompletionLatch(Integer countDownLatchId,
                       int offset)
```
  - registerCompletionListener
```
protected void registerCompletionListener()
```
  - deregisterCompletionListener
```
protected void deregisterCompletionListener()
```
  - createHandler
```
protected EventHandler<Object> createHandler(CacheEventListenerAdaptor adaptor)
```
  - createCompletedFuture
```
protected ICompletableFuture createCompletedFuture(Object value)
```
  - ensureOpen
```
protected void ensureOpen()
```
  - close
```
public void close()
```
  - destroy
```
public void destroy()
```
  - isClosed
```
public boolean isClosed()
```
  - getNameWithPrefix
```
public String getNameWithPrefix()
```
  - toObject
```
protected <T> T toObject(Object data)
```
  - toData
```
protected Data toData(Object o)
```
  - invoke
```
protected <T> T invoke(ClientRequest req)
```
  - validateCacheLoader
```
protected void validateCacheLoader(javax.cache.integration.CompletionListener completionListener)
```
  - closeCacheLoader
```
protected void closeCacheLoader()
```
  - submitLoadAllTask
```
protected void submitLoadAllTask(CacheLoadAllRequest request,
                     javax.cache.integration.CompletionListener completionListener)
```

Class ClientCacheProxy<K,V>

Nested Class Summary

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

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Methods inherited from interface com.hazelcast.cache.ICache

Methods inherited from interface javax.cache.Cache

Field Detail

logger

nearCache

clientContext

cacheConfig

name

nameWithPrefix

Constructor Detail

ClientCacheProxy

Method Detail

get

getAll

containsKey

loadAll

put

getAndPut

putAll

putIfAbsent

remove

remove

getAndRemove

replace

replace

getAndReplace

removeAll

removeAll

clear

getConfiguration

invoke

invokeAll

getName

getCacheManager

unwrap

registerCacheEntryListener

deregisterCacheEntryListener

updateCacheListenerConfigOnOtherNodes

iterator

getAsync

getAsync

putAsync

putAsync

putIfAbsentAsync

getAndPutAsync

getAndPutAsync

removeAsync

removeAsync

getAndRemoveAsync

replaceAsync

replaceAsync

replaceAsync

replaceAsync

getAndReplaceAsync

getAndReplaceAsync

get

getAll

put

getAndPut

putAll

putIfAbsent

replace

replace

getAndReplace

size

getLocalCacheStatistics

invoke

getSafely

removeAsyncInternal

replaceAsyncInternal

putAsyncInternal

putIfAbsentAsyncInternal

removeAllInternal