org.infinispan
Class CacheDelegate<K,V>

java.lang.Object
  extended by org.infinispan.CacheDelegate<K,V>
All Implemented Interfaces:
ConcurrentMap<K,V>, Map<K,V>, AdvancedCache<K,V>, AtomicMapCache<K,V>, Cache<K,V>, Lifecycle, Listenable

public class CacheDelegate<K,V>
extends Object
implements AdvancedCache<K,V>, AtomicMapCache<K,V>

Since:
4.0
Author:
Mircea.Markus@jboss.com

Nested Class Summary
 
Nested classes/interfaces inherited from interface java.util.Map
Map.Entry<K,V>
 
Nested classes/interfaces inherited from interface java.util.Map
Map.Entry<K,V>
 
Field Summary
protected  BatchContainer batchContainer
           
protected  CommandsFactory commandsFactory
           
protected  ComponentRegistry componentRegistry
           
protected  Configuration config
           
protected  InvocationContextContainer icc
           
protected  InterceptorChain invoker
           
protected  Marshaller marshaller
           
protected  CacheNotifier notifier
           
protected  RpcManager rpcManager
           
protected  TransactionManager transactionManager
           
 
Constructor Summary
CacheDelegate(String name)
           
 
Method Summary
 void addInterceptor(CommandInterceptor i, int position)
          Adds a custom interceptor to the interceptor chain, at specified position, where the first interceptor in the chain is at position 0 and the last one at NUM_INTERCEPTORS - 1.
 void addInterceptorAfter(CommandInterceptor i, Class<? extends CommandInterceptor> afterInterceptor)
          Adds a custom interceptor to the interceptor chain, after an instance of the specified interceptor type.
 void addInterceptorBefore(CommandInterceptor i, Class<? extends CommandInterceptor> beforeInterceptor)
          Adds a custom interceptor to the interceptor chain, before an instance of the specified interceptor type.
 void addListener(Object listener)
          Adds a listener to the component.
 void clear()
           
 void clear(Flag... flags)
           
 NotifyingFuture<Void> clearAsync()
          Asynchronous version of Map.clear().
 NotifyingFuture<Void> clearAsync(Flag... flags)
           
 void compact()
          Method that releases object references of cached objects held in the cache by serializing them to byte buffers.
 boolean containsKey(Object key)
           
 boolean containsKey(Object key, Flag... flags)
           
 boolean containsValue(Object value)
           
 void endBatch(boolean successful)
          Completes a batch if one has been started using Cache.startBatch().
 Set<Map.Entry<K,V>> entrySet()
           
 void evict(K key)
          Evicts an entry from the memory of the cache.
 V get(Object key)
           
 V get(Object key, Flag... flags)
           
 AdvancedCache<K,V> getAdvancedCache()
           
<AMK,AMV> AtomicMap<AMK,AMV>
getAtomicMap(K key)
          Returns an atomic map.
 BatchContainer getBatchContainer()
           
 CacheManager getCacheManager()
          Retrieves the cache manager responsible for creating this cache instance.
 ComponentRegistry getComponentRegistry()
           
 Configuration getConfiguration()
           
 DataContainer getDataContainer()
           
 EvictionManager getEvictionManager()
           
 List<CommandInterceptor> getInterceptorChain()
          Retrieves the current Interceptor chain.
 InvocationContextContainer getInvocationContextContainer()
           
 Set<Object> getListeners()
           
 String getName()
          Retrieves the name of the cache
 RpcManager getRpcManager()
           
 ComponentStatus getStatus()
           
 String getVersion()
          Retrieves the version of Infinispan
 void injectDependencies(EvictionManager evictionManager, InvocationContextContainer icc, CommandsFactory commandsFactory, InterceptorChain interceptorChain, Configuration configuration, CacheNotifier notifier, ComponentRegistry componentRegistry, TransactionManager transactionManager, BatchContainer batchContainer, RpcManager rpcManager, DataContainer dataContainer, Marshaller marshaller, ResponseGenerator responseGenerator, CacheManager cacheManager, StateTransferManager stateTransferManager)
           
 boolean isEmpty()
           
 Set<K> keySet()
           
 void lock(Collection<? extends K> keys)
          Locks collections of keys eagerly across cache nodes in a cluster.
 void lock(K key)
          Locks a given key eagerly across cache nodes in a cluster.
 V put(K key, V value)
           
 V put(K key, V value, Flag... flags)
           
 V put(K key, V value, long lifespan, TimeUnit unit)
          An overloaded form of Map.put(Object, Object), which takes in lifespan parameters.
 V put(K key, V value, long lifespan, TimeUnit lifespanUnit, long maxIdleTime, TimeUnit idleTimeUnit)
          An overloaded form of Map.put(Object, Object), which takes in lifespan parameters.
 V put(K key, V value, long lifespan, TimeUnit lifespanUnit, long maxIdleTime, TimeUnit maxIdleTimeUnit, Flag... flags)
           
 void putAll(Map<? extends K,? extends V> map)
           
 void putAll(Map<? extends K,? extends V> map, Flag... flags)
           
 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 idleTimeUnit)
          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, Flag... flags)
           
 NotifyingFuture<Void> putAllAsync(Map<? extends K,? extends V> data)
          Asynchronous version of Map.putAll(Map).
 NotifyingFuture<Void> putAllAsync(Map<? extends K,? extends V> map, Flag... flags)
           
 NotifyingFuture<Void> putAllAsync(Map<? extends K,? extends V> data, long lifespan, TimeUnit unit)
          Asynchronous version of Cache.putAll(Map, long, TimeUnit).
 NotifyingFuture<Void> putAllAsync(Map<? extends K,? extends V> data, long lifespan, TimeUnit lifespanUnit, long maxIdle, TimeUnit maxIdleUnit)
          Asynchronous version of Cache.putAll(Map, long, TimeUnit, long, TimeUnit).
 NotifyingFuture<Void> putAllAsync(Map<? extends K,? extends V> map, long lifespan, TimeUnit lifespanUnit, long maxIdleTime, TimeUnit maxIdleTimeUnit, Flag... flags)
           
 NotifyingFuture<V> putAsync(K key, V value)
          Asynchronous version of Map.put(Object, Object).
 NotifyingFuture<V> putAsync(K key, V value, Flag... flags)
           
 NotifyingFuture<V> putAsync(K key, V value, long lifespan, TimeUnit unit)
          Asynchronous version of Cache.put(Object, Object, long, TimeUnit) .
 NotifyingFuture<V> putAsync(K key, V value, long lifespan, TimeUnit lifespanUnit, long maxIdle, TimeUnit maxIdleUnit)
          Asynchronous version of Cache.put(Object, Object, long, TimeUnit, long, TimeUnit).
 NotifyingFuture<V> putAsync(K key, V value, long lifespan, TimeUnit lifespanUnit, long maxIdleTime, TimeUnit maxIdleTimeUnit, Flag... flags)
           
 void putForExternalRead(K key, V value)
          Under special operating behavior, associates the value with the specified key.
 void putForExternalRead(K key, V value, Flag... flags)
           
 V putIfAbsent(K key, V value)
           
 V putIfAbsent(K key, V value, Flag... flags)
           
 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 idleTimeUnit)
          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, Flag... flags)
           
 NotifyingFuture<V> putIfAbsentAsync(K key, V value)
          Asynchronous version of ConcurrentMap.putIfAbsent(Object, Object).
 NotifyingFuture<V> putIfAbsentAsync(K key, V value, Flag... flags)
           
 NotifyingFuture<V> putIfAbsentAsync(K key, V value, long lifespan, TimeUnit unit)
          Asynchronous version of Cache.putIfAbsent(Object, Object, long, TimeUnit) .
 NotifyingFuture<V> putIfAbsentAsync(K key, V value, long lifespan, TimeUnit lifespanUnit, long maxIdle, TimeUnit maxIdleUnit)
          Asynchronous version of Cache.putIfAbsent(Object, Object, long, TimeUnit, long, TimeUnit).
 NotifyingFuture<V> putIfAbsentAsync(K key, V value, long lifespan, TimeUnit lifespanUnit, long maxIdleTime, TimeUnit maxIdleTimeUnit, Flag... flags)
           
 V remove(Object key)
           
 V remove(Object key, Flag... flags)
           
 boolean remove(Object key, Object value)
           
 boolean remove(Object key, Object oldValue, Flag... flags)
           
 NotifyingFuture<V> removeAsync(Object key)
          Asynchronous version of Map.remove(Object).
 NotifyingFuture<V> removeAsync(Object key, Flag... flags)
           
 NotifyingFuture<Boolean> removeAsync(Object key, Object value)
          Asynchronous version of ConcurrentMap.remove(Object, Object).
 void removeInterceptor(Class<? extends CommandInterceptor> interceptorType)
          Removes the interceptor of specified type.
 void removeInterceptor(int position)
          Removes the interceptor at a specified position, where the first interceptor in the chain is at position 0 and the last one at getInterceptorChain().size() - 1.
 void removeListener(Object listener)
          Removes a listener from the component.
 V replace(K key, V value)
           
 V replace(K k, V v, Flag... flags)
           
 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 idleTimeUnit)
          An overloaded form of ConcurrentMap.replace(Object, Object), which takes in lifespan parameters.
 V replace(K k, V v, long lifespan, TimeUnit lifespanUnit, long maxIdle, TimeUnit maxIdleUnit, Flag... flags)
           
 boolean replace(K key, V oldValue, V newValue)
           
 boolean replace(K k, V oV, V nV, Flag... flags)
           
 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 idleTimeUnit)
          An overloaded form of ConcurrentMap.replace(Object, Object, Object), which takes in lifespan parameters.
 boolean replace(K k, V oV, V nV, long lifespan, TimeUnit lifespanUnit, long maxIdle, TimeUnit maxIdleUnit, Flag... flags)
           
 NotifyingFuture<V> replaceAsync(K key, V value)
          Asynchronous version of ConcurrentMap.replace(Object, Object).
 NotifyingFuture<V> replaceAsync(K k, V v, Flag... flags)
           
 NotifyingFuture<V> replaceAsync(K key, V value, long lifespan, TimeUnit unit)
          Asynchronous version of Cache.replace(Object, Object, long, TimeUnit).
 NotifyingFuture<V> replaceAsync(K key, V value, long lifespan, TimeUnit lifespanUnit, long maxIdle, TimeUnit maxIdleUnit)
          Asynchronous version of Cache.replace(Object, Object, long, TimeUnit, long, TimeUnit).
 NotifyingFuture<V> replaceAsync(K k, V v, long lifespan, TimeUnit lifespanUnit, long maxIdle, TimeUnit maxIdleUnit, Flag... flags)
           
 NotifyingFuture<Boolean> replaceAsync(K key, V oldValue, V newValue)
          Asynchronous version of ConcurrentMap.replace(Object, Object, Object).
 NotifyingFuture<Boolean> replaceAsync(K k, V oV, V nV, Flag... flags)
           
 NotifyingFuture<Boolean> replaceAsync(K key, V oldValue, V newValue, long lifespan, TimeUnit unit)
          Asynchronous version of Cache.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 Cache.replace(Object, Object, Object, long, TimeUnit, long, TimeUnit).
 NotifyingFuture<Boolean> replaceAsync(K k, V oV, V nV, long lifespan, TimeUnit lifespanUnit, long maxIdle, TimeUnit maxIdleUnit, Flag... flags)
           
 int size()
           
 void start()
           
 boolean startBatch()
          Starts a batch.
 void stop()
           
 String toString()
           
 Collection<V> values()
           
 
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
 
Methods inherited from interface java.util.Map
equals, hashCode
 

Field Detail

icc

protected InvocationContextContainer icc

commandsFactory

protected CommandsFactory commandsFactory

invoker

protected InterceptorChain invoker

config

protected Configuration config

notifier

protected CacheNotifier notifier

batchContainer

protected BatchContainer batchContainer

componentRegistry

protected ComponentRegistry componentRegistry

transactionManager

protected TransactionManager transactionManager

rpcManager

protected RpcManager rpcManager

marshaller

protected Marshaller marshaller
Constructor Detail

CacheDelegate

public CacheDelegate(String name)
Method Detail

injectDependencies

public void injectDependencies(EvictionManager evictionManager,
                               InvocationContextContainer icc,
                               CommandsFactory commandsFactory,
                               InterceptorChain interceptorChain,
                               Configuration configuration,
                               CacheNotifier notifier,
                               ComponentRegistry componentRegistry,
                               TransactionManager transactionManager,
                               BatchContainer batchContainer,
                               RpcManager rpcManager,
                               DataContainer dataContainer,
                               Marshaller marshaller,
                               ResponseGenerator responseGenerator,
                               CacheManager cacheManager,
                               StateTransferManager stateTransferManager)

putIfAbsent

public final V putIfAbsent(K key,
                           V value)
Specified by:
putIfAbsent in interface ConcurrentMap<K,V>

remove

public final boolean remove(Object key,
                            Object value)
Specified by:
remove in interface ConcurrentMap<K,V>

replace

public final boolean replace(K key,
                             V oldValue,
                             V newValue)
Specified by:
replace in interface ConcurrentMap<K,V>

replace

public final V replace(K key,
                       V value)
Specified by:
replace in interface ConcurrentMap<K,V>

size

public final int size()
Specified by:
size in interface Map<K,V>

isEmpty

public final boolean isEmpty()
Specified by:
isEmpty in interface Map<K,V>

containsKey

public final boolean containsKey(Object key)
Specified by:
containsKey in interface Map<K,V>

containsValue

public final boolean containsValue(Object value)
Specified by:
containsValue in interface Map<K,V>

get

public final V get(Object key)
Specified by:
get in interface Map<K,V>

put

public final V put(K key,
                   V value)
Specified by:
put in interface Map<K,V>

remove

public final V remove(Object key)
Specified by:
remove in interface Map<K,V>

putAll

public final void putAll(Map<? extends K,? extends V> map)
Specified by:
putAll in interface Map<K,V>

clear

public final void clear()
Specified by:
clear in interface Map<K,V>

keySet

public Set<K> keySet()
Specified by:
keySet in interface Map<K,V>

values

public Collection<V> values()
Specified by:
values in interface Map<K,V>

entrySet

public Set<Map.Entry<K,V>> entrySet()
Specified by:
entrySet in interface Map<K,V>

putForExternalRead

public final void putForExternalRead(K key,
                                     V value)
Description copied from interface: Cache
Under special operating behavior, associates the value with the specified key. 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 final 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 Map.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 tx's scope.

Specified by:
evict in interface Cache<K,V>
Parameters:
key - key to evict

getConfiguration

public Configuration getConfiguration()
Specified by:
getConfiguration in interface Cache<K,V>

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.

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.

lock

public void lock(K key)
Description copied from interface: AdvancedCache
Locks a given key eagerly across cache nodes in a cluster.

A key can be locked eagerly in the context of a transaction only

Specified by:
lock in interface AdvancedCache<K,V>
Parameters:
key - the key to lock

lock

public void lock(Collection<? extends K> keys)
Description copied from interface: AdvancedCache
Locks collections of keys eagerly across cache nodes in a cluster.

Collections of keys can be locked eagerly in the context of a transaction only

Specified by:
lock in interface AdvancedCache<K,V>
Parameters:
keys - collection of keys to lock

start

public void start()
Specified by:
start in interface Lifecycle

stop

public void stop()
Specified by:
stop in interface Lifecycle

getInterceptorChain

public List<CommandInterceptor> getInterceptorChain()
Description copied from interface: AdvancedCache
Retrieves the current Interceptor chain.

Specified by:
getInterceptorChain in interface AdvancedCache<K,V>
Returns:
an immutable List of CommandInterceptors configured for this cache

addInterceptor

public void addInterceptor(CommandInterceptor i,
                           int position)
Description copied from interface: AdvancedCache
Adds a custom interceptor to the interceptor chain, at specified position, where the first interceptor in the chain is at position 0 and the last one at NUM_INTERCEPTORS - 1.

Specified by:
addInterceptor in interface AdvancedCache<K,V>
Parameters:
i - the interceptor to add
position - the position to add the interceptor

addInterceptorAfter

public void addInterceptorAfter(CommandInterceptor i,
                                Class<? extends CommandInterceptor> afterInterceptor)
Description copied from interface: AdvancedCache
Adds a custom interceptor to the interceptor chain, after an instance of the specified interceptor type. Throws a cache exception if it cannot find an interceptor of the specified type.

Specified by:
addInterceptorAfter in interface AdvancedCache<K,V>
Parameters:
i - interceptor to add
afterInterceptor - interceptor type after which to place custom interceptor

addInterceptorBefore

public void addInterceptorBefore(CommandInterceptor i,
                                 Class<? extends CommandInterceptor> beforeInterceptor)
Description copied from interface: AdvancedCache
Adds a custom interceptor to the interceptor chain, before an instance of the specified interceptor type. Throws a cache exception if it cannot find an interceptor of the specified type.

Specified by:
addInterceptorBefore in interface AdvancedCache<K,V>
Parameters:
i - interceptor to add
beforeInterceptor - interceptor type before which to place custom interceptor

removeInterceptor

public void removeInterceptor(int position)
Description copied from interface: AdvancedCache
Removes the interceptor at a specified position, where the first interceptor in the chain is at position 0 and the last one at getInterceptorChain().size() - 1.

Specified by:
removeInterceptor in interface AdvancedCache<K,V>
Parameters:
position - the position at which to remove an interceptor

removeInterceptor

public void removeInterceptor(Class<? extends CommandInterceptor> interceptorType)
Description copied from interface: AdvancedCache
Removes the interceptor of specified type.

Specified by:
removeInterceptor in interface AdvancedCache<K,V>
Parameters:
interceptorType - type of interceptor to remove

getEvictionManager

public EvictionManager getEvictionManager()
Specified by:
getEvictionManager in interface AdvancedCache<K,V>
Returns:
the eviction manager - if one is configured - for this cache instance

getComponentRegistry

public ComponentRegistry getComponentRegistry()
Specified by:
getComponentRegistry in interface AdvancedCache<K,V>
Returns:
the component registry for this cache instance

putForExternalRead

public final void putForExternalRead(K key,
                                     V value,
                                     Flag... flags)
Specified by:
putForExternalRead in interface AdvancedCache<K,V>

put

public final V put(K key,
                   V value,
                   Flag... flags)
Specified by:
put in interface AdvancedCache<K,V>

put

public final V put(K key,
                   V value,
                   long lifespan,
                   TimeUnit lifespanUnit,
                   long maxIdleTime,
                   TimeUnit maxIdleTimeUnit,
                   Flag... flags)
Specified by:
put in interface AdvancedCache<K,V>

putIfAbsent

public final V putIfAbsent(K key,
                           V value,
                           Flag... flags)
Specified by:
putIfAbsent in interface AdvancedCache<K,V>

putIfAbsent

public final V putIfAbsent(K key,
                           V value,
                           long lifespan,
                           TimeUnit lifespanUnit,
                           long maxIdleTime,
                           TimeUnit maxIdleTimeUnit,
                           Flag... flags)
Specified by:
putIfAbsent in interface AdvancedCache<K,V>

putAll

public final void putAll(Map<? extends K,? extends V> map,
                         Flag... flags)
Specified by:
putAll in interface AdvancedCache<K,V>

putAll

public final void putAll(Map<? extends K,? extends V> map,
                         long lifespan,
                         TimeUnit lifespanUnit,
                         long maxIdleTime,
                         TimeUnit maxIdleTimeUnit,
                         Flag... flags)
Specified by:
putAll in interface AdvancedCache<K,V>

remove

public final V remove(Object key,
                      Flag... flags)
Specified by:
remove in interface AdvancedCache<K,V>

remove

public final boolean remove(Object key,
                            Object oldValue,
                            Flag... flags)

clear

public final void clear(Flag... flags)
Specified by:
clear in interface AdvancedCache<K,V>

replace

public final V replace(K k,
                       V v,
                       Flag... flags)
Specified by:
replace in interface AdvancedCache<K,V>

replace

public final boolean replace(K k,
                             V oV,
                             V nV,
                             Flag... flags)
Specified by:
replace in interface AdvancedCache<K,V>

replace

public final V replace(K k,
                       V v,
                       long lifespan,
                       TimeUnit lifespanUnit,
                       long maxIdle,
                       TimeUnit maxIdleUnit,
                       Flag... flags)
Specified by:
replace in interface AdvancedCache<K,V>

replace

public final boolean replace(K k,
                             V oV,
                             V nV,
                             long lifespan,
                             TimeUnit lifespanUnit,
                             long maxIdle,
                             TimeUnit maxIdleUnit,
                             Flag... flags)
Specified by:
replace in interface AdvancedCache<K,V>

putAsync

public final NotifyingFuture<V> putAsync(K key,
                                         V value,
                                         Flag... flags)
Specified by:
putAsync in interface AdvancedCache<K,V>

putAsync

public final NotifyingFuture<V> putAsync(K key,
                                         V value,
                                         long lifespan,
                                         TimeUnit lifespanUnit,
                                         long maxIdleTime,
                                         TimeUnit maxIdleTimeUnit,
                                         Flag... flags)
Specified by:
putAsync in interface AdvancedCache<K,V>

putIfAbsentAsync

public final NotifyingFuture<V> putIfAbsentAsync(K key,
                                                 V value,
                                                 Flag... flags)
Specified by:
putIfAbsentAsync in interface AdvancedCache<K,V>

putIfAbsentAsync

public final NotifyingFuture<V> putIfAbsentAsync(K key,
                                                 V value,
                                                 long lifespan,
                                                 TimeUnit lifespanUnit,
                                                 long maxIdleTime,
                                                 TimeUnit maxIdleTimeUnit,
                                                 Flag... flags)
Specified by:
putIfAbsentAsync in interface AdvancedCache<K,V>

putAllAsync

public final NotifyingFuture<Void> putAllAsync(Map<? extends K,? extends V> map,
                                               Flag... flags)
Specified by:
putAllAsync in interface AdvancedCache<K,V>

putAllAsync

public final NotifyingFuture<Void> putAllAsync(Map<? extends K,? extends V> map,
                                               long lifespan,
                                               TimeUnit lifespanUnit,
                                               long maxIdleTime,
                                               TimeUnit maxIdleTimeUnit,
                                               Flag... flags)
Specified by:
putAllAsync in interface AdvancedCache<K,V>

removeAsync

public final NotifyingFuture<V> removeAsync(Object key,
                                            Flag... flags)
Specified by:
removeAsync in interface AdvancedCache<K,V>

clearAsync

public final NotifyingFuture<Void> clearAsync(Flag... flags)
Specified by:
clearAsync in interface AdvancedCache<K,V>

replaceAsync

public final NotifyingFuture<V> replaceAsync(K k,
                                             V v,
                                             Flag... flags)
Specified by:
replaceAsync in interface AdvancedCache<K,V>

replaceAsync

public final NotifyingFuture<Boolean> replaceAsync(K k,
                                                   V oV,
                                                   V nV,
                                                   Flag... flags)
Specified by:
replaceAsync in interface AdvancedCache<K,V>

replaceAsync

public final NotifyingFuture<V> replaceAsync(K k,
                                             V v,
                                             long lifespan,
                                             TimeUnit lifespanUnit,
                                             long maxIdle,
                                             TimeUnit maxIdleUnit,
                                             Flag... flags)
Specified by:
replaceAsync in interface AdvancedCache<K,V>

replaceAsync

public final NotifyingFuture<Boolean> replaceAsync(K k,
                                                   V oV,
                                                   V nV,
                                                   long lifespan,
                                                   TimeUnit lifespanUnit,
                                                   long maxIdle,
                                                   TimeUnit maxIdleUnit,
                                                   Flag... flags)
Specified by:
replaceAsync in interface AdvancedCache<K,V>

containsKey

public final boolean containsKey(Object key,
                                 Flag... flags)
Specified by:
containsKey in interface AdvancedCache<K,V>

get

public final V get(Object key,
                   Flag... flags)
Specified by:
get in interface AdvancedCache<K,V>

getStatus

public ComponentStatus getStatus()
Specified by:
getStatus in interface Cache<K,V>

startBatch

public boolean startBatch()
Description copied from interface: Cache
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 Cache<K,V>
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: Cache
Completes a batch if one has been started using Cache.startBatch(). If no batch has been started, this is a no-op.

Specified by:
endBatch in interface Cache<K,V>
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: Cache
Retrieves the name of the cache

Specified by:
getName in interface Cache<K,V>
Returns:
the name of the cache

getVersion

public String getVersion()
Description copied from interface: Cache
Retrieves the version of Infinispan

Specified by:
getVersion in interface Cache<K,V>
Returns:
a version string

toString

public String toString()
Overrides:
toString in class Object

getAtomicMap

public <AMK,AMV> AtomicMap<AMK,AMV> getAtomicMap(K key)
                                throws ClassCastException
Description copied from interface: AtomicMapCache
Returns an atomic map. The classes passed in are used to parameterize the Map returned.

Specified by:
getAtomicMap in interface AtomicMapCache<K,V>
Type Parameters:
AMK - map keys
AMV - map values
Parameters:
key - key under which to obtain and store this map in the cache
Returns:
a new or existing atomic map. Never null.
Throws:
ClassCastException - if there already is a value stored under the given key and the type of value cannot be used as an AtomicMap.

getBatchContainer

public BatchContainer getBatchContainer()
Specified by:
getBatchContainer in interface AdvancedCache<K,V>

getInvocationContextContainer

public InvocationContextContainer getInvocationContextContainer()
Specified by:
getInvocationContextContainer in interface AdvancedCache<K,V>

getDataContainer

public DataContainer getDataContainer()
Specified by:
getDataContainer in interface AdvancedCache<K,V>

getCacheManager

public CacheManager 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 final V put(K key,
                   V value,
                   long lifespan,
                   TimeUnit lifespanUnit,
                   long maxIdleTime,
                   TimeUnit idleTimeUnit)
Description copied from interface: Cache
An overloaded form of Map.put(Object, Object), which takes in lifespan parameters.

Specified by:
put in interface Cache<K,V>
Parameters:
key - key to use
value - value to store
lifespan - lifespan of the entry. Negative values are intepreted 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
idleTimeUnit - time unit for max idle time
Returns:
the value being replaced, or null if nothing is being replaced.

putIfAbsent

public final V putIfAbsent(K key,
                           V value,
                           long lifespan,
                           TimeUnit lifespanUnit,
                           long maxIdleTime,
                           TimeUnit idleTimeUnit)
Description copied from interface: Cache
An overloaded form of ConcurrentMap.putIfAbsent(Object, Object), which takes in lifespan parameters.

Specified by:
putIfAbsent in interface Cache<K,V>
Parameters:
key - key to use
value - value to store
lifespan - lifespan of the entry. Negative values are intepreted 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
idleTimeUnit - time unit for max idle time
Returns:
the value being replaced, or null if nothing is being replaced.

putAll

public final void putAll(Map<? extends K,? extends V> map,
                         long lifespan,
                         TimeUnit lifespanUnit,
                         long maxIdleTime,
                         TimeUnit idleTimeUnit)
Description copied from interface: Cache
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 Cache<K,V>
Parameters:
map - map containing mappings to enter
lifespan - lifespan of the entry. Negative values are intepreted 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
idleTimeUnit - time unit for max idle time

replace

public final V replace(K key,
                       V value,
                       long lifespan,
                       TimeUnit lifespanUnit,
                       long maxIdleTime,
                       TimeUnit idleTimeUnit)
Description copied from interface: Cache
An overloaded form of ConcurrentMap.replace(Object, Object), which takes in lifespan parameters.

Specified by:
replace in interface Cache<K,V>
Parameters:
key - key to use
value - value to store
lifespan - lifespan of the entry. Negative values are intepreted 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
idleTimeUnit - time unit for max idle time
Returns:
the value being replaced, or null if nothing is being replaced.

replace

public final boolean replace(K key,
                             V oldValue,
                             V value,
                             long lifespan,
                             TimeUnit lifespanUnit,
                             long maxIdleTime,
                             TimeUnit idleTimeUnit)
Description copied from interface: Cache
An overloaded form of ConcurrentMap.replace(Object, Object, Object), which takes in lifespan parameters.

Specified by:
replace in interface Cache<K,V>
Parameters:
key - key to use
oldValue - value to replace
value - value to store
lifespan - lifespan of the entry. Negative values are intepreted 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
idleTimeUnit - time unit for max idle time
Returns:
true if the value was replaced, false otherwise

putAsync

public final NotifyingFuture<V> putAsync(K key,
                                         V value)
Description copied from interface: Cache
Asynchronous version of Map.put(Object, Object). This method does not block on remote calls, even if your cache mode is synchronous. Has no benefit over Map.put(Object, Object) if used in LOCAL mode.

Specified by:
putAsync in interface Cache<K,V>
Parameters:
key - key to use
value - value to store
Returns:
a future containing the old value replaced.

putAsync

public final NotifyingFuture<V> putAsync(K key,
                                         V value,
                                         long lifespan,
                                         TimeUnit unit)
Description copied from interface: Cache
Asynchronous version of Cache.put(Object, Object, long, TimeUnit) . This method does not block on remote calls, even if your cache mode is synchronous. Has no benefit over Cache.put(Object, Object, long, TimeUnit) if used in LOCAL mode.

Specified by:
putAsync in interface Cache<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 final NotifyingFuture<V> putAsync(K key,
                                         V value,
                                         long lifespan,
                                         TimeUnit lifespanUnit,
                                         long maxIdle,
                                         TimeUnit maxIdleUnit)
Description copied from interface: Cache
Asynchronous version of Cache.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 Cache.put(Object, Object, long, TimeUnit, long, TimeUnit) if used in LOCAL mode.

Specified by:
putAsync in interface Cache<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 final NotifyingFuture<Void> putAllAsync(Map<? extends K,? extends V> data)
Description copied from interface: Cache
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 Cache<K,V>
Parameters:
data - to store
Returns:
a future containing a void return type

putAllAsync

public final NotifyingFuture<Void> putAllAsync(Map<? extends K,? extends V> data,
                                               long lifespan,
                                               TimeUnit unit)
Description copied from interface: Cache
Asynchronous version of Cache.putAll(Map, long, TimeUnit). This method does not block on remote calls, even if your cache mode is synchronous. Has no benefit over Cache.putAll(Map, long, TimeUnit) if used in LOCAL mode.

Specified by:
putAllAsync in interface Cache<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 final NotifyingFuture<Void> putAllAsync(Map<? extends K,? extends V> data,
                                               long lifespan,
                                               TimeUnit lifespanUnit,
                                               long maxIdle,
                                               TimeUnit maxIdleUnit)
Description copied from interface: Cache
Asynchronous version of Cache.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 Cache.putAll(Map, long, TimeUnit, long, TimeUnit) if used in LOCAL mode.

Specified by:
putAllAsync in interface Cache<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 final NotifyingFuture<Void> clearAsync()
Description copied from interface: Cache
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 Cache<K,V>
Returns:
a future containing a void return type

putIfAbsentAsync

public final NotifyingFuture<V> putIfAbsentAsync(K key,
                                                 V value)
Description copied from interface: Cache
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 Cache<K,V>
Parameters:
key - key to use
value - value to store
Returns:
a future containing the old value replaced.

putIfAbsentAsync

public final NotifyingFuture<V> putIfAbsentAsync(K key,
                                                 V value,
                                                 long lifespan,
                                                 TimeUnit unit)
Description copied from interface: Cache
Asynchronous version of Cache.putIfAbsent(Object, Object, long, TimeUnit) . This method does not block on remote calls, even if your cache mode is synchronous. Has no benefit over Cache.putIfAbsent(Object, Object, long, TimeUnit) if used in LOCAL mode.

Specified by:
putIfAbsentAsync in interface Cache<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 final NotifyingFuture<V> putIfAbsentAsync(K key,
                                                 V value,
                                                 long lifespan,
                                                 TimeUnit lifespanUnit,
                                                 long maxIdle,
                                                 TimeUnit maxIdleUnit)
Description copied from interface: Cache
Asynchronous version of Cache.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 Cache.putIfAbsent(Object, Object, long, TimeUnit, long, TimeUnit) if used in LOCAL mode.

Specified by:
putIfAbsentAsync in interface Cache<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 final NotifyingFuture<V> removeAsync(Object key)
Description copied from interface: Cache
Asynchronous version of Map.remove(Object). This method does not block on remote calls, even if your cache mode is synchronous. Has no benefit over Map.remove(Object) if used in LOCAL mode.

Specified by:
removeAsync in interface Cache<K,V>
Parameters:
key - key to remove
Returns:
a future containing the value removed

removeAsync

public final NotifyingFuture<Boolean> removeAsync(Object key,
                                                  Object value)
Description copied from interface: Cache
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 Cache<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 final NotifyingFuture<V> replaceAsync(K key,
                                             V value)
Description copied from interface: Cache
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 Cache<K,V>
Parameters:
key - key to remove
value - value to store
Returns:
a future containing the previous value overwritten

replaceAsync

public final NotifyingFuture<V> replaceAsync(K key,
                                             V value,
                                             long lifespan,
                                             TimeUnit unit)
Description copied from interface: Cache
Asynchronous version of Cache.replace(Object, Object, long, TimeUnit). This method does not block on remote calls, even if your cache mode is synchronous. Has no benefit over Cache.replace(Object, Object, long, TimeUnit) if used in LOCAL mode.

Specified by:
replaceAsync in interface Cache<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 final NotifyingFuture<V> replaceAsync(K key,
                                             V value,
                                             long lifespan,
                                             TimeUnit lifespanUnit,
                                             long maxIdle,
                                             TimeUnit maxIdleUnit)
Description copied from interface: Cache
Asynchronous version of Cache.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 Cache.replace(Object, Object, long, TimeUnit, long, TimeUnit) if used in LOCAL mode.

Specified by:
replaceAsync in interface Cache<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 final NotifyingFuture<Boolean> replaceAsync(K key,
                                                   V oldValue,
                                                   V newValue)
Description copied from interface: Cache
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 Cache<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 final NotifyingFuture<Boolean> replaceAsync(K key,
                                                   V oldValue,
                                                   V newValue,
                                                   long lifespan,
                                                   TimeUnit unit)
Description copied from interface: Cache
Asynchronous version of Cache.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 Cache.replace(Object, Object, Object, long, TimeUnit) if used in LOCAL mode.

Specified by:
replaceAsync in interface Cache<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 final NotifyingFuture<Boolean> replaceAsync(K key,
                                                   V oldValue,
                                                   V newValue,
                                                   long lifespan,
                                                   TimeUnit lifespanUnit,
                                                   long maxIdle,
                                                   TimeUnit maxIdleUnit)
Description copied from interface: Cache
Asynchronous version of Cache.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 Cache.replace(Object, Object, Object, long, TimeUnit, long, TimeUnit) if used in LOCAL mode.

Specified by:
replaceAsync in interface Cache<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

put

public final V put(K key,
                   V value,
                   long lifespan,
                   TimeUnit unit)
Description copied from interface: Cache
An overloaded form of Map.put(Object, Object), which takes in lifespan parameters.

Specified by:
put in interface Cache<K,V>
Parameters:
key - key to use
value - value to store
lifespan - lifespan of the entry. Negative values are intepreted as unlimited lifespan.
unit - unit of measurement for the lifespan
Returns:
the value being replaced, or null if nothing is being replaced.

putIfAbsent

public final V putIfAbsent(K key,
                           V value,
                           long lifespan,
                           TimeUnit unit)
Description copied from interface: Cache
An overloaded form of ConcurrentMap.putIfAbsent(Object, Object), which takes in lifespan parameters.

Specified by:
putIfAbsent in interface Cache<K,V>
Parameters:
key - key to use
value - value to store
lifespan - lifespan of the entry. Negative values are intepreted as unlimited lifespan.
unit - unit of measurement for the lifespan
Returns:
the value being replaced, or null if nothing is being replaced.

putAll

public final void putAll(Map<? extends K,? extends V> map,
                         long lifespan,
                         TimeUnit unit)
Description copied from interface: Cache
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 Cache<K,V>
Parameters:
map - map containing mappings to enter
lifespan - lifespan of the entry. Negative values are intepreted as unlimited lifespan.
unit - unit of measurement for the lifespan

replace

public final V replace(K key,
                       V value,
                       long lifespan,
                       TimeUnit unit)
Description copied from interface: Cache
An overloaded form of ConcurrentMap.replace(Object, Object), which takes in lifespan parameters.

Specified by:
replace in interface Cache<K,V>
Parameters:
key - key to use
value - value to store
lifespan - lifespan of the entry. Negative values are intepreted as unlimited lifespan.
unit - unit of measurement for the lifespan
Returns:
the value being replaced, or null if nothing is being replaced.

replace

public final boolean replace(K key,
                             V oldValue,
                             V value,
                             long lifespan,
                             TimeUnit unit)
Description copied from interface: Cache
An overloaded form of ConcurrentMap.replace(Object, Object, Object), which takes in lifespan parameters.

Specified by:
replace in interface Cache<K,V>
Parameters:
key - key to use
oldValue - value to replace
value - value to store
lifespan - lifespan of the entry. Negative values are intepreted as unlimited lifespan.
unit - unit of measurement for the lifespan
Returns:
true if the value was replaced, false otherwise

getAdvancedCache

public AdvancedCache<K,V> getAdvancedCache()
Specified by:
getAdvancedCache in interface Cache<K,V>

compact

public void compact()
Description copied from interface: Cache
Method that releases object references of cached objects held in the cache by serializing them to byte buffers. Cached objects are lazily deserialized when accessed again, based on the calling thread's context class loader.

This can be expensive, based on the effort required to serialize cached objects.

Specified by:
compact in interface Cache<K,V>

getRpcManager

public RpcManager getRpcManager()
Specified by:
getRpcManager in interface AdvancedCache<K,V>


Copyright © 2009 JBoss, a division of Red Hat. All Rights Reserved.