RemoteCacheImpl (Infinispan 8.2.4.Final API)

java.lang.Object
- org.infinispan.client.hotrod.impl.RemoteCacheSupport<K,V>
- - org.infinispan.client.hotrod.impl.RemoteCacheImpl<K,V>

All Implemented Interfaces:

ConcurrentMap<K,V>, Map<K,V>, RemoteCache<K,V>, AsyncCache<K,V>, BasicCache<K,V>, Lifecycle

Direct Known Subclasses:

EagerNearRemoteCache, InvalidatedNearRemoteCache
```
public class RemoteCacheImpl<K,V>
extends RemoteCacheSupport<K,V>
```
Since:

4.1

Author:

Mircea.Markus@jboss.com

Nested Class Summary
- Nested classes/interfaces inherited from interface java.util.Map
  Map.Entry<K,V>

Field Summary

Fields
Modifier and Type Field and Description

protected OperationsFactory operationsFactory
- Fields inherited from class org.infinispan.client.hotrod.impl.RemoteCacheSupport
  defaultLifespan, defaultMaxIdleTime

Fields
Modifier and Type	Field and Description
`protected OperationsFactory`	`operationsFactory`

Constructor Summary

Constructors
Constructor and Description

RemoteCacheImpl(RemoteCacheManager rcm, String name)

Constructors
Constructor and Description
`RemoteCacheImpl(RemoteCacheManager rcm, String name)`

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`void`	`addClientListener(Object listener)` Add a client listener to receive events that happen in the remote cache.
`void`	`addClientListener(Object listener, Object[] filterFactoryParams, Object[] converterFactoryParams)` Add a client listener to receive events that happen in the remote cache.
`void`	`clear()`
`NotifyingFuture<Void>`	`clearAsync()` Asynchronous version of `#clear()`.
`boolean`	`containsKey(Object key)`
`<T> T`	`execute(String taskName, Map<String,?> params)` Executes a remote script passing a set of named parameters
`V`	`get(Object key)`
`Map<K,V>`	`getAll(Set<? extends K> keys)` Retrieves all of the entries for the provided keys.
`NotifyingFuture<V>`	`getAsync(K key)` Asynchronous version of `#get(Object)` that allows user code to retrieve the value associated with a key at a later stage, hence allowing multiple parallel get requests to be sent.
`Map<K,V>`	`getBulk()` Bulk get operations, returns all the entries within the remote cache.
`Map<K,V>`	`getBulk(int size)` Same as `RemoteCache.getBulk()`, but limits the returned set of values to the specified size.
`CacheTopologyInfo`	`getCacheTopologyInfo()` Returns `CacheTopologyInfo` for this cache.
`Set<Object>`	`getListeners()` Returns a set with all the listeners registered by this client for the given cache.
`String`	`getName()` Retrieves the name of the cache
`OperationsFactory`	`getOperationsFactory()`
`String`	`getProtocolVersion()` Returns the HotRod protocol version supported by this RemoteCache implementation
`RemoteCacheManager`	`getRemoteCacheManager()` Returns the `RemoteCacheManager` that created this cache.
`String`	`getVersion()` Retrieves the version of Infinispan
`VersionedValue<V>`	`getVersioned(K key)` Returns the `VersionedValue` associated to the supplied key param, or null if it doesn't exist.
`MetadataValue<V>`	`getWithMetadata(K key)` Returns the `MetadataValue` associated to the supplied key param, or null if it doesn't exist.
`void`	`init(Marshaller marshaller, ExecutorService executorService, OperationsFactory operationsFactory, int estimateKeySize, int estimateValueSize)`
`boolean`	`isEmpty()`
`Set<K>`	`keySet()` Returns all keys in the remote server.
`PingOperation.PingResult`	`ping()`
`V`	`put(K key, V value, long lifespan, TimeUnit lifespanUnit, long maxIdleTime, TimeUnit maxIdleTimeUnit)` An overloaded form of `BasicCache.put(Object, Object)`, which takes in lifespan parameters.
`void`	`putAll(Map<? extends K,? extends V> map, long lifespan, TimeUnit lifespanUnit, long maxIdleTime, TimeUnit maxIdleTimeUnit)` Synthetic operation.
`NotifyingFuture<Void>`	`putAllAsync(Map<? extends K,? extends V> data, long lifespan, TimeUnit lifespanUnit, long maxIdle, TimeUnit maxIdleUnit)` Synthetic operation.
`NotifyingFuture<V>`	`putAsync(K key, V value, long lifespan, TimeUnit lifespanUnit, long maxIdle, TimeUnit maxIdleUnit)` Asynchronous version of `#put(Object, Object, long, TimeUnit, long, TimeUnit)`.
`V`	`putIfAbsent(K key, V value, long lifespan, TimeUnit lifespanUnit, long maxIdleTime, TimeUnit maxIdleTimeUnit)` An overloaded form of `ConcurrentMap.putIfAbsent(Object, Object)`, which takes in lifespan parameters.
`NotifyingFuture<V>`	`putIfAbsentAsync(K key, V value, long lifespan, TimeUnit lifespanUnit, long maxIdle, TimeUnit maxIdleUnit)` Asynchronous version of `#putIfAbsent(Object, Object, long, TimeUnit, long, TimeUnit)`.
`V`	`remove(Object key)` If the return value of this operation will be ignored by the application, the user is strongly encouraged to use the `Flag.IGNORE_RETURN_VALUES` flag when invoking this method in order to make it behave as efficiently as possible (i.e.
`NotifyingFuture<V>`	`removeAsync(Object key)` Asynchronous version of `#remove(Object)`.
`void`	`removeClientListener(Object listener)` Remove a previously added client listener.
`boolean`	`removeWithVersion(K key, long version)` Removes the given entry only if its version matches the supplied version.
`NotifyingFuture<Boolean>`	`removeWithVersionAsync(K key, long version)`
`V`	`replace(K key, V value, long lifespan, TimeUnit lifespanUnit, long maxIdleTime, TimeUnit maxIdleTimeUnit)` An overloaded form of `ConcurrentMap.replace(Object, Object)`, which takes in lifespan parameters.
`NotifyingFuture<V>`	`replaceAsync(K key, V value, long lifespan, TimeUnit lifespanUnit, long maxIdle, TimeUnit maxIdleUnit)` Asynchronous version of `#replace(Object, Object, long, TimeUnit, long, TimeUnit)`.
`boolean`	`replaceWithVersion(K key, V newValue, long version, int lifespanSeconds, int maxIdleTimeSeconds)` A overloaded form of `RemoteCache.replaceWithVersion(Object, Object, long)` which takes in lifespan and maximum idle time parameters.
`boolean`	`replaceWithVersion(K key, V newValue, long version, long lifespan, TimeUnit lifespanTimeUnit, long maxIdle, TimeUnit maxIdleTimeUnit)` A overloaded form of `RemoteCache.replaceWithVersion(Object, Object, long)` which takes in lifespan and maximum idle time parameters.
`NotifyingFuture<Boolean>`	`replaceWithVersionAsync(K key, V newValue, long version, int lifespanSeconds, int maxIdleSeconds)`
`PingOperation.PingResult`	`resolveCompatibility()`
`CloseableIterator<Map.Entry<Object,Object>>`	`retrieveEntries(String filterConverterFactory, int batchSize)`
`CloseableIterator<Map.Entry<Object,Object>>`	`retrieveEntries(String filterConverterFactory, Object[] filterConverterParams, Set<Integer> segments, int batchSize)` Retrieve entries from the server
`CloseableIterator<Map.Entry<Object,Object>>`	`retrieveEntries(String filterConverterFactory, Set<Integer> segments, int batchSize)`
`CloseableIterator<Map.Entry<Object,Object>>`	`retrieveEntriesByQuery(Query filterQuery, Set<Integer> segments, int batchSize)` Retrieve entries from the server matching a query.
`CloseableIterator<Map.Entry<Object,MetadataValue<Object>>>`	`retrieveEntriesWithMetadata(Set<Integer> segments, int batchSize)` Retrieve entries with metadata information
`protected void`	`set(K key, V value)` This is intentionally a non-public method meant as an integration point for bytecode manipulation.
`int`	`size()`
`void`	`start()` Invoked on component start
`ServerStatistics`	`stats()`
`void`	`stop()` Invoked on component stop
`RemoteCache<K,V>`	`withFlags(Flag... flags)` Applies one or more `Flag`s to the scope of a single invocation.

Methods inherited from class org.infinispan.client.hotrod.impl.RemoteCacheSupport
containsValue, entrySet, put, put, putAll, putAll, putAllAsync, putAllAsync, putAsync, putAsync, putIfAbsent, putIfAbsent, putIfAbsentAsync, putIfAbsentAsync, remove, removeAsync, replace, replace, replace, replace, replace, replaceAsync, replaceAsync, replaceAsync, replaceAsync, replaceAsync, replaceWithVersion, replaceWithVersion, replaceWithVersionAsync, replaceWithVersionAsync, values

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

Methods inherited from interface java.util.concurrent.ConcurrentMap
compute, computeIfAbsent, computeIfPresent, forEach, getOrDefault, merge, replaceAll

Methods inherited from interface java.util.Map
equals, hashCode

- Field Detail
  - operationsFactory
```
protected OperationsFactory operationsFactory
```
- Constructor Detail
  - RemoteCacheImpl
```
public RemoteCacheImpl(RemoteCacheManager rcm,
                       String name)
```
- Method Detail
  - init
```
public void init(Marshaller marshaller,
                 ExecutorService executorService,
                 OperationsFactory operationsFactory,
                 int estimateKeySize,
                 int estimateValueSize)
```
  - getOperationsFactory
```
public OperationsFactory getOperationsFactory()
```
  - getRemoteCacheManager
```
public RemoteCacheManager getRemoteCacheManager()
```
    Description copied from interface: RemoteCache
    
    Returns the RemoteCacheManager that created this cache.
  - removeWithVersion
```
public boolean removeWithVersion(K key,
                                 long version)
```
    Description copied from interface: RemoteCache
    Removes the given entry only if its version matches the supplied version. A typical use case looks like this:
```
 VersionedEntry ve = remoteCache.getVersioned(key);
 //some processing
 remoteCache.removeWithVersion(key, ve.getVersion();
 
```
    Lat call (removeWithVersion) will make sure that the entry will only be removed if it hasn't been changed in between.
    Returns:
    
    true if the entry has been removed
    
    See Also:
    
    VersionedValue, RemoteCache.getVersioned(Object)
  - removeWithVersionAsync
```
public NotifyingFuture<Boolean> removeWithVersionAsync(K key,
                                                       long version)
```
    See Also:
    
    ConcurrentMap.remove(Object, Object)
  - replaceWithVersion
```
public boolean replaceWithVersion(K key,
                                  V newValue,
                                  long version,
                                  int lifespanSeconds,
                                  int maxIdleTimeSeconds)
```
    Description copied from interface: RemoteCache
    
    A overloaded form of RemoteCache.replaceWithVersion(Object, Object, long) which takes in lifespan and maximum idle time parameters.
    
    Parameters:
    
    key - key to use
    
    newValue - new value to be associated with the key
    
    version - numeric version that should match the one in the server for the operation to succeed
    
    lifespanSeconds - lifespan of the entry
    
    maxIdleTimeSeconds - the maximum amount of time this key is allowed to be idle for before it is considered as expired
    
    Returns:
    
    true if the value was replaced
  - replaceWithVersion
```
public boolean replaceWithVersion(K key,
                                  V newValue,
                                  long version,
                                  long lifespan,
                                  TimeUnit lifespanTimeUnit,
                                  long maxIdle,
                                  TimeUnit maxIdleTimeUnit)
```
    Description copied from interface: RemoteCache
    
    A overloaded form of RemoteCache.replaceWithVersion(Object, Object, long) which takes in lifespan and maximum idle time parameters.
    
    Parameters:
    
    key - key to use
    
    newValue - new value to be associated with the key
    
    version - numeric version that should match the one in the server for the operation to succeed
    
    lifespan - lifespan of the entry
    
    lifespanTimeUnit - TimeUnit for lifespan
    
    maxIdle - the maximum amount of time this key is allowed to be idle for before it is considered as expired
    
    maxIdleTimeUnit - TimeUnit for maxIdle
    
    Returns:
    
    true if the value was replaced
  - replaceWithVersionAsync
```
public NotifyingFuture<Boolean> replaceWithVersionAsync(K key,
                                                        V newValue,
                                                        long version,
                                                        int lifespanSeconds,
                                                        int maxIdleSeconds)
```
    See Also:
    
    RemoteCache.replaceWithVersion(Object, Object, long)
  - retrieveEntries
```
public CloseableIterator<Map.Entry<Object,Object>> retrieveEntries(String filterConverterFactory,
                                                                   Object[] filterConverterParams,
                                                                   Set<Integer> segments,
                                                                   int batchSize)
```
    Description copied from interface: RemoteCache
    
    Retrieve entries from the server
    
    Parameters:
    
    filterConverterFactory - Factory name for the KeyValueFilterConverter or null for no filtering.
    
    filterConverterParams - Parameters to the KeyValueFilterConverter
    
    segments - The segments to iterate. If null all segments will be iterated. An empty set will filter out all entries.
    
    batchSize - The number of entries transferred from the server at a time.
    
    Returns:
    
    Iterator for the entries
  - retrieveEntries
```
public CloseableIterator<Map.Entry<Object,Object>> retrieveEntries(String filterConverterFactory,
                                                                   Set<Integer> segments,
                                                                   int batchSize)
```
    See Also:
    
    RemoteCache.retrieveEntries(String, Object[], java.util.Set, int)
  - retrieveEntries
```
public CloseableIterator<Map.Entry<Object,Object>> retrieveEntries(String filterConverterFactory,
                                                                   int batchSize)
```
    See Also:
    
    RemoteCache.retrieveEntries(String, Object[], java.util.Set, int)
  - retrieveEntriesByQuery
```
public CloseableIterator<Map.Entry<Object,Object>> retrieveEntriesByQuery(Query filterQuery,
                                                                          Set<Integer> segments,
                                                                          int batchSize)
```
    Description copied from interface: RemoteCache
    
    Retrieve entries from the server matching a query.
    
    Parameters:
    
    filterQuery - Query
    
    segments - The segments to iterate. If null all segments will be iterated. An empty set will filter out all entries.
    
    batchSize - The number of entries transferred from the server at a time.
    
    Returns:
    
    CloseableIterator
  - retrieveEntriesWithMetadata
```
public CloseableIterator<Map.Entry<Object,MetadataValue<Object>>> retrieveEntriesWithMetadata(Set<Integer> segments,
                                                                                              int batchSize)
```
    Description copied from interface: RemoteCache
    
    Retrieve entries with metadata information
  - getVersioned
```
public VersionedValue<V> getVersioned(K key)
```
    Description copied from interface: RemoteCache
    
    Returns the VersionedValue associated to the supplied key param, or null if it doesn't exist.
  - getWithMetadata
```
public MetadataValue<V> getWithMetadata(K key)
```
    Description copied from interface: RemoteCache
    
    Returns the MetadataValue associated to the supplied key param, or null if it doesn't exist.
  - putAll
```
public void putAll(Map<? extends K,? extends V> map,
                   long lifespan,
                   TimeUnit lifespanUnit,
                   long maxIdleTime,
                   TimeUnit maxIdleTimeUnit)
```
    Description copied from interface: RemoteCache
    
    Synthetic operation.
    
    Parameters:
    
    map - map containing mappings to enter
    
    lifespan - lifespan of the entry. Negative values are interpreted as unlimited lifespan.
    
    lifespanUnit - time unit for lifespan
    
    maxIdleTime - the maximum amount of time this key is allowed to be idle for before it is considered as expired
    
    maxIdleTimeUnit - time unit for max idle time
    
    See Also:
    
    RemoteCache.putAll(java.util.Map, long, java.util.concurrent.TimeUnit)
  - putAllAsync
```
public NotifyingFuture<Void> putAllAsync(Map<? extends K,? extends V> data,
                                         long lifespan,
                                         TimeUnit lifespanUnit,
                                         long maxIdle,
                                         TimeUnit maxIdleUnit)
```
    Description copied from interface: RemoteCache
    
    Synthetic operation.
    
    Parameters:
    
    data - to store
    
    lifespan - lifespan of entry
    
    lifespanUnit - time unit for lifespan
    
    maxIdle - the maximum amount of time this key is allowed to be idle for before it is considered as expired
    
    maxIdleUnit - time unit for max idle time
    
    Returns:
    
    a future containing a void return type
    
    See Also:
    
    RemoteCache.putAll(java.util.Map, long, java.util.concurrent.TimeUnit)
  - size
```
public int size()
```
  - isEmpty
```
public boolean isEmpty()
```
  - stats
```
public ServerStatistics stats()
```
  - put
```
public V put(K key,
             V value,
             long lifespan,
             TimeUnit lifespanUnit,
             long maxIdleTime,
             TimeUnit maxIdleTimeUnit)
```
    Description copied from interface: BasicCache
    
    An overloaded form of BasicCache.put(Object, Object), which takes in lifespan parameters.
    
    Parameters:
    
    key - key to use
    
    value - value to store
    
    lifespan - lifespan of the entry. Negative values are interpreted as unlimited lifespan.
    
    lifespanUnit - time unit for lifespan
    
    maxIdleTime - the maximum amount of time this key is allowed to be idle for before it is considered as expired
    
    maxIdleTimeUnit - time unit for max idle time
    
    Returns:
    
    the value being replaced, or null if nothing is being replaced.
  - putIfAbsent
```
public V putIfAbsent(K key,
                     V value,
                     long lifespan,
                     TimeUnit lifespanUnit,
                     long maxIdleTime,
                     TimeUnit maxIdleTimeUnit)
```
    Description copied from interface: BasicCache
    
    An overloaded form of ConcurrentMap.putIfAbsent(Object, Object), which takes in lifespan parameters.
    
    Parameters:
    
    key - key to use
    
    value - value to store
    
    lifespan - lifespan of the entry. Negative values are interpreted as unlimited lifespan.
    
    lifespanUnit - time unit for lifespan
    
    maxIdleTime - the maximum amount of time this key is allowed to be idle for before it is considered as expired
    
    maxIdleTimeUnit - time unit for max idle time
    
    Returns:
    
    the value being replaced, or null if nothing is being replaced.
  - replace
```
public V replace(K key,
                 V value,
                 long lifespan,
                 TimeUnit lifespanUnit,
                 long maxIdleTime,
                 TimeUnit maxIdleTimeUnit)
```
    Description copied from interface: BasicCache
    
    An overloaded form of ConcurrentMap.replace(Object, Object), which takes in lifespan parameters.
    
    Parameters:
    
    key - key to use
    
    value - value to store
    
    lifespan - lifespan of the entry. Negative values are interpreted as unlimited lifespan.
    
    lifespanUnit - time unit for lifespan
    
    maxIdleTime - the maximum amount of time this key is allowed to be idle for before it is considered as expired
    
    maxIdleTimeUnit - time unit for max idle time
    
    Returns:
    
    the value being replaced, or null if nothing is being replaced.
  - putAsync
```
public NotifyingFuture<V> putAsync(K key,
                                   V value,
                                   long lifespan,
                                   TimeUnit lifespanUnit,
                                   long maxIdle,
                                   TimeUnit maxIdleUnit)
```
    Description copied from interface: AsyncCache
    
    Asynchronous version of #put(Object, Object, long, TimeUnit, long, TimeUnit). This method does not block on remote calls, even if your cache mode is synchronous. Has no benefit over #put(Object, Object, long, TimeUnit, long, TimeUnit) if used in LOCAL mode.
    
    Parameters:
    
    key - key to use
    
    value - value to store
    
    lifespan - lifespan of entry
    
    lifespanUnit - time unit for lifespan
    
    maxIdle - the maximum amount of time this key is allowed to be idle for before it is considered as expired
    
    maxIdleUnit - time unit for max idle time
    
    Returns:
    
    a future containing the old value replaced
  - clearAsync
```
public NotifyingFuture<Void> clearAsync()
```
    Description copied from interface: AsyncCache
    
    Asynchronous version of #clear(). This method does not block on remote calls, even if your cache mode is synchronous. Has no benefit over #clear() if used in LOCAL mode.
    
    Returns:
    
    a future containing a void return type
  - putIfAbsentAsync
```
public NotifyingFuture<V> putIfAbsentAsync(K key,
                                           V value,
                                           long lifespan,
                                           TimeUnit lifespanUnit,
                                           long maxIdle,
                                           TimeUnit maxIdleUnit)
```
    Description copied from interface: AsyncCache
    
    Asynchronous version of #putIfAbsent(Object, Object, long, TimeUnit, long, TimeUnit). This method does not block on remote calls, even if your cache mode is synchronous. Has no benefit over #putIfAbsent(Object, Object, long, TimeUnit, long, TimeUnit) if used in LOCAL mode.
    
    Parameters:
    
    key - key to use
    
    value - value to store
    
    lifespan - lifespan of entry
    
    lifespanUnit - time unit for lifespan
    
    maxIdle - the maximum amount of time this key is allowed to be idle for before it is considered as expired
    
    maxIdleUnit - time unit for max idle time
    
    Returns:
    
    a future containing the old value replaced
  - removeAsync
```
public NotifyingFuture<V> removeAsync(Object key)
```
    Description copied from interface: AsyncCache
    
    Asynchronous version of #remove(Object). This method does not block on remote calls, even if your cache mode is synchronous. Has no benefit over #remove(Object) if used in LOCAL mode.
    
    Parameters:
    
    key - key to remove
    
    Returns:
    
    a future containing the value removed
  - replaceAsync
```
public NotifyingFuture<V> replaceAsync(K key,
                                       V value,
                                       long lifespan,
                                       TimeUnit lifespanUnit,
                                       long maxIdle,
                                       TimeUnit maxIdleUnit)
```
    Description copied from interface: AsyncCache
    
    Asynchronous version of #replace(Object, Object, long, TimeUnit, long, TimeUnit). This method does not block on remote calls, even if your cache mode is synchronous. Has no benefit over #replace(Object, Object, long, TimeUnit, long, TimeUnit) if used in LOCAL mode.
    
    Parameters:
    
    key - key to remove
    
    value - value to store
    
    lifespan - lifespan of entry
    
    lifespanUnit - time unit for lifespan
    
    maxIdle - the maximum amount of time this key is allowed to be idle for before it is considered as expired
    
    maxIdleUnit - time unit for max idle time
    
    Returns:
    
    a future containing the previous value overwritten
  - containsKey
```
public boolean containsKey(Object key)
```
  - get
```
public V get(Object key)
```
  - getAll
```
public Map<K,V> getAll(Set<? extends K> keys)
```
    Description copied from interface: RemoteCache
    
    Retrieves all of the entries for the provided keys. A key will not be present in the resulting map if the entry was not found in the cache.
    
    Parameters:
    
    keys - The keys to find values for
    
    Returns:
    
    The entries that were present for the given keys
  - getBulk
```
public Map<K,V> getBulk()
```
    Description copied from interface: RemoteCache
    
    Bulk get operations, returns all the entries within the remote cache.
    
    Returns:
    
    the returned values depend on the configuration of the back-end infinispan servers. Read this for more details. The returned Map is unmodifiable.
  - getBulk
```
public Map<K,V> getBulk(int size)
```
    Description copied from interface: RemoteCache
    
    Same as RemoteCache.getBulk(), but limits the returned set of values to the specified size. No ordering is guaranteed, and there is no guarantee that "size" elements are returned( e.g. if the number of elements in the back-end server is smaller that "size")
  - remove
```
public V remove(Object key)
```
    Description copied from interface: BasicCache
    
    If the return value of this operation will be ignored by the application, the user is strongly encouraged to use the Flag.IGNORE_RETURN_VALUES flag when invoking this method in order to make it behave as efficiently as possible (i.e. avoiding needless remote or network calls).
  - clear
```
public void clear()
```
  - start
```
public void start()
```
    Description copied from interface: Lifecycle
    
    Invoked on component start
  - stop
```
public void stop()
```
    Description copied from interface: Lifecycle
    
    Invoked on component stop
  - getName
```
public String getName()
```
    Description copied from interface: BasicCache
    
    Retrieves the name of the cache
    
    Returns:
    
    the name of the cache
  - getVersion
```
public String getVersion()
```
    Description copied from interface: BasicCache
    
    Retrieves the version of Infinispan
    
    Returns:
    
    a version string
  - getProtocolVersion
```
public String getProtocolVersion()
```
    Description copied from interface: RemoteCache
    
    Returns the HotRod protocol version supported by this RemoteCache implementation
  - addClientListener
```
public void addClientListener(Object listener)
```
    Description copied from interface: RemoteCache
    
    Add a client listener to receive events that happen in the remote cache. The listener object must be annotated with @ClientListener annotation.
  - addClientListener
```
public void addClientListener(Object listener,
                              Object[] filterFactoryParams,
                              Object[] converterFactoryParams)
```
    Description copied from interface: RemoteCache
    
    Add a client listener to receive events that happen in the remote cache. The listener object must be annotated with @ClientListener annotation.
  - removeClientListener
```
public void removeClientListener(Object listener)
```
    Description copied from interface: RemoteCache
    
    Remove a previously added client listener. If the listener was not added before, this operation is a no-op.
  - getListeners
```
public Set<Object> getListeners()
```
    Description copied from interface: RemoteCache
    
    Returns a set with all the listeners registered by this client for the given cache.
  - withFlags
```
public RemoteCache<K,V> withFlags(Flag... flags)
```
    Description copied from interface: RemoteCache
    Applies one or more Flags to the scope of a single invocation. See the Flag enumeration to for information on available flags.
    Sample usage:
```
    remoteCache.withFlags(Flag.FORCE_RETURN_VALUE).put("hello", "world");
 
```
    Returns:
    
    the current RemoteCache instance to continue running operations on.
  - getAsync
```
public NotifyingFuture<V> getAsync(K key)
```
    Description copied from interface: AsyncCache
    
    Asynchronous version of #get(Object) that allows user code to retrieve the value associated with a key at a later stage, hence allowing multiple parallel get requests to be sent. Normally, when this method detects that the value is likely to be retrieved from from a remote entity, it will span a different thread in order to allow the asynchronous get call to return immediately. If the call will definitely resolve locally, for example when the cache is configured with LOCAL mode and no stores are configured, the get asynchronous call will act sequentially and will have no different to #get(Object).
    
    Parameters:
    
    key - key to retrieve
    
    Returns:
    
    a future that can be used to retrieve value associated with the key when this is available. The actual value returned by the future follows the same rules as #get(Object)
  - ping
```
public PingOperation.PingResult ping()
```
  - set
```
protected void set(K key,
                   V value)
```
    Description copied from class: RemoteCacheSupport
    
    This is intentionally a non-public method meant as an integration point for bytecode manipulation. Don't remove or alter the signature even if it might look like unreachable code. Implementors should perform a put operation but optimizing it as return values are not required.
    
    Specified by:
    
    set in class RemoteCacheSupport<K,V>
  - keySet
```
public Set<K> keySet()
```
    Description copied from interface: RemoteCache
    
    Returns all keys in the remote server. It'll invoke a command over the network each time this method is called. If the remote cache is a distributed cache, it will retrieve all of the keys from all nodes in the cluster. Please use with care for cache with large data set.
  - execute
```
public <T> T execute(String taskName,
                     Map<String,?> params)
```
    Description copied from interface: RemoteCache
    
    Executes a remote script passing a set of named parameters
  - getCacheTopologyInfo
```
public CacheTopologyInfo getCacheTopologyInfo()
```
    Description copied from interface: RemoteCache
    
    Returns CacheTopologyInfo for this cache.
  - resolveCompatibility
```
public PingOperation.PingResult resolveCompatibility()
```

Class RemoteCacheImpl<K,V>

Nested Class Summary

Nested classes/interfaces inherited from interface java.util.Map

Field Summary

Fields inherited from class org.infinispan.client.hotrod.impl.RemoteCacheSupport

Constructor Summary

Method Summary

Methods inherited from class org.infinispan.client.hotrod.impl.RemoteCacheSupport

Methods inherited from class java.lang.Object

Methods inherited from interface java.util.concurrent.ConcurrentMap

Methods inherited from interface java.util.Map

Field Detail

operationsFactory

Constructor Detail

RemoteCacheImpl

Method Detail

init

getOperationsFactory

getRemoteCacheManager

removeWithVersion

removeWithVersionAsync

replaceWithVersion

replaceWithVersion

replaceWithVersionAsync

retrieveEntries

retrieveEntries

retrieveEntries

retrieveEntriesByQuery

retrieveEntriesWithMetadata

getVersioned

getWithMetadata

putAll

putAllAsync

size

isEmpty

stats

put

putIfAbsent

replace

putAsync

clearAsync

putIfAbsentAsync

removeAsync

replaceAsync

containsKey

get

getAll

getBulk

getBulk

remove

clear

start

stop

getName

getVersion

getProtocolVersion

addClientListener

addClientListener

removeClientListener

getListeners

withFlags

getAsync

ping

set

keySet

execute

getCacheTopologyInfo

resolveCompatibility