RemoteCacheWithSyncListeners (Infinispan Distribution 6.3.1.Final-redhat-1 API)

java.lang.Object
- org.infinispan.jcache.remote.RemoteCacheWithSyncListeners<K,V>

All Implemented Interfaces:

ConcurrentMap<K,V>, Map<K,V>, RemoteCache<K,V>, AsyncCache<K,V>, BasicCache<K,V>, Lifecycle
```
public class RemoteCacheWithSyncListeners<K,V>
extends Object
```

Field Summary

Fields
Modifier and Type Field and Description

protected RemoteCache<K,V> delegate

Fields
Modifier and Type	Field and Description
`protected RemoteCache<K,V>`	`delegate`

Constructor Summary

Constructors
Constructor and Description
`RemoteCacheWithSyncListeners(RemoteCache<K,V> delegate, AbstractJCacheNotifier<K,V> notifier, javax.cache.Cache<K,V> cache)`

Method Summary

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`	`clearAsync()` Asynchronous version of `#clear()`.
`boolean`	`containsKey(Object key)`
`boolean`	`containsValue(Object value)`
`Set<Map.Entry<K,V>>`	`entrySet()`
`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.
`Set`	`getListeners()` Returns a set with all the listeners registered by this client for the given cache.
`String`	`getName()` Retrieves the name of the cache
`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.
`boolean`	`isEmpty()`
`Set<K>`	`keySet()` Returns all keys in the remote server.
`V`	`put(K key, V value)` 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.
`V`	`put(K key, V value, long lifespan, TimeUnit unit)` An overloaded form of `BasicCache.put(Object, Object)`, which takes in lifespan parameters.
`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> m)` Synthetic operation.
`void`	`putAll(Map<? extends K,? extends V> map, long lifespan, TimeUnit unit)` Synthetic operation.
`void`	`putAll(Map<? extends K,? extends V> map, long lifespan, TimeUnit lifespanUnit, long maxIdleTime, TimeUnit maxIdleTimeUnit)` Synthetic operation.
`NotifyingFuture`	`putAllAsync(Map<? extends K,? extends V> data)` Synthetic operation.
`NotifyingFuture`	`putAllAsync(Map<? extends K,? extends V> data, long lifespan, TimeUnit unit)` Synthetic operation.
`NotifyingFuture`	`putAllAsync(Map<? extends K,? extends V> data, long lifespan, TimeUnit lifespanUnit, long maxIdle, TimeUnit maxIdleUnit)` Synthetic operation.
`NotifyingFuture<V>`	`putAsync(K key, V value)` Asynchronous version of `#put(Object, Object)`.
`NotifyingFuture<V>`	`putAsync(K key, V value, long lifespan, TimeUnit unit)` Asynchronous version of `#put(Object, Object, long, TimeUnit)` .
`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)`
`V`	`putIfAbsent(K key, V value, long lifespan, TimeUnit unit)` An overloaded form of `ConcurrentMap.putIfAbsent(Object, Object)`, which takes in lifespan parameters.
`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)` Asynchronous version of `#putIfAbsent(Object, Object)`.
`NotifyingFuture<V>`	`putIfAbsentAsync(K key, V value, long lifespan, TimeUnit unit)` Asynchronous version of `#putIfAbsent(Object, Object, long, TimeUnit)` .
`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.
`boolean`	`remove(Object key, Object oldValue)`
`NotifyingFuture<V>`	`removeAsync(Object key)` Asynchronous version of `#remove(Object)`.
`NotifyingFuture`	`removeAsync(Object key, Object value)` Asynchronous version of `#remove(Object, 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`	`removeWithVersionAsync(K key, long version)`
`V`	`replace(K key, V value)`
`V`	`replace(K key, V value, long lifespan, TimeUnit unit)` An overloaded form of `ConcurrentMap.replace(Object, Object)`, which takes in lifespan parameters.
`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.
`boolean`	`replace(K key, V oldValue, V newValue)`
`boolean`	`replace(K key, V oldValue, V value, long lifespan, TimeUnit unit)` An overloaded form of `ConcurrentMap.replace(Object, Object, Object)`, which takes in lifespan parameters.
`boolean`	`replace(K key, V oldValue, V value, long lifespan, TimeUnit lifespanUnit, long maxIdleTime, TimeUnit maxIdleTimeUnit)` An overloaded form of `ConcurrentMap.replace(Object, Object, Object)`, which takes in lifespan parameters.
`NotifyingFuture<V>`	`replaceAsync(K key, V value)` Asynchronous version of `#replace(Object, Object)`.
`NotifyingFuture<V>`	`replaceAsync(K key, V value, long lifespan, TimeUnit unit)` Asynchronous version of `#replace(Object, Object, long, TimeUnit)`.
`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)`.
`NotifyingFuture`	`replaceAsync(K key, V oldValue, V newValue)` Asynchronous version of `#replace(Object, Object, Object)`.
`NotifyingFuture`	`replaceAsync(K key, V oldValue, V newValue, long lifespan, TimeUnit unit)` Asynchronous version of `#replace(Object, Object, Object, long, TimeUnit)`.
`NotifyingFuture`	`replaceAsync(K key, V oldValue, V newValue, long lifespan, TimeUnit lifespanUnit, long maxIdle, TimeUnit maxIdleUnit)` Asynchronous version of `#replace(Object, Object, Object, long, TimeUnit, long, TimeUnit)`.
`boolean`	`replaceWithVersion(K key, V newValue, long version)` Replaces the given value only if its version matches the supplied version.
`boolean`	`replaceWithVersion(K key, V newValue, long version, int lifespanSeconds)` A overloaded form of `RemoteCache.replaceWithVersion(Object, Object, long)` which takes in lifespan parameters.
`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`	`replaceWithVersionAsync(K key, V newValue, long version)`
`NotifyingFuture`	`replaceWithVersionAsync(K key, V newValue, long version, int lifespanSeconds)`
`NotifyingFuture`	`replaceWithVersionAsync(K key, V newValue, long version, int lifespanSeconds, int maxIdleSeconds)`
`int`	`size()`
`void`	`start()`
`ServerStatistics`	`stats()`
`void`	`stop()`
`Collection<V>`	`values()`
`RemoteCache<K,V>`	`withFlags(Flag... flags)` Applies one or more `Flag`s to the scope of a single invocation.

- Field Detail
  - delegate
```
protected final RemoteCache<K,V> delegate
```
- Constructor Detail
  - RemoteCacheWithSyncListeners
```
public RemoteCacheWithSyncListeners(RemoteCache<K,V> delegate,
                            AbstractJCacheNotifier<K,V> notifier,
                            javax.cache.Cache<K,V> cache)
```
- Method Detail
  - put
```
public V put(K key,
    V value)
```
    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).
    
    Specified by:
    
    put in interface BasicCache<K,V>
  - putIfAbsent
```
public V putIfAbsent(K key,
            V value)
```
  - 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).
    
    Specified by:
    
    remove in interface BasicCache<K,V>
  - replace
```
public V replace(K key,
        V value)
```
  - replaceWithVersion
```
public boolean replaceWithVersion(K key,
                         V newValue,
                         long version)
```
    Description copied from interface: RemoteCache
    
    Replaces the given value only if its version matches the supplied version. See RemoteCache.removeWithVersion(Object, long) for a sample usage of the version-based methods.
    
    Specified by:
    
    replaceWithVersion in interface RemoteCache<K,V>
    
    version - numeric version that should match the one in the server for the operation to succeed
    
    Returns:
    true if the value has been replaced
    See Also:
    RemoteCache.getVersioned(Object), VersionedValue
  - 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.
    
    Specified by:
    
    addClientListener in interface RemoteCache<K,V>
  - 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.
    
    Specified by:
    
    addClientListener in interface RemoteCache<K,V>
  - clear
```
public void clear()
```
  - clearAsync
```
public NotifyingFuture 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.
    
    Specified by:
    
    clearAsync in interface AsyncCache<K,V>
    
    Returns:
    a future containing a void return type
  - containsKey
```
public boolean containsKey(Object key)
```
  - containsValue
```
public boolean containsValue(Object value)
```
    Specified by:
    
    containsValue in interface RemoteCache<K,V>
  - entrySet
```
public Set<Map.Entry<K,V>> entrySet()
```
    Specified by:
    
    entrySet in interface RemoteCache<K,V>
  - 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.
    
    Specified by:
    
    getAll in interface RemoteCache<K,V>
    
    Parameters:
    keys - The keys to find values for
    
    Returns:
    The entries that were present for the given keys
  - 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).
    
    Specified by:
    
    getAsync in interface AsyncCache<K,V>
    
    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)
  - getBulk
```
public Map<K,V> getBulk()
```
    Description copied from interface: RemoteCache
    
    Bulk get operations, returns all the entries within the remote cache.
    
    Specified by:
    
    getBulk in interface RemoteCache<K,V>
    
    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")
    
    Specified by:
    
    getBulk in interface RemoteCache<K,V>
  - getListeners
```
public Set getListeners()
```
    Description copied from interface: RemoteCache
    
    Returns a set with all the listeners registered by this client for the given cache.
    
    Specified by:
    
    getListeners in interface RemoteCache<K,V>
  - getName
```
public String getName()
```
    Description copied from interface: BasicCache
    
    Retrieves the name of the cache
    
    Specified by:
    
    getName in interface BasicCache<K,V>
    
    Returns:
    the name of the cache
  - getProtocolVersion
```
public String getProtocolVersion()
```
    Description copied from interface: RemoteCache
    
    Returns the HotRod protocol version supported by this RemoteCache implementation
    
    Specified by:
    
    getProtocolVersion in interface RemoteCache<K,V>
  - getRemoteCacheManager
```
public RemoteCacheManager getRemoteCacheManager()
```
    Description copied from interface: RemoteCache
    
    Returns the RemoteCacheManager that created this cache.
    
    Specified by:
    
    getRemoteCacheManager in interface RemoteCache<K,V>
  - getVersion
```
public String getVersion()
```
    Description copied from interface: BasicCache
    
    Retrieves the version of Infinispan
    
    Specified by:
    
    getVersion in interface BasicCache<K,V>
    
    Returns:
    a version string
  - 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.
    
    Specified by:
    
    getVersioned in interface RemoteCache<K,V>
  - 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.
    
    Specified by:
    
    getWithMetadata in interface RemoteCache<K,V>
  - isEmpty
```
public boolean isEmpty()
```
    Specified by:
    
    isEmpty in interface RemoteCache<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.
    
    Specified by:
    
    keySet in interface RemoteCache<K,V>
  - put
```
public V put(K key,
    V value,
    long lifespan,
    TimeUnit unit)
```
    Description copied from interface: BasicCache
    
    An overloaded form of BasicCache.put(Object, Object), which takes in lifespan parameters.
    
    Specified by:
    
    put in interface BasicCache<K,V>
    
    Parameters:
    key - key to use
    value - value to store
    lifespan - lifespan of the entry. Negative values are interpreted as unlimited lifespan.
    unit - unit of measurement for the lifespan
    
    Returns:
    the value being replaced, or null if nothing is being replaced.
  - 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.
    
    Specified by:
    
    put in interface BasicCache<K,V>
    
    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.
  - putAll
```
public void putAll(Map<? extends K,? extends V> m)
```
    Description copied from interface: RemoteCache
    
    Synthetic operation.
    
    Specified by:
    
    putAll in interface RemoteCache<K,V>
    
    See Also:
    RemoteCache.putAll(java.util.Map, long, java.util.concurrent.TimeUnit)
  - putAll
```
public void putAll(Map<? extends K,? extends V> map,
          long lifespan,
          TimeUnit unit)
```
    Description copied from interface: RemoteCache
    
    Synthetic operation. The client iterates over the set of keys and calls put for each one of them. This results in operation not being atomic (if a failure happens after few puts it is not rolled back) and costly (for each key in the parameter map a remote call is performed).
    
    Specified by:
    
    putAll in interface RemoteCache<K,V>
    
    Specified by:
    
    putAll in interface BasicCache<K,V>
    
    Parameters:
    map - map containing mappings to enter
    lifespan - lifespan of the entry. Negative values are interpreted as unlimited lifespan.
    unit - unit of measurement for the lifespan
  - 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.
    
    Specified by:
    
    putAll in interface RemoteCache<K,V>
    
    Specified by:
    
    putAll in interface BasicCache<K,V>
    
    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 putAllAsync(Map<? extends K,? extends V> data)
```
    Description copied from interface: RemoteCache
    
    Synthetic operation.
    
    Specified by:
    
    putAllAsync in interface RemoteCache<K,V>
    
    Specified by:
    
    putAllAsync in interface AsyncCache<K,V>
    
    Parameters:
    data - to store
    
    Returns:
    a future containing a void return type
    See Also:
    RemoteCache.putAll(java.util.Map, long, java.util.concurrent.TimeUnit)
  - putAllAsync
```
public NotifyingFuture putAllAsync(Map<? extends K,? extends V> data,
                          long lifespan,
                          TimeUnit unit)
```
    Description copied from interface: RemoteCache
    
    Synthetic operation.
    
    Specified by:
    
    putAllAsync in interface RemoteCache<K,V>
    
    Specified by:
    
    putAllAsync in interface AsyncCache<K,V>
    
    Parameters:
    data - to store
    lifespan - lifespan of entry
    unit - time unit for lifespan
    
    Returns:
    a future containing a void return type
    See Also:
    RemoteCache.putAll(java.util.Map, long, java.util.concurrent.TimeUnit)
  - putAllAsync
```
public NotifyingFuture putAllAsync(Map<? extends K,? extends V> data,
                          long lifespan,
                          TimeUnit lifespanUnit,
                          long maxIdle,
                          TimeUnit maxIdleUnit)
```
    Description copied from interface: RemoteCache
    
    Synthetic operation.
    
    Specified by:
    
    putAllAsync in interface RemoteCache<K,V>
    
    Specified by:
    
    putAllAsync in interface AsyncCache<K,V>
    
    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)
  - putAsync
```
public NotifyingFuture<V> putAsync(K key,
                          V value)
```
    Description copied from interface: AsyncCache
    
    Asynchronous version of #put(Object, Object). This method does not block on remote calls, even if your cache mode is synchronous. Has no benefit over #put(Object, Object) if used in LOCAL mode.
    
    Specified by:
    
    putAsync in interface AsyncCache<K,V>
    
    Parameters:
    key - key to use
    value - value to store
    
    Returns:
    a future containing the old value replaced.
  - putAsync
```
public NotifyingFuture<V> putAsync(K key,
                          V value,
                          long lifespan,
                          TimeUnit unit)
```
    Description copied from interface: AsyncCache
    
    Asynchronous version of #put(Object, Object, 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) if used in LOCAL mode.
    
    Specified by:
    
    putAsync in interface AsyncCache<K,V>
    
    Parameters:
    key - key to use
    value - value to store
    lifespan - lifespan of entry
    unit - time unit for lifespan
    
    Returns:
    a future containing the old value 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.
    
    Specified by:
    
    putAsync in interface AsyncCache<K,V>
    
    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
  - putIfAbsent
```
public V putIfAbsent(K key,
            V value,
            long lifespan,
            TimeUnit unit)
```
    Description copied from interface: BasicCache
    
    An overloaded form of ConcurrentMap.putIfAbsent(Object, Object), which takes in lifespan parameters.
    
    Specified by:
    
    putIfAbsent in interface BasicCache<K,V>
    
    Parameters:
    key - key to use
    value - value to store
    lifespan - lifespan of the entry. Negative values are interpreted as unlimited lifespan.
    unit - unit of measurement for the lifespan
    
    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.
    
    Specified by:
    
    putIfAbsent in interface BasicCache<K,V>
    
    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.
  - putIfAbsentAsync
```
public NotifyingFuture<V> putIfAbsentAsync(K key,
                                  V value)
```
    Description copied from interface: AsyncCache
    
    Asynchronous version of #putIfAbsent(Object, Object). This method does not block on remote calls, even if your cache mode is synchronous. Has no benefit over #putIfAbsent(Object, Object) if used in LOCAL mode.
    
    Specified by:
    
    putIfAbsentAsync in interface AsyncCache<K,V>
    
    Parameters:
    key - key to use
    value - value to store
    
    Returns:
    a future containing the old value replaced.
  - putIfAbsentAsync
```
public NotifyingFuture<V> putIfAbsentAsync(K key,
                                  V value,
                                  long lifespan,
                                  TimeUnit unit)
```
    Description copied from interface: AsyncCache
    
    Asynchronous version of #putIfAbsent(Object, Object, 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) if used in LOCAL mode.
    
    Specified by:
    
    putIfAbsentAsync in interface AsyncCache<K,V>
    
    Parameters:
    key - key to use
    value - value to store
    lifespan - lifespan of entry
    unit - time unit for lifespan
    
    Returns:
    a future containing the old value replaced
  - 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.
    
    Specified by:
    
    putIfAbsentAsync in interface AsyncCache<K,V>
    
    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
  - remove
```
public boolean remove(Object key,
             Object oldValue)
```
  - 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.
    
    Specified by:
    
    removeAsync in interface AsyncCache<K,V>
    
    Parameters:
    key - key to remove
    
    Returns:
    a future containing the value removed
  - removeAsync
```
public NotifyingFuture removeAsync(Object key,
                          Object value)
```
    Description copied from interface: AsyncCache
    
    Asynchronous version of #remove(Object, Object). This method does not block on remote calls, even if your cache mode is synchronous. Has no benefit over #remove(Object, Object) if used in LOCAL mode.
    
    Specified by:
    
    removeAsync in interface AsyncCache<K,V>
    
    Parameters:
    key - key to remove
    value - value to match on
    
    Returns:
    a future containing a boolean, indicating whether the entry was removed or not
  - 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.
    
    Specified by:
    
    removeClientListener in interface RemoteCache<K,V>
  - 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.
    Specified by:
    
    removeWithVersion in interface RemoteCache<K,V>
    
    Returns:
    true if the entry has been removed
    See Also:
    VersionedValue, RemoteCache.getVersioned(Object)
  - removeWithVersionAsync
```
public NotifyingFuture removeWithVersionAsync(K key,
                                     long version)
```
    Specified by:
    
    removeWithVersionAsync in interface RemoteCache<K,V>
    
    See Also:
    ConcurrentMap.remove(Object, Object)
  - replace
```
public V replace(K key,
        V value,
        long lifespan,
        TimeUnit unit)
```
    Description copied from interface: BasicCache
    
    An overloaded form of ConcurrentMap.replace(Object, Object), which takes in lifespan parameters.
    
    Specified by:
    
    replace in interface BasicCache<K,V>
    
    Parameters:
    key - key to use
    value - value to store
    lifespan - lifespan of the entry. Negative values are interpreted as unlimited lifespan.
    unit - unit of measurement for the lifespan
    
    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.
    
    Specified by:
    
    replace in interface BasicCache<K,V>
    
    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 boolean replace(K key,
              V oldValue,
              V newValue)
```
  - replace
```
public boolean replace(K key,
              V oldValue,
              V value,
              long lifespan,
              TimeUnit unit)
```
    Description copied from interface: BasicCache
    
    An overloaded form of ConcurrentMap.replace(Object, Object, Object), which takes in lifespan parameters.
    
    Specified by:
    
    replace in interface BasicCache<K,V>
    
    Parameters:
    key - key to use
    oldValue - value to replace
    value - value to store
    lifespan - lifespan of the entry. Negative values are interpreted as unlimited lifespan.
    unit - unit of measurement for the lifespan
    
    Returns:
    true if the value was replaced, false otherwise
  - replace
```
public boolean replace(K key,
              V oldValue,
              V value,
              long lifespan,
              TimeUnit lifespanUnit,
              long maxIdleTime,
              TimeUnit maxIdleTimeUnit)
```
    Description copied from interface: BasicCache
    
    An overloaded form of ConcurrentMap.replace(Object, Object, Object), which takes in lifespan parameters.
    
    Specified by:
    
    replace in interface BasicCache<K,V>
    
    Parameters:
    key - key to use
    oldValue - value to replace
    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:
    true if the value was replaced, false otherwise
  - replaceAsync
```
public NotifyingFuture<V> replaceAsync(K key,
                              V value)
```
    Description copied from interface: AsyncCache
    
    Asynchronous version of #replace(Object, Object). This method does not block on remote calls, even if your cache mode is synchronous. Has no benefit over #replace(Object, Object) if used in LOCAL mode.
    
    Specified by:
    
    replaceAsync in interface AsyncCache<K,V>
    
    Parameters:
    key - key to remove
    value - value to store
    
    Returns:
    a future containing the previous value overwritten
  - replaceAsync
```
public NotifyingFuture<V> replaceAsync(K key,
                              V value,
                              long lifespan,
                              TimeUnit unit)
```
    Description copied from interface: AsyncCache
    
    Asynchronous version of #replace(Object, Object, 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) if used in LOCAL mode.
    
    Specified by:
    
    replaceAsync in interface AsyncCache<K,V>
    
    Parameters:
    key - key to remove
    value - value to store
    lifespan - lifespan of entry
    unit - time unit for lifespan
    
    Returns:
    a future containing the previous value overwritten
  - 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.
    
    Specified by:
    
    replaceAsync in interface AsyncCache<K,V>
    
    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
  - replaceAsync
```
public NotifyingFuture replaceAsync(K key,
                           V oldValue,
                           V newValue)
```
    Description copied from interface: AsyncCache
    
    Asynchronous version of #replace(Object, Object, Object). This method does not block on remote calls, even if your cache mode is synchronous. Has no benefit over #replace(Object, Object, Object) if used in LOCAL mode.
    
    Specified by:
    
    replaceAsync in interface AsyncCache<K,V>
    
    Parameters:
    key - key to remove
    oldValue - value to overwrite
    newValue - value to store
    
    Returns:
    a future containing a boolean, indicating whether the entry was replaced or not
  - replaceAsync
```
public NotifyingFuture replaceAsync(K key,
                           V oldValue,
                           V newValue,
                           long lifespan,
                           TimeUnit unit)
```
    Description copied from interface: AsyncCache
    
    Asynchronous version of #replace(Object, Object, Object, long, TimeUnit). This method does not block on remote calls, even if your cache mode is synchronous. Has no benefit over #replace(Object, Object, Object, long, TimeUnit) if used in LOCAL mode.
    
    Specified by:
    
    replaceAsync in interface AsyncCache<K,V>
    
    Parameters:
    key - key to remove
    oldValue - value to overwrite
    newValue - value to store
    lifespan - lifespan of entry
    unit - time unit for lifespan
    
    Returns:
    a future containing a boolean, indicating whether the entry was replaced or not
  - replaceAsync
```
public NotifyingFuture replaceAsync(K key,
                           V oldValue,
                           V newValue,
                           long lifespan,
                           TimeUnit lifespanUnit,
                           long maxIdle,
                           TimeUnit maxIdleUnit)
```
    Description copied from interface: AsyncCache
    
    Asynchronous version of #replace(Object, 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, Object, long, TimeUnit, long, TimeUnit) if used in LOCAL mode.
    
    Specified by:
    
    replaceAsync in interface AsyncCache<K,V>
    
    Parameters:
    key - key to remove
    oldValue - value to overwrite
    newValue - 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 a boolean, indicating whether the entry was replaced or not
  - replaceWithVersion
```
public boolean replaceWithVersion(K key,
                         V newValue,
                         long version,
                         int lifespanSeconds)
```
    Description copied from interface: RemoteCache
    
    A overloaded form of RemoteCache.replaceWithVersion(Object, Object, long) which takes in lifespan parameters.
    
    Specified by:
    
    replaceWithVersion in interface RemoteCache<K,V>
    
    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
    
    Returns:
    true if the value was replaced
  - 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.
    
    Specified by:
    
    replaceWithVersion in interface RemoteCache<K,V>
    
    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.
    
    Specified by:
    
    replaceWithVersion in interface RemoteCache<K,V>
    
    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 replaceWithVersionAsync(K key,
                                      V newValue,
                                      long version)
```
    Specified by:
    
    replaceWithVersionAsync in interface RemoteCache<K,V>
    
    See Also:
    RemoteCache.replaceWithVersion(Object, Object, long)
  - replaceWithVersionAsync
```
public NotifyingFuture replaceWithVersionAsync(K key,
                                      V newValue,
                                      long version,
                                      int lifespanSeconds)
```
    Specified by:
    
    replaceWithVersionAsync in interface RemoteCache<K,V>
    
    See Also:
    RemoteCache.replaceWithVersion(Object, Object, long)
  - replaceWithVersionAsync
```
public NotifyingFuture replaceWithVersionAsync(K key,
                                      V newValue,
                                      long version,
                                      int lifespanSeconds,
                                      int maxIdleSeconds)
```
    Specified by:
    
    replaceWithVersionAsync in interface RemoteCache<K,V>
    
    See Also:
    RemoteCache.replaceWithVersion(Object, Object, long)
  - size
```
public int size()
```
    Specified by:
    
    size in interface RemoteCache<K,V>
  - start
```
public void start()
```
    Specified by:
    
    start in interface Lifecycle
  - stats
```
public ServerStatistics stats()
```
    Specified by:
    
    stats in interface RemoteCache<K,V>
  - stop
```
public void stop()
```
    Specified by:
    
    stop in interface Lifecycle
  - values
```
public Collection<V> values()
```
    Specified by:
    
    values in interface RemoteCache<K,V>
  - 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");
 
```
    Specified by:
    
    withFlags in interface RemoteCache<K,V>
    
    Returns:
    the current RemoteCache instance to continue running operations on.

Class RemoteCacheWithSyncListeners<K,V>

Field Summary

Constructor Summary

Method Summary

Field Detail

delegate

Constructor Detail

RemoteCacheWithSyncListeners

Method Detail

put

putIfAbsent

remove

replace

replaceWithVersion

addClientListener

addClientListener

clear

clearAsync

containsKey

containsValue

entrySet

get

getAll

getAsync

getBulk

getBulk

getListeners

getName

getProtocolVersion

getRemoteCacheManager

getVersion

getVersioned

getWithMetadata

isEmpty

keySet

put

put

putAll

putAll

putAll

putAllAsync

putAllAsync

putAllAsync

putAsync

putAsync

putAsync

putIfAbsent

putIfAbsent

putIfAbsentAsync

putIfAbsentAsync

putIfAbsentAsync

remove

removeAsync

removeAsync

removeClientListener

removeWithVersion

removeWithVersionAsync

replace

replace

replace

replace

replace

replaceAsync

replaceAsync

replaceAsync

replaceAsync

replaceAsync

replaceAsync

replaceWithVersion

replaceWithVersion

replaceWithVersion

replaceWithVersionAsync

replaceWithVersionAsync

replaceWithVersionAsync

size

start

stats

stop

values

withFlags