AbstractDelegatingCache (Infinispan Distribution 6.0.2.Final API)

java.lang.Object
- org.infinispan.AbstractDelegatingCache<K,V>

All Implemented Interfaces:

ConcurrentMap<K,V>, Map<K,V>, Cache<K,V>, AsyncCache<K,V>, BasicCache<K,V>, BatchingCache, Lifecycle, FilteringListenable, Listenable

Direct Known Subclasses:

AbstractDelegatingAdvancedCache
```
public abstract class AbstractDelegatingCache<K,V>
extends Object
implements Cache<K,V>
```
This is a convenient base class for implementing a cache delegate. The only constructor takes a Cache argument, to which each method call is delegated. One can extend this class and override the method sub-set it is interested in. There is also an similar implementation for AdvancedCache: AbstractDelegatingAdvancedCache.

Author:

Mircea.Markus@jboss.com

See Also:
AbstractDelegatingAdvancedCache

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

Constructor Summary

Constructors
Constructor and Description

AbstractDelegatingCache(Cache<K,V> cache)

Constructors
Constructor and Description
`AbstractDelegatingCache(Cache<K,V> cache)`

Method Summary

Methods
Modifier and Type	Method and Description
`void`	`addListener(Object listener)` Adds a listener to the component.
`void`	`addListener(Object listener, KeyFilter filter)` Adds a listener to the component.
`void`	`clear()`
`NotifyingFuture<Void>`	`clearAsync()` Asynchronous version of `Map.clear()`.
`boolean`	`containsKey(Object key)`
`boolean`	`containsValue(Object value)`
`void`	`endBatch(boolean successful)` Completes a batch if one has been started using `BatchingCache.startBatch()`.
`Set<Map.Entry<K,V>>`	`entrySet()` Returns a set view of the mappings contained in this cache and cache loader.
`void`	`evict(K key)` Evicts an entry from the memory of the cache.
`V`	`get(Object key)`
`AdvancedCache<K,V>`	`getAdvancedCache()`
`NotifyingFuture<V>`	`getAsync(K key)` Asynchronous version of `Map.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.
`Configuration`	`getCacheConfiguration()`
`EmbeddedCacheManager`	`getCacheManager()` Retrieves the cache manager responsible for creating this cache instance.
`Cache<K,V>`	`getDelegate()`
`Set<Object>`	`getListeners()`
`String`	`getName()` Retrieves the name of the cache
`ComponentStatus`	`getStatus()`
`String`	`getVersion()` Retrieves the version of Infinispan
`boolean`	`isEmpty()`
`Set<K>`	`keySet()` Returns a set view of the keys contained in this cache and cache loader.
`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> t)`
`void`	`putAll(Map<? extends K,? extends V> map, long lifespan, TimeUnit unit)` An overloaded form of `Map.putAll(Map)`, which takes in lifespan parameters.
`void`	`putAll(Map<? extends K,? extends V> map, long lifespan, TimeUnit lifespanUnit, long maxIdleTime, TimeUnit maxIdleTimeUnit)` An overloaded form of `Map.putAll(Map)`, which takes in lifespan parameters.
`NotifyingFuture<Void>`	`putAllAsync(Map<? extends K,? extends V> data)` Asynchronous version of `Map.putAll(Map)`.
`NotifyingFuture<Void>`	`putAllAsync(Map<? extends K,? extends V> data, long lifespan, TimeUnit unit)` Asynchronous version of `BasicCache.putAll(Map, long, TimeUnit)`.
`NotifyingFuture<Void>`	`putAllAsync(Map<? extends K,? extends V> data, long lifespan, TimeUnit lifespanUnit, long maxIdle, TimeUnit maxIdleUnit)` Asynchronous version of `BasicCache.putAll(Map, long, TimeUnit, long, TimeUnit)`.
`NotifyingFuture<V>`	`putAsync(K key, V value)` Asynchronous version of `BasicCache.put(Object, Object)`.
`NotifyingFuture<V>`	`putAsync(K key, V value, long lifespan, TimeUnit unit)` Asynchronous version of `BasicCache.put(Object, Object, long, TimeUnit)` .
`NotifyingFuture<V>`	`putAsync(K key, V value, long lifespan, TimeUnit lifespanUnit, long maxIdle, TimeUnit maxIdleUnit)` Asynchronous version of `BasicCache.put(Object, Object, long, TimeUnit, long, TimeUnit)`.
`void`	`putForExternalRead(K key, V value)` Under special operating behavior, associates the value with the specified key.
`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 `ConcurrentMap.putIfAbsent(Object, Object)`.
`NotifyingFuture<V>`	`putIfAbsentAsync(K key, V value, long lifespan, TimeUnit unit)` Asynchronous version of `BasicCache.putIfAbsent(Object, Object, long, TimeUnit)` .
`NotifyingFuture<V>`	`putIfAbsentAsync(K key, V value, long lifespan, TimeUnit lifespanUnit, long maxIdle, TimeUnit maxIdleUnit)` Asynchronous version of `BasicCache.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 value)`
`NotifyingFuture<V>`	`removeAsync(Object key)` Asynchronous version of `BasicCache.remove(Object)`.
`NotifyingFuture<Boolean>`	`removeAsync(Object key, Object value)` Asynchronous version of `ConcurrentMap.remove(Object, Object)`.
`void`	`removeListener(Object listener)` Removes a listener from the component.
`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 `ConcurrentMap.replace(Object, Object)`.
`NotifyingFuture<V>`	`replaceAsync(K key, V value, long lifespan, TimeUnit unit)` Asynchronous version of `BasicCache.replace(Object, Object, long, TimeUnit)`.
`NotifyingFuture<V>`	`replaceAsync(K key, V value, long lifespan, TimeUnit lifespanUnit, long maxIdle, TimeUnit maxIdleUnit)` Asynchronous version of `BasicCache.replace(Object, Object, long, TimeUnit, long, TimeUnit)`.
`NotifyingFuture<Boolean>`	`replaceAsync(K key, V oldValue, V newValue)` Asynchronous version of `ConcurrentMap.replace(Object, Object, Object)`.
`NotifyingFuture<Boolean>`	`replaceAsync(K key, V oldValue, V newValue, long lifespan, TimeUnit unit)` Asynchronous version of `BasicCache.replace(Object, Object, Object, long, TimeUnit)`.
`NotifyingFuture<Boolean>`	`replaceAsync(K key, V oldValue, V newValue, long lifespan, TimeUnit lifespanUnit, long maxIdle, TimeUnit maxIdleUnit)` Asynchronous version of `BasicCache.replace(Object, Object, Object, long, TimeUnit, long, TimeUnit)`.
`protected void`	`set(K key, V value)` Don't remove.
`int`	`size()` Returns a count of all elements in this cache and cache loader.
`void`	`start()`
`boolean`	`startBatch()` Starts a batch.
`void`	`stop()`
`String`	`toString()`
`Collection<V>`	`values()` Returns a collection view of the values contained in this cache.

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

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

- Constructor Detail
  - AbstractDelegatingCache
```
public AbstractDelegatingCache(Cache<K,V> cache)
```
- Method Detail
  - putForExternalRead
```
public void putForExternalRead(K key,
                      V value)
```
    Description copied from interface: Cache
    Under special operating behavior, associates the value with the specified key.
    - Only goes through if the key specified does not exist; no-op otherwise (similar to ConcurrentMap.putIfAbsent(Object, Object))
    - Force asynchronous mode for replication to prevent any blocking.
    - invalidation does not take place.
    - 0ms lock timeout to prevent any blocking here either. If the lock is not acquired, this method is a no-op, and swallows the timeout exception.
    - Ongoing transactions are suspended before this call, so failures here will not affect any ongoing transactions.
    - Errors and exceptions are 'silent' - logged at a much lower level than normal, and this method does not throw exceptions
    This method is for caching data that has an external representation in storage, where, concurrent modification and transactions are not a consideration, and failure to put the data in the cache should be treated as a 'suboptimal outcome' rather than a 'failing outcome'.
    An example of when this method is useful is when data is read from, for example, a legacy datastore, and is cached before returning the data to the caller. Subsequent calls would prefer to get the data from the cache and if the data doesn't exist in the cache, fetch again from the legacy datastore.
    See JBCACHE-848 for details around this feature.
    Specified by:
    
    putForExternalRead in interface Cache<K,V>
    
    Parameters:
    key - key with which the specified value is to be associated.
    value - value to be associated with the specified key.
  - evict
```
public void evict(K key)
```
    Description copied from interface: Cache
    
    Evicts an entry from the memory of the cache. Note that the entry is not removed from any configured cache stores or any other caches in the cluster (if used in a clustered mode). Use BasicCache.remove(Object) to remove an entry from the entire cache system.
    This method is designed to evict an entry from memory to free up memory used by the application. This method uses a 0 lock acquisition timeout so it does not block in attempting to acquire locks. It behaves as a no-op if the lock on the entry cannot be acquired immediately.
    Important: this method should not be called from within a transaction scope.
    
    Specified by:
    
    evict in interface Cache<K,V>
    
    Parameters:
    key - key to evict
  - getCacheConfiguration
```
public Configuration getCacheConfiguration()
```
    Specified by:
    
    getCacheConfiguration in interface Cache<K,V>
  - startBatch
```
public boolean startBatch()
```
    Description copied from interface: BatchingCache
    
    Starts a batch. All operations on the current client thread are performed as a part of this batch, with locks held for the duration of the batch and any remote calls delayed till the end of the batch.
    
    Specified by:
    
    startBatch in interface BatchingCache
    
    Returns:
    true if a batch was successfully started; false if one was available and already running.
  - endBatch
```
public void endBatch(boolean successful)
```
    Description copied from interface: BatchingCache
    
    Completes a batch if one has been started using BatchingCache.startBatch(). If no batch has been started, this is a no-op.
    
    Specified by:
    
    endBatch in interface BatchingCache
    
    Parameters:
    successful - if true, the batch completes, otherwise the batch is aborted and changes are not committed.
  - 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
  - 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
  - getCacheManager
```
public EmbeddedCacheManager getCacheManager()
```
    Description copied from interface: Cache
    
    Retrieves the cache manager responsible for creating this cache instance.
    
    Specified by:
    
    getCacheManager in interface Cache<K,V>
    
    Returns:
    a cache manager
  - 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.
  - set
```
protected void set(K key,
       V value)
```
    Don't remove.
    
    See Also:
    org.infinispan.CacheSupport#set(Object, Object)}
  - 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.
  - putAll
```
public void putAll(Map<? extends K,? extends V> map,
          long lifespan,
          TimeUnit unit)
```
    Description copied from interface: BasicCache
    
    An overloaded form of Map.putAll(Map), which takes in lifespan parameters. Note that the lifespan is applied to all mappings in the map passed in.
    
    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
  - 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 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
  - 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.
  - 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.
  - putAll
```
public void putAll(Map<? extends K,? extends V> map,
          long lifespan,
          TimeUnit lifespanUnit,
          long maxIdleTime,
          TimeUnit maxIdleTimeUnit)
```
    Description copied from interface: BasicCache
    
    An overloaded form of Map.putAll(Map), which takes in lifespan parameters. Note that the lifespan is applied to all mappings in the map passed in.
    
    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
  - 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 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
  - putAsync
```
public NotifyingFuture<V> putAsync(K key,
                          V value)
```
    Description copied from interface: BasicCache
    
    Asynchronous version of BasicCache.put(Object, Object). This method does not block on remote calls, even if your cache mode is synchronous. Has no benefit over BasicCache.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: BasicCache
    
    Asynchronous version of BasicCache.put(Object, Object, long, TimeUnit) . This method does not block on remote calls, even if your cache mode is synchronous. Has no benefit over BasicCache.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: BasicCache
    
    Asynchronous version of BasicCache.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 BasicCache.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
  - putAllAsync
```
public NotifyingFuture<Void> putAllAsync(Map<? extends K,? extends V> data)
```
    Description copied from interface: BasicCache
    
    Asynchronous version of Map.putAll(Map). This method does not block on remote calls, even if your cache mode is synchronous. Has no benefit over Map.putAll(Map) if used in LOCAL mode.
    
    Specified by:
    
    putAllAsync in interface AsyncCache<K,V>
    
    Parameters:
    data - to store
    
    Returns:
    a future containing a void return type
  - putAllAsync
```
public NotifyingFuture<Void> putAllAsync(Map<? extends K,? extends V> data,
                                long lifespan,
                                TimeUnit unit)
```
    Description copied from interface: BasicCache
    
    Asynchronous version of BasicCache.putAll(Map, long, TimeUnit). This method does not block on remote calls, even if your cache mode is synchronous. Has no benefit over BasicCache.putAll(Map, long, TimeUnit) if used in LOCAL mode.
    
    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
  - putAllAsync
```
public NotifyingFuture<Void> putAllAsync(Map<? extends K,? extends V> data,
                                long lifespan,
                                TimeUnit lifespanUnit,
                                long maxIdle,
                                TimeUnit maxIdleUnit)
```
    Description copied from interface: BasicCache
    
    Asynchronous version of BasicCache.putAll(Map, long, TimeUnit, long, TimeUnit). This method does not block on remote calls, even if your cache mode is synchronous. Has no benefit over BasicCache.putAll(Map, long, TimeUnit, long, TimeUnit) if used in LOCAL mode.
    
    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
  - clearAsync
```
public NotifyingFuture<Void> clearAsync()
```
    Description copied from interface: BasicCache
    
    Asynchronous version of Map.clear(). This method does not block on remote calls, even if your cache mode is synchronous. Has no benefit over Map.clear() if used in LOCAL mode.
    
    Specified by:
    
    clearAsync in interface AsyncCache<K,V>
    
    Returns:
    a future containing a void return type
  - putIfAbsentAsync
```
public NotifyingFuture<V> putIfAbsentAsync(K key,
                                  V value)
```
    Description copied from interface: BasicCache
    
    Asynchronous version of ConcurrentMap.putIfAbsent(Object, Object). This method does not block on remote calls, even if your cache mode is synchronous. Has no benefit over ConcurrentMap.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: BasicCache
    
    Asynchronous version of BasicCache.putIfAbsent(Object, Object, long, TimeUnit) . This method does not block on remote calls, even if your cache mode is synchronous. Has no benefit over BasicCache.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: BasicCache
    
    Asynchronous version of BasicCache.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 BasicCache.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
  - removeAsync
```
public NotifyingFuture<V> removeAsync(Object key)
```
    Description copied from interface: BasicCache
    
    Asynchronous version of BasicCache.remove(Object). This method does not block on remote calls, even if your cache mode is synchronous. Has no benefit over BasicCache.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<Boolean> removeAsync(Object key,
                                   Object value)
```
    Description copied from interface: BasicCache
    
    Asynchronous version of ConcurrentMap.remove(Object, Object). This method does not block on remote calls, even if your cache mode is synchronous. Has no benefit over ConcurrentMap.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
  - replaceAsync
```
public NotifyingFuture<V> replaceAsync(K key,
                              V value)
```
    Description copied from interface: BasicCache
    
    Asynchronous version of ConcurrentMap.replace(Object, Object). This method does not block on remote calls, even if your cache mode is synchronous. Has no benefit over ConcurrentMap.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: BasicCache
    
    Asynchronous version of BasicCache.replace(Object, Object, long, TimeUnit). This method does not block on remote calls, even if your cache mode is synchronous. Has no benefit over BasicCache.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: BasicCache
    
    Asynchronous version of BasicCache.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 BasicCache.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<Boolean> replaceAsync(K key,
                                    V oldValue,
                                    V newValue)
```
    Description copied from interface: BasicCache
    
    Asynchronous version of ConcurrentMap.replace(Object, Object, Object). This method does not block on remote calls, even if your cache mode is synchronous. Has no benefit over ConcurrentMap.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<Boolean> replaceAsync(K key,
                                    V oldValue,
                                    V newValue,
                                    long lifespan,
                                    TimeUnit unit)
```
    Description copied from interface: BasicCache
    
    Asynchronous version of BasicCache.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 BasicCache.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<Boolean> replaceAsync(K key,
                                    V oldValue,
                                    V newValue,
                                    long lifespan,
                                    TimeUnit lifespanUnit,
                                    long maxIdle,
                                    TimeUnit maxIdleUnit)
```
    Description copied from interface: BasicCache
    
    Asynchronous version of BasicCache.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 BasicCache.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
  - getAdvancedCache
```
public AdvancedCache<K,V> getAdvancedCache()
```
    Specified by:
    
    getAdvancedCache in interface Cache<K,V>
  - getStatus
```
public ComponentStatus getStatus()
```
    Specified by:
    
    getStatus in interface Cache<K,V>
  - putIfAbsent
```
public V putIfAbsent(K key,
            V value)
```
    Specified by:
    
    putIfAbsent in interface ConcurrentMap<K,V>
  - remove
```
public boolean remove(Object key,
             Object value)
```
    Specified by:
    
    remove in interface ConcurrentMap<K,V>
  - replace
```
public boolean replace(K key,
              V oldValue,
              V newValue)
```
    Specified by:
    
    replace in interface ConcurrentMap<K,V>
  - replace
```
public V replace(K key,
        V value)
```
    Specified by:
    
    replace in interface ConcurrentMap<K,V>
  - size
```
public int size()
```
    Description copied from interface: Cache
    
    Returns a count of all elements in this cache and cache loader. To avoid performance issues, there will be no attempt to count keys from other nodes.
    If there are memory concerns then the org.infinispan.context.Flag.SKIP_CACHE_LOAD flag should be used to avoid hitting the cache store as all local keys will be loaded into memory at once.
    This method should only be used for debugging purposes such as to verify that the cache contains all the keys entered. Any other use involving execution of this method on a production system is not recommended.
    
    Specified by:
    
    size in interface Map<K,V>
    
    Specified by:
    
    size in interface Cache<K,V>
    
    Returns:
    the number of key-value mappings in this cache and cache loader
  - isEmpty
```
public boolean isEmpty()
```
    Specified by:
    
    isEmpty in interface Map<K,V>
  - containsKey
```
public boolean containsKey(Object key)
```
    Specified by:
    
    containsKey in interface Map<K,V>
  - containsValue
```
public boolean containsValue(Object value)
```
    Specified by:
    
    containsValue in interface Map<K,V>
  - get
```
public V get(Object key)
```
    Specified by:
    
    get in interface Map<K,V>
  - 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 Map<K,V>
    
    Specified by:
    
    put in interface BasicCache<K,V>
  - 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 Map<K,V>
    
    Specified by:
    
    remove in interface BasicCache<K,V>
  - putAll
```
public void putAll(Map<? extends K,? extends V> t)
```
    Specified by:
    
    putAll in interface Map<K,V>
  - clear
```
public void clear()
```
    Specified by:
    
    clear in interface Map<K,V>
  - keySet
```
public Set<K> keySet()
```
    Description copied from interface: Cache
    
    Returns a set view of the keys contained in this cache and cache loader. This set is immutable, so it cannot be modified and changes to the cache won't be reflected in the set. When this method is called on a cache configured with distribution mode, the set returned only contains the keys locally available in the cache instance including the cache loader if provided. To avoid memory issues, there will be not attempt to bring keys from other nodes.
    If there are memory concerns then the org.infinispan.context.Flag.SKIP_CACHE_LOAD flag should be used to avoid hitting the cache store as all local keys will be in memory at once.
    This method should only be used for debugging purposes such as to verify that the cache contains all the keys entered. Any other use involving execution of this method on a production system is not recommended.
    
    Specified by:
    
    keySet in interface Map<K,V>
    
    Specified by:
    
    keySet in interface Cache<K,V>
    
    Returns:
    a set view of the keys contained in this cache and cache loader.
  - entrySet
```
public Set<Map.Entry<K,V>> entrySet()
```
    Description copied from interface: Cache
    
    Returns a set view of the mappings contained in this cache and cache loader. This set is immutable, so it cannot be modified and changes to the cache won't be reflected in the set. Besides, each element in the returned set is an immutable Map.Entry. When this method is called on a cache configured with distribution mode, the set returned only contains the mappings locally available in the cache instance. To avoid memory issues, there will be not attempt to bring mappings from other nodes.
    If there are memory concerns then the org.infinispan.context.Flag.SKIP_CACHE_LOAD flag should be used to avoid hitting the cache store as all local entries will be in memory at once.
    This method should only be used for debugging purposes such as to verify that the cache contains all the mappings entered. Any other use involving execution of this method on a production system is not recommended.
    
    Specified by:
    
    entrySet in interface Map<K,V>
    
    Specified by:
    
    entrySet in interface Cache<K,V>
    
    Returns:
    a set view of the mappings contained in this cache and cache loader
  - values
```
public Collection<V> values()
```
    Description copied from interface: Cache
    
    Returns a collection view of the values contained in this cache. This collection is immutable, so it cannot be modified and changes to the cache won't be reflected in the set. When this method is called on a cache configured with distribution mode, the collection returned only contains the values locally available in the cache instance including the cache loader if provided. To avoid memory issues, there is no attempt to bring values from other nodes.
    If there are memory concerns then the org.infinispan.context.Flag.SKIP_CACHE_LOAD flag should be used to avoid hitting the cache store as all local values will be in memory at once.
    This method should only be used for testing or debugging purposes such as to verify that the cache contains all the values entered. Any other use involving execution of this method on a production system is not recommended.
    
    Specified by:
    
    values in interface Map<K,V>
    
    Specified by:
    
    values in interface Cache<K,V>
    
    Returns:
    a collection view of the values contained in this cache and cache loader.
  - start
```
public void start()
```
    Specified by:
    
    start in interface Lifecycle
  - stop
```
public void stop()
```
    Specified by:
    
    stop in interface Lifecycle
  - addListener
```
public void addListener(Object listener)
```
    Description copied from interface: Listenable
    
    Adds a listener to the component. Typically, listeners would need to be annotated with Listener and further to that, contain methods annotated appropriately, otherwise the listener will not be registered.
    See the Listener annotation for more information.
    
    Specified by:
    
    addListener in interface Listenable
    
    Parameters:
    listener - must not be null.
  - addListener
```
public void addListener(Object listener,
               KeyFilter filter)
```
    Description copied from interface: FilteringListenable
    
    Adds a listener to the component. Typically, listeners would need to be annotated with Listener and further to that, contain methods annotated appropriately, otherwise the listener will not be registered.
    See the Listener annotation for more information.
    
    Specified by:
    
    addListener in interface FilteringListenable
    
    Parameters:
    listener - must not be null.
  - removeListener
```
public void removeListener(Object listener)
```
    Description copied from interface: Listenable
    
    Removes a listener from the component.
    
    Specified by:
    
    removeListener in interface Listenable
    
    Parameters:
    listener - listener to remove. Must not be null.
  - getListeners
```
public Set<Object> getListeners()
```
    Specified by:
    
    getListeners in interface Listenable
    
    Returns:
    a set of all listeners registered on this component.
  - getAsync
```
public NotifyingFuture<V> getAsync(K key)
```
    Description copied from interface: BasicCache
    
    Asynchronous version of Map.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 Map.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 Map.get(Object)
  - toString
```
public String toString()
```
    Overrides:
    
    toString in class Object
  - getDelegate
```
public Cache<K,V> getDelegate()
```

Class AbstractDelegatingCache<K,V>

Nested Class Summary

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

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Methods inherited from interface java.util.Map

Constructor Detail

AbstractDelegatingCache

Method Detail

putForExternalRead

evict

getCacheConfiguration

startBatch

endBatch

getName

getVersion

getCacheManager

put

set

putIfAbsent

putAll

replace

replace

put

putIfAbsent

putAll

replace

replace

putAsync

putAsync

putAsync

putAllAsync

putAllAsync

putAllAsync

clearAsync

putIfAbsentAsync

putIfAbsentAsync

putIfAbsentAsync

removeAsync

removeAsync

replaceAsync

replaceAsync

replaceAsync

replaceAsync

replaceAsync

replaceAsync

getAdvancedCache

getStatus

putIfAbsent

remove

replace

replace

size

isEmpty

containsKey

containsValue

get

put

remove

putAll

clear

keySet

entrySet

values

start

stop

addListener

addListener

removeListener

getListeners

getAsync

toString

getDelegate