CacheImpl

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

All Implemented Interfaces:

AdvancedCache<K,V>, org.infinispan.api.BasicCache<K,V>, Cache<K,V>, org.infinispan.notifications.FilteringListenable, org.infinispan.notifications.Listenable
```
public class CacheImpl<K,V>
extends java.lang.Object
implements AdvancedCache<K,V>
```
Since:

4.0

Author:

Mircea.Markus@jboss.com, Galder Zamarreño, Sanne Grinovero, Trustin Lee

Field Summary

Fields
Modifier and Type	Field and Description
`private java.util.concurrent.ExecutorService`	`asyncExecutor`
`protected org.infinispan.batch.BatchContainer`	`batchContainer`
`private org.infinispan.manager.EmbeddedCacheManager`	`cacheManager`
`protected org.infinispan.commands.CommandsFactory`	`commandsFactory`
`protected org.infinispan.factories.ComponentRegistry`	`componentRegistry`
`protected Configuration`	`config`
`private org.infinispan.container.DataContainer`	`dataContainer`
`protected org.infinispan.metadata.Metadata`	`defaultMetadata`
`private org.infinispan.distribution.DistributionManager`	`distributionManager`
`private org.infinispan.eviction.EvictionManager`	`evictionManager`
`private GlobalConfiguration`	`globalCfg`
`protected org.infinispan.context.InvocationContextContainer`	`icc`
`protected org.infinispan.context.InvocationContextFactory`	`invocationContextFactory`
`protected org.infinispan.interceptors.InterceptorChain`	`invoker`
`private boolean`	`isClassLoaderInContext`
`private org.infinispan.util.concurrent.locks.LockManager`	`lockManager`
`private static org.infinispan.util.logging.Log`	`log`
`protected StreamingMarshaller`	`marshaller`
`private java.lang.String`	`name`
`protected org.infinispan.notifications.cachelistener.CacheNotifier`	`notifier`
`static java.lang.String`	`OBJECT_NAME`
`private org.infinispan.transaction.xa.recovery.RecoveryManager`	`recoveryManager`
`protected org.infinispan.remoting.rpc.RpcManager`	`rpcManager`
`private static boolean`	`trace`
`protected TransactionManager`	`transactionManager`
`private org.infinispan.transaction.TransactionCoordinator`	`txCoordinator`
`private org.infinispan.transaction.TransactionTable`	`txTable`

Constructor Summary

Constructors
Constructor and Description

CacheImpl(java.lang.String name)

Constructors
Constructor and Description
`CacheImpl(java.lang.String name)`

Method Summary

Methods
Modifier and Type	Method and Description
`void`	`addInterceptor(org.infinispan.interceptors.base.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.
`boolean`	`addInterceptorAfter(org.infinispan.interceptors.base.CommandInterceptor i, java.lang.Class<? extends org.infinispan.interceptors.base.CommandInterceptor> afterInterceptor)` Adds a custom interceptor to the interceptor chain, after an instance of the specified interceptor type.
`boolean`	`addInterceptorBefore(org.infinispan.interceptors.base.CommandInterceptor i, java.lang.Class<? extends org.infinispan.interceptors.base.CommandInterceptor> beforeInterceptor)` Adds a custom interceptor to the interceptor chain, before an instance of the specified interceptor type.
`void`	`addListener(java.lang.Object listener)` Adds a listener to the component.
`void`	`addListener(java.lang.Object listener, org.infinispan.notifications.KeyFilter filter)` Adds a listener to the component.
`void`	`applyDelta(K deltaAwareValueKey, org.infinispan.atomic.Delta delta, java.lang.Object... locksToAcquire)` Applies the given Delta to the DeltaAware object stored under deltaAwareValueKey if and only if all locksToAcquire locks are successfully obtained
`private void`	`assertKeyNotNull(java.lang.Object key)`
`private void`	`assertKeysNotNull(java.util.Map<?,?> data)`
`private void`	`assertKeyValueNotNull(java.lang.Object key, java.lang.Object value)`
`private void`	`assertValueNotNull(java.lang.Object value)`
`private void`	`associateImplicitTransactionWithCurrentThread(org.infinispan.context.InvocationContext ctx)`
`private boolean`	`asyncSkipsThread(java.util.EnumSet<org.infinispan.context.Flag> flags, K key)` Encodes the cases for an asyncGet operation in which it makes sense to actually perform the operation in sync.
`void`	`clear()`
`(package private) void`	`clear(java.util.EnumSet<org.infinispan.context.Flag> explicitFlags, java.lang.ClassLoader explicitClassLoader)`
`org.infinispan.util.concurrent.NotifyingFuture<java.lang.Void>`	`clearAsync()` Asynchronous version of `#clear()`.
`(package private) org.infinispan.util.concurrent.NotifyingFuture<java.lang.Void>`	`clearAsync(java.util.EnumSet<org.infinispan.context.Flag> explicitFlags, java.lang.ClassLoader explicitClassLoader)`
`private void`	`clearInternal(java.util.EnumSet<org.infinispan.context.Flag> explicitFlags, org.infinispan.context.InvocationContext ctx)`
`void`	`clearOperation()`
`boolean`	`containsKey(java.lang.Object key)`
`(package private) boolean`	`containsKey(java.lang.Object key, java.util.EnumSet<org.infinispan.context.Flag> explicitFlags, java.lang.ClassLoader explicitClassLoader)`
`boolean`	`containsValue(java.lang.Object value)`
`private org.infinispan.context.InvocationContext`	`createSingleKeyNonTxInvocationContext(java.lang.ClassLoader explicitClassLoader)`
`void`	`endBatch(boolean successful)`
`java.util.Set<java.util.Map.Entry<K,V>>`	`entrySet()` Returns a set view of the mappings contained in this cache and cache loader.
`(package private) java.util.Set<java.util.Map.Entry<K,V>>`	`entrySet(java.util.EnumSet<org.infinispan.context.Flag> explicitFlags, java.lang.ClassLoader explicitClassLoader)`
`void`	`evict(K key)` Evicts an entry from the memory of the cache.
`(package private) void`	`evict(K key, java.util.EnumSet<org.infinispan.context.Flag> explicitFlags, java.lang.ClassLoader explicitClassLoader)`
`private java.lang.Object`	`executeCommandAndCommitIfNeeded(org.infinispan.context.InvocationContext ctx, org.infinispan.commands.VisitableCommand command)`
`V`	`get(java.lang.Object key)`
`(package private) V`	`get(java.lang.Object key, java.util.EnumSet<org.infinispan.context.Flag> explicitFlags, java.lang.ClassLoader explicitClassLoader)`
`AdvancedCache<K,V>`	`getAdvancedCache()`
`org.infinispan.util.concurrent.NotifyingFuture<V>`	`getAsync(K key)` Asynchronous version of `#get(Object)` that allows user code to retrieve the value associated with a key at a later stage, hence allowing multiple parallel get requests to be sent.
`(package private) org.infinispan.util.concurrent.NotifyingFuture<V>`	`getAsync(K key, java.util.EnumSet<org.infinispan.context.Flag> explicitFlags, java.lang.ClassLoader explicitClassLoader)`
`org.infinispan.batch.BatchContainer`	`getBatchContainer()` Returns the component in charge of batching cache operations.
`Configuration`	`getCacheConfiguration()`
`org.infinispan.container.entries.CacheEntry`	`getCacheEntry(K key)` Retrieves a CacheEntry corresponding to a specific key.
`org.infinispan.container.entries.CacheEntry`	`getCacheEntry(java.lang.Object key, java.util.EnumSet<org.infinispan.context.Flag> explicitFlags, java.lang.ClassLoader explicitClassLoader)`
`org.infinispan.manager.EmbeddedCacheManager`	`getCacheManager()` Retrieves the cache manager responsible for creating this cache instance.
`java.lang.String`	`getCacheName()` Returns the cache name.
`java.lang.String`	`getCacheStatus()` Returns String representation of ComponentStatus enumeration in order to avoid class not found exceptions in JMX tools that don't have access to infinispan classes.
`java.lang.ClassLoader`	`getClassLoader()` Returns the cache loader associated associated with this cache.
`org.infinispan.factories.ComponentRegistry`	`getComponentRegistry()`
`java.util.Properties`	`getConfigurationAsProperties()`
`org.infinispan.container.DataContainer`	`getDataContainer()` Returns the container where data is stored in the cache.
`org.infinispan.distribution.DistributionManager`	`getDistributionManager()` Retrieves a reference to the `DistributionManager` if the cache is configured to use Distribution.
`org.infinispan.eviction.EvictionManager`	`getEvictionManager()`
`java.util.List<org.infinispan.interceptors.base.CommandInterceptor>`	`getInterceptorChain()` Retrieves the current Interceptor chain.
`private org.infinispan.context.InvocationContext`	`getInvocationContext(Transaction tx, java.lang.ClassLoader explicitClassLoader)`
`org.infinispan.context.InvocationContextContainer`	`getInvocationContextContainer()` Returns the component in charge of managing the interactions between the cache operations and the context information associated with them.
`private org.infinispan.context.InvocationContext`	`getInvocationContextForRead(Transaction tx, java.lang.ClassLoader explicitClassLoader, int keyCount)`
`private org.infinispan.context.InvocationContext`	`getInvocationContextForWrite(java.lang.ClassLoader explicitClassLoader, int keyCount, boolean isPutForExternalRead)`
`private org.infinispan.context.InvocationContext`	`getInvocationContextWithImplicitTransaction(boolean isPutForExternalRead, java.lang.ClassLoader explicitClassLoader, int keyCount)` If this is a transactional cache and autoCommit is set to true then starts a transaction if this is not a transactional call.
`private org.infinispan.context.InvocationContext`	`getInvocationContextWithImplicitTransactionForAsyncOps(boolean isPutForExternalRead, java.lang.ClassLoader explicitClassLoader, int keyCount)`
`java.util.Set<java.lang.Object>`	`getListeners()`
`org.infinispan.util.concurrent.locks.LockManager`	`getLockManager()` Returns the component that deals with all aspects of acquiring and releasing locks for cache entries.
`java.lang.String`	`getName()`
`private Transaction`	`getOngoingTransaction()`
`org.infinispan.remoting.rpc.RpcManager`	`getRpcManager()` Returns the component in charge of communication with other caches in the cluster.
`org.infinispan.stats.Stats`	`getStats()` Returns a `Stats` object that allows several statistics associated with this cache at runtime.
`org.infinispan.lifecycle.ComponentStatus`	`getStatus()`
`TransactionManager`	`getTransactionManager()` Returns the transaction manager configured for this cache.
`java.lang.String`	`getVersion()` Returns the cache configuration as XML string.
`javax.transaction.xa.XAResource`	`getXAResource()` Returns the `XAResource` associated with this cache which can be used to do transactional recovery.
`void`	injectDependencies(org.infinispan.eviction.EvictionManager evictionManager, org.infinispan.context.InvocationContextFactory invocationContextFactory, org.infinispan.context.InvocationContextContainer icc, org.infinispan.commands.CommandsFactory commandsFactory, org.infinispan.interceptors.InterceptorChain interceptorChain, Configuration configuration, org.infinispan.notifications.cachelistener.CacheNotifier notifier, org.infinispan.factories.ComponentRegistry componentRegistry, TransactionManager transactionManager, org.infinispan.batch.BatchContainer batchContainer, org.infinispan.remoting.rpc.RpcManager rpcManager, org.infinispan.container.DataContainer dataContainer, StreamingMarshaller marshaller, org.infinispan.distribution.DistributionManager distributionManager, org.infinispan.manager.EmbeddedCacheManager cacheManager, java.util.concurrent.ExecutorService asyncExecutor, org.infinispan.transaction.TransactionTable txTable, org.infinispan.transaction.xa.recovery.RecoveryManager recoveryManager, org.infinispan.transaction.TransactionCoordinator txCoordinator, org.infinispan.util.concurrent.locks.LockManager lockManager, GlobalConfiguration globalCfg)
`boolean`	`isEmpty()`
`(package private) boolean`	`isEmpty(java.util.EnumSet<org.infinispan.context.Flag> explicitFlags, java.lang.ClassLoader explicitClassLoader)`
`private boolean`	`isPutForExternalRead(java.util.EnumSet<org.infinispan.context.Flag> explicitFlags)`
`private boolean`	`isSkipLoader(java.util.EnumSet<org.infinispan.context.Flag> flags)`
`private boolean`	`isTxInjected(org.infinispan.context.InvocationContext ctx)`
`java.util.Set<K>`	`keySet()` Returns a set view of the keys contained in this cache and cache loader.
`(package private) java.util.Set<K>`	`keySet(java.util.EnumSet<org.infinispan.context.Flag> explicitFlags, java.lang.ClassLoader explicitClassLoader)`
`boolean`	`lock(java.util.Collection<? extends K> keys)` Locks collections of keys eagerly across cache nodes in a cluster.
`(package private) boolean`	`lock(java.util.Collection<? extends K> keys, java.util.EnumSet<org.infinispan.context.Flag> explicitFlags, java.lang.ClassLoader explicitClassLoader)`
`boolean`	`lock(K... keys)` Locks a given key or keys eagerly across cache nodes in a cluster.
`V`	`put(K key, V value)`
`V`	`put(K key, V value, long lifespan, java.util.concurrent.TimeUnit unit)`
`V`	`put(K key, V value, long lifespan, java.util.concurrent.TimeUnit lifespanUnit, long maxIdleTime, java.util.concurrent.TimeUnit idleTimeUnit)`
`V`	`put(K key, V value, org.infinispan.metadata.Metadata metadata)` An overloaded form of `#put(K, V)`, which takes in an instance of `Metadata` which can be used to provide metadata information for the entry being stored, such as lifespan, version of value...etc.
`(package private) V`	`put(K key, V value, org.infinispan.metadata.Metadata metadata, java.util.EnumSet<org.infinispan.context.Flag> explicitFlags, java.lang.ClassLoader explicitClassLoader)`
`void`	`putAll(java.util.Map<? extends K,? extends V> m)`
`void`	`putAll(java.util.Map<? extends K,? extends V> map, long lifespan, java.util.concurrent.TimeUnit unit)`
`void`	`putAll(java.util.Map<? extends K,? extends V> map, long lifespan, java.util.concurrent.TimeUnit lifespanUnit, long maxIdleTime, java.util.concurrent.TimeUnit idleTimeUnit)`
`(package private) void`	`putAll(java.util.Map<? extends K,? extends V> map, org.infinispan.metadata.Metadata metadata, java.util.EnumSet<org.infinispan.context.Flag> explicitFlags, java.lang.ClassLoader explicitClassLoader)`
`org.infinispan.util.concurrent.NotifyingFuture<java.lang.Void>`	`putAllAsync(java.util.Map<? extends K,? extends V> data)` Asynchronous version of `#putAll(Map)`.
`org.infinispan.util.concurrent.NotifyingFuture<java.lang.Void>`	`putAllAsync(java.util.Map<? extends K,? extends V> data, long lifespan, java.util.concurrent.TimeUnit unit)` Asynchronous version of `#putAll(Map, long, TimeUnit)`.
`org.infinispan.util.concurrent.NotifyingFuture<java.lang.Void>`	`putAllAsync(java.util.Map<? extends K,? extends V> data, long lifespan, java.util.concurrent.TimeUnit lifespanUnit, long maxIdle, java.util.concurrent.TimeUnit maxIdleUnit)` Asynchronous version of `#putAll(Map, long, TimeUnit, long, TimeUnit)`.
`(package private) org.infinispan.util.concurrent.NotifyingFuture<java.lang.Void>`	`putAllAsync(java.util.Map<? extends K,? extends V> data, org.infinispan.metadata.Metadata metadata, java.util.EnumSet<org.infinispan.context.Flag> explicitFlags, java.lang.ClassLoader explicitClassLoader)`
`private void`	`putAllInternal(java.util.Map<? extends K,? extends V> map, org.infinispan.metadata.Metadata metadata, java.util.EnumSet<org.infinispan.context.Flag> explicitFlags, org.infinispan.context.InvocationContext ctx)`
`org.infinispan.util.concurrent.NotifyingFuture<V>`	`putAsync(K key, V value)` Asynchronous version of `#put(Object, Object)`.
`org.infinispan.util.concurrent.NotifyingFuture<V>`	`putAsync(K key, V value, long lifespan, java.util.concurrent.TimeUnit unit)` Asynchronous version of `#put(Object, Object, long, TimeUnit)` .
`org.infinispan.util.concurrent.NotifyingFuture<V>`	`putAsync(K key, V value, long lifespan, java.util.concurrent.TimeUnit lifespanUnit, long maxIdle, java.util.concurrent.TimeUnit maxIdleUnit)` Asynchronous version of `#put(Object, Object, long, TimeUnit, long, TimeUnit)`.
`org.infinispan.util.concurrent.NotifyingFuture<V>`	`putAsync(K key, V value, org.infinispan.metadata.Metadata metadata)` Asynchronous version of `AdvancedCache.put(Object, Object, Metadata)` which stores metadata alongside the value.
`(package private) org.infinispan.util.concurrent.NotifyingFuture<V>`	`putAsync(K key, V value, org.infinispan.metadata.Metadata metadata, java.util.EnumSet<org.infinispan.context.Flag> explicitFlags, java.lang.ClassLoader explicitClassLoader)`
`void`	`putForExternalRead(K key, V value)` Under special operating behavior, associates the value with the specified key.
`(package private) void`	`putForExternalRead(K key, V value, java.util.EnumSet<org.infinispan.context.Flag> explicitFlags, java.lang.ClassLoader explicitClassLoader)`
`V`	`putIfAbsent(K key, V value)`
`V`	`putIfAbsent(K key, V value, long lifespan, java.util.concurrent.TimeUnit unit)`
`V`	`putIfAbsent(K key, V value, long lifespan, java.util.concurrent.TimeUnit lifespanUnit, long maxIdleTime, java.util.concurrent.TimeUnit idleTimeUnit)`
`V`	`putIfAbsent(K key, V value, org.infinispan.metadata.Metadata metadata)` An overloaded form of `#putIfAbsent(K, V)`, which takes in an instance of `Metadata` which can be used to provide metadata information for the entry being stored, such as lifespan, version of value...etc.
`(package private) V`	`putIfAbsent(K key, V value, org.infinispan.metadata.Metadata metadata, java.util.EnumSet<org.infinispan.context.Flag> explicitFlags, java.lang.ClassLoader explicitClassLoader)`
`org.infinispan.util.concurrent.NotifyingFuture<V>`	`putIfAbsentAsync(K key, V value)` Asynchronous version of `#putIfAbsent(Object, Object)`.
`org.infinispan.util.concurrent.NotifyingFuture<V>`	`putIfAbsentAsync(K key, V value, long lifespan, java.util.concurrent.TimeUnit unit)` Asynchronous version of `#putIfAbsent(Object, Object, long, TimeUnit)` .
`org.infinispan.util.concurrent.NotifyingFuture<V>`	`putIfAbsentAsync(K key, V value, long lifespan, java.util.concurrent.TimeUnit lifespanUnit, long maxIdle, java.util.concurrent.TimeUnit maxIdleUnit)` Asynchronous version of `#putIfAbsent(Object, Object, long, TimeUnit, long, TimeUnit)`.
`(package private) org.infinispan.util.concurrent.NotifyingFuture<V>`	`putIfAbsentAsync(K key, V value, org.infinispan.metadata.Metadata metadata, java.util.EnumSet<org.infinispan.context.Flag> explicitFlags, java.lang.ClassLoader explicitClassLoader)`
`private V`	`putIfAbsentInternal(K key, V value, org.infinispan.metadata.Metadata metadata, java.util.EnumSet<org.infinispan.context.Flag> explicitFlags, org.infinispan.context.InvocationContext ctx)`
`private V`	`putInternal(K key, V value, org.infinispan.metadata.Metadata metadata, java.util.EnumSet<org.infinispan.context.Flag> explicitFlags, org.infinispan.context.InvocationContext ctx)`
`V`	`remove(java.lang.Object key)`
`(package private) V`	`remove(java.lang.Object key, java.util.EnumSet<org.infinispan.context.Flag> explicitFlags, java.lang.ClassLoader explicitClassLoader)`
`boolean`	`remove(java.lang.Object key, java.lang.Object value)`
`(package private) boolean`	`remove(java.lang.Object key, java.lang.Object value, java.util.EnumSet<org.infinispan.context.Flag> explicitFlags, java.lang.ClassLoader explicitClassLoader)`
`org.infinispan.util.concurrent.NotifyingFuture<V>`	`removeAsync(java.lang.Object key)` Asynchronous version of `#remove(Object)`.
`(package private) org.infinispan.util.concurrent.NotifyingFuture<V>`	`removeAsync(java.lang.Object key, java.util.EnumSet<org.infinispan.context.Flag> explicitFlags, java.lang.ClassLoader explicitClassLoader)`
`org.infinispan.util.concurrent.NotifyingFuture<java.lang.Boolean>`	`removeAsync(java.lang.Object key, java.lang.Object value)` Asynchronous version of `#remove(Object, Object)`.
`(package private) org.infinispan.util.concurrent.NotifyingFuture<java.lang.Boolean>`	`removeAsync(java.lang.Object key, java.lang.Object value, java.util.EnumSet<org.infinispan.context.Flag> explicitFlags, java.lang.ClassLoader explicitClassLoader)`
`void`	`removeInterceptor(java.lang.Class<? extends org.infinispan.interceptors.base.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.
`private V`	`removeInternal(java.lang.Object key, java.util.EnumSet<org.infinispan.context.Flag> explicitFlags, org.infinispan.context.InvocationContext ctx)`
`private boolean`	`removeInternal(java.lang.Object key, java.lang.Object value, java.util.EnumSet<org.infinispan.context.Flag> explicitFlags, org.infinispan.context.InvocationContext ctx)`
`void`	`removeListener(java.lang.Object listener)` Removes a listener from the component.
`V`	`replace(K key, V value)`
`V`	`replace(K key, V value, long lifespan, java.util.concurrent.TimeUnit unit)`
`V`	`replace(K key, V value, long lifespan, java.util.concurrent.TimeUnit lifespanUnit, long maxIdleTime, java.util.concurrent.TimeUnit idleTimeUnit)`
`V`	`replace(K key, V value, org.infinispan.metadata.Metadata metadata)` An overloaded form of `#replace(K, V)`, which takes in an instance of `Metadata` which can be used to provide metadata information for the entry being stored, such as lifespan, version of value...etc.
`(package private) V`	`replace(K key, V value, org.infinispan.metadata.Metadata metadata, java.util.EnumSet<org.infinispan.context.Flag> explicitFlags, java.lang.ClassLoader explicitClassLoader)`
`boolean`	`replace(K key, V oldValue, V newValue)`
`boolean`	`replace(K key, V oldValue, V value, long lifespan, java.util.concurrent.TimeUnit unit)`
`boolean`	`replace(K key, V oldValue, V value, long lifespan, java.util.concurrent.TimeUnit lifespanUnit, long maxIdleTime, java.util.concurrent.TimeUnit idleTimeUnit)`
`boolean`	`replace(K key, V oldValue, V value, org.infinispan.metadata.Metadata metadata)` An overloaded form of `#replace(K, V, V)`, which takes in an instance of `Metadata` which can be used to provide metadata information for the entry being stored, such as lifespan, version of value...etc.
`(package private) boolean`	`replace(K key, V oldValue, V value, org.infinispan.metadata.Metadata metadata, java.util.EnumSet<org.infinispan.context.Flag> explicitFlags, java.lang.ClassLoader explicitClassLoader)`
`org.infinispan.util.concurrent.NotifyingFuture<V>`	`replaceAsync(K key, V value)` Asynchronous version of `#replace(Object, Object)`.
`org.infinispan.util.concurrent.NotifyingFuture<V>`	`replaceAsync(K key, V value, long lifespan, java.util.concurrent.TimeUnit unit)` Asynchronous version of `#replace(Object, Object, long, TimeUnit)`.
`org.infinispan.util.concurrent.NotifyingFuture<V>`	`replaceAsync(K key, V value, long lifespan, java.util.concurrent.TimeUnit lifespanUnit, long maxIdle, java.util.concurrent.TimeUnit maxIdleUnit)` Asynchronous version of `#replace(Object, Object, long, TimeUnit, long, TimeUnit)`.
`(package private) org.infinispan.util.concurrent.NotifyingFuture<V>`	`replaceAsync(K key, V value, org.infinispan.metadata.Metadata metadata, java.util.EnumSet<org.infinispan.context.Flag> explicitFlags, java.lang.ClassLoader explicitClassLoader)`
`org.infinispan.util.concurrent.NotifyingFuture<java.lang.Boolean>`	`replaceAsync(K key, V oldValue, V newValue)` Asynchronous version of `#replace(Object, Object, Object)`.
`org.infinispan.util.concurrent.NotifyingFuture<java.lang.Boolean>`	`replaceAsync(K key, V oldValue, V newValue, long lifespan, java.util.concurrent.TimeUnit unit)` Asynchronous version of `#replace(Object, Object, Object, long, TimeUnit)`.
`org.infinispan.util.concurrent.NotifyingFuture<java.lang.Boolean>`	`replaceAsync(K key, V oldValue, V newValue, long lifespan, java.util.concurrent.TimeUnit lifespanUnit, long maxIdle, java.util.concurrent.TimeUnit maxIdleUnit)` Asynchronous version of `#replace(Object, Object, Object, long, TimeUnit, long, TimeUnit)`.
`(package private) org.infinispan.util.concurrent.NotifyingFuture<java.lang.Boolean>`	`replaceAsync(K key, V oldValue, V newValue, org.infinispan.metadata.Metadata metadata, java.util.EnumSet<org.infinispan.context.Flag> explicitFlags, java.lang.ClassLoader explicitClassLoader)`
`private V`	`replaceInternal(K key, V value, org.infinispan.metadata.Metadata metadata, java.util.EnumSet<org.infinispan.context.Flag> explicitFlags, org.infinispan.context.InvocationContext ctx)`
`private boolean`	`replaceInternal(K key, V oldValue, V value, org.infinispan.metadata.Metadata metadata, java.util.EnumSet<org.infinispan.context.Flag> explicitFlags, org.infinispan.context.InvocationContext ctx)`
`private org.infinispan.context.InvocationContext`	`setInvocationContextClassLoader(org.infinispan.context.InvocationContext ctx, java.lang.ClassLoader explicitClassLoader)`
`int`	`size()` Returns a count of all elements in this cache and cache loader.
`(package private) int`	`size(java.util.EnumSet<org.infinispan.context.Flag> explicitFlags, java.lang.ClassLoader explicitClassLoader)`
`void`	`start()`
`boolean`	`startBatch()`
`void`	`stop()`
`(package private) void`	`stop(java.lang.ClassLoader explicitClassLoader)`
`java.lang.String`	`toString()`
`private void`	`tryRollback()`
`java.util.Collection<V>`	`values()` Returns a collection view of the values contained in this cache.
`(package private) java.util.Collection<V>`	`values(java.util.EnumSet<org.infinispan.context.Flag> explicitFlags, java.lang.ClassLoader explicitClassLoader)`
`AdvancedCache<K,V>`	`with(java.lang.ClassLoader classLoader)` Using this operation, users can call any `AdvancedCache` operation with a given `ClassLoader`.
`AdvancedCache<K,V>`	`withFlags(org.infinispan.context.Flag... flags)` A method that adds flags to any API call.
`private <X> org.infinispan.util.concurrent.NotifyingFuture<X>`	`wrapInFuture(java.lang.Object retval)` Wraps a return value as a future, if needed.

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

- Field Detail
  - OBJECT_NAME
```
public static final java.lang.String OBJECT_NAME
```
    See Also:
    Constant Field Values
  - icc
```
protected org.infinispan.context.InvocationContextContainer icc
```
  - invocationContextFactory
```
protected org.infinispan.context.InvocationContextFactory invocationContextFactory
```
  - commandsFactory
```
protected org.infinispan.commands.CommandsFactory commandsFactory
```
  - invoker
```
protected org.infinispan.interceptors.InterceptorChain invoker
```
  - config
```
protected Configuration config
```
  - notifier
```
protected org.infinispan.notifications.cachelistener.CacheNotifier notifier
```
  - batchContainer
```
protected org.infinispan.batch.BatchContainer batchContainer
```
  - componentRegistry
```
protected org.infinispan.factories.ComponentRegistry componentRegistry
```
  - transactionManager
```
protected TransactionManager transactionManager
```
  - rpcManager
```
protected org.infinispan.remoting.rpc.RpcManager rpcManager
```
  - marshaller
```
protected StreamingMarshaller marshaller
```
  - defaultMetadata
```
protected org.infinispan.metadata.Metadata defaultMetadata
```
  - name
```
private final java.lang.String name
```
  - evictionManager
```
private org.infinispan.eviction.EvictionManager evictionManager
```
  - dataContainer
```
private org.infinispan.container.DataContainer dataContainer
```
  - log
```
private static final org.infinispan.util.logging.Log log
```
  - trace
```
private static final boolean trace
```
  - cacheManager
```
private org.infinispan.manager.EmbeddedCacheManager cacheManager
```
  - lockManager
```
private org.infinispan.util.concurrent.locks.LockManager lockManager
```
  - distributionManager
```
private org.infinispan.distribution.DistributionManager distributionManager
```
  - asyncExecutor
```
private java.util.concurrent.ExecutorService asyncExecutor
```
  - txTable
```
private org.infinispan.transaction.TransactionTable txTable
```
  - recoveryManager
```
private org.infinispan.transaction.xa.recovery.RecoveryManager recoveryManager
```
  - txCoordinator
```
private org.infinispan.transaction.TransactionCoordinator txCoordinator
```
  - globalCfg
```
private GlobalConfiguration globalCfg
```
  - isClassLoaderInContext
```
private boolean isClassLoaderInContext
```
- Constructor Detail
  - CacheImpl
```
public CacheImpl(java.lang.String name)
```
- Method Detail
  - injectDependencies
```
public void injectDependencies(org.infinispan.eviction.EvictionManager evictionManager,
                      org.infinispan.context.InvocationContextFactory invocationContextFactory,
                      org.infinispan.context.InvocationContextContainer icc,
                      org.infinispan.commands.CommandsFactory commandsFactory,
                      org.infinispan.interceptors.InterceptorChain interceptorChain,
                      Configuration configuration,
                      org.infinispan.notifications.cachelistener.CacheNotifier notifier,
                      org.infinispan.factories.ComponentRegistry componentRegistry,
                      TransactionManager transactionManager,
                      org.infinispan.batch.BatchContainer batchContainer,
                      org.infinispan.remoting.rpc.RpcManager rpcManager,
                      org.infinispan.container.DataContainer dataContainer,
                      StreamingMarshaller marshaller,
                      org.infinispan.distribution.DistributionManager distributionManager,
                      org.infinispan.manager.EmbeddedCacheManager cacheManager,
                      java.util.concurrent.ExecutorService asyncExecutor,
                      org.infinispan.transaction.TransactionTable txTable,
                      org.infinispan.transaction.xa.recovery.RecoveryManager recoveryManager,
                      org.infinispan.transaction.TransactionCoordinator txCoordinator,
                      org.infinispan.util.concurrent.locks.LockManager lockManager,
                      GlobalConfiguration globalCfg)
```
  - assertKeyNotNull
```
private void assertKeyNotNull(java.lang.Object key)
```
  - assertKeyValueNotNull
```
private void assertKeyValueNotNull(java.lang.Object key,
                         java.lang.Object value)
```
  - assertValueNotNull
```
private void assertValueNotNull(java.lang.Object value)
```
  - assertKeysNotNull
```
private void assertKeysNotNull(java.util.Map<?,?> data)
```
  - put
```
public final V put(K key,
    V value)
```
  - put
```
public final V put(K key,
    V value,
    long lifespan,
    java.util.concurrent.TimeUnit unit)
```
  - putIfAbsent
```
public final V putIfAbsent(K key,
            V value,
            long lifespan,
            java.util.concurrent.TimeUnit unit)
```
  - putAll
```
public final void putAll(java.util.Map<? extends K,? extends V> map,
          long lifespan,
          java.util.concurrent.TimeUnit unit)
```
  - replace
```
public final V replace(K key,
        V value,
        long lifespan,
        java.util.concurrent.TimeUnit unit)
```
  - replace
```
public final boolean replace(K key,
              V oldValue,
              V value,
              long lifespan,
              java.util.concurrent.TimeUnit unit)
```
  - putIfAbsent
```
public final V putIfAbsent(K key,
            V value)
```
  - replace
```
public final boolean replace(K key,
              V oldValue,
              V newValue)
```
  - replace
```
public final V replace(K key,
        V value)
```
  - putAsync
```
public final org.infinispan.util.concurrent.NotifyingFuture<V> putAsync(K key,
                                                         V value)
```
    Description copied from interface: org.infinispan.api.BasicCache
    
    Asynchronous version of #put(Object, Object). This method does not block on remote calls, even if your cache mode is synchronous. Has no benefit over #put(Object, Object) if used in LOCAL mode.
    
    Specified by:
    
    putAsync in interface org.infinispan.api.BasicCache<K,V>
    
    Parameters:
    key - key to use
    value - value to store
    
    Returns:
    a future containing the old value replaced.
  - putAsync
```
public final org.infinispan.util.concurrent.NotifyingFuture<V> putAsync(K key,
                                                         V value,
                                                         long lifespan,
                                                         java.util.concurrent.TimeUnit unit)
```
    Description copied from interface: org.infinispan.api.BasicCache
    
    Asynchronous version of #put(Object, Object, long, TimeUnit) . This method does not block on remote calls, even if your cache mode is synchronous. Has no benefit over #put(Object, Object, long, TimeUnit) if used in LOCAL mode.
    
    Specified by:
    
    putAsync in interface org.infinispan.api.BasicCache<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
  - putAllAsync
```
public final org.infinispan.util.concurrent.NotifyingFuture<java.lang.Void> putAllAsync(java.util.Map<? extends K,? extends V> data)
```
    Description copied from interface: org.infinispan.api.BasicCache
    
    Asynchronous version of #putAll(Map). This method does not block on remote calls, even if your cache mode is synchronous. Has no benefit over #putAll(Map) if used in LOCAL mode.
    
    Specified by:
    
    putAllAsync in interface org.infinispan.api.BasicCache<K,V>
    
    Parameters:
    data - to store
    
    Returns:
    a future containing a void return type
  - putAllAsync
```
public final org.infinispan.util.concurrent.NotifyingFuture<java.lang.Void> putAllAsync(java.util.Map<? extends K,? extends V> data,
                                                                         long lifespan,
                                                                         java.util.concurrent.TimeUnit unit)
```
    Description copied from interface: org.infinispan.api.BasicCache
    
    Asynchronous version of #putAll(Map, long, TimeUnit). This method does not block on remote calls, even if your cache mode is synchronous. Has no benefit over #putAll(Map, long, TimeUnit) if used in LOCAL mode.
    
    Specified by:
    
    putAllAsync in interface org.infinispan.api.BasicCache<K,V>
    
    Parameters:
    data - to store
    lifespan - lifespan of entry
    unit - time unit for lifespan
    
    Returns:
    a future containing a void return type
  - putIfAbsentAsync
```
public final org.infinispan.util.concurrent.NotifyingFuture<V> putIfAbsentAsync(K key,
                                                                 V value)
```
    Description copied from interface: org.infinispan.api.BasicCache
    
    Asynchronous version of #putIfAbsent(Object, Object). This method does not block on remote calls, even if your cache mode is synchronous. Has no benefit over #putIfAbsent(Object, Object) if used in LOCAL mode.
    
    Specified by:
    
    putIfAbsentAsync in interface org.infinispan.api.BasicCache<K,V>
    
    Parameters:
    key - key to use
    value - value to store
    
    Returns:
    a future containing the old value replaced.
  - putIfAbsentAsync
```
public final org.infinispan.util.concurrent.NotifyingFuture<V> putIfAbsentAsync(K key,
                                                                 V value,
                                                                 long lifespan,
                                                                 java.util.concurrent.TimeUnit unit)
```
    Description copied from interface: org.infinispan.api.BasicCache
    
    Asynchronous version of #putIfAbsent(Object, Object, long, TimeUnit) . This method does not block on remote calls, even if your cache mode is synchronous. Has no benefit over #putIfAbsent(Object, Object, long, TimeUnit) if used in LOCAL mode.
    
    Specified by:
    
    putIfAbsentAsync in interface org.infinispan.api.BasicCache<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
  - replaceAsync
```
public final org.infinispan.util.concurrent.NotifyingFuture<V> replaceAsync(K key,
                                                             V value)
```
    Description copied from interface: org.infinispan.api.BasicCache
    
    Asynchronous version of #replace(Object, Object). This method does not block on remote calls, even if your cache mode is synchronous. Has no benefit over #replace(Object, Object) if used in LOCAL mode.
    
    Specified by:
    
    replaceAsync in interface org.infinispan.api.BasicCache<K,V>
    
    Parameters:
    key - key to remove
    value - value to store
    
    Returns:
    a future containing the previous value overwritten
  - replaceAsync
```
public final org.infinispan.util.concurrent.NotifyingFuture<V> replaceAsync(K key,
                                                             V value,
                                                             long lifespan,
                                                             java.util.concurrent.TimeUnit unit)
```
    Description copied from interface: org.infinispan.api.BasicCache
    
    Asynchronous version of #replace(Object, Object, long, TimeUnit). This method does not block on remote calls, even if your cache mode is synchronous. Has no benefit over #replace(Object, Object, long, TimeUnit) if used in LOCAL mode.
    
    Specified by:
    
    replaceAsync in interface org.infinispan.api.BasicCache<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 org.infinispan.util.concurrent.NotifyingFuture<java.lang.Boolean> replaceAsync(K key,
                                                                             V oldValue,
                                                                             V newValue)
```
    Description copied from interface: org.infinispan.api.BasicCache
    
    Asynchronous version of #replace(Object, Object, Object). This method does not block on remote calls, even if your cache mode is synchronous. Has no benefit over #replace(Object, Object, Object) if used in LOCAL mode.
    
    Specified by:
    
    replaceAsync in interface org.infinispan.api.BasicCache<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 org.infinispan.util.concurrent.NotifyingFuture<java.lang.Boolean> replaceAsync(K key,
                                                                             V oldValue,
                                                                             V newValue,
                                                                             long lifespan,
                                                                             java.util.concurrent.TimeUnit unit)
```
    Description copied from interface: org.infinispan.api.BasicCache
    
    Asynchronous version of #replace(Object, Object, Object, long, TimeUnit). This method does not block on remote calls, even if your cache mode is synchronous. Has no benefit over #replace(Object, Object, Object, long, TimeUnit) if used in LOCAL mode.
    
    Specified by:
    
    replaceAsync in interface org.infinispan.api.BasicCache<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
  - putAll
```
public final void putAll(java.util.Map<? extends K,? extends V> m)
```
  - remove
```
public final boolean remove(java.lang.Object key,
             java.lang.Object value)
```
  - remove
```
final boolean remove(java.lang.Object key,
             java.lang.Object value,
             java.util.EnumSet<org.infinispan.context.Flag> explicitFlags,
             java.lang.ClassLoader explicitClassLoader)
```
  - removeInternal
```
private boolean removeInternal(java.lang.Object key,
                     java.lang.Object value,
                     java.util.EnumSet<org.infinispan.context.Flag> explicitFlags,
                     org.infinispan.context.InvocationContext ctx)
```
  - size
```
public final 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 Cache<K,V>
    
    Returns:
    the number of key-value mappings in this cache and cache loader
  - size
```
final int size(java.util.EnumSet<org.infinispan.context.Flag> explicitFlags,
       java.lang.ClassLoader explicitClassLoader)
```
  - isEmpty
```
public final boolean isEmpty()
```
  - isEmpty
```
final boolean isEmpty(java.util.EnumSet<org.infinispan.context.Flag> explicitFlags,
              java.lang.ClassLoader explicitClassLoader)
```
  - containsKey
```
public final boolean containsKey(java.lang.Object key)
```
  - containsKey
```
final boolean containsKey(java.lang.Object key,
                  java.util.EnumSet<org.infinispan.context.Flag> explicitFlags,
                  java.lang.ClassLoader explicitClassLoader)
```
  - containsValue
```
public final boolean containsValue(java.lang.Object value)
```
  - get
```
public final V get(java.lang.Object key)
```
  - get
```
final V get(java.lang.Object key,
    java.util.EnumSet<org.infinispan.context.Flag> explicitFlags,
    java.lang.ClassLoader explicitClassLoader)
```
  - getCacheEntry
```
public final org.infinispan.container.entries.CacheEntry getCacheEntry(java.lang.Object key,
                                                        java.util.EnumSet<org.infinispan.context.Flag> explicitFlags,
                                                        java.lang.ClassLoader explicitClassLoader)
```
  - getCacheEntry
```
public final org.infinispan.container.entries.CacheEntry getCacheEntry(K key)
```
    Description copied from interface: AdvancedCache
    
    Retrieves a CacheEntry corresponding to a specific key.
    
    Specified by:
    
    getCacheEntry in interface AdvancedCache<K,V>
    
    Parameters:
    key - the key whose associated cache entry is to be returned
    
    Returns:
    the cache entry to which the specified key is mapped, or null if this map contains no mapping for the key
  - remove
```
public final V remove(java.lang.Object key)
```
  - remove
```
final V remove(java.lang.Object key,
       java.util.EnumSet<org.infinispan.context.Flag> explicitFlags,
       java.lang.ClassLoader explicitClassLoader)
```
  - removeInternal
```
private V removeInternal(java.lang.Object key,
               java.util.EnumSet<org.infinispan.context.Flag> explicitFlags,
               org.infinispan.context.InvocationContext ctx)
```
  - clearOperation
```
public final void clearOperation()
```
  - clear
```
public final void clear()
```
  - clear
```
final void clear(java.util.EnumSet<org.infinispan.context.Flag> explicitFlags,
         java.lang.ClassLoader explicitClassLoader)
```
  - clearInternal
```
private void clearInternal(java.util.EnumSet<org.infinispan.context.Flag> explicitFlags,
                 org.infinispan.context.InvocationContext ctx)
```
  - keySet
```
public java.util.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 Cache<K,V>
    
    Returns:
    a set view of the keys contained in this cache and cache loader.
  - keySet
```
java.util.Set<K> keySet(java.util.EnumSet<org.infinispan.context.Flag> explicitFlags,
                      java.lang.ClassLoader explicitClassLoader)
```
  - values
```
public java.util.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 Cache<K,V>
    
    Returns:
    a collection view of the values contained in this cache and cache loader.
  - values
```
java.util.Collection<V> values(java.util.EnumSet<org.infinispan.context.Flag> explicitFlags,
                             java.lang.ClassLoader explicitClassLoader)
```
  - entrySet
```
public java.util.Set<java.util.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 Cache<K,V>
    
    Returns:
    a set view of the mappings contained in this cache and cache loader
  - entrySet
```
java.util.Set<java.util.Map.Entry<K,V>> entrySet(java.util.EnumSet<org.infinispan.context.Flag> explicitFlags,
                                               java.lang.ClassLoader explicitClassLoader)
```
  - 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.
    - 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.
  - putForExternalRead
```
final void putForExternalRead(K key,
                      V value,
                      java.util.EnumSet<org.infinispan.context.Flag> explicitFlags,
                      java.lang.ClassLoader explicitClassLoader)
```
  - 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 #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
  - evict
```
final void evict(K key,
         java.util.EnumSet<org.infinispan.context.Flag> explicitFlags,
         java.lang.ClassLoader explicitClassLoader)
```
  - createSingleKeyNonTxInvocationContext
```
private org.infinispan.context.InvocationContext createSingleKeyNonTxInvocationContext(java.lang.ClassLoader explicitClassLoader)
```
  - getCacheConfiguration
```
public Configuration getCacheConfiguration()
```
    Specified by:
    
    getCacheConfiguration in interface Cache<K,V>
  - addListener
```
public void addListener(java.lang.Object listener)
```
    Description copied from interface: org.infinispan.notifications.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 org.infinispan.notifications.Listenable
    
    Parameters:
    listener - must not be null.
  - addListener
```
public void addListener(java.lang.Object listener,
               org.infinispan.notifications.KeyFilter filter)
```
    Description copied from interface: org.infinispan.notifications.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 org.infinispan.notifications.FilteringListenable
    
    Parameters:
    listener - must not be null.
  - removeListener
```
public void removeListener(java.lang.Object listener)
```
    Description copied from interface: org.infinispan.notifications.Listenable
    
    Removes a listener from the component.
    
    Specified by:
    
    removeListener in interface org.infinispan.notifications.Listenable
    
    Parameters:
    listener - listener to remove. Must not be null.
  - getListeners
```
public java.util.Set<java.lang.Object> getListeners()
```
    Specified by:
    
    getListeners in interface org.infinispan.notifications.Listenable
    
    Returns:
    a set of all listeners registered on this component.
  - getInvocationContextForWrite
```
private org.infinispan.context.InvocationContext getInvocationContextForWrite(java.lang.ClassLoader explicitClassLoader,
                                                                    int keyCount,
                                                                    boolean isPutForExternalRead)
```
  - getInvocationContextForRead
```
private org.infinispan.context.InvocationContext getInvocationContextForRead(Transaction tx,
                                                                   java.lang.ClassLoader explicitClassLoader,
                                                                   int keyCount)
```
  - getInvocationContextWithImplicitTransactionForAsyncOps
```
private org.infinispan.context.InvocationContext getInvocationContextWithImplicitTransactionForAsyncOps(boolean isPutForExternalRead,
                                                                                              java.lang.ClassLoader explicitClassLoader,
                                                                                              int keyCount)
```
  - getInvocationContextWithImplicitTransaction
```
private org.infinispan.context.InvocationContext getInvocationContextWithImplicitTransaction(boolean isPutForExternalRead,
                                                                                   java.lang.ClassLoader explicitClassLoader,
                                                                                   int keyCount)
```
    If this is a transactional cache and autoCommit is set to true then starts a transaction if this is not a transactional call.
  - isPutForExternalRead
```
private boolean isPutForExternalRead(java.util.EnumSet<org.infinispan.context.Flag> explicitFlags)
```
  - getInvocationContext
```
private org.infinispan.context.InvocationContext getInvocationContext(Transaction tx,
                                                            java.lang.ClassLoader explicitClassLoader)
```
  - setInvocationContextClassLoader
```
private org.infinispan.context.InvocationContext setInvocationContextClassLoader(org.infinispan.context.InvocationContext ctx,
                                                                       java.lang.ClassLoader explicitClassLoader)
```
  - lock
```
public boolean lock(K... keys)
```
    Description copied from interface: AdvancedCache
    
    Locks a given key or keys eagerly across cache nodes in a cluster.
    Keys can be locked eagerly in the context of a transaction only.
    
    Specified by:
    
    lock in interface AdvancedCache<K,V>
    
    Parameters:
    keys - the keys to lock
    
    Returns:
    true if the lock acquisition attempt was successful for all keys; false will only be returned if the lock acquisition timed out and the operation has been called with Flag.FAIL_SILENTLY.
  - lock
```
public boolean lock(java.util.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
    
    Returns:
    true if the lock acquisition attempt was successful for all keys; false will only be returned if the lock acquisition timed out and the operation has been called with Flag.FAIL_SILENTLY.
  - lock
```
boolean lock(java.util.Collection<? extends K> keys,
           java.util.EnumSet<org.infinispan.context.Flag> explicitFlags,
           java.lang.ClassLoader explicitClassLoader)
```
  - applyDelta
```
public void applyDelta(K deltaAwareValueKey,
              org.infinispan.atomic.Delta delta,
              java.lang.Object... locksToAcquire)
```
    Description copied from interface: AdvancedCache
    
    Applies the given Delta to the DeltaAware object stored under deltaAwareValueKey if and only if all locksToAcquire locks are successfully obtained
    
    Specified by:
    
    applyDelta in interface AdvancedCache<K,V>
    
    Parameters:
    deltaAwareValueKey - the key for DeltaAware object
    delta - the delta to be applied to DeltaAware object
    locksToAcquire - keys to be locked in DeltaAware scope
  - start
```
public void start()
```
  - stop
```
public void stop()
```
  - stop
```
void stop(java.lang.ClassLoader explicitClassLoader)
```
  - getInterceptorChain
```
public java.util.List<org.infinispan.interceptors.base.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(org.infinispan.interceptors.base.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 boolean addInterceptorAfter(org.infinispan.interceptors.base.CommandInterceptor i,
                          java.lang.Class<? extends org.infinispan.interceptors.base.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
    
    Returns:
    true if successful, false otherwise.
  - addInterceptorBefore
```
public boolean addInterceptorBefore(org.infinispan.interceptors.base.CommandInterceptor i,
                           java.lang.Class<? extends org.infinispan.interceptors.base.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
    
    Returns:
    true if successful, false otherwise.
  - 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(java.lang.Class<? extends org.infinispan.interceptors.base.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 org.infinispan.eviction.EvictionManager getEvictionManager()
```
    Specified by:
    
    getEvictionManager in interface AdvancedCache<K,V>
    
    Returns:
    the eviction manager - if one is configured - for this cache instance
  - getComponentRegistry
```
public org.infinispan.factories.ComponentRegistry getComponentRegistry()
```
    Specified by:
    
    getComponentRegistry in interface AdvancedCache<K,V>
    
    Returns:
    the component registry for this cache instance
  - getDistributionManager
```
public org.infinispan.distribution.DistributionManager getDistributionManager()
```
    Description copied from interface: AdvancedCache
    
    Retrieves a reference to the DistributionManager if the cache is configured to use Distribution. Otherwise, returns a null.
    
    Specified by:
    
    getDistributionManager in interface AdvancedCache<K,V>
    
    Returns:
    a DistributionManager, or null.
  - getStatus
```
public org.infinispan.lifecycle.ComponentStatus getStatus()
```
    Specified by:
    
    getStatus in interface Cache<K,V>
  - getCacheStatus
```
public java.lang.String getCacheStatus()
```
    Returns String representation of ComponentStatus enumeration in order to avoid class not found exceptions in JMX tools that don't have access to infinispan classes.
  - startBatch
```
public boolean startBatch()
```
  - endBatch
```
public void endBatch(boolean successful)
```
  - getName
```
public java.lang.String getName()
```
  - getCacheName
```
public java.lang.String getCacheName()
```
    Returns the cache name. If this is the default cache, it returns a more friendly name.
  - getVersion
```
public java.lang.String getVersion()
```
    Returns the cache configuration as XML string.
  - toString
```
public java.lang.String toString()
```
    Overrides:
    
    toString in class java.lang.Object
  - getBatchContainer
```
public org.infinispan.batch.BatchContainer getBatchContainer()
```
    Description copied from interface: AdvancedCache
    
    Returns the component in charge of batching cache operations.
    
    Specified by:
    
    getBatchContainer in interface AdvancedCache<K,V>
    
    Returns:
    the batching component associated with this cache instance
  - getInvocationContextContainer
```
public org.infinispan.context.InvocationContextContainer getInvocationContextContainer()
```
    Description copied from interface: AdvancedCache
    
    Returns the component in charge of managing the interactions between the cache operations and the context information associated with them.
    
    Specified by:
    
    getInvocationContextContainer in interface AdvancedCache<K,V>
    
    Returns:
    the invocation context container component
  - getDataContainer
```
public org.infinispan.container.DataContainer getDataContainer()
```
    Description copied from interface: AdvancedCache
    
    Returns the container where data is stored in the cache. Users should interact with this component with care because direct calls on it bypass the internal interceptors and other infrastructure in place to guarantee the consistency of data.
    
    Specified by:
    
    getDataContainer in interface AdvancedCache<K,V>
    
    Returns:
    the data container associated with this cache instance
  - getTransactionManager
```
public TransactionManager getTransactionManager()
```
    Description copied from interface: AdvancedCache
    
    Returns the transaction manager configured for this cache. If no transaction manager was configured, this method returns null.
    
    Specified by:
    
    getTransactionManager in interface AdvancedCache<K,V>
    
    Returns:
    the transaction manager associated with this cache instance or null
  - getLockManager
```
public org.infinispan.util.concurrent.locks.LockManager getLockManager()
```
    Description copied from interface: AdvancedCache
    
    Returns the component that deals with all aspects of acquiring and releasing locks for cache entries.
    
    Specified by:
    
    getLockManager in interface AdvancedCache<K,V>
    
    Returns:
    retrieves the lock manager associated with this cache instance
  - getCacheManager
```
public org.infinispan.manager.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
  - getStats
```
public org.infinispan.stats.Stats getStats()
```
    Description copied from interface: AdvancedCache
    
    Returns a Stats object that allows several statistics associated with this cache at runtime.
    
    Specified by:
    
    getStats in interface AdvancedCache<K,V>
    
    Returns:
    this cache's Stats object
  - getXAResource
```
public javax.transaction.xa.XAResource getXAResource()
```
    Description copied from interface: AdvancedCache
    
    Returns the XAResource associated with this cache which can be used to do transactional recovery.
    
    Specified by:
    
    getXAResource in interface AdvancedCache<K,V>
    
    Returns:
    an instance of XAResource
  - put
```
public final V put(K key,
    V value,
    long lifespan,
    java.util.concurrent.TimeUnit lifespanUnit,
    long maxIdleTime,
    java.util.concurrent.TimeUnit idleTimeUnit)
```
  - put
```
final V put(K key,
    V value,
    org.infinispan.metadata.Metadata metadata,
    java.util.EnumSet<org.infinispan.context.Flag> explicitFlags,
    java.lang.ClassLoader explicitClassLoader)
```
  - putInternal
```
private V putInternal(K key,
            V value,
            org.infinispan.metadata.Metadata metadata,
            java.util.EnumSet<org.infinispan.context.Flag> explicitFlags,
            org.infinispan.context.InvocationContext ctx)
```
  - putIfAbsent
```
public final V putIfAbsent(K key,
            V value,
            long lifespan,
            java.util.concurrent.TimeUnit lifespanUnit,
            long maxIdleTime,
            java.util.concurrent.TimeUnit idleTimeUnit)
```
  - putIfAbsent
```
final V putIfAbsent(K key,
            V value,
            org.infinispan.metadata.Metadata metadata,
            java.util.EnumSet<org.infinispan.context.Flag> explicitFlags,
            java.lang.ClassLoader explicitClassLoader)
```
  - putIfAbsentInternal
```
private V putIfAbsentInternal(K key,
                    V value,
                    org.infinispan.metadata.Metadata metadata,
                    java.util.EnumSet<org.infinispan.context.Flag> explicitFlags,
                    org.infinispan.context.InvocationContext ctx)
```
  - putAll
```
public final void putAll(java.util.Map<? extends K,? extends V> map,
          long lifespan,
          java.util.concurrent.TimeUnit lifespanUnit,
          long maxIdleTime,
          java.util.concurrent.TimeUnit idleTimeUnit)
```
  - putAll
```
final void putAll(java.util.Map<? extends K,? extends V> map,
          org.infinispan.metadata.Metadata metadata,
          java.util.EnumSet<org.infinispan.context.Flag> explicitFlags,
          java.lang.ClassLoader explicitClassLoader)
```
  - putAllInternal
```
private void putAllInternal(java.util.Map<? extends K,? extends V> map,
                  org.infinispan.metadata.Metadata metadata,
                  java.util.EnumSet<org.infinispan.context.Flag> explicitFlags,
                  org.infinispan.context.InvocationContext ctx)
```
  - replace
```
public final V replace(K key,
        V value,
        long lifespan,
        java.util.concurrent.TimeUnit lifespanUnit,
        long maxIdleTime,
        java.util.concurrent.TimeUnit idleTimeUnit)
```
  - replace
```
final V replace(K key,
        V value,
        org.infinispan.metadata.Metadata metadata,
        java.util.EnumSet<org.infinispan.context.Flag> explicitFlags,
        java.lang.ClassLoader explicitClassLoader)
```
  - replaceInternal
```
private V replaceInternal(K key,
                V value,
                org.infinispan.metadata.Metadata metadata,
                java.util.EnumSet<org.infinispan.context.Flag> explicitFlags,
                org.infinispan.context.InvocationContext ctx)
```
  - replace
```
public final boolean replace(K key,
              V oldValue,
              V value,
              long lifespan,
              java.util.concurrent.TimeUnit lifespanUnit,
              long maxIdleTime,
              java.util.concurrent.TimeUnit idleTimeUnit)
```
  - replace
```
final boolean replace(K key,
              V oldValue,
              V value,
              org.infinispan.metadata.Metadata metadata,
              java.util.EnumSet<org.infinispan.context.Flag> explicitFlags,
              java.lang.ClassLoader explicitClassLoader)
```
  - replaceInternal
```
private boolean replaceInternal(K key,
                      V oldValue,
                      V value,
                      org.infinispan.metadata.Metadata metadata,
                      java.util.EnumSet<org.infinispan.context.Flag> explicitFlags,
                      org.infinispan.context.InvocationContext ctx)
```
  - wrapInFuture
```
private <X> org.infinispan.util.concurrent.NotifyingFuture<X> wrapInFuture(java.lang.Object retval)
```
    Wraps a return value as a future, if needed. Typically, if the stack, operation and configuration support handling of futures, this retval is already a future in which case this method does nothing except cast to future.
    Otherwise, a future wrapper is created, which has already completed and simply returns the retval. This is used for API consistency.
    
    Type Parameters:
    X - contents of the future
    Parameters:
    retval - return value to wrap
    
    Returns:
    a future
  - putAsync
```
public final org.infinispan.util.concurrent.NotifyingFuture<V> putAsync(K key,
                                                         V value,
                                                         long lifespan,
                                                         java.util.concurrent.TimeUnit lifespanUnit,
                                                         long maxIdle,
                                                         java.util.concurrent.TimeUnit maxIdleUnit)
```
    Description copied from interface: org.infinispan.api.BasicCache
    
    Asynchronous version of #put(Object, Object, long, TimeUnit, long, TimeUnit). This method does not block on remote calls, even if your cache mode is synchronous. Has no benefit over #put(Object, Object, long, TimeUnit, long, TimeUnit) if used in LOCAL mode.
    
    Specified by:
    
    putAsync in interface org.infinispan.api.BasicCache<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
  - putAsync
```
final org.infinispan.util.concurrent.NotifyingFuture<V> putAsync(K key,
                                                         V value,
                                                         org.infinispan.metadata.Metadata metadata,
                                                         java.util.EnumSet<org.infinispan.context.Flag> explicitFlags,
                                                         java.lang.ClassLoader explicitClassLoader)
```
  - putAllAsync
```
public final org.infinispan.util.concurrent.NotifyingFuture<java.lang.Void> putAllAsync(java.util.Map<? extends K,? extends V> data,
                                                                         long lifespan,
                                                                         java.util.concurrent.TimeUnit lifespanUnit,
                                                                         long maxIdle,
                                                                         java.util.concurrent.TimeUnit maxIdleUnit)
```
    Description copied from interface: org.infinispan.api.BasicCache
    
    Asynchronous version of #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 #putAll(Map, long, TimeUnit, long, TimeUnit) if used in LOCAL mode.
    
    Specified by:
    
    putAllAsync in interface org.infinispan.api.BasicCache<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
  - putAllAsync
```
final org.infinispan.util.concurrent.NotifyingFuture<java.lang.Void> putAllAsync(java.util.Map<? extends K,? extends V> data,
                                                                         org.infinispan.metadata.Metadata metadata,
                                                                         java.util.EnumSet<org.infinispan.context.Flag> explicitFlags,
                                                                         java.lang.ClassLoader explicitClassLoader)
```
  - clearAsync
```
public final org.infinispan.util.concurrent.NotifyingFuture<java.lang.Void> clearAsync()
```
    Description copied from interface: org.infinispan.api.BasicCache
    
    Asynchronous version of #clear(). This method does not block on remote calls, even if your cache mode is synchronous. Has no benefit over #clear() if used in LOCAL mode.
    
    Specified by:
    
    clearAsync in interface org.infinispan.api.BasicCache<K,V>
    
    Returns:
    a future containing a void return type
  - clearAsync
```
final org.infinispan.util.concurrent.NotifyingFuture<java.lang.Void> clearAsync(java.util.EnumSet<org.infinispan.context.Flag> explicitFlags,
                                                                        java.lang.ClassLoader explicitClassLoader)
```
  - putIfAbsentAsync
```
public final org.infinispan.util.concurrent.NotifyingFuture<V> putIfAbsentAsync(K key,
                                                                 V value,
                                                                 long lifespan,
                                                                 java.util.concurrent.TimeUnit lifespanUnit,
                                                                 long maxIdle,
                                                                 java.util.concurrent.TimeUnit maxIdleUnit)
```
    Description copied from interface: org.infinispan.api.BasicCache
    
    Asynchronous version of #putIfAbsent(Object, Object, long, TimeUnit, long, TimeUnit). This method does not block on remote calls, even if your cache mode is synchronous. Has no benefit over #putIfAbsent(Object, Object, long, TimeUnit, long, TimeUnit) if used in LOCAL mode.
    
    Specified by:
    
    putIfAbsentAsync in interface org.infinispan.api.BasicCache<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
  - putIfAbsentAsync
```
final org.infinispan.util.concurrent.NotifyingFuture<V> putIfAbsentAsync(K key,
                                                                 V value,
                                                                 org.infinispan.metadata.Metadata metadata,
                                                                 java.util.EnumSet<org.infinispan.context.Flag> explicitFlags,
                                                                 java.lang.ClassLoader explicitClassLoader)
```
  - removeAsync
```
public final org.infinispan.util.concurrent.NotifyingFuture<V> removeAsync(java.lang.Object key)
```
    Description copied from interface: org.infinispan.api.BasicCache
    
    Asynchronous version of #remove(Object). This method does not block on remote calls, even if your cache mode is synchronous. Has no benefit over #remove(Object) if used in LOCAL mode.
    
    Specified by:
    
    removeAsync in interface org.infinispan.api.BasicCache<K,V>
    
    Parameters:
    key - key to remove
    
    Returns:
    a future containing the value removed
  - removeAsync
```
final org.infinispan.util.concurrent.NotifyingFuture<V> removeAsync(java.lang.Object key,
                                                            java.util.EnumSet<org.infinispan.context.Flag> explicitFlags,
                                                            java.lang.ClassLoader explicitClassLoader)
```
  - removeAsync
```
public final org.infinispan.util.concurrent.NotifyingFuture<java.lang.Boolean> removeAsync(java.lang.Object key,
                                                                            java.lang.Object value)
```
    Description copied from interface: org.infinispan.api.BasicCache
    
    Asynchronous version of #remove(Object, Object). This method does not block on remote calls, even if your cache mode is synchronous. Has no benefit over #remove(Object, Object) if used in LOCAL mode.
    
    Specified by:
    
    removeAsync in interface org.infinispan.api.BasicCache<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
  - removeAsync
```
final org.infinispan.util.concurrent.NotifyingFuture<java.lang.Boolean> removeAsync(java.lang.Object key,
                                                                            java.lang.Object value,
                                                                            java.util.EnumSet<org.infinispan.context.Flag> explicitFlags,
                                                                            java.lang.ClassLoader explicitClassLoader)
```
  - replaceAsync
```
public final org.infinispan.util.concurrent.NotifyingFuture<V> replaceAsync(K key,
                                                             V value,
                                                             long lifespan,
                                                             java.util.concurrent.TimeUnit lifespanUnit,
                                                             long maxIdle,
                                                             java.util.concurrent.TimeUnit maxIdleUnit)
```
    Description copied from interface: org.infinispan.api.BasicCache
    
    Asynchronous version of #replace(Object, Object, long, TimeUnit, long, TimeUnit). This method does not block on remote calls, even if your cache mode is synchronous. Has no benefit over #replace(Object, Object, long, TimeUnit, long, TimeUnit) if used in LOCAL mode.
    
    Specified by:
    
    replaceAsync in interface org.infinispan.api.BasicCache<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
```
final org.infinispan.util.concurrent.NotifyingFuture<V> replaceAsync(K key,
                                                             V value,
                                                             org.infinispan.metadata.Metadata metadata,
                                                             java.util.EnumSet<org.infinispan.context.Flag> explicitFlags,
                                                             java.lang.ClassLoader explicitClassLoader)
```
  - replaceAsync
```
public final org.infinispan.util.concurrent.NotifyingFuture<java.lang.Boolean> replaceAsync(K key,
                                                                             V oldValue,
                                                                             V newValue,
                                                                             long lifespan,
                                                                             java.util.concurrent.TimeUnit lifespanUnit,
                                                                             long maxIdle,
                                                                             java.util.concurrent.TimeUnit maxIdleUnit)
```
    Description copied from interface: org.infinispan.api.BasicCache
    
    Asynchronous version of #replace(Object, Object, Object, long, TimeUnit, long, TimeUnit). This method does not block on remote calls, even if your cache mode is synchronous. Has no benefit over #replace(Object, Object, Object, long, TimeUnit, long, TimeUnit) if used in LOCAL mode.
    
    Specified by:
    
    replaceAsync in interface org.infinispan.api.BasicCache<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
  - replaceAsync
```
final org.infinispan.util.concurrent.NotifyingFuture<java.lang.Boolean> replaceAsync(K key,
                                                                             V oldValue,
                                                                             V newValue,
                                                                             org.infinispan.metadata.Metadata metadata,
                                                                             java.util.EnumSet<org.infinispan.context.Flag> explicitFlags,
                                                                             java.lang.ClassLoader explicitClassLoader)
```
  - getAsync
```
public org.infinispan.util.concurrent.NotifyingFuture<V> getAsync(K key)
```
    Description copied from interface: org.infinispan.api.BasicCache
    
    Asynchronous version of #get(Object) that allows user code to retrieve the value associated with a key at a later stage, hence allowing multiple parallel get requests to be sent. Normally, when this method detects that the value is likely to be retrieved from from a remote entity, it will span a different thread in order to allow the asynchronous get call to return immediately. If the call will definitely resolve locally, for example when the cache is configured with LOCAL mode and no stores are configured, the get asynchronous call will act sequentially and will have no different to #get(Object).
    
    Specified by:
    
    getAsync in interface org.infinispan.api.BasicCache<K,V>
    
    Parameters:
    key - key to retrieve
    
    Returns:
    a future that can be used to retrieve value associated with the key when this is available. The actual value returned by the future follows the same rules as #get(Object)
  - getAsync
```
org.infinispan.util.concurrent.NotifyingFuture<V> getAsync(K key,
                                                         java.util.EnumSet<org.infinispan.context.Flag> explicitFlags,
                                                         java.lang.ClassLoader explicitClassLoader)
```
  - asyncSkipsThread
```
private boolean asyncSkipsThread(java.util.EnumSet<org.infinispan.context.Flag> flags,
                       K key)
```
    Encodes the cases for an asyncGet operation in which it makes sense to actually perform the operation in sync.
    
    Returns:
    true if we skip the thread (performing it in sync)
  - isSkipLoader
```
private boolean isSkipLoader(java.util.EnumSet<org.infinispan.context.Flag> flags)
```
  - getAdvancedCache
```
public AdvancedCache<K,V> getAdvancedCache()
```
    Specified by:
    
    getAdvancedCache in interface Cache<K,V>
  - getRpcManager
```
public org.infinispan.remoting.rpc.RpcManager getRpcManager()
```
    Description copied from interface: AdvancedCache
    
    Returns the component in charge of communication with other caches in the cluster. If the cache's ClusteringConfiguration.cacheMode() is CacheMode.LOCAL, this method will return null.
    
    Specified by:
    
    getRpcManager in interface AdvancedCache<K,V>
    
    Returns:
    the RPC manager component associated with this cache instance or null
  - withFlags
```
public AdvancedCache<K,V> withFlags(org.infinispan.context.Flag... flags)
```
    Description copied from interface: AdvancedCache
    A method that adds flags to any API call. For example, consider the following code snippet:
```
   cache.withFlags(Flag.FORCE_WRITE_LOCK).get(key);
 
```
    will invoke a cache.get() with a write lock forced.
    Note that for the flag to take effect, the cache operation must be invoked on the instance returned by this method.
    As an alternative to setting this on every invocation, users could also consider using the DecoratedCache wrapper, as this allows for more readable code. E.g.:
```
    Cache forceWriteLockCache = new DecoratedCache(cache, Flag.FORCE_WRITE_LOCK);
    forceWriteLockCache.get(key1);
    forceWriteLockCache.get(key2);
    forceWriteLockCache.get(key3);
 
```
    Specified by:
    
    withFlags in interface AdvancedCache<K,V>
    
    Parameters:
    flags - a set of flags to apply. See the Flag documentation.
    
    Returns:
    an AdvancedCache instance on which a real operation is to be invoked, if the flags are to be applied.
  - getOngoingTransaction
```
private Transaction getOngoingTransaction()
```
  - executeCommandAndCommitIfNeeded
```
private java.lang.Object executeCommandAndCommitIfNeeded(org.infinispan.context.InvocationContext ctx,
                                               org.infinispan.commands.VisitableCommand command)
```
  - isTxInjected
```
private boolean isTxInjected(org.infinispan.context.InvocationContext ctx)
```
  - tryRollback
```
private void tryRollback()
```
  - getClassLoader
```
public java.lang.ClassLoader getClassLoader()
```
    Description copied from interface: AdvancedCache
    
    Returns the cache loader associated associated with this cache. As an alternative to setting this on every invocation, users could also consider using the DecoratedCache wrapper.
    
    Specified by:
    
    getClassLoader in interface AdvancedCache<K,V>
    
    Returns:
    this cache's cache loader
  - with
```
public AdvancedCache<K,V> with(java.lang.ClassLoader classLoader)
```
    Description copied from interface: AdvancedCache
    Using this operation, users can call any AdvancedCache operation with a given ClassLoader. This means that any ClassLoader happening as a result of the cache operation will be done using the ClassLoader given. For example:
    When users store POJO instances in caches configured with StoreAsBinaryConfiguration, these instances are transformed into byte arrays. When these entries are read from the cache, a lazy unmarshalling process happens where these byte arrays are transformed back into POJO instances. Using AdvancedCache.with(ClassLoader) when reading that enables users to provide the class loader that should be used when trying to locate the classes that are constructed as a result of the unmarshalling process.
```
    cache.with(classLoader).get(key);
 
```
    Note that for the flag to take effect, the cache operation must be invoked on the instance returned by this method.
    As an alternative to setting this on every invocation, users could also consider using the DecoratedCache wrapper, as this allows for more readable code. E.g.:
```
    Cache classLoaderSpecificCache = new DecoratedCache(cache, classLoader);
    classLoaderSpecificCache.get(key1);
    classLoaderSpecificCache.get(key2);
    classLoaderSpecificCache.get(key3);
 
```
    Specified by:
    
    with in interface AdvancedCache<K,V>
    
    Returns:
    an AdvancedCache instance upon which operations can be called with a particular ClassLoader.
  - put
```
public V put(K key,
    V value,
    org.infinispan.metadata.Metadata metadata)
```
    Description copied from interface: AdvancedCache
    
    An overloaded form of #put(K, V), which takes in an instance of Metadata which can be used to provide metadata information for the entry being stored, such as lifespan, version of value...etc.
    
    Specified by:
    
    put in interface AdvancedCache<K,V>
    
    Parameters:
    key - key to use
    value - value to store
    metadata - information to store alongside the value
    
    Returns:
    the previous value associated with key, or null if there was no mapping for key.
  - replace
```
public V replace(K key,
        V value,
        org.infinispan.metadata.Metadata metadata)
```
    Description copied from interface: AdvancedCache
    
    An overloaded form of #replace(K, V), which takes in an instance of Metadata which can be used to provide metadata information for the entry being stored, such as lifespan, version of value...etc. The Metadata is only stored if the call is successful.
    
    Specified by:
    
    replace in interface AdvancedCache<K,V>
    
    Parameters:
    key - key with which the specified value is associated
    value - value to be associated with the specified key
    metadata - information to store alongside the new value
    
    Returns:
    the previous value associated with the specified key, or null if there was no mapping for the key.
  - replace
```
public boolean replace(K key,
              V oldValue,
              V value,
              org.infinispan.metadata.Metadata metadata)
```
    Description copied from interface: AdvancedCache
    
    An overloaded form of #replace(K, V, V), which takes in an instance of Metadata which can be used to provide metadata information for the entry being stored, such as lifespan, version of value...etc. The Metadata is only stored if the call is successful.
    
    Specified by:
    
    replace in interface AdvancedCache<K,V>
    
    Parameters:
    key - key with which the specified value is associated
    oldValue - value expected to be associated with the specified key
    value - value to be associated with the specified key
    metadata - information to store alongside the new value
    
    Returns:
    true if the value was replaced
  - putIfAbsent
```
public V putIfAbsent(K key,
            V value,
            org.infinispan.metadata.Metadata metadata)
```
    Description copied from interface: AdvancedCache
    
    An overloaded form of #putIfAbsent(K, V), which takes in an instance of Metadata which can be used to provide metadata information for the entry being stored, such as lifespan, version of value...etc. The Metadata is only stored if the call is successful.
    
    Specified by:
    
    putIfAbsent in interface AdvancedCache<K,V>
    
    Parameters:
    key - key with which the specified value is to be associated
    value - value to be associated with the specified key
    metadata - information to store alongside the new value
    
    Returns:
    the previous value associated with the specified key, or null if there was no mapping for the key.
  - putAsync
```
public org.infinispan.util.concurrent.NotifyingFuture<V> putAsync(K key,
                                                         V value,
                                                         org.infinispan.metadata.Metadata metadata)
```
    Description copied from interface: AdvancedCache
    
    Asynchronous version of AdvancedCache.put(Object, Object, Metadata) which stores metadata alongside the value. This method does not block on remote calls, even if your cache mode is synchronous. Has no benefit over AdvancedCache.put(Object, Object, Metadata) if used in LOCAL mode.
    
    Specified by:
    
    putAsync in interface AdvancedCache<K,V>
    
    Parameters:
    key - key to use
    value - value to store
    metadata - information to store alongside the new value
    
    Returns:
    a future containing the old value replaced.
  - associateImplicitTransactionWithCurrentThread
```
private void associateImplicitTransactionWithCurrentThread(org.infinispan.context.InvocationContext ctx)
                                                    throws javax.transaction.InvalidTransactionException,
                                                           SystemException
```
    Throws:
    
    javax.transaction.InvalidTransactionException
    
    SystemException
  - getConfigurationAsProperties
```
public java.util.Properties getConfigurationAsProperties()
```

Class CacheImpl<K,V>

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

OBJECT_NAME

icc

invocationContextFactory

commandsFactory

invoker

config

notifier

batchContainer

componentRegistry

transactionManager

rpcManager

marshaller

defaultMetadata

name

evictionManager

dataContainer

log

trace

cacheManager

lockManager

distributionManager

asyncExecutor

txTable

recoveryManager

txCoordinator

globalCfg

isClassLoaderInContext

Constructor Detail

CacheImpl

Method Detail

injectDependencies

assertKeyNotNull

assertKeyValueNotNull

assertValueNotNull

assertKeysNotNull

put

put

putIfAbsent

putAll

replace

replace

putIfAbsent

replace

replace

putAsync

putAsync

putAllAsync

putAllAsync

putIfAbsentAsync

putIfAbsentAsync

replaceAsync

replaceAsync

replaceAsync

replaceAsync

putAll

remove

remove

removeInternal

size

size

isEmpty

isEmpty

containsKey

containsKey

containsValue

get

get

getCacheEntry

getCacheEntry

remove

remove

removeInternal

clearOperation

clear