org.infinispan.client.hotrod.impl
Class RemoteCacheImpl<K,V>

java.lang.Object
  extended by org.infinispan.CacheSupport<K,V>
      extended by org.infinispan.client.hotrod.impl.RemoteCacheSupport<K,V>
          extended by org.infinispan.client.hotrod.impl.RemoteCacheImpl<K,V>
All Implemented Interfaces:
ConcurrentMap<K,V>, Map<K,V>, Cache<K,V>, RemoteCache<K,V>, Lifecycle, Listenable

public class RemoteCacheImpl<K,V>
extends RemoteCacheSupport<K,V>

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

Nested Class Summary
 
Nested classes/interfaces inherited from interface java.util.Map
Map.Entry<K,V>
 
Field Summary
 
Fields inherited from class org.infinispan.CacheSupport
defaultLifespan, defaultMaxIdleTime
 
Constructor Summary
RemoteCacheImpl(RemoteCacheManager rcm, String name)
           
 
Method Summary
 void clear()
           
 NotifyingFuture<Void> clearAsync()
          Asynchronous version of Map.clear().
 boolean containsKey(Object key)
           
 V get(Object key)
           
 Map<K,V> getBulk()
          Bulk get operations, returns all the entries within the remote cache.
 Map<K,V> getBulk(int size)
          Same as RemoteCache.getBulk(), but limits the returned set of values to the specified size.
 String getName()
          Retrieves the name of the cache
 RemoteCacheManager getRemoteCacheManager()
          Returns the RemoteCacheManager that created this cache.
 String getVersion()
          Retrieves the version of Infinispan
 VersionedValue<V> getVersioned(K key)
          Returns the VersionedValue associated to the supplied key param, or null if it doesn't exist.
 void init(Marshaller marshaller, ExecutorService executorService, OperationsFactory operationsFactory, int estimateKeySize, int estimateValueSize)
           
 V put(K key, V value, long lifespan, TimeUnit lifespanUnit, long maxIdleTime, TimeUnit maxIdleTimeUnit)
          An overloaded form of Map.put(Object, Object), which takes in lifespan parameters.
 void putAll(Map<? extends K,? extends V> map, long lifespan, TimeUnit lifespanUnit, long maxIdleTime, TimeUnit maxIdleTimeUnit)
          Synthetic operation.
 NotifyingFuture<Void> putAllAsync(Map<? extends K,? extends V> data, long lifespan, TimeUnit lifespanUnit, long maxIdle, TimeUnit maxIdleUnit)
          Synthetic operation.
 NotifyingFuture<V> putAsync(K key, V value, long lifespan, TimeUnit lifespanUnit, long maxIdle, TimeUnit maxIdleUnit)
          Asynchronous version of Cache.put(Object, Object, long, TimeUnit, long, TimeUnit).
 V putIfAbsent(K key, V value, long lifespan, TimeUnit lifespanUnit, long maxIdleTime, TimeUnit maxIdleTimeUnit)
          An overloaded form of ConcurrentMap.putIfAbsent(Object, Object), which takes in lifespan parameters.
 NotifyingFuture<V> putIfAbsentAsync(K key, V value, long lifespan, TimeUnit lifespanUnit, long maxIdle, TimeUnit maxIdleUnit)
          Asynchronous version of Cache.putIfAbsent(Object, Object, long, TimeUnit, long, TimeUnit).
 V remove(Object key)
           
 NotifyingFuture<V> removeAsync(Object key)
          Asynchronous version of Map.remove(Object).
 boolean removeWithVersion(K key, long version)
          Removes the given entry only if its version matches the supplied version.
 NotifyingFuture<Boolean> removeWithVersionAsync(K key, long version)
           
 V replace(K key, V value, long lifespan, TimeUnit lifespanUnit, long maxIdleTime, TimeUnit maxIdleTimeUnit)
          An overloaded form of ConcurrentMap.replace(Object, Object), which takes in lifespan parameters.
 NotifyingFuture<V> replaceAsync(K key, V value, long lifespan, TimeUnit lifespanUnit, long maxIdle, TimeUnit maxIdleUnit)
          Asynchronous version of Cache.replace(Object, Object, long, TimeUnit, long, TimeUnit).
 boolean replaceWithVersion(K key, V newValue, long version, int lifespanSeconds, int maxIdleTimeSeconds)
           
 NotifyingFuture<Boolean> replaceWithVersionAsync(K key, V newValue, long version, int lifespanSeconds, int maxIdleSeconds)
           
 void start()
           
 ServerStatistics stats()
           
 void stop()
           
 RemoteCache<K,V> withFlags(Flag... flags)
          Applies one or more Flags to the scope of a single invocation.
 
Methods inherited from class org.infinispan.client.hotrod.impl.RemoteCacheSupport
addListener, compact, containsValue, endBatch, entrySet, evict, getAdvancedCache, getCacheManager, getConfiguration, getListeners, getStatus, isEmpty, keySet, putForExternalRead, remove, removeAsync, removeListener, replace, replaceAsync, replaceWithVersion, replaceWithVersion, replaceWithVersionAsync, replaceWithVersionAsync, size, startBatch, values
 
Methods inherited from class org.infinispan.CacheSupport
put, put, putAll, putAll, putAllAsync, putAllAsync, putAsync, putAsync, putIfAbsent, putIfAbsent, putIfAbsentAsync, putIfAbsentAsync, replace, replace, replace, replace, replaceAsync, replaceAsync, replaceAsync, replaceAsync
 
Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait
 
Methods inherited from interface org.infinispan.client.hotrod.RemoteCache
putAll, putAll, putAllAsync, putAllAsync, replace, replace, replaceAsync, replaceAsync
 
Methods inherited from interface org.infinispan.Cache
put, putAsync, putAsync, putIfAbsent, putIfAbsentAsync, putIfAbsentAsync, replace, replaceAsync, replaceAsync
 
Methods inherited from interface java.util.concurrent.ConcurrentMap
putIfAbsent, replace
 
Methods inherited from interface java.util.Map
equals, hashCode, put
 

Constructor Detail

RemoteCacheImpl

public RemoteCacheImpl(RemoteCacheManager rcm,
                       String name)
Method Detail

init

public void init(Marshaller marshaller,
                 ExecutorService executorService,
                 OperationsFactory operationsFactory,
                 int estimateKeySize,
                 int estimateValueSize)

getRemoteCacheManager

public RemoteCacheManager getRemoteCacheManager()
Description copied from interface: RemoteCache
Returns the RemoteCacheManager that created this cache.


removeWithVersion

public 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.

Returns:
true if the entry has been removed
See Also:
VersionedValue, RemoteCache.getVersioned(Object)

removeWithVersionAsync

public NotifyingFuture<Boolean> removeWithVersionAsync(K key,
                                                       long version)
See Also:
RemoteCache.remove(Object, Object)

replaceWithVersion

public boolean replaceWithVersion(K key,
                                  V newValue,
                                  long version,
                                  int lifespanSeconds,
                                  int maxIdleTimeSeconds)
See Also:
RemoteCache.replaceWithVersion(Object, Object, long)

replaceWithVersionAsync

public NotifyingFuture<Boolean> replaceWithVersionAsync(K key,
                                                        V newValue,
                                                        long version,
                                                        int lifespanSeconds,
                                                        int maxIdleSeconds)
See Also:
RemoteCache.replaceWithVersion(Object, Object, long)

getVersioned

public VersionedValue<V> getVersioned(K key)
Description copied from interface: RemoteCache
Returns the VersionedValue associated to the supplied key param, or null if it doesn't exist.


putAll

public void putAll(Map<? extends K,? extends V> map,
                   long lifespan,
                   TimeUnit lifespanUnit,
                   long maxIdleTime,
                   TimeUnit maxIdleTimeUnit)
Description copied from interface: RemoteCache
Synthetic operation.

Parameters:
map - map containing mappings to enter
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
See Also:
RemoteCache.putAll(java.util.Map, long, java.util.concurrent.TimeUnit)

putAllAsync

public NotifyingFuture<Void> putAllAsync(Map<? extends K,? extends V> data,
                                         long lifespan,
                                         TimeUnit lifespanUnit,
                                         long maxIdle,
                                         TimeUnit maxIdleUnit)
Description copied from interface: RemoteCache
Synthetic operation.

Parameters:
data - to store
lifespan - lifespan of entry
lifespanUnit - time unit for lifespan
maxIdle - the maximum amount of time this key is allowed to be idle for before it is considered as expired
maxIdleUnit - time unit for max idle time
Returns:
a future containing a void return type
See Also:
RemoteCache.putAll(java.util.Map, long, java.util.concurrent.TimeUnit)

stats

public ServerStatistics stats()

put

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

Parameters:
key - key to use
value - value to store
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 value being replaced, or null if nothing is being replaced.

putIfAbsent

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

Parameters:
key - key to use
value - value to store
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 value being replaced, or null if nothing is being replaced.

replace

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

Parameters:
key - key to use
value - value to store
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 value being replaced, or null if nothing is being replaced.

putAsync

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

Parameters:
key - key to use
value - value to store
lifespan - lifespan of entry
lifespanUnit - time unit for lifespan
maxIdle - the maximum amount of time this key is allowed to be idle for before it is considered as expired
maxIdleUnit - time unit for max idle time
Returns:
a future containing the old value replaced

clearAsync

public NotifyingFuture<Void> clearAsync()
Description copied from interface: Cache
Asynchronous version of Map.clear(). This method does not block on remote calls, even if your cache mode is synchronous. Has no benefit over Map.clear() if used in LOCAL mode.

Returns:
a future containing a void return type

putIfAbsentAsync

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

Parameters:
key - key to use
value - value to store
lifespan - lifespan of entry
lifespanUnit - time unit for lifespan
maxIdle - the maximum amount of time this key is allowed to be idle for before it is considered as expired
maxIdleUnit - time unit for max idle time
Returns:
a future containing the old value replaced

removeAsync

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

Parameters:
key - key to remove
Returns:
a future containing the value removed

replaceAsync

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

Parameters:
key - key to remove
value - value to store
lifespan - lifespan of entry
lifespanUnit - time unit for lifespan
maxIdle - the maximum amount of time this key is allowed to be idle for before it is considered as expired
maxIdleUnit - time unit for max idle time
Returns:
a future containing the previous value overwritten

containsKey

public boolean containsKey(Object key)

get

public V get(Object key)

getBulk

public Map<K,V> getBulk()
Description copied from interface: RemoteCache
Bulk get operations, returns all the entries within the remote cache.

Returns:
the returned values depend on the configuration of the back-end infinispan servers. Read this for more details. The returned Map is unmodifiable.

getBulk

public Map<K,V> getBulk(int size)
Description copied from interface: RemoteCache
Same as RemoteCache.getBulk(), but limits the returned set of values to the specified size. No ordering is guaranteed, and there is no guarantee that "size" elements are returned( e.g. if the number of elements in the back-end server is smaller that "size")


remove

public V remove(Object key)

clear

public void clear()

start

public void start()

stop

public void stop()

getName

public String getName()
Description copied from interface: Cache
Retrieves the name of the cache

Returns:
the name of the cache

getVersion

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

Returns:
a version string

withFlags

public RemoteCache<K,V> withFlags(Flag... flags)
Description copied from interface: RemoteCache
Applies one or more Flags to the scope of a single invocation. See the Flag enumeration to for information on available flags.

Sample usage:

    remoteCache.withFlags(Flag.FORCE_RETURN_VALUE).put("hello", "world");
 

Returns:
the current RemoteCache instance to continue running operations on.

Google Analytics

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