org.gridgain.grid.kernal.processors.cache.local.atomic

Class GridLocalAtomicCache<K,V>

java.lang.Object

org.gridgain.grid.util.lang.GridMetadataAwareAdapter

org.gridgain.grid.kernal.processors.cache.GridCacheAdapter<K,V>

org.gridgain.grid.kernal.processors.cache.local.atomic.GridLocalAtomicCache<K,V>

All Implemented Interfaces:

Externalizable, Serializable, Iterable<GridCacheEntry<K,V>>, GridCache<K,V>, GridCacheProjection<K,V>, GridMetadataAware, GridCacheProjectionEx<K,V>

public class GridLocalAtomicCache<K,V>
extends GridCacheAdapter<K,V>

Non-transactional local cache.

See Also:

Serialized Form

Nested Class Summary

Nested classes/interfaces inherited from class org.gridgain.grid.kernal.processors.cache.GridCacheAdapter

GridCacheAdapter.AsyncOp<T>, GridCacheAdapter.FutureHolder

Field Summary

Fields inherited from class org.gridgain.grid.kernal.processors.cache.GridCacheAdapter

afterPessimisticUnlock, beforePessimisticLock, cacheCfg, CLEAR_ALL_SPLIT_THRESHOLD, ctx, gridCfg, lastFut, locNodeId, log, map, metrics

Constructor Summary

Constructors

Constructor and Description
GridLocalAtomicCache() Empty constructor required by Externalizable.
GridLocalAtomicCache(GridCacheContext<K,V> ctx)

Method Summary

Methods

Modifier and Type	Method and Description
protected GridFuture	asyncOp(Callable<?> op)
V	get(K key, GridPredicate<GridCacheEntry<K,V>> filter)
Map<K,V>	getAll(Collection<? extends K> keys, GridPredicate<GridCacheEntry<K,V>> filter)
GridFuture<Map<K,V>>	getAllAsync(Collection<? extends K> keys, boolean forcePrimary, boolean skipTx, GridCacheEntryEx<K,V> entry, UUID subjId, GridPredicate<GridCacheEntry<K,V>>[] filter)
protected void	init() Post constructor initialization for subclasses.
boolean	isLocal()
GridFuture<Boolean>	lockAllAsync(Collection<? extends K> keys, long timeout, GridPredicate<GridCacheEntry<K,V>>... filter) All or nothing synchronous lock for passed in keys.
GridCacheTxLocalAdapter<K,V>	newTx(boolean implicit, boolean implicitSingle, GridCacheTxConcurrency concurrency, GridCacheTxIsolation isolation, long timeout, boolean invalidate, boolean syncCommit, boolean syncRollback, boolean swapOrOffheapEnabled, boolean storeEnabled, int txSize, Object grpLockKey, boolean partLock)
void	onDeferredDelete(GridCacheEntryEx<K,V> entry, GridCacheVersion ver)
GridCachePreloader<K,V>	preloader()
V	put(K key, V val, GridCacheEntryEx<K,V> cached, long ttl, GridPredicate<GridCacheEntry<K,V>>[] filter) Internal method that is called from GridCacheEntryImpl.
void	putAll(Map<? extends K,? extends V> m, GridPredicate<GridCacheEntry<K,V>>[] filter) Stores given key-value pairs in cache.
GridFuture<?>	putAllAsync(Map<? extends K,? extends V> m, GridPredicate<GridCacheEntry<K,V>>[] filter) Asynchronously stores given key-value pairs in cache.
GridFuture<V>	putAsync(K key, V val, GridCacheEntryEx<K,V> entry, long ttl, GridPredicate<GridCacheEntry<K,V>>... filter) Internal method that is called from GridCacheEntryImpl.
V	putIfAbsent(K key, V val) Stores given key-value pair in cache only if cache had no previous mapping for it.
GridFuture<V>	putIfAbsentAsync(K key, V val) Asynchronously stores given key-value pair in cache only if cache had no previous mapping for it.
boolean	putx(K key, V val, GridCacheEntryEx<K,V> cached, long ttl, GridPredicate<GridCacheEntry<K,V>>... filter) Internal method that is called from GridCacheEntryImpl.
boolean	putx(K key, V val, GridPredicate<GridCacheEntry<K,V>>[] filter) Stores given key-value pair in cache.
GridFuture<Boolean>	putxAsync(K key, V val, GridCacheEntryEx<K,V> entry, long ttl, GridPredicate<GridCacheEntry<K,V>>... filter) Internal method that is called from GridCacheEntryImpl.
boolean	putxIfAbsent(K key, V val) Stores given key-value pair in cache only if cache had no previous mapping for it.
GridFuture<Boolean>	putxIfAbsentAsync(K key, V val) Asynchronously stores given key-value pair in cache only if cache had no previous mapping for it.
V	remove(K key, GridCacheEntryEx<K,V> entry, GridPredicate<GridCacheEntry<K,V>>... filter) Internal method that is called from GridCacheEntryImpl.
boolean	remove(K key, V val) Removes given key mapping from cache if one exists and value is equal to the passed in value.
void	removeAll(Collection<? extends K> keys, GridPredicate<GridCacheEntry<K,V>>... filter) Removes given key mappings from cache for entries for which the optionally passed in filters do pass.
void	removeAll(GridPredicate<GridCacheEntry<K,V>>[] filter) Removes mappings from cache for entries for which the optionally passed in filters do pass.
GridFuture<?>	removeAllAsync(Collection<? extends K> keys, GridPredicate<GridCacheEntry<K,V>>[] filter) Asynchronously removes given key mappings from cache for entries for which the optionally passed in filters do pass.
GridFuture<?>	removeAllAsync(GridPredicate<GridCacheEntry<K,V>>[] filter) Asynchronously removes mappings from cache for entries for which the optionally passed in filters do pass.
GridFuture<V>	removeAsync(K key, GridCacheEntryEx<K,V> entry, GridPredicate<GridCacheEntry<K,V>>... filter) Internal method that is called from GridCacheEntryImpl.
GridFuture<Boolean>	removeAsync(K key, V val) Asynchronously removes given key mapping from cache if one exists and value is equal to the passed in value.
boolean	removex(K key, GridCacheEntryEx<K,V> entry, GridPredicate<GridCacheEntry<K,V>>... filter) Internal method that is called from GridCacheEntryImpl.
GridCacheReturn<V>	removex(K key, V val) Removes given key mapping from cache if one exists and value is equal to the passed in value.
GridFuture<Boolean>	removexAsync(K key, GridCacheEntryEx<K,V> entry, GridPredicate<GridCacheEntry<K,V>>... filter) Internal method that is called from GridCacheEntryImpl.
GridFuture<GridCacheReturn<V>>	removexAsync(K key, V val) Asynchronously removes given key mapping from cache if one exists and value is equal to the passed in value.
V	replace(K key, V val) Stores given key-value pair in cache only if if there is a previous mapping for it.
boolean	replace(K key, V oldVal, V newVal) Stores given key-value pair in cache only if only if the previous value is equal to the 'oldVal' passed in.
GridFuture<V>	replaceAsync(K key, V val) Asynchronously stores given key-value pair in cache only if if there is a previous mapping for it.
GridFuture<Boolean>	replaceAsync(K key, V oldVal, V newVal) Asynchronously stores given key-value pair in cache only if only if the previous value is equal to the 'oldVal' passed in.
boolean	replacex(K key, V val) Stores given key-value pair in cache only if only if there is a previous mapping for it.
GridCacheReturn<V>	replacex(K key, V oldVal, V newVal) Stores given key-value pair in cache only if only if the previous value is equal to the 'oldVal' passed in.
GridFuture<Boolean>	replacexAsync(K key, V val) Asynchronously stores given key-value pair in cache only if only if there is a previous mapping for it.
GridFuture<GridCacheReturn<V>>	replacexAsync(K key, V oldVal, V newVal) Asynchronously stores given key-value pair in cache only if only if the previous value is equal to the 'oldVal' passed in.
void	start() Starts this cache.
void	transform(K key, GridClosure<V,V> transformer) Stores result of applying valTransform closure to the previous value associated with given key in cache.
void	transformAll(Map<? extends K,? extends GridClosure<V,V>> m) Stores result of applying transform closures from the given map to previous values associated with corresponding keys in cache.
GridFuture<?>	transformAllAsync(Map<? extends K,? extends GridClosure<V,V>> m) Stores result of applying transform closures from the given map to previous values associated with corresponding keys in cache.
<R> R	transformAndCompute(K key, GridClosure<V,GridBiTuple<V,R>> transformer) Applies transformer closure to the previous value associated with given key in cache, closure should return GridBiTuple instance where first value is new value stored in cache and second value is returned as result of this method.
GridFuture<?>	transformAsync(K key, GridClosure<V,V> transformer, GridCacheEntryEx<K,V> entry, long ttl) Internal method that is called from GridCacheEntryImpl.
GridFuture<Boolean>	txLockAsync(Collection<? extends K> keys, long timeout, GridCacheTxLocalEx<K,V> tx, boolean isRead, boolean retval, GridCacheTxIsolation isolation, boolean invalidate, GridPredicate<GridCacheEntry<K,V>>[] filter)
void	unlockAll(Collection<? extends K> keys, GridPredicate<GridCacheEntry<K,V>>... filter) Unlocks given keys only if current thread owns the locks.

Methods inherited from class org.gridgain.grid.kernal.processors.cache.GridCacheAdapter

affinity, afterPessimisticUnlock, afterPessimisticUnlock, allEntries, asyncOp, asyncOpAcquire, asyncOpRelease, beforePessimisticLock, beforePessimisticLock, cache, checkJta, clear, clear0, clearAll, clearAll, clearAll0, compact, compact, compactAll, compactAll, configuration, containsAllKeys, containsAllValues, containsAnyKeys, containsAnyValues, containsKey, containsKey, containsValue, containsValue, context, dataStructures, dgc, dgc, drBackupQueueSize, drListStateTransfers, drPause, drPauseState, drResume, drStateTransfer, entries, entry, entryEx, entryEx, entryEx, entryExSafe, entrySet, entrySet, entrySet, entrySet, entrySetx, evict, evict, evictAll, evictAll, evictAll, flags, flagsOff, flagsOn, forAll, forceRepartition, forEach, forSubjectId, get, get, getAll, getAllAsync, getAllAsync, getAllAsync, getAllOutTx, getAllOutTxAsync, getAsync, getAsync, getForcePrimary, getForcePrimaryAsync, ggfsDataSpaceMax, ggfsDataSpaceUsed, globalClearAll, gridProjection, isColocated, isDht, isDhtAtomic, isDrSystemCache, isEmpty, isGgfsDataCache, isLocked, isLockedByThread, isMongoDataCache, isMongoMetaCache, isNear, iterator, keySet, keySet, loadCache, loadCacheAsync, lock, lockAll, lockAsync, log, map, metrics, metrics0, name, nearSize, offHeapAllocatedSize, offHeapEntriesCount, offHeapIterator, onGgfsDataSizeChanged, onKernalStart, onKernalStop, onUndeploy, overflowSize, peek, peek, peek, peek0, peek0, peek0, peekAll, peekAll0, peekAll0, peekEx, predicate, primaryEntrySet, primaryEntrySet, primaryKeySet, primaryKeySet, primarySize, primaryValues, primaryValues, printMemoryStats, processCheckCommittedTxRequest, processCheckCommittedTxResponse, processCheckPreparedTxRequest, processCheckPreparedTxResponse, projection, projection, projection, promote, promoteAll, put, putAllDr, putAllDrAsync, putAsync, putxAsync, queries, randomEntry, readExternal, readResolve, readThroughAllAsync, reload, reload, reloadAll, reloadAll, reloadAll, reloadAll, reloadAll, reloadAllAsync, reloadAllAsync, reloadAllAsync, reloadAllAsync, reloadAllAsync, reloadAsync, reloadAsync, remove, removeAllDr, removeAllDrAsync, removeAsync, removeEntry, removeIfObsolete, removex, removexAsync, resetMetrics, saveFuture, size, splitClearAll, startInfo, stop, stopInfo, swapIterator, swapKeys, swapSize, toMap, toString, transformAll, transformAllAsync, transformAsync, tx, txStart, txStart, txStart, txStartAffinity, txStartPartition, txSynchronizations, txSynchronize, txUnsynchronize, unlock, values, values, wrappers, writeExternal

Methods inherited from class org.gridgain.grid.util.lang.GridMetadataAwareAdapter

addMeta, addMetaIfAbsent, addMetaIfAbsent, allMeta, clone, copyMeta, copyMeta, hasMeta, hasMeta, meta, putMetaIfAbsent, putMetaIfAbsent, readExternalMeta, removeMeta, removeMeta, replaceMeta, writeExternalMeta

Methods inherited from class java.lang.Object

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

Methods inherited from interface org.gridgain.grid.GridMetadataAware

addMeta, addMetaIfAbsent, addMetaIfAbsent, allMeta, copyMeta, copyMeta, hasMeta, hasMeta, meta, putMetaIfAbsent, putMetaIfAbsent, removeMeta, removeMeta, replaceMeta

Constructor Detail

GridLocalAtomicCache

public GridLocalAtomicCache()

Empty constructor required by Externalizable.

GridLocalAtomicCache

public GridLocalAtomicCache(GridCacheContext<K,V> ctx)

Parameters:

ctx - Cache context.

Method Detail

init

protected void init()

Post constructor initialization for subclasses.

Overrides:

init in class GridCacheAdapter<K,V>

start

public void start()
           throws GridException

Starts this cache. Child classes should override this method to provide custom start-up behavior.

Overrides:

start in class GridCacheAdapter<K,V>

Throws:

GridException - If start failed.

isLocal

public boolean isLocal()

Overrides:

isLocal in class GridCacheAdapter<K,V>

Returns:

True if cache is local.

preloader

public GridCachePreloader<K,V> preloader()

Specified by:

preloader in class GridCacheAdapter<K,V>

Returns:

Preloader.

put

public V put(K key,
    V val,
    @Nullable
    GridCacheEntryEx<K,V> cached,
    long ttl,
    @Nullable
    GridPredicate<GridCacheEntry<K,V>>[] filter)
      throws GridException

Internal method that is called from GridCacheEntryImpl.

Specified by:

put in interface GridCacheProjectionEx<K,V>

Overrides:

put in class GridCacheAdapter<K,V>

Parameters:

key - Key.

val - Value.

cached - Cached entry. If not provided, equivalent to {GridCacheProjection#put}.

ttl - Optional time-to-live. If negative, leaves ttl value unchanged.

filter - Optional filter.

Returns:

Previous value.

Throws:

GridException - If failed.

putx

public boolean putx(K key,
           V val,
           @Nullable
           GridCacheEntryEx<K,V> cached,
           long ttl,
           @Nullable
           GridPredicate<GridCacheEntry<K,V>>... filter)
             throws GridException

Internal method that is called from GridCacheEntryImpl.

Specified by:

putx in interface GridCacheProjectionEx<K,V>

Overrides:

putx in class GridCacheAdapter<K,V>

Parameters:

key - Key.

val - Value.

cached - Cached entry. If not provided, equivalent to {GridCacheProjection#put}.

ttl - Optional time-to-live. If negative, leaves ttl value unchanged.

filter - Optional filter.

Returns:

Previous value.

Throws:

GridException - If failed.

putx

public boolean putx(K key,
           V val,
           GridPredicate<GridCacheEntry<K,V>>[] filter)
             throws GridException

Stores given key-value pair in cache. If filters are provided, then entries will be stored in cache only if they pass the filter. Note that filter check is atomic, so value stored in cache is guaranteed to be consistent with the filters.

This method will return true if value is stored in cache and false otherwise. Unlike GridCacheProjection.put(Object, Object, GridPredicate[]) method, it does not return previous value and, therefore, does not have any overhead associated with returning a value. It should be used whenever return value is not required.

If write-through is enabled, the stored value will be persisted to GridCacheStore via GridCacheStore.put(GridCacheTx, Object, Object) method.

Transactions

This method is transactional and will enlist the entry into ongoing transaction if there is one.

Cache Flags

This method is not available if any of the following flags are set on projection: GridCacheFlag.LOCAL, GridCacheFlag.READ.

Specified by:

putx in interface GridCacheProjection<K,V>

Overrides:

putx in class GridCacheAdapter<K,V>

Parameters:

key - Key to store in cache.

val - Value to be associated with the given key.

filter - Optional filter to check prior to putting value in cache. Note that filter check is atomic with put operation.

Returns:

True if optional filter passed and value was stored in cache, false otherwise. Note that this method will return true if filter is not specified.

Throws:

GridException - If put operation failed.

putAsync

public GridFuture<V> putAsync(K key,
                     V val,
                     @Nullable
                     GridCacheEntryEx<K,V> entry,
                     long ttl,
                     @Nullable
                     GridPredicate<GridCacheEntry<K,V>>... filter)

Internal method that is called from GridCacheEntryImpl.

Specified by:

putAsync in interface GridCacheProjectionEx<K,V>

Overrides:

putAsync in class GridCacheAdapter<K,V>

Parameters:

key - Key.

val - Value.

entry - Optional cached entry.

ttl - Optional time-to-live value. If negative, leaves ttl value unchanged.

filter - Optional filter.

Returns:

Put operation future.

putxAsync

public GridFuture<Boolean> putxAsync(K key,
                            V val,
                            @Nullable
                            GridCacheEntryEx<K,V> entry,
                            long ttl,
                            @Nullable
                            GridPredicate<GridCacheEntry<K,V>>... filter)

Internal method that is called from GridCacheEntryImpl.

Specified by:

putxAsync in interface GridCacheProjectionEx<K,V>

Overrides:

putxAsync in class GridCacheAdapter<K,V>

Parameters:

key - Key.

val - Value.

entry - Cached entry. If not provided, equivalent to {GridCacheProjection#put}.

ttl - Optional time-to-live. If negative, leave ttl value unchanged.

filter - Optional filter.

Returns:

Putx operation future.

putIfAbsent

public V putIfAbsent(K key,
            V val)
              throws GridException

Stores given key-value pair in cache only if cache had no previous mapping for it. If cache previously contained value for the given key, then this value is returned. In case of GridCacheMode.PARTITIONED or GridCacheMode.REPLICATED caches, the value will be loaded from the primary node, which in its turn may load the value from the swap storage, and consecutively, if it's not in swap, from the underlying persistent storage. If value has to be loaded from persistent storage, GridCacheStore.load(GridCacheTx, Object) method will be used.

If the returned value is not needed, method GridCacheProjection.putxIfAbsent(Object, Object) should always be used instead of this one to avoid the overhead associated with returning of the previous value.

If write-through is enabled, the stored value will be persisted to GridCacheStore via GridCacheStore.put(GridCacheTx, Object, Object) method.

Transactions

This method is transactional and will enlist the entry into ongoing transaction if there is one.

Cache Flags

This method is not available if any of the following flags are set on projection: GridCacheFlag.LOCAL, GridCacheFlag.READ.

Specified by:

putIfAbsent in interface GridCacheProjection<K,V>

Overrides:

putIfAbsent in class GridCacheAdapter<K,V>

Parameters:

key - Key to store in cache.

val - Value to be associated with the given key.

Returns:

Previously contained value regardless of whether put happened or not.

Throws:

GridException - If put operation failed.

putIfAbsentAsync

public GridFuture<V> putIfAbsentAsync(K key,
                             V val)

Asynchronously stores given key-value pair in cache only if cache had no previous mapping for it. If cache previously contained value for the given key, then this value is returned. In case of GridCacheMode.PARTITIONED or GridCacheMode.REPLICATED caches, the value will be loaded from the primary node, which in its turn may load the value from the swap storage, and consecutively, if it's not in swap, from the underlying persistent storage. If value has to be loaded from persistent storage, GridCacheStore.load(GridCacheTx, Object) method will be used.

If the returned value is not needed, method GridCacheProjection.putxIfAbsentAsync(Object, Object) should always be used instead of this one to avoid the overhead associated with returning of the previous value.

If write-through is enabled, the stored value will be persisted to GridCacheStore via GridCacheStore.put(GridCacheTx, Object, Object) method.

Transactions

This method is transactional and will enlist the entry into ongoing transaction if there is one.

Cache Flags

This method is not available if any of the following flags are set on projection: GridCacheFlag.LOCAL, GridCacheFlag.READ.

Specified by:

putIfAbsentAsync in interface GridCacheProjection<K,V>

Overrides:

putIfAbsentAsync in class GridCacheAdapter<K,V>

Parameters:

key - Key to store in cache.

val - Value to be associated with the given key.

Returns:

Future of put operation which will provide previously contained value regardless of whether put happened or not.

putxIfAbsent

public boolean putxIfAbsent(K key,
                   V val)
                     throws GridException

Stores given key-value pair in cache only if cache had no previous mapping for it.

This method will return true if value is stored in cache and false otherwise. Unlike GridCacheProjection.putIfAbsent(Object, Object) method, it does not return previous value and, therefore, does not have any overhead associated with returning of a value. It should always be used whenever return value is not required.

If write-through is enabled, the stored value will be persisted to GridCacheStore via GridCacheStore.put(GridCacheTx, Object, Object) method.

Transactions

This method is transactional and will enlist the entry into ongoing transaction if there is one.

Cache Flags

This method is not available if any of the following flags are set on projection: GridCacheFlag.LOCAL, GridCacheFlag.READ.

Specified by:

putxIfAbsent in interface GridCacheProjection<K,V>

Overrides:

putxIfAbsent in class GridCacheAdapter<K,V>

Parameters:

key - Key to store in cache.

val - Value to be associated with the given key.

Returns:

true if value is stored in cache and false otherwise.

Throws:

GridException - If put operation failed.

putxIfAbsentAsync

public GridFuture<Boolean> putxIfAbsentAsync(K key,
                                    V val)

Asynchronously stores given key-value pair in cache only if cache had no previous mapping for it.

This method will return true if value is stored in cache and false otherwise. Unlike GridCacheProjection.putIfAbsent(Object, Object) method, it does not return previous value and, therefore, does not have any overhead associated with returning of a value. It should always be used whenever return value is not required.

If write-through is enabled, the stored value will be persisted to GridCacheStore via GridCacheStore.put(GridCacheTx, Object, Object) method.

Transactions

This method is transactional and will enlist the entry into ongoing transaction if there is one.

Cache Flags

This method is not available if any of the following flags are set on projection: GridCacheFlag.LOCAL, GridCacheFlag.READ.

Specified by:

putxIfAbsentAsync in interface GridCacheProjection<K,V>

Overrides:

putxIfAbsentAsync in class GridCacheAdapter<K,V>

Parameters:

key - Key to store in cache.

val - Value to be associated with the given key.

Returns:

Future for this put operation.

replace

public V replace(K key,
        V val)
          throws GridException

Stores given key-value pair in cache only if if there is a previous mapping for it. In case of GridCacheMode.PARTITIONED or GridCacheMode.REPLICATED caches, the value will be loaded from the primary node, which in its turn may load the value from the swap storage, and consecutively, if it's not in swap, from the underlying persistent storage. If value has to be loaded from persistent storage, GridCacheStore.load(GridCacheTx, Object) method will be used.

If the returned value is not needed, method GridCacheProjection.replacex(Object, Object) should always be used instead of this one to avoid the overhead associated with returning of the previous value.

If write-through is enabled, the stored value will be persisted to GridCacheStore via GridCacheStore.put(GridCacheTx, Object, Object) method.

Transactions

This method is transactional and will enlist the entry into ongoing transaction if there is one.

Cache Flags

This method is not available if any of the following flags are set on projection: GridCacheFlag.LOCAL, GridCacheFlag.READ.

Specified by:

replace in interface GridCacheProjection<K,V>

Overrides:

replace in class GridCacheAdapter<K,V>

Parameters:

key - Key to store in cache.

val - Value to be associated with the given key.

Returns:

Previously contained value regardless of whether replace happened or not.

Throws:

GridException - If replace operation failed.

replaceAsync

public GridFuture<V> replaceAsync(K key,
                         V val)

Asynchronously stores given key-value pair in cache only if if there is a previous mapping for it. If cache previously contained value for the given key, then this value is returned.In case of GridCacheMode.PARTITIONED caches, the value will be loaded from the primary node, which in its turn may load the value from the swap storage, and consecutively, if it's not in swap, from the underlying persistent storage. If value has to be loaded from persistent storage, GridCacheStore.load(GridCacheTx, Object) method will be used.

If the returned value is not needed, method GridCacheProjection.replacex(Object, Object) should always be used instead of this one to avoid the overhead associated with returning of the previous value.

If write-through is enabled, the stored value will be persisted to GridCacheStore via GridCacheStore.put(GridCacheTx, Object, Object) method.

Transactions

This method is transactional and will enlist the entry into ongoing transaction if there is one.

Cache Flags

This method is not available if any of the following flags are set on projection: GridCacheFlag.LOCAL, GridCacheFlag.READ.

Specified by:

replaceAsync in interface GridCacheProjection<K,V>

Overrides:

replaceAsync in class GridCacheAdapter<K,V>

Parameters:

key - Key to store in cache.

val - Value to be associated with the given key.

Returns:

Future for replace operation.

replacex

public boolean replacex(K key,
               V val)
                 throws GridException

Stores given key-value pair in cache only if only if there is a previous mapping for it.

This method will return true if value is stored in cache and false otherwise. Unlike GridCacheProjection.replace(Object, Object) method, it does not return previous value and, therefore, does not have any overhead associated with returning of a value. It should always be used whenever return value is not required.

If write-through is enabled, the stored value will be persisted to GridCacheStore via GridCacheStore.put(GridCacheTx, Object, Object) method.

Transactions

This method is transactional and will enlist the entry into ongoing transaction if there is one.

Cache Flags

This method is not available if any of the following flags are set on projection: GridCacheFlag.LOCAL, GridCacheFlag.READ.

Specified by:

replacex in interface GridCacheProjection<K,V>

Overrides:

replacex in class GridCacheAdapter<K,V>

Parameters:

key - Key to store in cache.

val - Value to be associated with the given key.

Returns:

True if replace happened, false otherwise.

Throws:

GridException - If replace operation failed.

replacexAsync

public GridFuture<Boolean> replacexAsync(K key,
                                V val)

Asynchronously stores given key-value pair in cache only if only if there is a previous mapping for it.

This method will return true if value is stored in cache and false otherwise. Unlike GridCacheProjection.replaceAsync(Object, Object) method, it does not return previous value and, therefore, does not have any overhead associated with returning of a value. It should always be used whenever return value is not required.

If write-through is enabled, the stored value will be persisted to GridCacheStore via GridCacheStore.put(GridCacheTx, Object, Object) method.

Transactions

This method is transactional and will enlist the entry into ongoing transaction if there is one.

Cache Flags

This method is not available if any of the following flags are set on projection: GridCacheFlag.LOCAL, GridCacheFlag.READ.

Specified by:

replacexAsync in interface GridCacheProjection<K,V>

Overrides:

replacexAsync in class GridCacheAdapter<K,V>

Parameters:

key - Key to store in cache.

val - Value to be associated with the given key.

Returns:

Future for the replace operation.

replace

public boolean replace(K key,
              V oldVal,
              V newVal)
                throws GridException

Stores given key-value pair in cache only if only if the previous value is equal to the 'oldVal' passed in.

This method will return true if value is stored in cache and false otherwise.

If write-through is enabled, the stored value will be persisted to GridCacheStore via GridCacheStore.put(GridCacheTx, Object, Object) method.

Transactions

This method is transactional and will enlist the entry into ongoing transaction if there is one.

Cache Flags

This method is not available if any of the following flags are set on projection: GridCacheFlag.LOCAL, GridCacheFlag.READ.

Specified by:

replace in interface GridCacheProjection<K,V>

Overrides:

replace in class GridCacheAdapter<K,V>

Parameters:

key - Key to store in cache.

oldVal - Old value to match.

newVal - Value to be associated with the given key.

Returns:

True if replace happened, false otherwise.

Throws:

GridException - If replace operation failed.

replaceAsync

public GridFuture<Boolean> replaceAsync(K key,
                               V oldVal,
                               V newVal)

Asynchronously stores given key-value pair in cache only if only if the previous value is equal to the 'oldVal' passed in.

This method will return true if value is stored in cache and false otherwise.

If write-through is enabled, the stored value will be persisted to GridCacheStore via GridCacheStore.put(GridCacheTx, Object, Object) method.

Transactions

This method is transactional and will enlist the entry into ongoing transaction if there is one.

Cache Flags

This method is not available if any of the following flags are set on projection: GridCacheFlag.LOCAL, GridCacheFlag.READ.

Specified by:

replaceAsync in interface GridCacheProjection<K,V>

Overrides:

replaceAsync in class GridCacheAdapter<K,V>

Parameters:

key - Key to store in cache.

oldVal - Old value to match.

newVal - Value to be associated with the given key.

Returns:

Future for the replace operation.

replacex

public GridCacheReturn<V> replacex(K key,
                          V oldVal,
                          V newVal)
                            throws GridException

Stores given key-value pair in cache only if only if the previous value is equal to the 'oldVal' passed in.

This method will return true if value is stored in cache and false otherwise.

If write-through is enabled, the stored value will be persisted to GridCacheStore via GridCacheStore.put(GridCacheTx, Object, Object) method.

Transactions

This method is transactional and will enlist the entry into ongoing transaction if there is one.

Cache Flags

This method is not available if any of the following flags are set on projection: GridCacheFlag.LOCAL, GridCacheFlag.READ.

Specified by:

replacex in interface GridCacheProjectionEx<K,V>

Overrides:

replacex in class GridCacheAdapter<K,V>

Parameters:

key - Key to store in cache.

oldVal - Old value to match.

newVal - Value to be associated with the given key.

Returns:

Object containing actual old value and success flag.

Throws:

GridException - If replace operation failed.

removex

public GridCacheReturn<V> removex(K key,
                         V val)
                           throws GridException

Removes given key mapping from cache if one exists and value is equal to the passed in value.

If write-through is enabled, the value will be removed from GridCacheStore via GridCacheStore.remove(GridCacheTx, Object) method.

Transactions

This method is transactional and will enlist the entry into ongoing transaction if there is one.

Cache Flags

This method is not available if any of the following flags are set on projection: GridCacheFlag.LOCAL, GridCacheFlag.READ.

Specified by:

removex in interface GridCacheProjectionEx<K,V>

Overrides:

removex in class GridCacheAdapter<K,V>

Parameters:

key - Key whose mapping is to be removed from cache.

val - Value to match against currently cached value.

Returns:

Object containing actual old value and success flag.

Throws:

GridException - If remove failed.

removexAsync

public GridFuture<GridCacheReturn<V>> removexAsync(K key,
                                          V val)

Asynchronously removes given key mapping from cache if one exists and value is equal to the passed in value.

This method will return true if remove did occur, which means that all optionally provided filters have passed and there was something to remove, false otherwise.

If write-through is enabled, the value will be removed from GridCacheStore via GridCacheStore.remove(GridCacheTx, Object) method.

Transactions

This method is transactional and will enlist the entry into ongoing transaction if there is one.

Cache Flags

This method is not available if any of the following flags are set on projection: GridCacheFlag.LOCAL, GridCacheFlag.READ.

Specified by:

removexAsync in interface GridCacheProjectionEx<K,V>

Overrides:

removexAsync in class GridCacheAdapter<K,V>

Parameters:

key - Key whose mapping is to be removed from cache.

val - Value to match against currently cached value.

Returns:

Future for the remove operation. The future will return object containing actual old value and success flag.

replacexAsync

public GridFuture<GridCacheReturn<V>> replacexAsync(K key,
                                           V oldVal,
                                           V newVal)

Asynchronously stores given key-value pair in cache only if only if the previous value is equal to the 'oldVal' passed in.

This method will return true if value is stored in cache and false otherwise.

If write-through is enabled, the stored value will be persisted to GridCacheStore via GridCacheStore.put(GridCacheTx, Object, Object) method.

Transactions

This method is transactional and will enlist the entry into ongoing transaction if there is one.

Cache Flags

This method is not available if any of the following flags are set on projection: GridCacheFlag.LOCAL, GridCacheFlag.READ.

Specified by:

replacexAsync in interface GridCacheProjectionEx<K,V>

Overrides:

replacexAsync in class GridCacheAdapter<K,V>

Parameters:

key - Key to store in cache.

oldVal - Old value to match.

newVal - Value to be associated with the given key.

Returns:

Future for the replace operation. The future will return object containing actual old value and success flag.

putAll

public void putAll(Map<? extends K,? extends V> m,
          GridPredicate<GridCacheEntry<K,V>>[] filter)
            throws GridException

Stores given key-value pairs in cache. If filters are provided, then entries will be stored in cache only if they pass the filter. Note that filter check is atomic, so value stored in cache is guaranteed to be consistent with the filters.

If write-through is enabled, the stored values will be persisted to GridCacheStore via GridCacheStore.putAll(GridCacheTx, Map) method.

Transactions

This method is transactional and will enlist the entry into ongoing transaction if there is one.

Cache Flags

This method is not available if any of the following flags are set on projection: GridCacheFlag.LOCAL, GridCacheFlag.READ.

Specified by:

putAll in interface GridCacheProjection<K,V>

Overrides:

putAll in class GridCacheAdapter<K,V>

Parameters:

m - Key-value pairs to store in cache.

filter - Optional entry filter. If provided, then entry will be stored only if the filter returned true.

Throws:

GridException - If put operation failed.

putAllAsync

public GridFuture<?> putAllAsync(Map<? extends K,? extends V> m,
                        @Nullable
                        GridPredicate<GridCacheEntry<K,V>>[] filter)

Asynchronously stores given key-value pairs in cache. If filters are provided, then entries will be stored in cache only if they pass the filter. Note that filter check is atomic, so value stored in cache is guaranteed to be consistent with the filters.

If write-through is enabled, the stored values will be persisted to GridCacheStore via GridCacheStore.putAll(GridCacheTx, Map) method.

Transactions

This method is transactional and will enlist the entry into ongoing transaction if there is one.

Cache Flags

This method is not available if any of the following flags are set on projection: GridCacheFlag.LOCAL, GridCacheFlag.READ.

Specified by:

putAllAsync in interface GridCacheProjection<K,V>

Overrides:

putAllAsync in class GridCacheAdapter<K,V>

Parameters:

m - Key-value pairs to store in cache.

filter - Optional entry filter. If provided, then entry will be stored only if the filter returned true.

Returns:

Future for putAll operation.

transform

public void transform(K key,
             GridClosure<V,V> transformer)
               throws GridException

Stores result of applying valTransform closure to the previous value associated with given key in cache. Result of closure application is guaranteed to be atomic, however, closure itself can be applied more than once.

Note that transform closure must not throw any exceptions. If exception is thrown from apply method, the transaction will be invalidated and entries participating in transaction will be nullified.

Unlike GridCacheProjection.putx(Object, Object, GridPredicate[]) or GridCacheProjection.put(Object, Object, GridPredicate[]) methods, this method will not transfer the whole updated value over the network, but instead will transfer the transforming closure that will be applied on each remote node involved in transaction. It may add significant performance gain when dealing with large values as the value is much larger than the closure itself. If write-through is enabled, the stored value will be persisted to GridCacheStore via GridCacheStore.put(GridCacheTx, Object, Object) method.

Transactions

This method is transactional and will enlist the entry into ongoing transaction if there is one.

Cache Flags

This method is not available if any of the following flags are set on projection: GridCacheFlag.LOCAL, GridCacheFlag.READ.

Specified by:

transform in interface GridCacheProjection<K,V>

Overrides:

transform in class GridCacheAdapter<K,V>

Parameters:

key - Key to store in cache.

transformer - Closure to be applied to the previous value in cache. If this closure returns null, the associated value will be removed from cache.

Throws:

GridException - On any error occurred while storing value in cache.

transformAndCompute

public <R> R transformAndCompute(K key,
                        GridClosure<V,GridBiTuple<V,R>> transformer)
                      throws GridException

Applies transformer closure to the previous value associated with given key in cache, closure should return GridBiTuple instance where first value is new value stored in cache and second value is returned as result of this method.

Transactions

This method is transactional and will enlist the entry into ongoing transaction if there is one.

Cache Flags

This method is not available if any of the following flags are set on projection: GridCacheFlag.LOCAL, GridCacheFlag.READ.

Specified by:

transformAndCompute in interface GridCacheProjection<K,V>

Overrides:

transformAndCompute in class GridCacheAdapter<K,V>

Parameters:

key - Key to store in cache.

transformer - Closure to be applied to the previous value in cache.

Returns:

Value computed by the closure.

Throws:

GridException - On any error occurred while storing value in cache.

transformAsync

public GridFuture<?> transformAsync(K key,
                           GridClosure<V,V> transformer,
                           @Nullable
                           GridCacheEntryEx<K,V> entry,
                           long ttl)

Internal method that is called from GridCacheEntryImpl.

Specified by:

transformAsync in interface GridCacheProjectionEx<K,V>

Overrides:

transformAsync in class GridCacheAdapter<K,V>

Parameters:

key - Key.

transformer - Transformer closure.

entry - Cached entry.

ttl - Optional time-to-lve.

Returns:

Transform operation future.

transformAll

public void transformAll(@Nullable
                Map<? extends K,? extends GridClosure<V,V>> m)
                  throws GridException

Stores result of applying transform closures from the given map to previous values associated with corresponding keys in cache. Execution of closure is guaranteed to be atomic, however, closure itself can be applied more than once.

Note that transform closure must not throw any exceptions. If exception is thrown from apply method, the transaction will be invalidated and entries participating in transaction will be nullified.

Unlike GridCacheProjection.putAll(Map, GridPredicate[]) method, this method will not transfer the whole updated value over the network, but instead will transfer the transforming closures that will be applied on each remote node involved in transaction. It may add significant performance gain when dealing with large values as the value is much larger than the closure itself. If write-through is enabled, the stored value will be persisted to GridCacheStore via GridCacheStore.put(GridCacheTx, Object, Object) method.

Transactions

This method is transactional and will enlist the entry into ongoing transaction if there is one.

Cache Flags

This method is not available if any of the following flags are set on projection: GridCacheFlag.LOCAL, GridCacheFlag.READ.

Specified by:

transformAll in interface GridCacheProjection<K,V>

Overrides:

transformAll in class GridCacheAdapter<K,V>

Parameters:

m - Map containing keys and closures to be applied to values.

Throws:

GridException - On any error occurred while storing value in cache.

transformAllAsync

public GridFuture<?> transformAllAsync(@Nullable
                              Map<? extends K,? extends GridClosure<V,V>> m)

Stores result of applying transform closures from the given map to previous values associated with corresponding keys in cache. Result of closure application is guaranteed to be atomic, however, closure itself can be applied more than once.

Note that transform closure must not throw any exceptions. If exception is thrown from apply method, the transaction will be invalidated and entries participating in transaction will be nullified.

Unlike GridCacheProjection.putAll(Map, GridPredicate[]) method, this method will not transfer the whole updated value over the network, but instead will transfer the transforming closures that will be applied on each remote node involved in transaction. It may add significant performance gain when dealing with large values as the value is much larger than the closure itself. If write-through is enabled, the stored value will be persisted to GridCacheStore via GridCacheStore.put(GridCacheTx, Object, Object) method.

Transactions

This method is transactional and will enlist the entry into ongoing transaction if there is one.

Cache Flags

This method is not available if any of the following flags are set on projection: GridCacheFlag.LOCAL, GridCacheFlag.READ.

Specified by:

transformAllAsync in interface GridCacheProjection<K,V>

Overrides:

transformAllAsync in class GridCacheAdapter<K,V>

Parameters:

m - Map containing keys and closures to be applied to values.

Returns:

Future for operation.

remove

public V remove(K key,
       @Nullable
       GridCacheEntryEx<K,V> entry,
       @Nullable
       GridPredicate<GridCacheEntry<K,V>>... filter)
         throws GridException

Internal method that is called from GridCacheEntryImpl.

Specified by:

remove in interface GridCacheProjectionEx<K,V>

Overrides:

remove in class GridCacheAdapter<K,V>

Parameters:

key - Key to remove.

entry - Cached entry. If not provided, equivalent to {GridCacheProjection#put}.

filter - Optional filter.

Returns:

Previous value.

Throws:

GridException - If failed.

removeAsync

public GridFuture<V> removeAsync(K key,
                        @Nullable
                        GridCacheEntryEx<K,V> entry,
                        @Nullable
                        GridPredicate<GridCacheEntry<K,V>>... filter)

Internal method that is called from GridCacheEntryImpl.

Specified by:

removeAsync in interface GridCacheProjectionEx<K,V>

Overrides:

removeAsync in class GridCacheAdapter<K,V>

Parameters:

key - Key to remove.

entry - Optional cached entry.

filter - Optional filter.

Returns:

Put operation future.

removeAll

public void removeAll(Collection<? extends K> keys,
             GridPredicate<GridCacheEntry<K,V>>... filter)
               throws GridException

Removes given key mappings from cache for entries for which the optionally passed in filters do pass.

If write-through is enabled, the values will be removed from GridCacheStore via GridCacheStore.removeAll(GridCacheTx, Collection) method.

Transactions

This method is transactional and will enlist the entry into ongoing transaction if there is one.

Cache Flags

This method is not available if any of the following flags are set on projection: GridCacheFlag.LOCAL, GridCacheFlag.READ.

Specified by:

removeAll in interface GridCacheProjection<K,V>

Overrides:

removeAll in class GridCacheAdapter<K,V>

Parameters:

keys - Keys whose mappings are to be removed from cache.

filter - Optional filter to check prior to removing value form cache. Note that filter is checked atomically together with remove operation.

Throws:

GridException - If remove failed.

removeAllAsync

public GridFuture<?> removeAllAsync(Collection<? extends K> keys,
                           GridPredicate<GridCacheEntry<K,V>>[] filter)

Asynchronously removes given key mappings from cache for entries for which the optionally passed in filters do pass.

If write-through is enabled, the values will be removed from GridCacheStore via GridCacheStore.removeAll(GridCacheTx, Collection) method.

Transactions

This method is transactional and will enlist the entry into ongoing transaction if there is one.

Cache Flags

This method is not available if any of the following flags are set on projection: GridCacheFlag.LOCAL, GridCacheFlag.READ.

Specified by:

removeAllAsync in interface GridCacheProjection<K,V>

Overrides:

removeAllAsync in class GridCacheAdapter<K,V>

Parameters:

keys - Keys whose mappings are to be removed from cache.

filter - Optional filter to check prior to removing value form cache. Note that filter is checked atomically together with remove operation.

Returns:

Future for the remove operation. The future will complete whenever remove operation completes.

removex

public boolean removex(K key,
              @Nullable
              GridCacheEntryEx<K,V> entry,
              @Nullable
              GridPredicate<GridCacheEntry<K,V>>... filter)
                throws GridException

Internal method that is called from GridCacheEntryImpl.

Specified by:

removex in interface GridCacheProjectionEx<K,V>

Overrides:

removex in class GridCacheAdapter<K,V>

Parameters:

key - Key to remove.

entry - Cached entry. If not provided, equivalent to {GridCacheProjection#put}.

filter - Optional filter.

Returns:

Previous value.

Throws:

GridException - If failed.

removexAsync

public GridFuture<Boolean> removexAsync(K key,
                               @Nullable
                               GridCacheEntryEx<K,V> entry,
                               @Nullable
                               GridPredicate<GridCacheEntry<K,V>>... filter)

Internal method that is called from GridCacheEntryImpl.

Specified by:

removexAsync in interface GridCacheProjectionEx<K,V>

Overrides:

removexAsync in class GridCacheAdapter<K,V>

Parameters:

key - Key to remove.

entry - Cached entry. If not provided, equivalent to {GridCacheProjection#put}.

filter - Optional filter.

Returns:

Putx operation future.

remove

public boolean remove(K key,
             V val)
               throws GridException

Removes given key mapping from cache if one exists and value is equal to the passed in value.

If write-through is enabled, the value will be removed from GridCacheStore via GridCacheStore.remove(GridCacheTx, Object) method.

Transactions

This method is transactional and will enlist the entry into ongoing transaction if there is one.

Cache Flags

This method is not available if any of the following flags are set on projection: GridCacheFlag.LOCAL, GridCacheFlag.READ.

Specified by:

remove in interface GridCacheProjection<K,V>

Overrides:

remove in class GridCacheAdapter<K,V>

Parameters:

key - Key whose mapping is to be removed from cache.

val - Value to match against currently cached value.

Returns:

True if entry was removed and passed in value matched the cached one, false otherwise.

Throws:

GridException - If remove failed.

removeAsync

public GridFuture<Boolean> removeAsync(K key,
                              V val)

Asynchronously removes given key mapping from cache if one exists and value is equal to the passed in value.

This method will return true if remove did occur, which means that all optionally provided filters have passed and there was something to remove, false otherwise.

If write-through is enabled, the value will be removed from GridCacheStore via GridCacheStore.remove(GridCacheTx, Object) method.

Transactions

This method is transactional and will enlist the entry into ongoing transaction if there is one.

Cache Flags

This method is not available if any of the following flags are set on projection: GridCacheFlag.LOCAL, GridCacheFlag.READ.

Specified by:

removeAsync in interface GridCacheProjection<K,V>

Overrides:

removeAsync in class GridCacheAdapter<K,V>

Parameters:

key - Key whose mapping is to be removed from cache.

val - Value to match against currently cached value.

Returns:

Future for the remove operation. The future will return true if currently cached value will match the passed in one.

removeAll

public void removeAll(GridPredicate<GridCacheEntry<K,V>>[] filter)
               throws GridException

Removes mappings from cache for entries for which the optionally passed in filters do pass. If passed in filters are null, then all entries in cache will be enrolled into transaction.

USE WITH CARE - if your cache has many entries that pass through the filter or if filter is empty, then transaction will quickly become very heavy and slow. Also, locks are acquired in undefined order, so it may cause a deadlock when used with other concurrent transactional updates.

If write-through is enabled, the values will be removed from GridCacheStore via GridCacheStore.removeAll(GridCacheTx, Collection) method.

Transactions

This method is transactional and will enlist the entry into ongoing transaction if there is one.

Cache Flags

This method is not available if any of the following flags are set on projection: GridCacheFlag.LOCAL, GridCacheFlag.READ.

Specified by:

removeAll in interface GridCacheProjection<K,V>

Overrides:

removeAll in class GridCacheAdapter<K,V>

Parameters:

filter - Filter used to supply keys for remove operation (if null, then nothing will be removed).

Throws:

GridException - If remove failed.

removeAllAsync

public GridFuture<?> removeAllAsync(GridPredicate<GridCacheEntry<K,V>>[] filter)

Asynchronously removes mappings from cache for entries for which the optionally passed in filters do pass. If passed in filters are null, then all entries in cache will be enrolled into transaction.

USE WITH CARE - if your cache has many entries that pass through the filter or if filter is empty, then transaction will quickly become very heavy and slow.

If write-through is enabled, the values will be removed from GridCacheStore via GridCacheStore.removeAll(GridCacheTx, Collection) method.

Transactions

This method is transactional and will enlist the entry into ongoing transaction if there is one.

Cache Flags

This method is not available if any of the following flags are set on projection: GridCacheFlag.LOCAL, GridCacheFlag.READ.

Specified by:

removeAllAsync in interface GridCacheProjection<K,V>

Overrides:

removeAllAsync in class GridCacheAdapter<K,V>

Parameters:

filter - Filter used to supply keys for remove operation (if null, then nothing will be removed).

Returns:

Future for the remove operation. The future will complete whenever remove operation completes.

get

@Nullable
public V get(K key,
             @Nullable
             GridPredicate<GridCacheEntry<K,V>> filter)
      throws GridException

Overrides:

get in class GridCacheAdapter<K,V>

Parameters:

key - Key.

filter - Filter to evaluate.

Returns:

Cached value.

Throws:

GridException - If failed.

getAll

public final Map<K,V> getAll(Collection<? extends K> keys,
              GridPredicate<GridCacheEntry<K,V>> filter)
                      throws GridException

Overrides:

getAll in class GridCacheAdapter<K,V>

Parameters:

keys - Keys.

filter - Filter to evaluate.

Returns:

Map of cached values.

Throws:

GridException - If read failed.

getAllAsync

public GridFuture<Map<K,V>> getAllAsync(@Nullable
                               Collection<? extends K> keys,
                               boolean forcePrimary,
                               boolean skipTx,
                               @Nullable
                               GridCacheEntryEx<K,V> entry,
                               @Nullable
                               UUID subjId,
                               @Nullable
                               GridPredicate<GridCacheEntry<K,V>>[] filter)

Overrides:

getAllAsync in class GridCacheAdapter<K,V>

txLockAsync

public GridFuture<Boolean> txLockAsync(Collection<? extends K> keys,
                              long timeout,
                              GridCacheTxLocalEx<K,V> tx,
                              boolean isRead,
                              boolean retval,
                              GridCacheTxIsolation isolation,
                              boolean invalidate,
                              GridPredicate<GridCacheEntry<K,V>>[] filter)

Specified by:

txLockAsync in class GridCacheAdapter<K,V>

Parameters:

keys - Keys to lock.

timeout - Lock timeout.

tx - Transaction.

isRead - True for read operations.

retval - Flag to return value.

isolation - Transaction isolation.

invalidate - Invalidate flag.

filter - Optional filter.

Returns:

Locks future.

newTx

public GridCacheTxLocalAdapter<K,V> newTx(boolean implicit,
                                 boolean implicitSingle,
                                 GridCacheTxConcurrency concurrency,
                                 GridCacheTxIsolation isolation,
                                 long timeout,
                                 boolean invalidate,
                                 boolean syncCommit,
                                 boolean syncRollback,
                                 boolean swapOrOffheapEnabled,
                                 boolean storeEnabled,
                                 int txSize,
                                 @Nullable
                                 Object grpLockKey,
                                 boolean partLock)

Specified by:

newTx in class GridCacheAdapter<K,V>

Parameters:

implicit - True if transaction is implicit.

implicitSingle - Implicit-with-single-key flag.

concurrency - Concurrency.

isolation - Isolation.

timeout - transaction timeout.

invalidate - Invalidation flag.

syncCommit - Synchronous commit flag.

syncRollback - Synchronous rollback flag.

swapOrOffheapEnabled - If true then swap storage will be used.

storeEnabled - if true then read/write through will be used.

txSize - Expected transaction size.

grpLockKey - Group lock key if this is a group-lock transaction.

partLock - True if partition is locked.

Returns:

New transaction.

lockAllAsync

public GridFuture<Boolean> lockAllAsync(@Nullable
                               Collection<? extends K> keys,
                               long timeout,
                               @Nullable
                               GridPredicate<GridCacheEntry<K,V>>... filter)

All or nothing synchronous lock for passed in keys. This method together with filter check will be executed as one atomic operation. If at least one filter validation failed, no locks will be acquired.

Transactions

Locks are not transactional and should not be used from within transactions. If you do need explicit locking within transaction, then you should use GridCacheTxConcurrency.PESSIMISTIC concurrency control for transaction which will acquire explicit locks for relevant cache operations.

Cache Flags

This method is not available if any of the following flags are set on projection: GridCacheFlag.LOCAL, GridCacheFlag.READ.

Parameters:

keys - Keys to lock.

timeout - Timeout in milliseconds to wait for lock to be acquired ('0' for no expiration).

filter - Optional filter that needs to atomically pass in order for the locks to be acquired.

Returns:

Future for the collection of locks. The future will return true if all filters passed and locks were acquired before timeout has expired, false otherwise.

unlockAll

public void unlockAll(@Nullable
             Collection<? extends K> keys,
             @Nullable
             GridPredicate<GridCacheEntry<K,V>>... filter)
               throws GridException

Unlocks given keys only if current thread owns the locks. Only the keys that have been locked by calling thread and pass through the filter (if any) will be unlocked. If none of the key locks is owned by current thread, then this method will do nothing.

Transactions

Locks are not transactional and should not be used from within transactions. If you do need explicit locking within transaction, then you should use GridCacheTxConcurrency.PESSIMISTIC concurrency control for transaction which will acquire explicit locks for relevant cache operations.

Cache Flags

This method is not available if any of the following flags are set on projection: GridCacheFlag.LOCAL, GridCacheFlag.READ.

Parameters:

keys - Keys to unlock.

filter - Optional filter which needs to pass for individual entries to be unlocked.

Throws:

GridException - If unlock execution resulted in error.

asyncOp

protected GridFuture asyncOp(Callable<?> op)

Parameters:

op - Operation closure.

Returns:

Future.

onDeferredDelete

public void onDeferredDelete(GridCacheEntryEx<K,V> entry,
                    GridCacheVersion ver)

Specified by:

onDeferredDelete in class GridCacheAdapter<K,V>

Parameters:

entry - Entry.

ver - Version.