com.hazelcast.cache
Interface ICache<K,V>

Type Parameters:
K - the type of key.
V - the type of value.
All Superinterfaces:
javax.cache.Cache<K,V>, Closeable, Iterable<javax.cache.Cache.Entry<K,V>>
All Known Implementing Classes:
CacheProxy, ClientCacheProxy

public interface ICache<K,V>
extends javax.cache.Cache<K,V>

This ICache interface is the Cache extension offered by Hazelcast JCache.
In addition to the standard set of JCache methods defined in the JSR 107 specification, Hazelcast provides additional operations to support a broader range of programing styles.

There are three different types of extensions methods provided:

To take advantage of the methods of this interface, the Cache instance needs to be unwrapped as defined in the JSR 107 standard (Cache.unwrap(Class)) by providing the ICache interface parameter.

   ICache<Key , Value> unwrappedCache =  cache.unwrap( ICache.class );
 
The unwrapped cache instance can now be used for both ICache and Cache operations.

Asynchronous operations:
For most of the typical operations, Hazelcast provides asynchronous versions to program in a more reactive styled way. All asynchronous operations follow the same naming pattern: the operation's name from JCache extended by the term Async, e.g. the asynchronous version of Cache.get(Object) is getAsync(Object).
These methods return an ICompletableFuture that can be used to get the result by implementing a callback based on ExecutionCallback or wait for the operation to be completed in a blocking fashion Future.get() or Future.get(long, java.util.concurrent.TimeUnit).

In a reactive way:

   ICompletableFuture<Value> future = unwrappedCache.getAsync( "key-1" ) ;
   future.andThen( new ExecutionCallback() {
     public void onResponse( Value value ) {
         System.out.println( value );
     }

     public void onFailure( Throwable throwable ) {
         throwable.printStackTrace();
     }
   } );
 
Or in a blocking way:
   ICompletableFuture<Value> future = unwrappedCache.getAsync( "key-1" ) ;
   Value value = future.get();
   System.out.println( value );
 

Custom ExpirePolicy:
Again for most of the typical operations, Hazelcast provides overloaded versions with an additional ExpiryPolicy parameter to configure a different expiration policy from the default one set in the CompleteConfiguration passed to the cache creation. Therefore the Cache.put(Object, Object) operation has an overload put(Object, Object, javax.cache.expiry.ExpiryPolicy) to pass in the special policy.

Important to note: The overloads use an instance of ExpiryPolicy and not a Factory instance as used in the configuration.

   unwrappedCache.put( "key", "value", new AccessedExpiryPolicy( Duration.ONE_DAY ) );
 

Since:
3.3.1
See Also:
Cache

Nested Class Summary
 
Nested classes/interfaces inherited from interface javax.cache.Cache
javax.cache.Cache.Entry<K,V>
 
Method Summary
 void destroy()
          Closes the cache.
 V get(K key, javax.cache.expiry.ExpiryPolicy expiryPolicy)
          Retrieves the mapped value of the given key using a custom ExpiryPolicy.
 Map<K,V> getAll(Set<? extends K> keys, javax.cache.expiry.ExpiryPolicy expiryPolicy)
          Gets a collection of entries from the cache with custom expiry policy, returning them as Map of the values associated with the set of keys requested.
 V getAndPut(K key, V value, javax.cache.expiry.ExpiryPolicy expiryPolicy)
          Associates the specified value with the specified key in this cache using a custom ExpiryPolicy, returning an existing value if one existed.
 ICompletableFuture<V> getAndPutAsync(K key, V value)
          Asynchronously associates the specified value with the specified key in this cache, returning an existing value if one existed.
 ICompletableFuture<V> getAndPutAsync(K key, V value, javax.cache.expiry.ExpiryPolicy expiryPolicy)
          Asynchronously associates the specified value with the specified key in this cache, returning an existing value if one existed using a custom ExpiryPolicy.
 ICompletableFuture<V> getAndRemoveAsync(K key)
          Asynchronously removes the entry for a key and returns the previously assigned value or null if no value was assigned.
 V getAndReplace(K key, V value, javax.cache.expiry.ExpiryPolicy expiryPolicy)
          Atomically replaces the assigned value of the given key by the specified value using a custom ExpiryPolicy and returns the previously assigned value.
 ICompletableFuture<V> getAndReplaceAsync(K key, V value)
          Asynchronously replaces the assigned value of the given key by the specified value and returns the previously assigned value.
 ICompletableFuture<V> getAndReplaceAsync(K key, V value, javax.cache.expiry.ExpiryPolicy expiryPolicy)
          Asynchronously replaces the assigned value of the given key by the specified value using a custom ExpiryPolicy and returns the previously assigned value.
 ICompletableFuture<V> getAsync(K key)
          Asynchronously retrieves the mapped value of the given key using a custom ExpiryPolicy.
 ICompletableFuture<V> getAsync(K key, javax.cache.expiry.ExpiryPolicy expiryPolicy)
          Asynchronously gets an entry from cache using a custom ExpiryPolicy.
 CacheStatistics getLocalCacheStatistics()
           
 boolean isDestroyed()
          Determines whether this Cache instance has been destroyed.
 void put(K key, V value, javax.cache.expiry.ExpiryPolicy expiryPolicy)
          Associates the specified value with the specified key in the cache using a custom ExpiryPolicy.
 void putAll(Map<? extends K,? extends V> map, javax.cache.expiry.ExpiryPolicy expiryPolicy)
          Copies all of the entries from the given map to the cache using a custom ExpiryPolicy.
 ICompletableFuture<Void> putAsync(K key, V value)
          Asynchronously associates the specified value with the specified key in the cache.
 ICompletableFuture<Void> putAsync(K key, V value, javax.cache.expiry.ExpiryPolicy expiryPolicy)
          Asynchronously associates the specified value with the specified key in the cache using a custom ExpiryPolicy.
 boolean putIfAbsent(K key, V value, javax.cache.expiry.ExpiryPolicy expiryPolicy)
          Associates the specified key with the given value if and only if there is not yet a mapping for the specified key defined.
 ICompletableFuture<Boolean> putIfAbsentAsync(K key, V value)
          Asynchronously associates the specified key with the given value if and only if there is not yet a mapping for the specified key defined.
 ICompletableFuture<Boolean> putIfAbsentAsync(K key, V value, javax.cache.expiry.ExpiryPolicy expiryPolicy)
          Asynchronously associates the specified key with the given value if and only if there is not yet a mapping for the specified key defined.
 ICompletableFuture<Boolean> removeAsync(K key)
          Asynchronously removes the mapping for a key from this cache if it is present.
 ICompletableFuture<Boolean> removeAsync(K key, V oldValue)
          Asynchronously removes the mapping for the given key if and only if the currently mapped value equals to the value of oldValue.
 boolean replace(K key, V value, javax.cache.expiry.ExpiryPolicy expiryPolicy)
          Atomically replaces the assigned value of the given key by the specified value using a custom ExpiryPolicy.
 boolean replace(K key, V oldValue, V newValue, javax.cache.expiry.ExpiryPolicy expiryPolicy)
          Atomically replaces the currently assigned value for the given key with the specified newValue if and only if the currently assigned value equals the value of oldValue using a custom ExpiryPolicy.
 ICompletableFuture<Boolean> replaceAsync(K key, V value)
          Asynchronously replaces the assigned value of the given key by the specified value.
 ICompletableFuture<Boolean> replaceAsync(K key, V value, javax.cache.expiry.ExpiryPolicy expiryPolicy)
          Asynchronously replaces the assigned value of the given key by the specified value using a custom ExpiryPolicy.
 ICompletableFuture<Boolean> replaceAsync(K key, V oldValue, V newValue)
          Asynchronously replaces the currently assigned value for the given key with the specified newValue if and only if the currently assigned value equals the value of oldValue.
 ICompletableFuture<Boolean> replaceAsync(K key, V oldValue, V newValue, javax.cache.expiry.ExpiryPolicy expiryPolicy)
          Asynchronously replaces the currently assigned value for the given key with the specified newValue if and only if the currently assigned value equals the value of oldValue using a custom ExpiryPolicy.
 int size()
          Total entry count.
 
Methods inherited from interface javax.cache.Cache
clear, close, containsKey, deregisterCacheEntryListener, get, getAll, getAndPut, getAndRemove, getAndReplace, getCacheManager, getConfiguration, getName, invoke, invokeAll, isClosed, iterator, loadAll, put, putAll, putIfAbsent, registerCacheEntryListener, remove, remove, removeAll, removeAll, replace, replace, unwrap
 

Method Detail

getAsync

ICompletableFuture<V> getAsync(K key)
Asynchronously retrieves the mapped value of the given key using a custom ExpiryPolicy. If no mapping exists null is returned.

If the cache is configured for read-through operation mode, the underlying configured CacheLoader might be called to retrieve the value of the key from any kind of external resource.

Parameters:
key - the key whose associated value is to be returned
Returns:
ICompletableFuture to retrieve the value assigned to the given key
Throws:
NullPointerException - if given key is null
javax.cache.CacheException - if anything exceptional happens while invoking the request, other exceptions are wrapped
See Also:
javax.cache.Cache#get(K), ICompletableFuture

getAsync

ICompletableFuture<V> getAsync(K key,
                               javax.cache.expiry.ExpiryPolicy expiryPolicy)
Asynchronously gets an entry from cache using a custom ExpiryPolicy.

If the cache is configured for read-through operation mode, the underlying configured CacheLoader might be called to retrieve the value of the key from any kind of external resource.

Parameters:
key - the key whose associated value is to be returned
expiryPolicy - custom expiry policy for this operation, a null value is equivalent to getAsync(Object)
Returns:
ICompletableFuture to retrieve the value assigned to the given key
Throws:
NullPointerException - if given key is null
javax.cache.CacheException - if anything exceptional happens while invoking the request, other exceptions are wrapped
See Also:
javax.cache.Cache#get(K), ICompletableFuture

putAsync

ICompletableFuture<Void> putAsync(K key,
                                  V value)
Asynchronously associates the specified value with the specified key in the cache.

In case a previous assignment already exists, the previous value is overridden by the new given value.

If the cache is configured for write-through operation mode, the underlying configured CacheWriter might be called to store the value of the key to any kind of external resource.

Parameters:
key - the key whose associated value is to be returned
value - the value to be associated with the specified key
Returns:
ICompletableFuture to get notified when the operation succeed
Throws:
NullPointerException - if given key or value is null
javax.cache.CacheException - if anything exceptional happens while invoking the request, other exceptions are wrapped
See Also:
javax.cache.Cache#put(K,V), ICompletableFuture

putAsync

ICompletableFuture<Void> putAsync(K key,
                                  V value,
                                  javax.cache.expiry.ExpiryPolicy expiryPolicy)
Asynchronously associates the specified value with the specified key in the cache using a custom ExpiryPolicy.

In case a previous assignment already exists, the previous value is overridden by the new given value.

If the cache is configured for write-through operation mode, the underlying configured CacheWriter might be called to store the value of the key to any kind of external resource.

Parameters:
key - the key whose associated value is to be returned
value - the value to be associated with the specified key
expiryPolicy - custom expiry policy for this operation, a null value is equivalent to putAsync(Object, Object)
Returns:
ICompletableFuture to get notified when the operation succeed
Throws:
NullPointerException - if given key or value is null
javax.cache.CacheException - if anything exceptional happens while invoking the request, other exceptions are wrapped
See Also:
javax.cache.Cache#put(K,V), ICompletableFuture

putIfAbsentAsync

ICompletableFuture<Boolean> putIfAbsentAsync(K key,
                                             V value)
Asynchronously associates the specified key with the given value if and only if there is not yet a mapping for the specified key defined.

This is equivalent to:

   if (!cache.containsKey(key)) {}
     cache.put(key, value);
     return true;
   } else {
     return false;
   }
 
except that the action is performed atomically.

If the cache is configured for write-through operation mode, the underlying configured CacheWriter might be called to store the value of the key to any kind of external resource.

Parameters:
key - the key with which the specified value is to be associated
value - the value to be associated with the specified key
Returns:
ICompletableFuture to retrieve if a previous value was assigned with the key
Throws:
NullPointerException - if given key or value is null
javax.cache.CacheException - if anything exceptional happens while invoking the request, other exceptions are wrapped
See Also:
javax.cache.Cache#putIfAbsent(K,V), ICompletableFuture

putIfAbsentAsync

ICompletableFuture<Boolean> putIfAbsentAsync(K key,
                                             V value,
                                             javax.cache.expiry.ExpiryPolicy expiryPolicy)
Asynchronously associates the specified key with the given value if and only if there is not yet a mapping for the specified key defined. using a custom ExpiryPolicy.

This is equivalent to:

   if (!cache.containsKey(key)) {}
     cache.put(key, value);
     return true;
   } else {
     return false;
   }
 
except that the action is performed atomically.

If the cache is configured for write-through operation mode, the underlying configured CacheWriter might be called to store the value of the key to any kind of external resource.

Parameters:
key - the key with which the specified value is to be associated
value - the value to be associated with the specified key
expiryPolicy - custom expiry policy for this operation, a null value is equivalent to putIfAbsentAsync(Object, Object, javax.cache.expiry.ExpiryPolicy)
Returns:
ICompletableFuture to retrieve if a previous value was assigned with the key
Throws:
NullPointerException - if given key or value is null
javax.cache.CacheException - if anything exceptional happens while invoking the request, other exceptions are wrapped
See Also:
javax.cache.Cache#putIfAbsent(K,V), ICompletableFuture

getAndPutAsync

ICompletableFuture<V> getAndPutAsync(K key,
                                     V value)
Asynchronously associates the specified value with the specified key in this cache, returning an existing value if one existed.

In case a previous assignment already exists, the previous value is overridden by the new given value and the previous value is returned to the caller. This is equivalent to the Map.put(Object, Object) operation.

If the cache is configured for write-through operation mode, the underlying configured CacheWriter might be called to store the value of the key to any kind of external resource.

Parameters:
key - the key whose associated value is to be returned
value - the value to be associated with the specified key
Returns:
ICompletableFuture to retrieve a possible previously assigned value for the given key
Throws:
NullPointerException - if given key or value is null
javax.cache.CacheException - if anything exceptional happens while invoking the request, other exceptions are wrapped
See Also:
javax.cache.Cache#getAndPut(K,V), ICompletableFuture

getAndPutAsync

ICompletableFuture<V> getAndPutAsync(K key,
                                     V value,
                                     javax.cache.expiry.ExpiryPolicy expiryPolicy)
Asynchronously associates the specified value with the specified key in this cache, returning an existing value if one existed using a custom ExpiryPolicy.

In case a previous assignment already exists, the previous value is overridden by the new given value and the previous value is returned to the caller. This is equivalent to the Map.put(Object, Object) operation.

If the cache is configured for write-through operation mode, the underlying configured CacheWriter might be called to store the value of the key to any kind of external resource.

Parameters:
key - the key whose associated value is to be returned.
value - the value to be associated with the specified key.
expiryPolicy - custom expiry policy for this operation, a null value is equivalent to getAndPutAsync(Object, Object, javax.cache.expiry.ExpiryPolicy)
Returns:
ICompletableFuture to retrieve a possible previously assigned value for the given key
Throws:
NullPointerException - if given key or value is null
javax.cache.CacheException - if anything exceptional happens while invoking the request, other exceptions are wrapped
See Also:
javax.cache.Cache#getAndPut(K,V), ICompletableFuture

removeAsync

ICompletableFuture<Boolean> removeAsync(K key)
Asynchronously removes the mapping for a key from this cache if it is present.

If the cache is configured for write-through operation mode, the underlying configured CacheWriter might be called to store the value of the key to any kind of external resource.

Parameters:
key - the key whose associated value is to be returned
Returns:
ICompletableFuture to retrieve if value could be removed or not
Throws:
NullPointerException - if given key is null
javax.cache.CacheException - if anything exceptional happens while invoking the request, other exceptions are wrapped
See Also:
javax.cache.Cache#remove(K), ICompletableFuture

removeAsync

ICompletableFuture<Boolean> removeAsync(K key,
                                        V oldValue)
Asynchronously removes the mapping for the given key if and only if the currently mapped value equals to the value of oldValue.

This is equivalent to:

   if (cache.containsKey(key) && equals(cache.get(key), oldValue) {
     cache.remove(key);
     return true;
   } else {
     return false;
   }
 
except that the action is performed atomically.

If the cache is configured for write-through operation mode, the underlying configured CacheWriter might be called to store the value of the key to any kind of external resource.

Parameters:
key - the key whose associated value is to be returned.
oldValue - the value expected to be associated with the specified key.
Returns:
ICompletableFuture to retrieve if value could be removed or not
Throws:
NullPointerException - if given key or oldValue is null
javax.cache.CacheException - if anything exceptional happens while invoking the request, other exceptions are wrapped
See Also:
javax.cache.Cache#remove(K,V), ICompletableFuture

getAndRemoveAsync

ICompletableFuture<V> getAndRemoveAsync(K key)
Asynchronously removes the entry for a key and returns the previously assigned value or null if no value was assigned.

If the cache is configured for write-through operation mode, the underlying configured CacheWriter might be called to store the value of the key to any kind of external resource.

Parameters:
key - the key whose associated value is to be returned
Returns:
ICompletableFuture to retrieve a possible previously assigned value for the removed key
Throws:
NullPointerException - if given key is null
javax.cache.CacheException - if anything exceptional happens while invoking the request, other exceptions are wrapped
See Also:
javax.cache.Cache#getAndRemove(K), ICompletableFuture

replaceAsync

ICompletableFuture<Boolean> replaceAsync(K key,
                                         V value)
Asynchronously replaces the assigned value of the given key by the specified value.

If the cache is configured for write-through operation mode, the underlying configured CacheWriter might be called to store the value of the key to any kind of external resource.

Parameters:
key - the key whose associated value is to be returned
value - the value to be associated with the specified key
Returns:
ICompletableFuture to get notified if the operation succeed or not
Throws:
NullPointerException - if given key or value is null
javax.cache.CacheException - if anything exceptional happens while invoking the request, other exceptions are wrapped
See Also:
javax.cache.Cache#replace(K,V), ICompletableFuture

replaceAsync

ICompletableFuture<Boolean> replaceAsync(K key,
                                         V value,
                                         javax.cache.expiry.ExpiryPolicy expiryPolicy)
Asynchronously replaces the assigned value of the given key by the specified value using a custom ExpiryPolicy.

If the cache is configured for write-through operation mode, the underlying configured CacheWriter might be called to store the value of the key to any kind of external resource.

Parameters:
key - the key with which the specified value is associated
value - the value to be associated with the specified key
expiryPolicy - custom expiry policy for this operation, a null value is equivalent to replaceAsync(Object, Object)
Returns:
ICompletableFuture to get notified if the operation succeed or not
Throws:
NullPointerException - if given key or value is null
javax.cache.CacheException - if anything exceptional happens while invoking the request, other exceptions are wrapped
See Also:
javax.cache.Cache#replace(K,V), ICompletableFuture

replaceAsync

ICompletableFuture<Boolean> replaceAsync(K key,
                                         V oldValue,
                                         V newValue)
Asynchronously replaces the currently assigned value for the given key with the specified newValue if and only if the currently assigned value equals the value of oldValue.

This is equivalent to:

   if (cache.containsKey(key) && equals(cache.get(key), oldValue) {
     cache.put(key, newValue);
     return true;
   } else {
     return false;
   }
 
except that the action is performed atomically.

If the cache is configured for write-through operation mode, the underlying configured CacheWriter might be called to store the value of the key to any kind of external resource.

Parameters:
key - the key with which the specified value is associated
oldValue - the value expected to be associated with the specified key
newValue - the value to be associated with the specified key
Returns:
ICompletableFuture to get notified if the operation succeed or not
Throws:
NullPointerException - if given key, oldValue or newValue is null
javax.cache.CacheException - if anything exceptional happens while invoking the request, other exceptions are wrapped
See Also:
javax.cache.Cache#replace(K,V,V), ICompletableFuture

replaceAsync

ICompletableFuture<Boolean> replaceAsync(K key,
                                         V oldValue,
                                         V newValue,
                                         javax.cache.expiry.ExpiryPolicy expiryPolicy)
Asynchronously replaces the currently assigned value for the given key with the specified newValue if and only if the currently assigned value equals the value of oldValue using a custom ExpiryPolicy.

This is equivalent to:

   if (cache.containsKey(key) && equals(cache.get(key), oldValue) {
     cache.put(key, newValue);
     return true;
   } else {
     return false;
   }
 
except that the action is performed atomically.

If the cache is configured for write-through operation mode, the underlying configured CacheWriter might be called to store the value of the key to any kind of external resource.

Parameters:
key - the key with which the specified value is associated
oldValue - the value expected to be associated with the specified key
newValue - the value to be associated with the specified key
expiryPolicy - custom expiry policy for this operation, a null value is equivalent to replaceAsync(Object, Object, Object)
Returns:
ICompletableFuture to get notified if the operation succeed or not
Throws:
NullPointerException - if given key, oldValue or newValue is null
javax.cache.CacheException - if anything exceptional happens while invoking the request, other exceptions are wrapped
See Also:
javax.cache.Cache#replace(K,V,V), ICompletableFuture

getAndReplaceAsync

ICompletableFuture<V> getAndReplaceAsync(K key,
                                         V value)
Asynchronously replaces the assigned value of the given key by the specified value and returns the previously assigned value.

If the cache is configured for write-through operation mode, the underlying configured CacheWriter might be called to store the value of the key to any kind of external resource.

Parameters:
key - the key with which the specified value is associated
value - the value to be associated with the specified key
Returns:
ICompletableFuture to retrieve a possible previously assigned value for the given key
Throws:
NullPointerException - if given key or value is null
javax.cache.CacheException - if anything exceptional happens while invoking the request, other exceptions are wrapped
See Also:
javax.cache.Cache#getAndReplace(K,V), ICompletableFuture

getAndReplaceAsync

ICompletableFuture<V> getAndReplaceAsync(K key,
                                         V value,
                                         javax.cache.expiry.ExpiryPolicy expiryPolicy)
Asynchronously replaces the assigned value of the given key by the specified value using a custom ExpiryPolicy and returns the previously assigned value.

If the cache is configured for write-through operation mode, the underlying configured CacheWriter might be called to store the value of the key to any kind of external resource.

Parameters:
key - the key with which the specified value is associated
value - the value to be associated with the specified key
expiryPolicy - custom expiry policy for this operation, a null value is equivalent to Cache.getAndReplace(Object, Object)
Returns:
ICompletableFuture to retrieve a possible previously assigned value for the given key
Throws:
NullPointerException - if given key or value is null
javax.cache.CacheException - if anything exceptional happens while invoking the request, other exceptions are wrapped
See Also:
javax.cache.Cache#getAndReplace(K,V), ICompletableFuture

get

V get(K key,
      javax.cache.expiry.ExpiryPolicy expiryPolicy)
Retrieves the mapped value of the given key using a custom ExpiryPolicy. If no mapping exists null is returned.

If the cache is configured for read-through operation mode, the underlying configured CacheLoader might be called to retrieve the value of the key from any kind of external resource.

Parameters:
key - the key whose associated value is to be returned
expiryPolicy - custom expiry policy for this operation, a null value is equivalent to Cache.get(Object)
Returns:
returns the value assigned to the given key or null if not assigned
Throws:
NullPointerException - if given key is null
javax.cache.CacheException - if anything exceptional happens while invoking the request, other exceptions are wrapped
See Also:
javax.cache.Cache#get(K)

getAll

Map<K,V> getAll(Set<? extends K> keys,
                javax.cache.expiry.ExpiryPolicy expiryPolicy)
Gets a collection of entries from the cache with custom expiry policy, returning them as Map of the values associated with the set of keys requested.

If the cache is configured for read-through operation mode, the underlying configured CacheLoader might be called to retrieve the values of the keys from any kind of external resource.

Parameters:
keys - the keys whose associated values are to be returned
expiryPolicy - custom expiry policy for this operation, a null value is equivalent to Cache.getAll(java.util.Set)
Returns:
A map of entries that were found for the given keys. Keys not found in the cache are not in the returned map.
Throws:
NullPointerException - if given keys is null
javax.cache.CacheException - if anything exceptional happens while invoking the request, other exceptions are wrapped
See Also:
Cache.getAll(java.util.Set)

put

void put(K key,
         V value,
         javax.cache.expiry.ExpiryPolicy expiryPolicy)
Associates the specified value with the specified key in the cache using a custom ExpiryPolicy.

Parameters:
key - the key with which the specified value is to be associated
value - value to be associated with the specified key
expiryPolicy - custom expiry policy for this operation, a null value is equivalent to Cache.put(Object, Object)
Throws:
NullPointerException - if given key or value is null
javax.cache.CacheException - if anything exceptional happens while invoking the request, other exceptions are wrapped
See Also:
javax.cache.Cache#put(K,V)

getAndPut

V getAndPut(K key,
            V value,
            javax.cache.expiry.ExpiryPolicy expiryPolicy)
Associates the specified value with the specified key in this cache using a custom ExpiryPolicy, returning an existing value if one existed.

Parameters:
key - the key with which the specified value is to be associated
value - the value to be associated with the specified key
expiryPolicy - custom expiry policy for this operation, a null value is equivalent to Cache.getAndPut(Object, Object)
Returns:
returns the value previously assigned to the given key or null if not assigned
Throws:
NullPointerException - if given key or value is null
javax.cache.CacheException - if anything exceptional happens while invoking the request, other exceptions are wrapped
See Also:
javax.cache.Cache#getAndPut(K,V)

putAll

void putAll(Map<? extends K,? extends V> map,
            javax.cache.expiry.ExpiryPolicy expiryPolicy)
Copies all of the entries from the given map to the cache using a custom ExpiryPolicy.

Puts of single entries happen atomically but there is no transactional guarantee over the complete putAll operation. If other concurrent operations modify or remove all or single values of the provided map, the result is undefined.

If the cache is configured for write-through operation mode, the underlying configured CacheWriter might be called to store the values of the keys to any kind of external resource.

Parameters:
map - the mappings to be stored in this cache
expiryPolicy - custom expiry policy for this operation, a null value is equivalent to Cache.putAll(java.util.Map)
Throws:
NullPointerException - if given map is null
javax.cache.CacheException - if anything exceptional happens while invoking the request, other exceptions are wrapped
See Also:
Cache.putAll(java.util.Map)

putIfAbsent

boolean putIfAbsent(K key,
                    V value,
                    javax.cache.expiry.ExpiryPolicy expiryPolicy)
Associates the specified key with the given value if and only if there is not yet a mapping for the specified key defined.

This is equivalent to:

   if (!cache.containsKey(key)) {}
     cache.put(key, value);
     return true;
   } else {
     return false;
   }
 
except that the action is performed atomically.

If the cache is configured for write-through operation mode, the underlying configured CacheWriter might be called to store the value of the key to any kind of external resource.

Parameters:
key - the key with which the specified value is to be associated
value - the value to be associated with the specified key
expiryPolicy - custom expiry policy for this operation, a null value is equivalent to Cache.putIfAbsent(Object, Object)
Returns:
true if a value was set
Throws:
NullPointerException - if given key or value is null
javax.cache.CacheException - if anything exceptional happens while invoking the request, other exceptions are wrapped
See Also:
javax.cache.Cache#putIfAbsent(K,V)

replace

boolean replace(K key,
                V oldValue,
                V newValue,
                javax.cache.expiry.ExpiryPolicy expiryPolicy)
Atomically replaces the currently assigned value for the given key with the specified newValue if and only if the currently assigned value equals the value of oldValue using a custom ExpiryPolicy.

This is equivalent to:

   if (cache.containsKey(key) && equals(cache.get(key), oldValue) {
     cache.put(key, newValue);
     return true;
   } else {
     return false;
   }
 
except that the action is performed atomically.

If the cache is configured for write-through operation mode, the underlying configured CacheWriter might be called to store the value of the key to any kind of external resource.

Parameters:
key - the key with which the specified value is associated
oldValue - the value expected to be associated with the specified key
newValue - the value to be associated with the specified key
expiryPolicy - custom expiry policy for this operation, a null value is equivalent to Cache.replace(Object, Object, Object)
Returns:
true if a value was replaced
Throws:
NullPointerException - if given key, oldValue or newValue is null
javax.cache.CacheException - if anything exceptional happens while invoking the request, other exceptions are wrapped
See Also:
javax.cache.Cache#replace(K,V,V)

replace

boolean replace(K key,
                V value,
                javax.cache.expiry.ExpiryPolicy expiryPolicy)
Atomically replaces the assigned value of the given key by the specified value using a custom ExpiryPolicy.

If the cache is configured for write-through operation mode, the underlying configured CacheWriter might be called to store the value of the key to any kind of external resource.

Parameters:
key - the key with which the specified value is associated
value - the value to be associated with the specified key
expiryPolicy - custom expiry policy for this operation, a null value is equivalent to Cache.replace(Object, Object)
Returns:
true if a value was replaced
Throws:
NullPointerException - if given key, oldValue or newValue is null
javax.cache.CacheException - if anything exceptional happens while invoking the request, other exceptions are wrapped
See Also:
javax.cache.Cache#replace(K,V)

getAndReplace

V getAndReplace(K key,
                V value,
                javax.cache.expiry.ExpiryPolicy expiryPolicy)
Atomically replaces the assigned value of the given key by the specified value using a custom ExpiryPolicy and returns the previously assigned value.

If the cache is configured for write-through operation mode, the underlying configured CacheWriter might be called to store the value of the key to any kind of external resource.

Parameters:
key - the key with which the specified value is associated
value - the value to be associated with the specified key
expiryPolicy - custom expiry policy for this operation, a null value is equivalent to Cache.getAndReplace(Object, Object)
Returns:
the value previously assigned to the given key
Throws:
NullPointerException - if given key or value is null
javax.cache.CacheException - if anything exceptional happens while invoking the request, other exceptions are wrapped
See Also:
javax.cache.Cache#getAndReplace(K,V)

size

int size()
Total entry count.

Returns:
total entry count

destroy

void destroy()
Closes the cache. Clears the internal content and releases any resource.

See Also:
CacheManager.destroyCache(String)

isDestroyed

boolean isDestroyed()
Determines whether this Cache instance has been destroyed.

Returns:
true if this Cache instance is destroyed; false if it is still open

getLocalCacheStatistics

CacheStatistics getLocalCacheStatistics()


Copyright © 2015 Hazelcast, Inc.. All Rights Reserved.