org.infinispan

Interface AdvancedCache<K,V>

All Superinterfaces:

AsyncCache<K,V>, BasicCache<K,V>, BatchingCache, Cache<K,V>, java.util.concurrent.ConcurrentMap<K,V>, FilteringListenable<K,V>, Lifecycle, Listenable, java.util.Map<K,V>, TransactionalCache

All Known Subinterfaces:

SecureCache<K,V>

All Known Implementing Classes:

AbstractDelegatingAdvancedCache, AbstractDelegatingAdvancedCache

public interface AdvancedCache<K,V>
extends Cache<K,V>, TransactionalCache

An advanced interface that exposes additional methods not available on Cache.

Since:

4.0

Nested Class Summary

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

java.util.Map.Entry<K,V>

Method Summary

Modifier and Type	Method and Description
void	addInterceptor(CommandInterceptor i, int position) Deprecated. Since 9.0, use getAsyncInterceptorChain() instead.
boolean	addInterceptorAfter(CommandInterceptor i, java.lang.Class<? extends CommandInterceptor> afterInterceptor) Deprecated. Since 9.0, use getAsyncInterceptorChain() instead.
boolean	addInterceptorBefore(CommandInterceptor i, java.lang.Class<? extends CommandInterceptor> beforeInterceptor) Deprecated. Since 9.0, use getAsyncInterceptorChain() instead.
void	applyDelta(K deltaAwareValueKey, Delta delta, java.lang.Object... locksToAcquire) Deprecated. since 9.1
CacheSet<CacheEntry<K,V>>	cacheEntrySet() Identical to Cache.entrySet() but is typed to return CacheEntries instead of Entries.
V	compute(K key, java.util.function.BiFunction<? super K,? super V,? extends V> remappingFunction, Metadata metadata) An overloaded form of #compute(K, BiFunction), 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.
default V	compute(K key, SerializableBiFunction<? super K,? super V,? extends V> remappingFunction, Metadata metadata) Overloaded compute(Object, BiFunction, Metadata) with SerializableBiFunction
java.util.concurrent.CompletableFuture<V>	computeAsync(K key, java.util.function.BiFunction<? super K,? super V,? extends V> remappingFunction, Metadata metadata) Overloaded #computeAsync(K, BiFunction), which stores metadata alongside the value.
default java.util.concurrent.CompletableFuture<V>	computeAsync(K key, SerializableBiFunction<? super K,? super V,? extends V> remappingFunction, Metadata metadata) Overloaded computeAsync(Object, BiFunction, Metadata) with SerializableBiFunction
V	computeIfAbsent(K key, java.util.function.Function<? super K,? extends V> mappingFunction, Metadata metadata) An overloaded form of #computeIfAbsent(K, Function), 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.
default V	computeIfAbsent(K key, SerializableFunction<? super K,? extends V> mappingFunction, Metadata metadata) Overloaded computeIfAbsent(Object, Function, Metadata) with SerializableFunction
java.util.concurrent.CompletableFuture<V>	computeIfAbsentAsync(K key, java.util.function.Function<? super K,? extends V> mappingFunction, Metadata metadata) Overloaded #computeIfAbsentAsync(K, Function), 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.
default java.util.concurrent.CompletableFuture<V>	computeIfAbsentAsync(K key, SerializableFunction<? super K,? extends V> mappingFunction, Metadata metadata) Overloaded computeIfAbsentAsync(Object, Function, Metadata) with SerializableFunction
V	computeIfPresent(K key, java.util.function.BiFunction<? super K,? super V,? extends V> remappingFunction, Metadata metadata) An overloaded form of #computeIfPresent(K, BiFunction), 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.
default V	computeIfPresent(K key, SerializableBiFunction<? super K,? super V,? extends V> remappingFunction, Metadata metadata) Overloaded computeIfPresent(Object, BiFunction, Metadata) with SerializableBiFunction
java.util.concurrent.CompletableFuture<V>	computeIfPresentAsync(K key, java.util.function.BiFunction<? super K,? super V,? extends V> remappingFunction, Metadata metadata) Overloaded #computeIfPresentAsync(K, BiFunction), 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.
default java.util.concurrent.CompletableFuture<V>	computeIfPresentAsync(K key, SerializableBiFunction<? super K,? super V,? extends V> remappingFunction, Metadata metadata) Overloaded computeIfPresentAsync(Object, BiFunction, Metadata) with SerializableBiFunction
java.util.Map<K,V>	getAll(java.util.Set<?> keys) Gets a collection of entries, returning them as Map of the values associated with the set of keys requested.
java.util.Map<K,CacheEntry<K,V>>	getAllCacheEntries(java.util.Set<?> keys) Gets a collection of entries from the AdvancedCache, returning them as Map of the cache entries associated with the set of keys requested.
default java.util.Map<K,V>	getAndPutAll(java.util.Map<? extends K,? extends V> map) Executes an equivalent of Map.putAll(Map), returning previous values of the modified entries.
AsyncInterceptorChain	getAsyncInterceptorChain() Allows the modification of the interceptor chain.
AuthorizationManager	getAuthorizationManager() Retrieves the AuthorizationManager if the cache has security enabled.
AvailabilityMode	getAvailability() Returns the cache's availability.
BatchContainer	getBatchContainer() Returns the component in charge of batching cache operations.
CacheEntry<K,V>	getCacheEntry(java.lang.Object key) Retrieves a CacheEntry corresponding to a specific key.
default java.util.concurrent.CompletableFuture<CacheEntry<K,V>>	getCacheEntryAsync(java.lang.Object key) Retrieves a CacheEntry corresponding to a specific key.
java.lang.ClassLoader	getClassLoader() Returns the cache loader associated associated with this cache.
ComponentRegistry	getComponentRegistry()
DataContainer<K,V>	getDataContainer() Returns the container where data is stored in the cache.
DistributionManager	getDistributionManager() Retrieves a reference to the DistributionManager if the cache is configured to use Distribution.
EvictionManager	getEvictionManager()
ExpirationManager<K,V>	getExpirationManager()
java.util.Map<K,V>	getGroup(java.lang.String groupName) It fetches all the keys which belong to the group.
java.util.List<CommandInterceptor>	getInterceptorChain() Deprecated. Since 9.0, use getAsyncInterceptorChain() instead.
InvocationContextContainer	getInvocationContextContainer() Deprecated. No longer in use, implementations might return null.
DataConversion	getKeyDataConversion()
Encoder	getKeyEncoder() Deprecated. Use getKeyDataConversion() and then DataConversion.getEncoder()
Wrapper	getKeyWrapper() Deprecated. Use getKeyDataConversion() and then DataConversion.getWrapper()
LockManager	getLockManager() Returns the component that deals with all aspects of acquiring and releasing locks for cache entries.
RpcManager	getRpcManager() Returns the component in charge of communication with other caches in the cluster.
Stats	getStats() Returns a Stats object that allows several statistics associated with this cache at runtime.
DataConversion	getValueDataConversion()
Encoder	getValueEncoder() Deprecated. Use getValueDataConversion() ()} and then DataConversion.getEncoder()
Wrapper	getValueWrapper() Deprecated. Use getValueDataConversion() ()} and then DataConversion.getWrapper()
javax.transaction.xa.XAResource	getXAResource() Returns the XAResource associated with this cache which can be used to do transactional recovery.
boolean	lock(java.util.Collection<? extends K> keys) Locks collections of keys eagerly across cache nodes in a cluster.
boolean	lock(K... keys) Locks a given key or keys eagerly across cache nodes in a cluster.
AdvancedCache<K,V>	lockAs(java.lang.Object lockOwner) Whenever this cache acquires a lock it will do so using the given Object as the owner of said lock.
LockedStream<K,V>	lockedStream() Returns a sequential stream using this Cache as the source.
V	merge(K key, V value, java.util.function.BiFunction<? super V,? super V,? extends V> remappingFunction, Metadata metadata) An overloaded form of Cache.merge(Object, Object, BiFunction), 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.
default V	merge(K key, V value, SerializableBiFunction<? super V,? super V,? extends V> remappingFunction, Metadata metadata) Overloaded merge(Object, Object, BiFunction, Metadata) with SerializableBiFunction
java.util.concurrent.CompletableFuture<V>	mergeAsync(K key, V value, java.util.function.BiFunction<? super V,? super V,? extends V> remappingFunction, long lifespan, java.util.concurrent.TimeUnit lifespanUnit) Overloaded AsyncCache.mergeAsync(Object, Object, BiFunction) which takes in lifespan parameters.
java.util.concurrent.CompletableFuture<V>	mergeAsync(K key, V value, java.util.function.BiFunction<? super V,? super V,? extends V> remappingFunction, long lifespan, java.util.concurrent.TimeUnit lifespanUnit, long maxIdleTime, java.util.concurrent.TimeUnit maxIdleTimeUnit) Overloaded AsyncCache.mergeAsync(Object, Object, BiFunction) which takes in lifespan parameters.
java.util.concurrent.CompletableFuture<V>	mergeAsync(K key, V value, java.util.function.BiFunction<? super V,? super V,? extends V> remappingFunction, Metadata metadata) Overloaded AsyncCache.mergeAsync(Object, Object, BiFunction), 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.
default java.util.concurrent.CompletableFuture<V>	mergeAsync(K key, V value, SerializableBiFunction<? super V,? super V,? extends V> remappingFunction, Metadata metadata) Overloaded mergeAsync(Object, Object, BiFunction, Metadata) with SerializableBiFunction
default AdvancedCache<K,V>	noFlags() Unset all flags set on this cache using withFlags(Flag...) or withFlags(Collection) methods.
V	put(K key, V value, 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.
void	putAll(java.util.Map<? extends K,? extends V> map, Metadata metadata) An overloaded form of Map.putAll(Map), which takes in an instance of Metadata which can be used to provide metadata information for the entries being stored, such as lifespan, version of value...etc.
default java.util.concurrent.CompletableFuture<java.lang.Void>	putAllAsync(java.util.Map<? extends K,? extends V> map, Metadata metadata)
java.util.concurrent.CompletableFuture<V>	putAsync(K key, V value, Metadata metadata) Asynchronous version of put(Object, Object, Metadata) which stores metadata alongside the value.
void	putForExternalRead(K key, V value, Metadata metadata) An overloaded form of #putForExternalRead(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.
V	putIfAbsent(K key, V value, 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.
default java.util.concurrent.CompletableFuture<V>	putIfAbsentAsync(K key, V value, Metadata metadata) An overloaded form of #putIfAbsentAsync(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.
void	removeGroup(java.lang.String groupName) It removes all the key which belongs to a group.
void	removeInterceptor(java.lang.Class<? extends CommandInterceptor> interceptorType) Deprecated. Since 9.0, use getAsyncInterceptorChain() instead.
void	removeInterceptor(int position) Deprecated. Since 9.0, use getAsyncInterceptorChain() instead.
java.util.concurrent.CompletableFuture<java.lang.Void>	removeLifespanExpired(K key, V value, java.lang.Long lifespan) Attempts to remove the entry if it is expired.
java.util.concurrent.CompletableFuture<java.lang.Boolean>	removeMaxIdleExpired(K key, V value) Attempts to remove the entry for the given key, if it has expired due to max idle.
V	replace(K key, V value, 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.
boolean	replace(K key, V oldValue, V newValue, 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.
default java.util.concurrent.CompletableFuture<V>	replaceAsync(K key, V value, Metadata metadata) An overloaded form of #replaceAsync(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.
default java.util.concurrent.CompletableFuture<java.lang.Boolean>	replaceAsync(K key, V oldValue, V newValue, Metadata metadata)
void	setAvailability(AvailabilityMode availabilityMode) Manually change the availability of the cache.
default AdvancedCache<K,V>	transform(java.util.function.Function<AdvancedCache<K,V>,? extends AdvancedCache<K,V>> transformation) Apply the transformation on each AdvancedCache instance in a delegation chain, starting with the innermost implementation.
AdvancedCache<K,V>	with(java.lang.ClassLoader classLoader) Deprecated. Since 9.4, the classloader is ignored.
AdvancedCache<?,?>	withEncoding(java.lang.Class<? extends Encoder> encoder) Performs any cache operations using the specified Encoder.
AdvancedCache<?,?>	withEncoding(java.lang.Class<? extends Encoder> keyEncoder, java.lang.Class<? extends Encoder> valueEncoder) Performs any cache operations using the specified pair of Encoder.
default AdvancedCache<K,V>	withFlags(java.util.Collection<Flag> flags) An alternative to withFlags(Flag...) not requiring array allocation.
AdvancedCache<K,V>	withFlags(Flag... flags) A method that adds flags to any API call.
AdvancedCache<?,?>	withKeyEncoding(java.lang.Class<? extends Encoder> encoder)
AdvancedCache<?,?>	withMediaType(java.lang.String keyMediaType, java.lang.String valueMediaType) Perform any cache operations using an alternate MediaType.
AdvancedCache<K,V>	withSubject(javax.security.auth.Subject subject) Performs any cache operations using the specified Subject.
AdvancedCache<K,V>	withWrapping(java.lang.Class<? extends Wrapper> wrapper) Performs any cache operations using the specified Wrapper.
AdvancedCache<K,V>	withWrapping(java.lang.Class<? extends Wrapper> keyWrapper, java.lang.Class<? extends Wrapper> valueWrapper) Performs any cache operations using the specified pair of Wrapper.

Methods inherited from interface org.infinispan.Cache

clear, compute, compute, computeIfAbsent, computeIfAbsent, computeIfPresent, computeIfPresent, entrySet, evict, getAdvancedCache, getCacheConfiguration, getCacheManager, getStatus, keySet, merge, merge, putForExternalRead, putForExternalRead, putForExternalRead, shutdown, size, stop, values

Methods inherited from interface org.infinispan.commons.api.BasicCache

compute, compute, computeIfAbsent, computeIfAbsent, computeIfPresent, computeIfPresent, getName, getVersion, merge, merge, put, put, put, putAll, putAll, putIfAbsent, putIfAbsent, remove, replace, replace, replace, replace

Methods inherited from interface org.infinispan.commons.api.AsyncCache

clearAsync, computeAsync, computeAsync, computeAsync, computeIfAbsentAsync, computeIfAbsentAsync, computeIfAbsentAsync, computeIfPresentAsync, computeIfPresentAsync, computeIfPresentAsync, containsKeyAsync, getAllAsync, getAsync, mergeAsync, putAllAsync, putAllAsync, putAllAsync, putAsync, putAsync, putAsync, putIfAbsentAsync, putIfAbsentAsync, putIfAbsentAsync, removeAsync, removeAsync, replaceAsync, replaceAsync, replaceAsync, replaceAsync, replaceAsync, replaceAsync

Methods inherited from interface java.util.concurrent.ConcurrentMap

forEach, getOrDefault, putIfAbsent, remove, replace, replace, replaceAll

Methods inherited from interface java.util.Map

containsKey, containsValue, equals, get, hashCode, isEmpty, putAll

Methods inherited from interface org.infinispan.commons.api.Lifecycle

start

Methods inherited from interface org.infinispan.commons.api.BatchingCache

endBatch, startBatch

Methods inherited from interface org.infinispan.notifications.FilteringListenable

addFilteredListener, addListener, addListener, addStorageFormatFilteredListener

Methods inherited from interface org.infinispan.notifications.Listenable

addListener, getListeners, removeListener

Methods inherited from interface org.infinispan.commons.api.TransactionalCache

getTransactionManager

Method Detail

withFlags

AdvancedCache<K,V> withFlags(Flag... flags)

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);
 

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.

withFlags

default AdvancedCache<K,V> withFlags(java.util.Collection<Flag> flags)

An alternative to withFlags(Flag...) not requiring array allocation.

Parameters:

flags -

Returns:

noFlags

default AdvancedCache<K,V> noFlags()

Unset all flags set on this cache using withFlags(Flag...) or withFlags(Collection) methods.

Returns:

Cache not applying any flags to the command; possibly this.

transform

default AdvancedCache<K,V> transform(java.util.function.Function<AdvancedCache<K,V>,? extends AdvancedCache<K,V>> transformation)

Apply the transformation on each AdvancedCache instance in a delegation chain, starting with the innermost implementation.

Parameters:

transformation -

Returns:

The outermost transformed cache.

withSubject

AdvancedCache<K,V> withSubject(javax.security.auth.Subject subject)

Performs any cache operations using the specified Subject. Only applies to caches with authorization enabled (see ConfigurationBuilder.security()).

Parameters:

subject -

Returns:

an AdvancedCache instance on which a real operation is to be invoked, using the specified subject

addInterceptor

@Deprecated
void addInterceptor(CommandInterceptor i,
                                int position)

Deprecated. Since 9.0, use getAsyncInterceptorChain() instead.

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.

Parameters:

i - the interceptor to add

position - the position to add the interceptor

addInterceptorAfter

@Deprecated
boolean addInterceptorAfter(CommandInterceptor i,
                                        java.lang.Class<? extends CommandInterceptor> afterInterceptor)

Deprecated. Since 9.0, use getAsyncInterceptorChain() instead.

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.

Parameters:

i - interceptor to add

afterInterceptor - interceptor type after which to place custom interceptor

Returns:

true if successful, false otherwise.

addInterceptorBefore

@Deprecated
boolean addInterceptorBefore(CommandInterceptor i,
                                         java.lang.Class<? extends CommandInterceptor> beforeInterceptor)

Deprecated. Since 9.0, use getAsyncInterceptorChain() instead.

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.

Parameters:

i - interceptor to add

beforeInterceptor - interceptor type before which to place custom interceptor

Returns:

true if successful, false otherwise.

removeInterceptor

@Deprecated
void removeInterceptor(int position)

Deprecated. Since 9.0, use getAsyncInterceptorChain() instead.

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.

Parameters:

position - the position at which to remove an interceptor

removeInterceptor

@Deprecated
void removeInterceptor(java.lang.Class<? extends CommandInterceptor> interceptorType)

Deprecated. Since 9.0, use getAsyncInterceptorChain() instead.

Removes the interceptor of specified type.

Parameters:

interceptorType - type of interceptor to remove

getInterceptorChain

@Deprecated
java.util.List<CommandInterceptor> getInterceptorChain()

Deprecated. Since 9.0, use getAsyncInterceptorChain() instead.

getAsyncInterceptorChain

AsyncInterceptorChain getAsyncInterceptorChain()

Allows the modification of the interceptor chain.

Experimental: The ability to modify the interceptors at runtime may be removed in future versions.

Since:

9.0

getEvictionManager

EvictionManager getEvictionManager()

Returns:

the eviction manager - if one is configured - for this cache instance

getExpirationManager

ExpirationManager<K,V> getExpirationManager()

Returns:

the expiration manager - if one is configured - for this cache instance

getComponentRegistry

ComponentRegistry getComponentRegistry()

Returns:

the component registry for this cache instance

getDistributionManager

DistributionManager getDistributionManager()

Retrieves a reference to the DistributionManager if the cache is configured to use Distribution. Otherwise, returns a null.

Returns:

a DistributionManager, or null.

getAuthorizationManager

AuthorizationManager getAuthorizationManager()

Retrieves the AuthorizationManager if the cache has security enabled. Otherwise returns null

Returns:

an AuthorizationManager or null

lockAs

AdvancedCache<K,V> lockAs(java.lang.Object lockOwner)

Whenever this cache acquires a lock it will do so using the given Object as the owner of said lock.

This can be useful when a lock may have been manually acquired and you wish to reuse that lock across invocations.

Great care should be taken with this command as misuse can very easily lead to deadlocks.

Parameters:

lockOwner - the lock owner to lock any keys as

Returns:

an AdvancedCache instance on which when an operation is invoked it will use lock owner object to acquire any locks

lock

boolean lock(K... keys)

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.

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.

Throws:

TimeoutException - if the lock cannot be acquired within the configured lock acquisition time.

lock

boolean lock(java.util.Collection<? extends K> keys)

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.

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.

Throws:

TimeoutException - if the lock cannot be acquired within the configured lock acquisition time.

applyDelta

@Deprecated
void applyDelta(K deltaAwareValueKey,
                            Delta delta,
                            java.lang.Object... locksToAcquire)

Deprecated. since 9.1

Applies the given Delta to the DeltaAware object stored under deltaAwareValueKey if and only if all locksToAcquire locks are successfully obtained

Parameters:

deltaAwareValueKey - the key for DeltaAware object

delta - the delta to be applied to DeltaAware object

locksToAcquire - keys to be locked in DeltaAware scope. Must contain only single key equal to deltaAwareValueKey

getRpcManager

RpcManager getRpcManager()

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.

Returns:

the RPC manager component associated with this cache instance or null

getBatchContainer

BatchContainer getBatchContainer()

Returns the component in charge of batching cache operations.

Returns:

the batching component associated with this cache instance

getInvocationContextContainer

@Deprecated
InvocationContextContainer getInvocationContextContainer()

Deprecated. No longer in use, implementations might return null.

Returns the component in charge of managing the interactions between the cache operations and the context information associated with them.

Returns:

the invocation context container component

getDataContainer

DataContainer<K,V> getDataContainer()

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.

Returns:

the data container associated with this cache instance

getLockManager

LockManager getLockManager()

Returns the component that deals with all aspects of acquiring and releasing locks for cache entries.

Returns:

retrieves the lock manager associated with this cache instance

getStats

Stats getStats()

Returns a Stats object that allows several statistics associated with this cache at runtime.

Returns:

this cache's Stats object

getXAResource

javax.transaction.xa.XAResource getXAResource()

Returns the XAResource associated with this cache which can be used to do transactional recovery.

Returns:

an instance of XAResource

getClassLoader

java.lang.ClassLoader getClassLoader()

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.

Returns:

this cache's cache loader

with

@Deprecated
AdvancedCache<K,V> with(java.lang.ClassLoader classLoader)

Deprecated. Since 9.4, the classloader is ignored.

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 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);
 

Returns:

an AdvancedCache instance upon which operations can be called with a particular ClassLoader.

put

V put(K key,
      V value,
      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.

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.

Since:

5.3

putAll

void putAll(java.util.Map<? extends K,? extends V> map,
            Metadata metadata)

An overloaded form of Map.putAll(Map), which takes in an instance of Metadata which can be used to provide metadata information for the entries being stored, such as lifespan, version of value...etc.

Parameters:

map - the values to store

metadata - information to store alongside the value(s)

Since:

7.2

putAllAsync

default java.util.concurrent.CompletableFuture<java.lang.Void> putAllAsync(java.util.Map<? extends K,? extends V> map,
                                                                           Metadata metadata)

replace

V replace(K key,
          V value,
          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. The Metadata is only stored if the call is successful.

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.

Since:

5.3

replaceAsync

default java.util.concurrent.CompletableFuture<V> replaceAsync(K key,
                                                               V value,
                                                               Metadata metadata)

An overloaded form of #replaceAsync(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.

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 future that contains previous value associated with the specified key, or null if there was no mapping for the key.

Since:

9.2

replace

boolean replace(K key,
                V oldValue,
                V newValue,
                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. The Metadata is only stored if the call is successful.

Parameters:

key - key with which the specified value is associated

oldValue - value expected to be associated with the specified key

newValue - value to be associated with the specified key

metadata - information to store alongside the new value

Returns:

true if the value was replaced

Since:

5.3

replaceAsync

default java.util.concurrent.CompletableFuture<java.lang.Boolean> replaceAsync(K key,
                                                                               V oldValue,
                                                                               V newValue,
                                                                               Metadata metadata)

putIfAbsent

V putIfAbsent(K key,
              V value,
              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. The Metadata is only stored if the call is successful.

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.

Since:

5.3

putIfAbsentAsync

default java.util.concurrent.CompletableFuture<V> putIfAbsentAsync(K key,
                                                                   V value,
                                                                   Metadata metadata)

An overloaded form of #putIfAbsentAsync(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.

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:

A future containing the previous value associated with the specified key, or null if there was no mapping for the key.

Since:

9.2

putForExternalRead

void putForExternalRead(K key,
                        V value,
                        Metadata metadata)

An overloaded form of #putForExternalRead(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.

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

Since:

7.0

compute

V compute(K key,
          java.util.function.BiFunction<? super K,? super V,? extends V> remappingFunction,
          Metadata metadata)

An overloaded form of #compute(K, BiFunction), 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.

Parameters:

key - key with which the specified value is associated

remappingFunction - function to be applied to the specified key/value

metadata - information to store alongside the new value

Returns:

the previous value associated with the specified key, or null if remapping function is gives null.

Since:

9.1

compute

default V compute(K key,
                  SerializableBiFunction<? super K,? super V,? extends V> remappingFunction,
                  Metadata metadata)

Overloaded compute(Object, BiFunction, Metadata) with SerializableBiFunction

computeIfPresent

V computeIfPresent(K key,
                   java.util.function.BiFunction<? super K,? super V,? extends V> remappingFunction,
                   Metadata metadata)

An overloaded form of #computeIfPresent(K, BiFunction), 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.

Parameters:

key - key with which the specified value is associated

remappingFunction - function to be applied to the specified key/value

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.

Since:

9.1

computeIfPresent

default V computeIfPresent(K key,
                           SerializableBiFunction<? super K,? super V,? extends V> remappingFunction,
                           Metadata metadata)

Overloaded computeIfPresent(Object, BiFunction, Metadata) with SerializableBiFunction

computeIfAbsent

V computeIfAbsent(K key,
                  java.util.function.Function<? super K,? extends V> mappingFunction,
                  Metadata metadata)

An overloaded form of #computeIfAbsent(K, Function), 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.

Parameters:

key - key with which the specified value is associated

mappingFunction - function to be applied to the specified key

metadata - information to store alongside the new value

Returns:

the value created with the mapping function associated with the specified key, or the previous value associated with the specified key if the key is not absent.

Since:

9.1

computeIfAbsent

default V computeIfAbsent(K key,
                          SerializableFunction<? super K,? extends V> mappingFunction,
                          Metadata metadata)

Overloaded computeIfAbsent(Object, Function, Metadata) with SerializableFunction

merge

V merge(K key,
        V value,
        java.util.function.BiFunction<? super V,? super V,? extends V> remappingFunction,
        Metadata metadata)

An overloaded form of Cache.merge(Object, Object, BiFunction), 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.

Parameters:

key, - key with which the resulting value is to be associated

value, - the non-null value to be merged with the existing value associated with the key or, if no existing value or a null value is associated with the key, to be associated with the key

remappingFunction, - the function to recompute a value if present

metadata, - information to store alongside the new value

Returns:

the new value associated with the specified key, or null if no value is associated with the key

Since:

9.2

merge

default V merge(K key,
                V value,
                SerializableBiFunction<? super V,? super V,? extends V> remappingFunction,
                Metadata metadata)

Overloaded merge(Object, Object, BiFunction, Metadata) with SerializableBiFunction

putAsync

java.util.concurrent.CompletableFuture<V> putAsync(K key,
                                                   V value,
                                                   Metadata metadata)

Asynchronous version of 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 put(Object, Object, Metadata) if used in LOCAL mode.

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.

Since:

5.3

computeAsync

java.util.concurrent.CompletableFuture<V> computeAsync(K key,
                                                       java.util.function.BiFunction<? super K,? super V,? extends V> remappingFunction,
                                                       Metadata metadata)

Overloaded #computeAsync(K, BiFunction), which stores metadata alongside the value. This method does not block on remote calls, even if your cache mode is synchronous.

Parameters:

key - key with which the specified value is associated

remappingFunction - function to be applied to the specified key/value

metadata - information to store alongside the new value

Returns:

the previous value associated with the specified key, or null if remapping function is gives null.

Since:

9.4

computeAsync

default java.util.concurrent.CompletableFuture<V> computeAsync(K key,
                                                               SerializableBiFunction<? super K,? super V,? extends V> remappingFunction,
                                                               Metadata metadata)

Overloaded computeAsync(Object, BiFunction, Metadata) with SerializableBiFunction

Since:

9.4

computeIfPresentAsync

java.util.concurrent.CompletableFuture<V> computeIfPresentAsync(K key,
                                                                java.util.function.BiFunction<? super K,? super V,? extends V> remappingFunction,
                                                                Metadata metadata)

Overloaded #computeIfPresentAsync(K, BiFunction), 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.

Parameters:

key - key with which the specified value is associated

remappingFunction - function to be applied to the specified key/value

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.

Since:

9.4

computeIfPresentAsync

default java.util.concurrent.CompletableFuture<V> computeIfPresentAsync(K key,
                                                                        SerializableBiFunction<? super K,? super V,? extends V> remappingFunction,
                                                                        Metadata metadata)

Overloaded computeIfPresentAsync(Object, BiFunction, Metadata) with SerializableBiFunction

Since:

9.4

computeIfAbsentAsync

java.util.concurrent.CompletableFuture<V> computeIfAbsentAsync(K key,
                                                               java.util.function.Function<? super K,? extends V> mappingFunction,
                                                               Metadata metadata)

Overloaded #computeIfAbsentAsync(K, Function), 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.

Parameters:

key - key with which the specified value is associated

mappingFunction - function to be applied to the specified key

metadata - information to store alongside the new value

Returns:

the value created with the mapping function associated with the specified key, or the previous value associated with the specified key if the key is not absent.

Since:

9.4

computeIfAbsentAsync

default java.util.concurrent.CompletableFuture<V> computeIfAbsentAsync(K key,
                                                                       SerializableFunction<? super K,? extends V> mappingFunction,
                                                                       Metadata metadata)

Overloaded computeIfAbsentAsync(Object, Function, Metadata) with SerializableFunction

Since:

9.4

mergeAsync

java.util.concurrent.CompletableFuture<V> mergeAsync(K key,
                                                     V value,
                                                     java.util.function.BiFunction<? super V,? super V,? extends V> remappingFunction,
                                                     long lifespan,
                                                     java.util.concurrent.TimeUnit lifespanUnit)

Overloaded AsyncCache.mergeAsync(Object, Object, BiFunction) which takes in lifespan parameters.

Specified by:

mergeAsync in interface AsyncCache<K,V>

Parameters:

key - key to use

value - new value to merge with existing value

remappingFunction - function to use to merge new and existing values into a merged value to store under key

lifespan - lifespan of the entry. Negative values are interpreted as unlimited lifespan.

lifespanUnit - time unit for lifespan

Returns:

the merged value that was stored under key

Since:

9.4

mergeAsync

java.util.concurrent.CompletableFuture<V> mergeAsync(K key,
                                                     V value,
                                                     java.util.function.BiFunction<? super V,? super V,? extends V> remappingFunction,
                                                     long lifespan,
                                                     java.util.concurrent.TimeUnit lifespanUnit,
                                                     long maxIdleTime,
                                                     java.util.concurrent.TimeUnit maxIdleTimeUnit)

Overloaded AsyncCache.mergeAsync(Object, Object, BiFunction) which takes in lifespan parameters.

Specified by:

mergeAsync in interface AsyncCache<K,V>

Parameters:

key - key to use

value - new value to merge with existing value

remappingFunction - function to use to merge new and existing values into a merged value to store under key

lifespan - lifespan of the entry. Negative values are interpreted as unlimited lifespan.

lifespanUnit - time unit for lifespan

maxIdleTime - the maximum amount of time this key is allowed to be idle for before it is considered as expired

maxIdleTimeUnit - time unit for max idle time

Returns:

the merged value that was stored under key

Since:

9.4

mergeAsync

java.util.concurrent.CompletableFuture<V> mergeAsync(K key,
                                                     V value,
                                                     java.util.function.BiFunction<? super V,? super V,? extends V> remappingFunction,
                                                     Metadata metadata)

Overloaded AsyncCache.mergeAsync(Object, Object, BiFunction), 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.

Parameters:

key, - key with which the resulting value is to be associated

value, - the non-null value to be merged with the existing value associated with the key or, if no existing value or a null value is associated with the key, to be associated with the key

remappingFunction, - the function to recompute a value if present

metadata, - information to store alongside the new value

Returns:

the new value associated with the specified key, or null if no value is associated with the key

Since:

9.4

mergeAsync

default java.util.concurrent.CompletableFuture<V> mergeAsync(K key,
                                                             V value,
                                                             SerializableBiFunction<? super V,? super V,? extends V> remappingFunction,
                                                             Metadata metadata)

Overloaded mergeAsync(Object, Object, BiFunction, Metadata) with SerializableBiFunction

getAll

java.util.Map<K,V> getAll(java.util.Set<?> keys)

Gets a collection of entries, returning them as Map of the values associated with the set of keys requested.

If the cache is configured read-through, and a get for a key would return null because an entry is missing from the cache, the Cache's CacheLoader is called in an attempt to load the entry. If an entry cannot be loaded for a given key, the returned Map will contain null for value of the key.

Unlike other bulk methods if this invoked in an existing transaction all entries will be stored in the current transactional context

The returned Map will be a copy and updates to the map will not be reflected in the Cache and vice versa. The keys and values themselves however may not be copies depending on if storeAsBinary is enabled and the value was retrieved from the local node.

Parameters:

keys - The keys whose associated values are to be returned.

Returns:

A map of entries that were found for the given keys. If an entry is not found for a given key, it will not be in the returned map.

Throws:

java.lang.NullPointerException - if keys is null or if keys contains a null

getCacheEntry

CacheEntry<K,V> getCacheEntry(java.lang.Object key)

Retrieves a CacheEntry corresponding to a specific key.

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

Since:

5.3

getCacheEntryAsync

default java.util.concurrent.CompletableFuture<CacheEntry<K,V>> getCacheEntryAsync(java.lang.Object key)

Retrieves a CacheEntry corresponding to a specific key.

Parameters:

key - the key whose associated cache entry is to be returned

Returns:

a future with the cache entry to which the specified key is mapped, or with null if this map contains no mapping for the key

Since:

9.2

getAllCacheEntries

java.util.Map<K,CacheEntry<K,V>> getAllCacheEntries(java.util.Set<?> keys)

Gets a collection of entries from the AdvancedCache, returning them as Map of the cache entries associated with the set of keys requested.

If the cache is configured read-through, and a get for a key would return null because an entry is missing from the cache, the Cache's CacheLoader is called in an attempt to load the entry. If an entry cannot be loaded for a given key, the returned Map will contain null for value of the key.

Unlike other bulk methods if this invoked in an existing transaction all entries will be stored in the current transactional context

The returned Map will be a copy and updates to the map will not be reflected in the Cache and vice versa. The keys and values themselves however may not be copies depending on if storeAsBinary is enabled and the value was retrieved from the local node.

Parameters:

keys - The keys whose associated values are to be returned.

Returns:

A map of entries that were found for the given keys. Keys not found in the cache are present in the map with null values.

Throws:

java.lang.NullPointerException - if keys is null or if keys contains a null

getAndPutAll

default java.util.Map<K,V> getAndPutAll(java.util.Map<? extends K,? extends V> map)

Executes an equivalent of Map.putAll(Map), returning previous values of the modified entries.

Parameters:

map - mappings to be stored in this map

Returns:

A map of previous values for the given keys. If the previous mapping does not exist it will not be in the returned map.

Since:

9.1

getGroup

java.util.Map<K,V> getGroup(java.lang.String groupName)

It fetches all the keys which belong to the group.

Semantically, it iterates over all the keys in memory and persistence, and performs a read operation in the keys found. Multiple invocations inside a transaction ensures that all the keys previous read are returned and it may return newly added keys to the group from other committed transactions (also known as phantom reads).

The map returned is immutable and represents the group at the time of the invocation. If you want to add or remove keys from a group use BasicCache.put(Object, Object) and BasicCache.remove(Object). To remove all the keys in the group use removeGroup(String).

To improve performance you may use the flag Flag.SKIP_CACHE_LOAD to avoid fetching the key/value from persistence. However, you will get an inconsistent snapshot of the group.

Parameters:

groupName - the group name.

Returns:

an immutable Map with the key/value pairs.

removeGroup

void removeGroup(java.lang.String groupName)

It removes all the key which belongs to a group.

Semantically, it fetches the most recent group keys/values and removes them.

Note that, concurrent addition perform by other transactions/threads to the group may not be removed.

Parameters:

groupName - the group name.

getAvailability

AvailabilityMode getAvailability()

Returns the cache's availability. In local mode this method will always return AvailabilityMode.AVAILABLE. In clustered mode, the PartitionHandlingManager is queried to obtain the availability mode.

setAvailability

void setAvailability(AvailabilityMode availabilityMode)

Manually change the availability of the cache. Doesn't change anything if the cache is not clustered or PartitionHandlingConfiguration#whenSplit() is set to {@link org.infinispan.partitionhandling.PartitionHandling#ALLOW_READ_WRITES }

cacheEntrySet

CacheSet<CacheEntry<K,V>> cacheEntrySet()

Identical to Cache.entrySet() but is typed to return CacheEntries instead of Entries. Please see the other method for a description of its behaviors.

This method is needed since nested generics do not support covariance

Returns:

the entry set containing all of the CacheEntries

See Also:

Cache.entrySet()

lockedStream

LockedStream<K,V> lockedStream()

Returns a sequential stream using this Cache as the source. This stream is very similar to using the CacheStream returned from the CacheCollection.stream() method of the collection returned via cacheEntrySet(). The use of this locked stream is that when an entry is being processed by the user the entry is locked for the invocation preventing a different thread from modifying it.

Note that this stream is not supported when using a optimistic transactional or simple cache. Both non transactional and pessimistic transactional caches are supported.

The stream will not share any ongoing transaction the user may have. Code executed by the stream should be treated as completely independent. That is any operation performed via the stream will require the user to start their own transaction or will be done intrinsically on the invocation. Note that if there is an ongoing transaction that has a lock on a key from the cache, that it will cause a deadlock.

Currently simple cache, ConfigurationBuilder.simpleCache(boolean) was set to true, and optimistic caches, TransactionConfigurationBuilder.lockingMode(LockingMode) was set to LockingMode.OPTIMISTIC, do not support this method. In this case it will throw an UnsupportedOperationException. This restriction may be removed in a future version. Also this method cannot be used on a cache that has a lock owner already specified via lockAs(Object) as this could lead to a deadlock or the release of locks early and will throw an IllegalStateException.

Returns:

the locked stream

Throws:

java.lang.UnsupportedOperationException - this is thrown if invoked from a cache that doesn't support this

java.lang.IllegalStateException - if this cache has already explicitly set a lock owner

Since:

9.1

removeLifespanExpired

java.util.concurrent.CompletableFuture<java.lang.Void> removeLifespanExpired(K key,
                                                                             V value,
                                                                             java.lang.Long lifespan)

Attempts to remove the entry if it is expired. Due to expired entries not being consistent across nodes, this will still attempt to remove the value if it is not present. Note that this will raise an expired event even if the entry is not present. Normally this method should never be invoked except by the ExpirationManager.

This command will only remove the value if the value and lifespan also match if provided.

This method will suspend any ongoing transaction and start a new one just for the invocation of this command. It is automatically committed or rolled back after the command completes, either successfully or via an exception.

NOTE: This method may be removed at any point including in a minor release and is not supported for external usage.

Parameters:

key - the key that is expiring

value - the value that mapped to the given. Null means it will match any value

lifespan - the lifespan that should match. If null is provided it will match any lifespan value

Returns:

if the entry was removed

removeMaxIdleExpired

java.util.concurrent.CompletableFuture<java.lang.Boolean> removeMaxIdleExpired(K key,
                                                                               V value)

Attempts to remove the entry for the given key, if it has expired due to max idle. This command first locks the key and then verifies that the entry has expired via maxIdle across all nodes. If it has this will then remove the given key.

This method returns a boolean when it has determined if the entry has expired. This is useful for when a backup node invokes this command for a get that found the entry expired. This way the node can return back to the caller much faster when the entry is not expired and do any additional processing asynchronously if needed.

This method will suspend any ongoing transaction and start a new one just for the invocation of this command. It is automatically committed or rolled back after the command completes, either successfully or via an exception.

NOTE: This method may be removed at any point including in a minor release and is not supported for external usage.

Parameters:

key - the key that expired via max idle for the given entry

Returns:

if the entry was removed

withEncoding

AdvancedCache<?,?> withEncoding(java.lang.Class<? extends Encoder> keyEncoder,
                                java.lang.Class<? extends Encoder> valueEncoder)

Performs any cache operations using the specified pair of Encoder.

Parameters:

keyEncoder - Encoder for the keys.

valueEncoder - Encoder for the values.

Returns:

an instance of AdvancedCache where all operations will use the supplied encoders.

withWrapping

AdvancedCache<K,V> withWrapping(java.lang.Class<? extends Wrapper> keyWrapper,
                                java.lang.Class<? extends Wrapper> valueWrapper)

Performs any cache operations using the specified pair of Wrapper.

Parameters:

keyWrapper - Wrapper for the keys.

valueWrapper - Wrapper for the values.

Returns:

AdvancedCache where all operations will use the supplied wrappers.

withEncoding

AdvancedCache<?,?> withEncoding(java.lang.Class<? extends Encoder> encoder)

Performs any cache operations using the specified Encoder.

Parameters:

encoder - Encoder used for both keys and values.

Returns:

an instance of AdvancedCache where all operations will use the supplied encoder.

withWrapping

AdvancedCache<K,V> withWrapping(java.lang.Class<? extends Wrapper> wrapper)

Performs any cache operations using the specified Wrapper.

Parameters:

wrapper - Wrapper for the keys and values.

Returns:

an instance of AdvancedCache where all operations will use the supplied wrapper.

withMediaType

AdvancedCache<?,?> withMediaType(java.lang.String keyMediaType,
                                 java.lang.String valueMediaType)

Perform any cache operations using an alternate MediaType.

Parameters:

keyMediaType - MediaType for the keys.

valueMediaType - org.infinispan.commons.dataconversion for the values.

Returns:

an instance of AdvancedCache where all data will formatted according to the supplied MediaType.

getKeyEncoder

Encoder getKeyEncoder()

Deprecated. Use getKeyDataConversion() and then DataConversion.getEncoder()

Returns:

The associated Encoder for the keys.

getValueEncoder

Encoder getValueEncoder()

Deprecated. Use getValueDataConversion() ()} and then DataConversion.getEncoder()

Returns:

The associated Encoder for the cache's values.

getKeyWrapper

Wrapper getKeyWrapper()

Deprecated. Use getKeyDataConversion() and then DataConversion.getWrapper()

Returns:

The associated Wrapper for the cache's keys.

getValueWrapper

Wrapper getValueWrapper()

Deprecated. Use getValueDataConversion() ()} and then DataConversion.getWrapper()

Returns:

The associated Wrapper for the cache's values.

getKeyDataConversion

DataConversion getKeyDataConversion()

Returns:

The associated DataConversion for the keys.

getValueDataConversion

DataConversion getValueDataConversion()

Returns:

The associated DataConversion for the cache's values.

withKeyEncoding

AdvancedCache<?,?> withKeyEncoding(java.lang.Class<? extends Encoder> encoder)