Package org.infinispan.client.hotrod.impl

Class RemoteCacheSupport<K,V>

java.lang.Object

org.infinispan.client.hotrod.impl.RemoteCacheSupport<K,V>

All Implemented Interfaces:

ConcurrentMap<K,V>, Map<K,V>, RemoteCache<K,V>, org.infinispan.commons.api.AsyncCache<K,V>, org.infinispan.commons.api.BasicCache<K,V>, org.infinispan.commons.api.Lifecycle, org.infinispan.commons.api.TransactionalCache

Direct Known Subclasses:

DelegatingRemoteCache, RemoteCacheImpl

public abstract class RemoteCacheSupport<K,V>
extends Object
implements RemoteCache<K,V>

Purpose: keep all delegating and unsupported methods in one place -> readability.

Since:

4.1

Author:

Mircea.Markus@jboss.com

Nested Class Summary

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

Map.Entry<K extends Object,V extends Object>

Field Summary

Fields

Modifier and Type	Field	Description
protected long	defaultLifespan
protected long	defaultMaxIdleTime

Constructor Summary

Constructors

Modifier	Constructor	Description
protected	RemoteCacheSupport()
protected	RemoteCacheSupport(long defaultLifespan, long defaultMaxIdleTime)

Method Summary

Modifier and Type	Method	Description
void	clear()
V	compute(K key, BiFunction<? super K,? super V,? extends V> remappingFunction)
V	compute(K key, BiFunction<? super K,? super V,? extends V> remappingFunction, long lifespan, TimeUnit lifespanUnit)
V	compute(K key, BiFunction<? super K,? super V,? extends V> remappingFunction, long lifespan, TimeUnit lifespanUnit, long maxIdleTime, TimeUnit maxIdleTimeUnit)
CompletableFuture<V>	computeAsync(K key, BiFunction<? super K,? super V,? extends V> remappingFunction)
CompletableFuture<V>	computeAsync(K key, BiFunction<? super K,? super V,? extends V> remappingFunction, long lifespan, TimeUnit lifespanUnit)
abstract CompletableFuture<V>	computeAsync(K key, BiFunction<? super K,? super V,? extends V> remappingFunction, long lifespan, TimeUnit lifespanUnit, long maxIdle, TimeUnit maxIdleUnit)
V	computeIfAbsent(K key, Function<? super K,? extends V> mappingFunction)
V	computeIfAbsent(K key, Function<? super K,? extends V> mappingFunction, long lifespan, TimeUnit lifespanUnit)
V	computeIfAbsent(K key, Function<? super K,? extends V> mappingFunction, long lifespan, TimeUnit lifespanUnit, long maxIdleTime, TimeUnit maxIdleTimeUnit)
CompletableFuture<V>	computeIfAbsentAsync(K key, Function<? super K,? extends V> mappingFunction)
CompletableFuture<V>	computeIfAbsentAsync(K key, Function<? super K,? extends V> mappingFunction, long lifespan, TimeUnit lifespanUnit)
abstract CompletableFuture<V>	computeIfAbsentAsync(K key, Function<? super K,? extends V> mappingFunction, long lifespan, TimeUnit lifespanUnit, long maxIdle, TimeUnit maxIdleUnit)
V	computeIfPresent(K key, BiFunction<? super K,? super V,? extends V> remappingFunction)
V	computeIfPresent(K key, BiFunction<? super K,? super V,? extends V> remappingFunction, long lifespan, TimeUnit lifespanUnit)
V	computeIfPresent(K key, BiFunction<? super K,? super V,? extends V> remappingFunction, long lifespan, TimeUnit lifespanUnit, long maxIdleTime, TimeUnit maxIdleTimeUnit)
CompletableFuture<V>	computeIfPresentAsync(K key, BiFunction<? super K,? super V,? extends V> remappingFunction)
CompletableFuture<V>	computeIfPresentAsync(K key, BiFunction<? super K,? super V,? extends V> remappingFunction, long lifespan, TimeUnit lifespanUnit)
abstract CompletableFuture<V>	computeIfPresentAsync(K key, BiFunction<? super K,? super V,? extends V> remappingFunction, long lifespan, TimeUnit lifespanUnit, long maxIdle, TimeUnit maxIdleUnit)
boolean	containsKey(Object key)
abstract CompletableFuture<Boolean>	containsKeyAsync(K key)
V	get(Object key)
Map<K,V>	getAll(Set<? extends K> keys)	Retrieves all of the entries for the provided keys.
abstract CompletableFuture<Map<K,V>>	getAllAsync(Set<?> keys)
abstract CompletableFuture<V>	getAsync(K key)
MetadataValue<V>	getWithMetadata(K key)	Returns the MetadataValue associated to the supplied key param, or null if it doesn't exist.
abstract CompletableFuture<MetadataValue<V>>	getWithMetadataAsync(K key)	Asynchronously returns the MetadataValue associated to the supplied key param, or null if it doesn't exist.
V	merge(K key, V value, BiFunction<? super V,? super V,? extends V> remappingFunction)
V	merge(K key, V value, BiFunction<? super V,? super V,? extends V> remappingFunction, long lifespan, TimeUnit lifespanUnit)
V	merge(K key, V value, BiFunction<? super V,? super V,? extends V> remappingFunction, long lifespan, TimeUnit lifespanUnit, long maxIdleTime, TimeUnit maxIdleTimeUnit)
CompletableFuture<V>	mergeAsync(K key, V value, BiFunction<? super V,? super V,? extends V> remappingFunction)
CompletableFuture<V>	mergeAsync(K key, V value, BiFunction<? super V,? super V,? extends V> remappingFunction, long lifespan, TimeUnit lifespanUnit)
abstract CompletableFuture<V>	mergeAsync(K key, V value, BiFunction<? super V,? super V,? extends V> remappingFunction, long lifespan, TimeUnit lifespanUnit, long maxIdleTime, TimeUnit maxIdleTimeUnit)
V	put(K key, V value)
V	put(K key, V value, long lifespan, TimeUnit unit)
V	put(K key, V value, long lifespan, TimeUnit lifespanUnit, long maxIdleTime, TimeUnit maxIdleTimeUnit)
void	putAll(Map<? extends K,? extends V> map)	Adds or overrides each specified entry in the remote cache.
void	putAll(Map<? extends K,? extends V> map, long lifespan, TimeUnit unit)	Adds or overrides each specified entry in the remote cache.
void	putAll(Map<? extends K,? extends V> map, long lifespan, TimeUnit lifespanUnit, long maxIdleTime, TimeUnit maxIdleTimeUnit)	Adds or overrides each specified entry in the remote cache.
CompletableFuture<Void>	putAllAsync(Map<? extends K,? extends V> data)	Adds or overrides each specified entry in the remote cache.
CompletableFuture<Void>	putAllAsync(Map<? extends K,? extends V> data, long lifespan, TimeUnit unit)	Adds or overrides each specified entry in the remote cache.
abstract CompletableFuture<Void>	putAllAsync(Map<? extends K,? extends V> data, long lifespan, TimeUnit lifespanUnit, long maxIdle, TimeUnit maxIdleUnit)	Adds or overrides each specified entry in the remote cache.
CompletableFuture<V>	putAsync(K key, V value)
CompletableFuture<V>	putAsync(K key, V value, long lifespan, TimeUnit unit)
abstract CompletableFuture<V>	putAsync(K key, V value, long lifespan, TimeUnit lifespanUnit, long maxIdle, TimeUnit maxIdleUnit)
V	putIfAbsent(K key, V value)
V	putIfAbsent(K key, V value, long lifespan, TimeUnit unit)
V	putIfAbsent(K key, V value, long lifespan, TimeUnit lifespanUnit, long maxIdleTime, TimeUnit maxIdleTimeUnit)
CompletableFuture<V>	putIfAbsentAsync(K key, V value)
CompletableFuture<V>	putIfAbsentAsync(K key, V value, long lifespan, TimeUnit lifespanUnit)
abstract CompletableFuture<V>	putIfAbsentAsync(K key, V value, long lifespan, TimeUnit lifespanUnit, long maxIdle, TimeUnit maxIdleUnit)
V	remove(Object key)
boolean	remove(Object key, Object value)
abstract CompletableFuture<V>	removeAsync(Object key)
abstract CompletableFuture<Boolean>	removeAsync(Object key, Object value)
boolean	removeWithVersion(K key, long version)	Removes the given entry only if its version matches the supplied version.
abstract CompletableFuture<Boolean>	removeWithVersionAsync(K key, long version)
V	replace(K key, V value)
V	replace(K key, V value, long lifespan, TimeUnit unit)
V	replace(K key, V value, long lifespan, TimeUnit lifespanUnit, long maxIdleTime, TimeUnit maxIdleTimeUnit)
boolean	replace(K key, V oldValue, V newValue)
boolean	replace(K key, V oldValue, V value, long lifespan, TimeUnit unit)
boolean	replace(K key, V oldValue, V value, long lifespan, TimeUnit lifespanUnit, long maxIdleTime, TimeUnit maxIdleTimeUnit)
abstract void	replaceAll(BiFunction<? super K,? super V,? extends V> function)
CompletableFuture<V>	replaceAsync(K key, V value)
CompletableFuture<V>	replaceAsync(K key, V value, long lifespan, TimeUnit unit)
abstract CompletableFuture<V>	replaceAsync(K key, V value, long lifespan, TimeUnit lifespanUnit, long maxIdle, TimeUnit maxIdleUnit)
CompletableFuture<Boolean>	replaceAsync(K key, V oldValue, V newValue)
CompletableFuture<Boolean>	replaceAsync(K key, V oldValue, V newValue, long lifespan, TimeUnit unit)
abstract CompletableFuture<Boolean>	replaceAsync(K key, V oldValue, V newValue, long lifespan, TimeUnit lifespanUnit, long maxIdle, TimeUnit maxIdleUnit)
boolean	replaceWithVersion(K key, V newValue, long version)	Replaces the given value only if its version matches the supplied version.
boolean	replaceWithVersion(K key, V newValue, long version, int lifespanSeconds)	A overloaded form of RemoteCache.replaceWithVersion(Object, Object, long) which takes in lifespan parameters.
boolean	replaceWithVersion(K key, V newValue, long version, int lifespanSeconds, int maxIdleTimeSeconds)	A overloaded form of RemoteCache.replaceWithVersion(Object, Object, long) which takes in lifespan and maximum idle time parameters.
boolean	replaceWithVersion(K key, V newValue, long version, long lifespan, TimeUnit lifespanTimeUnit, long maxIdle, TimeUnit maxIdleTimeUnit)	A overloaded form of RemoteCache.replaceWithVersion(Object, Object, long) which takes in lifespan and maximum idle time parameters.
CompletableFuture<Boolean>	replaceWithVersionAsync(K key, V newValue, long version)
CompletableFuture<Boolean>	replaceWithVersionAsync(K key, V newValue, long version, int lifespanSeconds)
CompletableFuture<Boolean>	replaceWithVersionAsync(K key, V newValue, long version, int lifespanSeconds, int maxIdleSeconds)
int	size()
abstract CompletableFuture<Long>	sizeAsync()

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

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

clearAsync

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

getName, getVersion

Methods inherited from interface java.util.concurrent.ConcurrentMap

forEach, getOrDefault

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

start, stop

Methods inherited from interface java.util.Map

containsValue, equals, hashCode, isEmpty

Methods inherited from interface org.infinispan.client.hotrod.RemoteCache

addClientListener, addClientListener, clientStatistics, entrySet, entrySet, execute, execute, execute, getCacheTopologyInfo, getDataFormat, getListeners, getProtocolVersion, getRemoteCacheManager, isTransactional, keySet, keySet, publishEntries, publishEntriesByQuery, publishEntriesWithMetadata, removeClientListener, replaceWithVersionAsync, retrieveEntries, retrieveEntries, retrieveEntries, retrieveEntriesByQuery, retrieveEntriesWithMetadata, serverStatistics, serverStatisticsAsync, stats, streaming, values, values, withDataFormat, withFlags

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

getTransactionManager

Field Detail

defaultLifespan

protected long defaultLifespan

defaultMaxIdleTime

protected long defaultMaxIdleTime

Constructor Detail

RemoteCacheSupport

protected RemoteCacheSupport()

RemoteCacheSupport

protected RemoteCacheSupport(long defaultLifespan,
                             long defaultMaxIdleTime)

Method Detail

putAll

public final void putAll(Map<? extends K,? extends V> map)

Description copied from interface: RemoteCache

Adds or overrides each specified entry in the remote cache. This operation provides better performance than calling put() for each entry.

Specified by:

putAll in interface Map<K,V>

Specified by:

putAll in interface RemoteCache<K,V>

See Also:

RemoteCache.putAll(java.util.Map, long, java.util.concurrent.TimeUnit)

putAll

public final void putAll(Map<? extends K,? extends V> map,
                         long lifespan,
                         TimeUnit unit)

Description copied from interface: RemoteCache

Adds or overrides each specified entry in the remote cache. This operation provides better performance than calling put() for each entry.

Specified by:

putAll in interface org.infinispan.commons.api.BasicCache<K,V>

Specified by:

putAll in interface RemoteCache<K,V>

putAll

public final void putAll(Map<? extends K,? extends V> map,
                         long lifespan,
                         TimeUnit lifespanUnit,
                         long maxIdleTime,
                         TimeUnit maxIdleTimeUnit)

Description copied from interface: RemoteCache

Adds or overrides each specified entry in the remote cache. This operation provides better performance than calling put() for each entry.

Specified by:

putAll in interface org.infinispan.commons.api.BasicCache<K,V>

Specified by:

putAll in interface RemoteCache<K,V>

See Also:

RemoteCache.putAll(java.util.Map, long, java.util.concurrent.TimeUnit)

putAllAsync

public final CompletableFuture<Void> putAllAsync(Map<? extends K,? extends V> data)

Description copied from interface: RemoteCache

Adds or overrides each specified entry in the remote cache. This operation provides better performance than calling put() for each entry.

Specified by:

putAllAsync in interface org.infinispan.commons.api.AsyncCache<K,V>

Specified by:

putAllAsync in interface RemoteCache<K,V>

See Also:

RemoteCache.putAll(java.util.Map, long, java.util.concurrent.TimeUnit)

putAllAsync

public final CompletableFuture<Void> putAllAsync(Map<? extends K,? extends V> data,
                                                 long lifespan,
                                                 TimeUnit unit)

Description copied from interface: RemoteCache

Adds or overrides each specified entry in the remote cache. This operation provides better performance than calling put() for each entry.

Specified by:

putAllAsync in interface org.infinispan.commons.api.AsyncCache<K,V>

Specified by:

putAllAsync in interface RemoteCache<K,V>

See Also:

RemoteCache.putAll(java.util.Map, long, java.util.concurrent.TimeUnit)

putAllAsync

public abstract CompletableFuture<Void> putAllAsync(Map<? extends K,? extends V> data,
                                                    long lifespan,
                                                    TimeUnit lifespanUnit,
                                                    long maxIdle,
                                                    TimeUnit maxIdleUnit)

Description copied from interface: RemoteCache

Adds or overrides each specified entry in the remote cache. This operation provides better performance than calling put() for each entry.

Specified by:

putAllAsync in interface org.infinispan.commons.api.AsyncCache<K,V>

Specified by:

putAllAsync in interface RemoteCache<K,V>

See Also:

RemoteCache.putAll(java.util.Map, long, java.util.concurrent.TimeUnit)

putIfAbsent

public final V putIfAbsent(K key,
                           V value)

Specified by:

putIfAbsent in interface ConcurrentMap<K,V>

Specified by:

putIfAbsent in interface Map<K,V>

putIfAbsent

public final V putIfAbsent(K key,
                           V value,
                           long lifespan,
                           TimeUnit unit)

Specified by:

putIfAbsent in interface org.infinispan.commons.api.BasicCache<K,V>

putIfAbsent

public final V putIfAbsent(K key,
                           V value,
                           long lifespan,
                           TimeUnit lifespanUnit,
                           long maxIdleTime,
                           TimeUnit maxIdleTimeUnit)

Specified by:

putIfAbsent in interface org.infinispan.commons.api.BasicCache<K,V>

putIfAbsentAsync

public final CompletableFuture<V> putIfAbsentAsync(K key,
                                                   V value)

Specified by:

putIfAbsentAsync in interface org.infinispan.commons.api.AsyncCache<K,V>

putIfAbsentAsync

public final CompletableFuture<V> putIfAbsentAsync(K key,
                                                   V value,
                                                   long lifespan,
                                                   TimeUnit lifespanUnit)

Specified by:

putIfAbsentAsync in interface org.infinispan.commons.api.AsyncCache<K,V>

putIfAbsentAsync

public abstract CompletableFuture<V> putIfAbsentAsync(K key,
                                                      V value,
                                                      long lifespan,
                                                      TimeUnit lifespanUnit,
                                                      long maxIdle,
                                                      TimeUnit maxIdleUnit)

Specified by:

putIfAbsentAsync in interface org.infinispan.commons.api.AsyncCache<K,V>

replace

public final boolean replace(K key,
                             V oldValue,
                             V newValue)

Description copied from interface: RemoteCache

This method requires 2 round trips to the server. The first to retrieve the value and version and a second to replace the key with the version if the value matches. If possible user should use RemoteCache.getWithMetadata(Object) and RemoteCache.replaceWithVersion(Object, Object, long).

Specified by:

replace in interface ConcurrentMap<K,V>

Specified by:

replace in interface Map<K,V>

Specified by:

replace in interface RemoteCache<K,V>

replace

public final boolean replace(K key,
                             V oldValue,
                             V value,
                             long lifespan,
                             TimeUnit unit)

Description copied from interface: RemoteCache

This method requires 2 round trips to the server. The first to retrieve the value and version and a second to replace the key with the version if the value matches. If possible user should use RemoteCache.getWithMetadata(Object) and RemoteCache.replaceWithVersion(Object, Object, long, long, TimeUnit, long, TimeUnit).

Specified by:

replace in interface org.infinispan.commons.api.BasicCache<K,V>

Specified by:

replace in interface RemoteCache<K,V>

replace

public final boolean replace(K key,
                             V oldValue,
                             V value,
                             long lifespan,
                             TimeUnit lifespanUnit,
                             long maxIdleTime,
                             TimeUnit maxIdleTimeUnit)

Description copied from interface: RemoteCache

This method requires 2 round trips to the server. The first to retrieve the value and version and a second to replace the key with the version if the value matches. If possible user should use RemoteCache.getWithMetadata(Object) and RemoteCache.replaceWithVersion(Object, Object, long, long, TimeUnit, long, TimeUnit) if possible.

Specified by:

replace in interface org.infinispan.commons.api.BasicCache<K,V>

Specified by:

replace in interface RemoteCache<K,V>

replaceAsync

public final CompletableFuture<Boolean> replaceAsync(K key,
                                                     V oldValue,
                                                     V newValue)

Specified by:

replaceAsync in interface org.infinispan.commons.api.AsyncCache<K,V>

replaceAsync

public final CompletableFuture<Boolean> replaceAsync(K key,
                                                     V oldValue,
                                                     V newValue,
                                                     long lifespan,
                                                     TimeUnit unit)

Specified by:

replaceAsync in interface org.infinispan.commons.api.AsyncCache<K,V>

replaceAsync

public abstract CompletableFuture<Boolean> replaceAsync(K key,
                                                        V oldValue,
                                                        V newValue,
                                                        long lifespan,
                                                        TimeUnit lifespanUnit,
                                                        long maxIdle,
                                                        TimeUnit maxIdleUnit)

Specified by:

replaceAsync in interface org.infinispan.commons.api.AsyncCache<K,V>

replace

public final V replace(K key,
                       V value)

Specified by:

replace in interface ConcurrentMap<K,V>

Specified by:

replace in interface Map<K,V>

replace

public final V replace(K key,
                       V value,
                       long lifespan,
                       TimeUnit unit)

Specified by:

replace in interface org.infinispan.commons.api.BasicCache<K,V>

replace

public final V replace(K key,
                       V value,
                       long lifespan,
                       TimeUnit lifespanUnit,
                       long maxIdleTime,
                       TimeUnit maxIdleTimeUnit)

Specified by:

replace in interface org.infinispan.commons.api.BasicCache<K,V>

replaceAsync

public final CompletableFuture<V> replaceAsync(K key,
                                               V value)

Specified by:

replaceAsync in interface org.infinispan.commons.api.AsyncCache<K,V>

replaceAsync

public final CompletableFuture<V> replaceAsync(K key,
                                               V value,
                                               long lifespan,
                                               TimeUnit unit)

Specified by:

replaceAsync in interface org.infinispan.commons.api.AsyncCache<K,V>

replaceAsync

public abstract CompletableFuture<V> replaceAsync(K key,
                                                  V value,
                                                  long lifespan,
                                                  TimeUnit lifespanUnit,
                                                  long maxIdle,
                                                  TimeUnit maxIdleUnit)

Specified by:

replaceAsync in interface org.infinispan.commons.api.AsyncCache<K,V>

get

public final V get(Object key)

Specified by:

get in interface Map<K,V>

getAsync

public abstract CompletableFuture<V> getAsync(K key)

Specified by:

getAsync in interface org.infinispan.commons.api.AsyncCache<K,V>

getAll

public final Map<K,V> getAll(Set<? extends K> keys)

Description copied from interface: RemoteCache

Retrieves all of the entries for the provided keys. A key will not be present in the resulting map if the entry was not found in the cache.

Specified by:

getAll in interface RemoteCache<K,V>

Parameters:

keys - The keys to find values for

Returns:

The entries that were present for the given keys

getAllAsync

public abstract CompletableFuture<Map<K,V>> getAllAsync(Set<?> keys)

Specified by:

getAllAsync in interface org.infinispan.commons.api.AsyncCache<K,V>

getWithMetadata

public final MetadataValue<V> getWithMetadata(K key)

Description copied from interface: RemoteCache

Returns the MetadataValue associated to the supplied key param, or null if it doesn't exist.

Specified by:

getWithMetadata in interface RemoteCache<K,V>

getWithMetadataAsync

public abstract CompletableFuture<MetadataValue<V>> getWithMetadataAsync(K key)

Description copied from interface: RemoteCache

Asynchronously returns the MetadataValue associated to the supplied key param, or null if it doesn't exist.

Specified by:

getWithMetadataAsync in interface RemoteCache<K,V>

containsKey

public final boolean containsKey(Object key)

Specified by:

containsKey in interface Map<K,V>

containsKeyAsync

public abstract CompletableFuture<Boolean> containsKeyAsync(K key)

Specified by:

containsKeyAsync in interface org.infinispan.commons.api.AsyncCache<K,V>

put

public final V put(K key,
                   V value)

Specified by:

put in interface org.infinispan.commons.api.BasicCache<K,V>

Specified by:

put in interface Map<K,V>

put

public final V put(K key,
                   V value,
                   long lifespan,
                   TimeUnit unit)

Specified by:

put in interface org.infinispan.commons.api.BasicCache<K,V>

put

public final V put(K key,
                   V value,
                   long lifespan,
                   TimeUnit lifespanUnit,
                   long maxIdleTime,
                   TimeUnit maxIdleTimeUnit)

Specified by:

put in interface org.infinispan.commons.api.BasicCache<K,V>

putAsync

public final CompletableFuture<V> putAsync(K key,
                                           V value)

Specified by:

putAsync in interface org.infinispan.commons.api.AsyncCache<K,V>

putAsync

public final CompletableFuture<V> putAsync(K key,
                                           V value,
                                           long lifespan,
                                           TimeUnit unit)

Specified by:

putAsync in interface org.infinispan.commons.api.AsyncCache<K,V>

putAsync

public abstract CompletableFuture<V> putAsync(K key,
                                              V value,
                                              long lifespan,
                                              TimeUnit lifespanUnit,
                                              long maxIdle,
                                              TimeUnit maxIdleUnit)

Specified by:

putAsync in interface org.infinispan.commons.api.AsyncCache<K,V>

replaceWithVersion

public final boolean replaceWithVersion(K key,
                                        V newValue,
                                        long version)

Description copied from interface: RemoteCache

Replaces the given value only if its version matches the supplied version. See RemoteCache.removeWithVersion(Object, long) for a sample usage of the version-based methods.

Specified by:

replaceWithVersion in interface RemoteCache<K,V>

version - numeric version that should match the one in the server for the operation to succeed

Returns:

true if the value has been replaced

See Also:

RemoteCache.getWithMetadata(Object), VersionedValue

replaceWithVersion

public final boolean replaceWithVersion(K key,
                                        V newValue,
                                        long version,
                                        int lifespanSeconds)

Description copied from interface: RemoteCache

A overloaded form of RemoteCache.replaceWithVersion(Object, Object, long) which takes in lifespan parameters.

Specified by:

replaceWithVersion in interface RemoteCache<K,V>

Parameters:

key - key to use

newValue - new value to be associated with the key

version - numeric version that should match the one in the server for the operation to succeed

lifespanSeconds - lifespan of the entry

Returns:

true if the value was replaced

replaceWithVersion

public final boolean replaceWithVersion(K key,
                                        V newValue,
                                        long version,
                                        int lifespanSeconds,
                                        int maxIdleTimeSeconds)

Description copied from interface: RemoteCache

A overloaded form of RemoteCache.replaceWithVersion(Object, Object, long) which takes in lifespan and maximum idle time parameters.

Specified by:

replaceWithVersion in interface RemoteCache<K,V>

Parameters:

key - key to use

newValue - new value to be associated with the key

version - numeric version that should match the one in the server for the operation to succeed

lifespanSeconds - lifespan of the entry

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

Returns:

true if the value was replaced

replaceWithVersion

public final boolean replaceWithVersion(K key,
                                        V newValue,
                                        long version,
                                        long lifespan,
                                        TimeUnit lifespanTimeUnit,
                                        long maxIdle,
                                        TimeUnit maxIdleTimeUnit)

Description copied from interface: RemoteCache

A overloaded form of RemoteCache.replaceWithVersion(Object, Object, long) which takes in lifespan and maximum idle time parameters.

Specified by:

replaceWithVersion in interface RemoteCache<K,V>

Parameters:

key - key to use

newValue - new value to be associated with the key

version - numeric version that should match the one in the server for the operation to succeed

lifespan - lifespan of the entry

lifespanTimeUnit - TimeUnit for lifespan

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

maxIdleTimeUnit - TimeUnit for maxIdle

Returns:

true if the value was replaced

replaceWithVersionAsync

public final CompletableFuture<Boolean> replaceWithVersionAsync(K key,
                                                                V newValue,
                                                                long version)

Specified by:

replaceWithVersionAsync in interface RemoteCache<K,V>

See Also:

RemoteCache.replaceWithVersion(Object, Object, long)

replaceWithVersionAsync

public final CompletableFuture<Boolean> replaceWithVersionAsync(K key,
                                                                V newValue,
                                                                long version,
                                                                int lifespanSeconds)

Specified by:

replaceWithVersionAsync in interface RemoteCache<K,V>

See Also:

RemoteCache.replaceWithVersion(Object, Object, long)

replaceWithVersionAsync

public final CompletableFuture<Boolean> replaceWithVersionAsync(K key,
                                                                V newValue,
                                                                long version,
                                                                int lifespanSeconds,
                                                                int maxIdleSeconds)

Specified by:

replaceWithVersionAsync in interface RemoteCache<K,V>

See Also:

RemoteCache.replaceWithVersion(Object, Object, long)

remove

public final V remove(Object key)

Description copied from interface: RemoteCache

The returned value is only sent back if Flag.FORCE_RETURN_VALUE is enabled.

Specified by:

remove in interface org.infinispan.commons.api.BasicCache<K,V>

Specified by:

remove in interface Map<K,V>

Specified by:

remove in interface RemoteCache<K,V>

removeAsync

public abstract CompletableFuture<V> removeAsync(Object key)

Specified by:

removeAsync in interface org.infinispan.commons.api.AsyncCache<K,V>

remove

public final boolean remove(Object key,
                            Object value)

Description copied from interface: RemoteCache

This method requires 2 round trips to the server. The first to retrieve the value and version and a second to remove the key with the version if the value matches. If possible user should use RemoteCache.getWithMetadata(Object) and RemoteCache.removeWithVersion(Object, long).

Specified by:

remove in interface ConcurrentMap<K,V>

Specified by:

remove in interface Map<K,V>

Specified by:

remove in interface RemoteCache<K,V>

removeAsync

public abstract CompletableFuture<Boolean> removeAsync(Object key,
                                                       Object value)

Specified by:

removeAsync in interface org.infinispan.commons.api.AsyncCache<K,V>

removeWithVersion

public final boolean removeWithVersion(K key,
                                       long version)

Description copied from interface: RemoteCache

Removes the given entry only if its version matches the supplied version. A typical use case looks like this:

 VersionedEntry ve = remoteCache.getVersioned(key);
 //some processing
 remoteCache.removeWithVersion(key, ve.getVersion();
 

Lat call (removeWithVersion) will make sure that the entry will only be removed if it hasn't been changed in between.

Specified by:

removeWithVersion in interface RemoteCache<K,V>

Returns:

true if the entry has been removed

See Also:

VersionedValue, RemoteCache.getWithMetadata(Object)

removeWithVersionAsync

public abstract CompletableFuture<Boolean> removeWithVersionAsync(K key,
                                                                  long version)

Specified by:

removeWithVersionAsync in interface RemoteCache<K,V>

See Also:

RemoteCache.remove(Object, Object)

merge

public final V merge(K key,
                     V value,
                     BiFunction<? super V,? super V,? extends V> remappingFunction)

Specified by:

merge in interface ConcurrentMap<K,V>

Specified by:

merge in interface Map<K,V>

merge

public final V merge(K key,
                     V value,
                     BiFunction<? super V,? super V,? extends V> remappingFunction,
                     long lifespan,
                     TimeUnit lifespanUnit)

Specified by:

merge in interface org.infinispan.commons.api.BasicCache<K,V>

merge

public final V merge(K key,
                     V value,
                     BiFunction<? super V,? super V,? extends V> remappingFunction,
                     long lifespan,
                     TimeUnit lifespanUnit,
                     long maxIdleTime,
                     TimeUnit maxIdleTimeUnit)

Specified by:

merge in interface org.infinispan.commons.api.BasicCache<K,V>

mergeAsync

public final CompletableFuture<V> mergeAsync(K key,
                                             V value,
                                             BiFunction<? super V,? super V,? extends V> remappingFunction)

Specified by:

mergeAsync in interface org.infinispan.commons.api.AsyncCache<K,V>

mergeAsync

public final CompletableFuture<V> mergeAsync(K key,
                                             V value,
                                             BiFunction<? super V,? super V,? extends V> remappingFunction,
                                             long lifespan,
                                             TimeUnit lifespanUnit)

Specified by:

mergeAsync in interface org.infinispan.commons.api.AsyncCache<K,V>

mergeAsync

public abstract CompletableFuture<V> mergeAsync(K key,
                                                V value,
                                                BiFunction<? super V,? super V,? extends V> remappingFunction,
                                                long lifespan,
                                                TimeUnit lifespanUnit,
                                                long maxIdleTime,
                                                TimeUnit maxIdleTimeUnit)

Specified by:

mergeAsync in interface org.infinispan.commons.api.AsyncCache<K,V>

clear

public final void clear()

Specified by:

clear in interface Map<K,V>

compute

public final V compute(K key,
                       BiFunction<? super K,? super V,? extends V> remappingFunction)

Specified by:

compute in interface ConcurrentMap<K,V>

Specified by:

compute in interface Map<K,V>

compute

public final V compute(K key,
                       BiFunction<? super K,? super V,? extends V> remappingFunction,
                       long lifespan,
                       TimeUnit lifespanUnit)

Specified by:

compute in interface org.infinispan.commons.api.BasicCache<K,V>

compute

public final V compute(K key,
                       BiFunction<? super K,? super V,? extends V> remappingFunction,
                       long lifespan,
                       TimeUnit lifespanUnit,
                       long maxIdleTime,
                       TimeUnit maxIdleTimeUnit)

Specified by:

compute in interface org.infinispan.commons.api.BasicCache<K,V>

computeAsync

public final CompletableFuture<V> computeAsync(K key,
                                               BiFunction<? super K,? super V,? extends V> remappingFunction)

Specified by:

computeAsync in interface org.infinispan.commons.api.AsyncCache<K,V>

computeAsync

public final CompletableFuture<V> computeAsync(K key,
                                               BiFunction<? super K,? super V,? extends V> remappingFunction,
                                               long lifespan,
                                               TimeUnit lifespanUnit)

Specified by:

computeAsync in interface org.infinispan.commons.api.AsyncCache<K,V>

computeAsync

public abstract CompletableFuture<V> computeAsync(K key,
                                                  BiFunction<? super K,? super V,? extends V> remappingFunction,
                                                  long lifespan,
                                                  TimeUnit lifespanUnit,
                                                  long maxIdle,
                                                  TimeUnit maxIdleUnit)

Specified by:

computeAsync in interface org.infinispan.commons.api.AsyncCache<K,V>

computeIfAbsent

public final V computeIfAbsent(K key,
                               Function<? super K,? extends V> mappingFunction)

Specified by:

computeIfAbsent in interface ConcurrentMap<K,V>

Specified by:

computeIfAbsent in interface Map<K,V>

computeIfAbsent

public final V computeIfAbsent(K key,
                               Function<? super K,? extends V> mappingFunction,
                               long lifespan,
                               TimeUnit lifespanUnit)

Specified by:

computeIfAbsent in interface org.infinispan.commons.api.BasicCache<K,V>

computeIfAbsent

public final V computeIfAbsent(K key,
                               Function<? super K,? extends V> mappingFunction,
                               long lifespan,
                               TimeUnit lifespanUnit,
                               long maxIdleTime,
                               TimeUnit maxIdleTimeUnit)

Specified by:

computeIfAbsent in interface org.infinispan.commons.api.BasicCache<K,V>

computeIfAbsentAsync

public final CompletableFuture<V> computeIfAbsentAsync(K key,
                                                       Function<? super K,? extends V> mappingFunction)

Specified by:

computeIfAbsentAsync in interface org.infinispan.commons.api.AsyncCache<K,V>

computeIfAbsentAsync

public final CompletableFuture<V> computeIfAbsentAsync(K key,
                                                       Function<? super K,? extends V> mappingFunction,
                                                       long lifespan,
                                                       TimeUnit lifespanUnit)

Specified by:

computeIfAbsentAsync in interface org.infinispan.commons.api.AsyncCache<K,V>

computeIfAbsentAsync

public abstract CompletableFuture<V> computeIfAbsentAsync(K key,
                                                          Function<? super K,? extends V> mappingFunction,
                                                          long lifespan,
                                                          TimeUnit lifespanUnit,
                                                          long maxIdle,
                                                          TimeUnit maxIdleUnit)

Specified by:

computeIfAbsentAsync in interface org.infinispan.commons.api.AsyncCache<K,V>

computeIfPresent

public final V computeIfPresent(K key,
                                BiFunction<? super K,? super V,? extends V> remappingFunction)

Specified by:

computeIfPresent in interface ConcurrentMap<K,V>

Specified by:

computeIfPresent in interface Map<K,V>

computeIfPresent

public final V computeIfPresent(K key,
                                BiFunction<? super K,? super V,? extends V> remappingFunction,
                                long lifespan,
                                TimeUnit lifespanUnit)

Specified by:

computeIfPresent in interface org.infinispan.commons.api.BasicCache<K,V>

computeIfPresent

public final V computeIfPresent(K key,
                                BiFunction<? super K,? super V,? extends V> remappingFunction,
                                long lifespan,
                                TimeUnit lifespanUnit,
                                long maxIdleTime,
                                TimeUnit maxIdleTimeUnit)

Specified by:

computeIfPresent in interface org.infinispan.commons.api.BasicCache<K,V>

computeIfPresentAsync

public final CompletableFuture<V> computeIfPresentAsync(K key,
                                                        BiFunction<? super K,? super V,? extends V> remappingFunction)

Specified by:

computeIfPresentAsync in interface org.infinispan.commons.api.AsyncCache<K,V>

computeIfPresentAsync

public final CompletableFuture<V> computeIfPresentAsync(K key,
                                                        BiFunction<? super K,? super V,? extends V> remappingFunction,
                                                        long lifespan,
                                                        TimeUnit lifespanUnit)

Specified by:

computeIfPresentAsync in interface org.infinispan.commons.api.AsyncCache<K,V>

computeIfPresentAsync

public abstract CompletableFuture<V> computeIfPresentAsync(K key,
                                                           BiFunction<? super K,? super V,? extends V> remappingFunction,
                                                           long lifespan,
                                                           TimeUnit lifespanUnit,
                                                           long maxIdle,
                                                           TimeUnit maxIdleUnit)

Specified by:

computeIfPresentAsync in interface org.infinispan.commons.api.AsyncCache<K,V>

replaceAll

public abstract void replaceAll(BiFunction<? super K,? super V,? extends V> function)

Specified by:

replaceAll in interface ConcurrentMap<K,V>

Specified by:

replaceAll in interface Map<K,V>

size

public final int size()

Specified by:

size in interface Map<K,V>

sizeAsync

public abstract CompletableFuture<Long> sizeAsync()

Specified by:

sizeAsync in interface org.infinispan.commons.api.AsyncCache<K,V>