org.infinispan

Class CacheSupport<K,V>

java.lang.Object

org.infinispan.CacheSupport<K,V>

All Implemented Interfaces:

org.infinispan.api.BasicCache<K,V>

public abstract class CacheSupport<K,V>
extends java.lang.Object
implements org.infinispan.api.BasicCache<K,V>

Since:

4.1

Author:

Mircea.Markus@jboss.com

Field Summary

Fields

Modifier and Type	Field and Description
protected long	defaultLifespan
protected long	defaultMaxIdleTime

Constructor Summary

Constructors

Modifier	Constructor and Description
protected	CacheSupport()
protected	CacheSupport(long defaultLifespan, long defaultMaxIdleTime)

Method Summary

Methods

Modifier and Type	Method and Description
V	put(K key, V value)
V	put(K key, V value, long lifespan, java.util.concurrent.TimeUnit unit)
void	putAll(java.util.Map<? extends K,? extends V> map)
void	putAll(java.util.Map<? extends K,? extends V> map, long lifespan, java.util.concurrent.TimeUnit unit)
org.infinispan.util.concurrent.NotifyingFuture<java.lang.Void>	putAllAsync(java.util.Map<? extends K,? extends V> data) Asynchronous version of #putAll(Map).
org.infinispan.util.concurrent.NotifyingFuture<java.lang.Void>	putAllAsync(java.util.Map<? extends K,? extends V> data, long lifespan, java.util.concurrent.TimeUnit unit) Asynchronous version of #putAll(Map, long, TimeUnit).
org.infinispan.util.concurrent.NotifyingFuture<V>	putAsync(K key, V value) Asynchronous version of #put(Object, Object).
org.infinispan.util.concurrent.NotifyingFuture<V>	putAsync(K key, V value, long lifespan, java.util.concurrent.TimeUnit unit) Asynchronous version of #put(Object, Object, long, TimeUnit) .
V	putIfAbsent(K key, V value)
V	putIfAbsent(K key, V value, long lifespan, java.util.concurrent.TimeUnit unit)
org.infinispan.util.concurrent.NotifyingFuture<V>	putIfAbsentAsync(K key, V value) Asynchronous version of #putIfAbsent(Object, Object).
org.infinispan.util.concurrent.NotifyingFuture<V>	putIfAbsentAsync(K key, V value, long lifespan, java.util.concurrent.TimeUnit unit) Asynchronous version of #putIfAbsent(Object, Object, long, TimeUnit) .
V	replace(K key, V value)
V	replace(K key, V value, long lifespan, java.util.concurrent.TimeUnit unit)
boolean	replace(K key, V oldValue, V newValue)
boolean	replace(K key, V oldValue, V value, long lifespan, java.util.concurrent.TimeUnit unit)
org.infinispan.util.concurrent.NotifyingFuture<V>	replaceAsync(K key, V value) Asynchronous version of #replace(Object, Object).
org.infinispan.util.concurrent.NotifyingFuture<V>	replaceAsync(K key, V value, long lifespan, java.util.concurrent.TimeUnit unit) Asynchronous version of #replace(Object, Object, long, TimeUnit).
org.infinispan.util.concurrent.NotifyingFuture<java.lang.Boolean>	replaceAsync(K key, V oldValue, V newValue) Asynchronous version of #replace(Object, Object, Object).
org.infinispan.util.concurrent.NotifyingFuture<java.lang.Boolean>	replaceAsync(K key, V oldValue, V newValue, long lifespan, java.util.concurrent.TimeUnit unit) Asynchronous version of #replace(Object, Object, Object, long, TimeUnit).
protected abstract void	set(K key, V value) This is intentionally a non-public method meant as an integration point for bytecode manipulation.

Methods inherited from class java.lang.Object

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

Methods inherited from interface org.infinispan.api.BasicCache

clearAsync, getAsync, putAllAsync, putAsync, putIfAbsentAsync, removeAsync, removeAsync, replaceAsync, replaceAsync

Field Detail

defaultLifespan

protected long defaultLifespan

defaultMaxIdleTime

protected long defaultMaxIdleTime

Constructor Detail

CacheSupport

protected CacheSupport()

CacheSupport

protected CacheSupport(long defaultLifespan,
            long defaultMaxIdleTime)

Method Detail

put

public final V put(K key,
    V value)

set

protected abstract void set(K key,
       V value)

This is intentionally a non-public method meant as an integration point for bytecode manipulation. Don't remove or alter the signature even if it might look like unreachable code. Implementors should perform a put operation but optimizing it as return values are not required.

Since:

5.0

putAll

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

putAsync

public final org.infinispan.util.concurrent.NotifyingFuture<V> putAsync(K key,
                                                         V value)

Description copied from interface: org.infinispan.api.BasicCache

Asynchronous version of #put(Object, Object). This method does not block on remote calls, even if your cache mode is synchronous. Has no benefit over #put(Object, Object) if used in LOCAL mode.

Specified by:

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

Parameters:

key - key to use

value - value to store

Returns:

a future containing the old value replaced.

putIfAbsent

public final V putIfAbsent(K key,
            V value)

putAsync

public final org.infinispan.util.concurrent.NotifyingFuture<V> putAsync(K key,
                                                         V value,
                                                         long lifespan,
                                                         java.util.concurrent.TimeUnit unit)

Description copied from interface: org.infinispan.api.BasicCache

Asynchronous version of #put(Object, Object, long, TimeUnit) . This method does not block on remote calls, even if your cache mode is synchronous. Has no benefit over #put(Object, Object, long, TimeUnit) if used in LOCAL mode.

Specified by:

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

Parameters:

key - key to use

value - value to store

lifespan - lifespan of entry

unit - time unit for lifespan

Returns:

a future containing the old value replaced

putAllAsync

public final org.infinispan.util.concurrent.NotifyingFuture<java.lang.Void> putAllAsync(java.util.Map<? extends K,? extends V> data)

Description copied from interface: org.infinispan.api.BasicCache

Asynchronous version of #putAll(Map). This method does not block on remote calls, even if your cache mode is synchronous. Has no benefit over #putAll(Map) if used in LOCAL mode.

Specified by:

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

Parameters:

data - to store

Returns:

a future containing a void return type

putAllAsync

public final org.infinispan.util.concurrent.NotifyingFuture<java.lang.Void> putAllAsync(java.util.Map<? extends K,? extends V> data,
                                                                         long lifespan,
                                                                         java.util.concurrent.TimeUnit unit)

Description copied from interface: org.infinispan.api.BasicCache

Asynchronous version of #putAll(Map, long, TimeUnit). This method does not block on remote calls, even if your cache mode is synchronous. Has no benefit over #putAll(Map, long, TimeUnit) if used in LOCAL mode.

Specified by:

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

Parameters:

data - to store

lifespan - lifespan of entry

unit - time unit for lifespan

Returns:

a future containing a void return type

putIfAbsentAsync

public final org.infinispan.util.concurrent.NotifyingFuture<V> putIfAbsentAsync(K key,
                                                                 V value)

Description copied from interface: org.infinispan.api.BasicCache

Asynchronous version of #putIfAbsent(Object, Object). This method does not block on remote calls, even if your cache mode is synchronous. Has no benefit over #putIfAbsent(Object, Object) if used in LOCAL mode.

Specified by:

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

Parameters:

key - key to use

value - value to store

Returns:

a future containing the old value replaced.

putIfAbsentAsync

public final org.infinispan.util.concurrent.NotifyingFuture<V> putIfAbsentAsync(K key,
                                                                 V value,
                                                                 long lifespan,
                                                                 java.util.concurrent.TimeUnit unit)

Description copied from interface: org.infinispan.api.BasicCache

Asynchronous version of #putIfAbsent(Object, Object, long, TimeUnit) . This method does not block on remote calls, even if your cache mode is synchronous. Has no benefit over #putIfAbsent(Object, Object, long, TimeUnit) if used in LOCAL mode.

Specified by:

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

Parameters:

key - key to use

value - value to store

lifespan - lifespan of entry

unit - time unit for lifespan

Returns:

a future containing the old value replaced

replaceAsync

public final org.infinispan.util.concurrent.NotifyingFuture<V> replaceAsync(K key,
                                                             V value,
                                                             long lifespan,
                                                             java.util.concurrent.TimeUnit unit)

Description copied from interface: org.infinispan.api.BasicCache

Asynchronous version of #replace(Object, Object, long, TimeUnit). This method does not block on remote calls, even if your cache mode is synchronous. Has no benefit over #replace(Object, Object, long, TimeUnit) if used in LOCAL mode.

Specified by:

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

Parameters:

key - key to remove

value - value to store

lifespan - lifespan of entry

unit - time unit for lifespan

Returns:

a future containing the previous value overwritten

replaceAsync

public final org.infinispan.util.concurrent.NotifyingFuture<java.lang.Boolean> replaceAsync(K key,
                                                                             V oldValue,
                                                                             V newValue)

Description copied from interface: org.infinispan.api.BasicCache

Asynchronous version of #replace(Object, Object, Object). This method does not block on remote calls, even if your cache mode is synchronous. Has no benefit over #replace(Object, Object, Object) if used in LOCAL mode.

Specified by:

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

Parameters:

key - key to remove

oldValue - value to overwrite

newValue - value to store

Returns:

a future containing a boolean, indicating whether the entry was replaced or not

replaceAsync

public final org.infinispan.util.concurrent.NotifyingFuture<V> replaceAsync(K key,
                                                             V value)

Description copied from interface: org.infinispan.api.BasicCache

Asynchronous version of #replace(Object, Object). This method does not block on remote calls, even if your cache mode is synchronous. Has no benefit over #replace(Object, Object) if used in LOCAL mode.

Specified by:

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

Parameters:

key - key to remove

value - value to store

Returns:

a future containing the previous value overwritten

replaceAsync

public final org.infinispan.util.concurrent.NotifyingFuture<java.lang.Boolean> replaceAsync(K key,
                                                                             V oldValue,
                                                                             V newValue,
                                                                             long lifespan,
                                                                             java.util.concurrent.TimeUnit unit)

Description copied from interface: org.infinispan.api.BasicCache

Asynchronous version of #replace(Object, Object, Object, long, TimeUnit). This method does not block on remote calls, even if your cache mode is synchronous. Has no benefit over #replace(Object, Object, Object, long, TimeUnit) if used in LOCAL mode.

Specified by:

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

Parameters:

key - key to remove

oldValue - value to overwrite

newValue - value to store

lifespan - lifespan of entry

unit - time unit for lifespan

Returns:

a future containing a boolean, indicating whether the entry was replaced or not

put

public final V put(K key,
    V value,
    long lifespan,
    java.util.concurrent.TimeUnit unit)

putIfAbsent

public final V putIfAbsent(K key,
            V value,
            long lifespan,
            java.util.concurrent.TimeUnit unit)

putAll

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

replace

public final V replace(K key,
        V value,
        long lifespan,
        java.util.concurrent.TimeUnit unit)

replace

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

replace

public final V replace(K key,
        V value)

replace

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