GridCacheAdapter (gridgain-core 6.1.9 API)

java.lang.Object
- org.gridgain.grid.util.lang.GridMetadataAwareAdapter
- - org.gridgain.grid.kernal.processors.cache.GridCacheAdapter<K,V>

All Implemented Interfaces:

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

Direct Known Subclasses:

GridDistributedCacheAdapter, GridLocalAtomicCache, GridLocalCache
```
public abstract class GridCacheAdapter<K,V>
extends GridMetadataAwareAdapter
implements GridCache<K,V>, GridCacheProjectionEx<K,V>, Externalizable
```
Adapter for different cache implementations.

See Also:
Serialized Form

Nested Class Summary

Nested Classes
Modifier and Type	Class and Description
`protected class`	`GridCacheAdapter.AsyncOp<T>` Cache operation.
`protected static class`	`GridCacheAdapter.FutureHolder` Holder for last async operation future.

Field Summary

Fields
Modifier and Type	Field and Description
`protected GridInClosure3<K,Boolean,GridCacheOperation>`	`afterPessimisticUnlock` After lock callback.
`protected GridBiClosure<Collection<K>,Boolean,GridFuture<Object>>`	`beforePessimisticLock` Before lock callback.
`protected GridCacheConfiguration`	`cacheCfg` Cache configuration.
`static int`	`CLEAR_ALL_SPLIT_THRESHOLD` clearAll() split threshold.
`protected GridCacheContext<K,V>`	`ctx` Cache configuration.
`protected GridConfiguration`	`gridCfg` Grid configuration.
`protected ThreadLocal<GridCacheAdapter.FutureHolder>`	`lastFut` Last asynchronous future.
`protected UUID`	`locNodeId` Local node ID.
`protected GridLogger`	`log` Logger.
`protected GridCacheConcurrentMap<K,V>`	`map` Local map.
`protected GridCacheMetricsAdapter`	`metrics` Cache metrics.

Constructor Summary

Constructors
Modifier	Constructor and Description
`protected`	`GridCacheAdapter()` Empty constructor required by `Externalizable`.
`protected`	`GridCacheAdapter(GridCacheContext<K,V> ctx, GridCacheConcurrentMap<K,V> map)`
`protected`	`GridCacheAdapter(GridCacheContext<K,V> ctx, int startSize)`

Method Summary

Methods
Modifier and Type	Method and Description
`GridCacheAffinity<K>`	`affinity()` Gets affinity service to provide information about data partitioning and distribution.
`GridInClosure3<K,Boolean,GridCacheOperation>`	`afterPessimisticUnlock()`
`void`	`afterPessimisticUnlock(GridInClosure3<K,Boolean,GridCacheOperation> afterPessimisticUnlock)` Sets callback that will be invoked after keys are unlocked.
`Set<GridCacheEntryEx<K,V>>`	`allEntries()`
`protected <T> GridFuture<T>`	`asyncOp(GridCacheTxLocalAdapter<K,V> tx, GridCacheAdapter.AsyncOp<T> op)`
`protected <T> GridFuture<T>`	`asyncOpAcquire()` Tries to acquire asynchronous operations permit, if limited.
`protected void`	`asyncOpRelease()` Releases asynchronous operations permit, if limited.
`GridBiClosure<Collection<K>,Boolean,GridFuture<Object>>`	`beforePessimisticLock()`
`void`	`beforePessimisticLock(GridBiClosure<Collection<K>,Boolean,GridFuture<Object>> beforePessimisticLock)` Sets callback that will be invoked before keys are locked.
`<K1,V1> GridCache<K1,V1>`	`cache()` Gets base cache for this projection.
`protected void`	`checkJta()` Checks if cache is working in JTA transaction and enlist cache as XAResource if necessary.
`boolean`	`clear(K key)` Clears an entry from this cache and swap storage only if the entry is not currently locked, and is not participating in a transaction.
`boolean`	`clear0(K key, GridPredicate<GridCacheEntry<K,V>>... filter)`
`void`	`clearAll()` Clears all entries from this cache only if the entry is not currently locked or participating in a transaction.
`void`	`clearAll(Collection<? extends K> keys, boolean readers)`
`void`	`clearAll0(Collection<? extends K> keys, GridPredicate<GridCacheEntry<K,V>>... filter)`
`boolean`	`compact(K key)` Clears serialized value bytes from entry (if any) leaving only object representation.
`boolean`	`compact(K key, GridPredicate<GridCacheEntry<K,V>>... filter)`
`void`	`compactAll()` Clears serialized value bytes from cache entries (if any) leaving only object representation.
`void`	`compactAll(Iterable<K> keys, GridPredicate<GridCacheEntry<K,V>>... filter)`
`GridCacheConfiguration`	`configuration()` Gets configuration bean for this cache.
`boolean`	`containsAllKeys(Collection<? extends K> keys, GridPredicate<GridCacheEntry<K,V>> filter)`
`boolean`	`containsAllValues(Collection<? extends V> vals, GridPredicate<GridCacheEntry<K,V>> filter)`
`boolean`	`containsAnyKeys(Collection<? extends K> keys, GridPredicate<GridCacheEntry<K,V>> filter)`
`boolean`	`containsAnyValues(Collection<? extends V> vals, GridPredicate<GridCacheEntry<K,V>> filter)`
`boolean`	`containsKey(K key)` Returns `true` if this cache contains a mapping for the specified key.
`boolean`	`containsKey(K key, GridPredicate<GridCacheEntry<K,V>> filter)`
`boolean`	`containsValue(V val)` Returns `true` if this cache contains given value.
`boolean`	`containsValue(V val, GridPredicate<GridCacheEntry<K,V>> filter)`
`GridCacheContext<K,V>`	`context()`
`GridCacheDataStructures`	`dataStructures()` Gets data structures service to provide a gateway for creating various distributed data structures similar in APIs to `java.util.concurrent` package.
`void`	`dgc()` Runs DGC procedure on demand using `GridCacheConfiguration.getDgcSuspectLockTimeout()` to identify suspect locks.
`void`	`dgc(long suspectLockTimeout, boolean global, boolean rmvLocks)` Runs DGC procedure on demand using provided parameter to identify suspect locks.
`protected int`	`drBackupQueueSize()`
`Collection<GridDrStateTransferDescriptor>`	`drListStateTransfers()` List currently active state transfers.
`void`	`drPause()` Pauses data center replication for this cache.
`GridDrStatus`	`drPauseState()` Get DR pause state.
`void`	`drResume()` Resumes data center replication for this cache.
`GridFuture<?>`	`drStateTransfer(Collection<Byte> dataCenterIds)` Starts full state transfer.
`Set<GridCacheEntryEx<K,V>>`	`entries()`
`GridCacheEntry<K,V>`	`entry(K key)` Gets entry from cache with the specified key.
`GridCacheEntryEx<K,V>`	`entryEx(K key)`
`GridCacheEntryEx<K,V>`	`entryEx(K key, boolean touch)`
`GridCacheEntryEx<K,V>`	`entryEx(K key, long topVer)`
`protected GridCacheEntryEx<K,V>`	`entryExSafe(K key, long topVer)`
`Set<GridCacheEntry<K,V>>`	`entrySet()` Gets set containing all cache entries.
`Set<GridCacheEntry<K,V>>`	`entrySet(Collection<? extends K> keys, GridPredicate<K> keyFilter, GridPredicate<GridCacheEntry<K,V>>... filter)`
`Set<GridCacheEntry<K,V>>`	`entrySet(GridPredicate<GridCacheEntry<K,V>>... filter)`
`Set<GridCacheEntry<K,V>>`	`entrySet(int part)` Gets set containing cache entries that belong to provided partition or `null` if partition not found locally.
`Set<GridCacheEntry<K,V>>`	`entrySetx(GridPredicate<GridCacheEntry<K,V>>... filter)` Gets entry set containing internal entries.
`boolean`	`evict(K key)` Evicts entry associated with given key from cache.
`boolean`	`evict(K key, GridPredicate<GridCacheEntry<K,V>>... filter)`
`void`	`evictAll()` Attempts to evict all cache entries.
`void`	`evictAll(Collection<? extends K> keys)` Attempts to evict all entries associated with keys.
`void`	`evictAll(Collection<? extends K> keys, GridPredicate<GridCacheEntry<K,V>>... filter)`
`Set<GridCacheFlag>`	`flags()` Gets cache flags enabled on this projection.
`GridCacheProjection<K,V>`	`flagsOff(GridCacheFlag[] flags)` Gets cache projection base on this but with the specified flags turned off.
`GridCacheProjection<K,V>`	`flagsOn(GridCacheFlag[] flags)` Gets cache projection base on this one, but with the specified flags turned on.
`boolean`	`forAll(GridPredicate<GridCacheEntry<K,V>> vis)` Tests whether the predicate holds for all entries.
`GridFuture<?>`	`forceRepartition()` Forces this cache node to re-balance its partitions.
`void`	`forEach(GridInClosure<GridCacheEntry<K,V>> vis)` Executes visitor closure on each cache element.
`GridCacheProjectionEx<K,V>`	`forSubjectId(UUID subjId)` Creates projection for specified subject ID.
`V`	`get(K key)` Retrieves value mapped to the specified key from cache.
`V`	`get(K key, GridCacheEntryEx<K,V> entry, GridPredicate<GridCacheEntry<K,V>>... filter)`
`V`	`get(K key, GridPredicate<GridCacheEntry<K,V>> filter)`
`Map<K,V>`	`getAll(Collection<? extends K> keys)` Retrieves values mapped to the specified keys from cache.
`Map<K,V>`	`getAll(Collection<? extends K> keys, GridPredicate<GridCacheEntry<K,V>> filter)`
`GridFuture<Map<K,V>>`	`getAllAsync(Collection<? extends K> keys)` Asynchronously retrieves values mapped to the specified keys from cache.
`protected GridFuture<Map<K,V>>`	`getAllAsync(Collection<? extends K> keys, boolean forcePrimary, boolean skipTx, GridCacheEntryEx<K,V> entry, UUID subjId, GridPredicate<GridCacheEntry<K,V>>... filter)`
`GridFuture<Map<K,V>>`	`getAllAsync(Collection<? extends K> keys, GridCacheEntryEx<K,V> cached, boolean checkTx, UUID subjId, GridPredicate<GridCacheEntry<K,V>>... filter)`
`GridFuture<Map<K,V>>`	`getAllAsync(Collection<? extends K> keys, GridPredicate<GridCacheEntry<K,V>> filter)`
`Map<K,V>`	`getAllOutTx(List<K> keys)` Gets values from cache.
`GridFuture<Map<K,V>>`	`getAllOutTxAsync(List<K> keys)` Asynchronously gets values from cache.
`GridFuture<V>`	`getAsync(K key)` Asynchronously retrieves value mapped to the specified key from cache.
`GridFuture<V>`	`getAsync(K key, GridPredicate<GridCacheEntry<K,V>> filter)`
`V`	`getForcePrimary(K key)` Gets value from cache.
`GridFuture<V>`	`getForcePrimaryAsync(K key)` Asynchronously gets value from cache.
`long`	`ggfsDataSpaceMax()` Get maximum space available for GGFS.
`long`	`ggfsDataSpaceUsed()` Get current amount of used GGFS space in bytes.
`void`	`globalClearAll()` Clears cache on all nodes that store it's data.
`GridProjection`	`gridProjection()` Gets grid projection for this cache.
`protected void`	`init()` Post constructor initialization for subclasses.
`boolean`	`isColocated()`
`boolean`	`isDht()`
`boolean`	`isDhtAtomic()`
`boolean`	`isDrSystemCache()` Checks whether this cache is DR system cache.
`boolean`	`isEmpty()` Returns `true` if this map contains no key-value mappings.
`boolean`	`isGgfsDataCache()` Checks whether this cache is GGFS data cache.
`boolean`	`isLocal()`
`boolean`	`isLocked(K key)` Checks if any node owns a lock for this key.
`boolean`	`isLockedByThread(K key)` Checks if current thread owns a lock on this key.
`boolean`	`isMongoDataCache()` Checks whether this cache is Mongo data cache.
`boolean`	`isMongoMetaCache()` Checks whether this cache is Mongo meta cache.
`boolean`	`isNear()`
`Iterator<GridCacheEntry<K,V>>`	`iterator()`
`Set<K>`	`keySet()` Set of cached keys.
`Set<K>`	`keySet(GridPredicate<GridCacheEntry<K,V>>... filter)`
`void`	`loadCache(GridBiPredicate<K,V> p, long ttl, Object[] args)` Delegates to `GridCacheStore.loadCache(GridBiInClosure,Object...)` method to load state from the underlying persistent storage.
`GridFuture<?>`	`loadCacheAsync(GridBiPredicate<K,V> p, long ttl, Object[] args)` Asynchronously delegates to `GridCacheStore.loadCache(GridBiInClosure, Object...)` method to reload state from the underlying persistent storage.
`boolean`	`lock(K key, long timeout, GridPredicate<GridCacheEntry<K,V>>... filter)` Synchronously acquires lock on a cached object with given key only if the passed in filter (if any) passes.
`boolean`	`lockAll(Collection<? extends K> keys, long timeout, GridPredicate<GridCacheEntry<K,V>>... filter)` All or nothing synchronous lock for passed in keys.
`GridFuture<Boolean>`	`lockAsync(K key, long timeout, GridPredicate<GridCacheEntry<K,V>>... filter)` Asynchronously acquires lock on a cached object with given key only if the passed in filter (if any) passes.
`protected GridLogger`	`log()`
`GridCacheConcurrentMap<K,V>`	`map()`
`GridCacheMetrics`	`metrics()` Gets metrics (statistics) for this cache.
`GridCacheMetricsAdapter`	`metrics0()`
`String`	`name()` Gets name of this cache (`null` for default cache).
`int`	`nearSize()` Gets size of near cache key set.
`abstract 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)`
`long`	`offHeapAllocatedSize()` Gets memory size allocated in off-heap.
`long`	`offHeapEntriesCount()` Gets number of cache entries stored in off-heap memory.
`Iterator<Map.Entry<K,V>>`	`offHeapIterator()` Gets iterator over keys and values belonging to this cache off-heap memory on local node.
`abstract void`	`onDeferredDelete(GridCacheEntryEx<K,V> entry, GridCacheVersion ver)`
`void`	`onGgfsDataSizeChanged(long delta)` Callback invoked when data is added to GGFS cache.
`protected void`	`onKernalStart()` Kernal start callback.
`void`	`onKernalStop()` Kernal stop callback.
`void`	`onUndeploy(UUID leftNodeId, ClassLoader ldr)` Undeploys and removes all entries for class loader.
`long`	`overflowSize()` Gets size (in bytes) of all entries swapped to disk.
`V`	`peek(K key)` Peeks at in-memory cached value using default `GridCachePeekMode.SMART` peek mode.
`V`	`peek(K key, Collection<GridCachePeekMode> modes)` Peeks at cached value using optional set of peek modes.
`V`	`peek(K key, GridPredicate<GridCacheEntry<K,V>> filter)`
`protected GridTuple<V>`	`peek0(boolean failFast, K key, Collection<GridCachePeekMode> modes, GridCacheTxEx<K,V> tx)`
`protected GridTuple<V>`	`peek0(boolean failFast, K key, GridCachePeekMode mode, GridPredicate<GridCacheEntry<K,V>>... filter)`
`protected V`	`peek0(K key, Collection<GridCachePeekMode> modes, GridCacheTxEx<K,V> tx)`
`Map<K,V>`	`peekAll(Collection<? extends K> keys, GridPredicate<GridCacheEntry<K,V>>... filter)`
`protected Map<K,V>`	`peekAll0(Collection<? extends K> keys, Collection<GridCachePeekMode> modes, GridCacheTxEx<K,V> tx, Collection<K> skipped)`
`protected Map<K,V>`	`peekAll0(Collection<? extends K> keys, GridPredicate<GridCacheEntry<K,V>>[] filter, Collection<K> skipped)`
`GridCacheEntryEx<K,V>`	`peekEx(K key)`
`GridPredicate<GridCacheEntry<K,V>>`	`predicate()` Gets predicate on which this projection is based on or `null` if predicate is not defined.
`abstract GridCachePreloader<K,V>`	`preloader()`
`Set<GridCacheEntry<K,V>>`	`primaryEntrySet()` Gets set containing cache entries for which local node is the primary node.
`Set<GridCacheEntry<K,V>>`	`primaryEntrySet(GridPredicate<GridCacheEntry<K,V>>... filter)`
`Set<K>`	`primaryKeySet()` Set of cached primary keys for which local node is the primary node.
`Set<K>`	`primaryKeySet(GridPredicate<GridCacheEntry<K,V>>... filter)`
`int`	`primarySize()` Gets size of all primary keys for this cache.
`Collection<V>`	`primaryValues()` Collection of primary cached values.for which local node is the primary node.
`Collection<V>`	`primaryValues(GridPredicate<GridCacheEntry<K,V>>... filter)`
`void`	`printMemoryStats()` Prints memory stats.
`protected void`	`processCheckCommittedTxRequest(UUID nodeId, GridCachePessimisticCheckCommittedTxRequest<K,V> req)`
`protected void`	`processCheckCommittedTxResponse(UUID nodeId, GridCachePessimisticCheckCommittedTxResponse<K,V> res)`
`protected void`	`processCheckPreparedTxRequest(UUID nodeId, GridCacheOptimisticCheckPreparedTxRequest<K,V> req)`
`protected void`	`processCheckPreparedTxResponse(UUID nodeId, GridCacheOptimisticCheckPreparedTxResponse<K,V> res)`
`<K1,V1> GridCacheProjection<K1,V1>`	`projection(Class<? super K1> keyType, Class<? super V1> valType)` Gets cache projection only for given key and value type.
`GridCacheProjection<K,V>`	`projection(GridBiPredicate<K,V> p)` Gets cache projection based on given key-value predicate.
`GridCacheProjection<K,V>`	`projection(GridPredicate<GridCacheEntry<K,V>> filter)` Gets cache projection based on given entry filter.
`V`	`promote(K key)` This method promotes cache entry from offheap by given key, if any, from offheap or swap storage into memory.
`void`	`promoteAll(Collection<? extends K> keys)` This method unswaps cache entries by given keys, if any, from swap storage into memory.
`V`	`put(K key, V val, GridCacheEntryEx<K,V> cached, long ttl, GridPredicate<GridCacheEntry<K,V>>[] filter)` Internal method that is called from `GridCacheEntryImpl`.
`V`	`put(K key, V val, GridPredicate<GridCacheEntry<K,V>>... filter)` Stores given key-value pair in cache.
`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.
`void`	`putAllDr(Map<? extends K,GridCacheDrInfo<V>> drMap)` Store DR data.
`GridFuture<?>`	`putAllDrAsync(Map<? extends K,GridCacheDrInfo<V>> drMap)` Store DR data asynchronously.
`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`.
`GridFuture<V>`	`putAsync(K key, V val, GridPredicate<GridCacheEntry<K,V>>[] filter)` Asynchronously stores given key-value pair in cache.
`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`.
`GridFuture<Boolean>`	`putxAsync(K key, V val, GridPredicate<GridCacheEntry<K,V>>... filter)` Stores given key-value pair in cache.
`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.
`GridCacheQueries<K,V>`	`queries()` Returns queries facade responsible for creating various SQL, TEXT, or SCAN queries.
`GridCacheEntry<K,V>`	`randomEntry()` Gets a random entry out of cache.
`void`	`readExternal(ObjectInput in)`
`protected Object`	`readResolve()` Reconstructs object on demarshalling.
`GridFuture<Object>`	`readThroughAllAsync(Collection<? extends K> keys, boolean reload, GridCacheTxEx<K,V> tx, GridPredicate<GridCacheEntry<K,V>>[] filter, UUID subjId, GridBiInClosure<K,V> vis)`
`V`	`reload(K key)` Reloads a single key from persistent storage.
`V`	`reload(K key, GridPredicate<GridCacheEntry<K,V>>... filter)`
`void`	`reloadAll()` Reloads all currently cached keys form persistent storage.
`void`	`reloadAll(Collection<? extends K> keys)` Reloads specified entries from underlying persistent storage.
`Map<K,V>`	`reloadAll(Collection<? extends K> keys, boolean ret, GridPredicate<GridCacheEntry<K,V>>... filter)`
`void`	`reloadAll(Collection<? extends K> keys, GridPredicate<GridCacheEntry<K,V>>... filter)`
`void`	`reloadAll(GridPredicate<GridCacheEntry<K,V>>... filter)`
`GridFuture<?>`	`reloadAllAsync()` Asynchronously reloads all specified entries from underlying persistent storage.
`GridFuture<?>`	`reloadAllAsync(Collection<? extends K> keys)` Asynchronously reloads all specified entries from underlying persistent storage.
`GridFuture<Map<K,V>>`	`reloadAllAsync(Collection<? extends K> keys, boolean ret, UUID subjId, GridPredicate<GridCacheEntry<K,V>>... filter)`
`GridFuture<?>`	`reloadAllAsync(Collection<? extends K> keys, GridPredicate<GridCacheEntry<K,V>>... filter)`
`GridFuture<?>`	`reloadAllAsync(GridPredicate<GridCacheEntry<K,V>> filter)`
`GridFuture<V>`	`reloadAsync(K key)` Asynchronously reloads a single key from persistent storage.
`GridFuture<V>`	`reloadAsync(K key, GridPredicate<GridCacheEntry<K,V>>... filter)`
`V`	`remove(K key, GridCacheEntryEx<K,V> entry, GridPredicate<GridCacheEntry<K,V>>... filter)` Internal method that is called from `GridCacheEntryImpl`.
`V`	`remove(K key, GridPredicate<GridCacheEntry<K,V>>[] filter)` Removes given key mapping from cache.
`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.
`void`	`removeAllDr(Map<? extends K,GridCacheVersion> drMap)` Removes DR data.
`GridFuture<?>`	`removeAllDrAsync(Map<? extends K,GridCacheVersion> drMap)` Removes DR data asynchronously.
`GridFuture<V>`	`removeAsync(K key, GridCacheEntryEx<K,V> entry, GridPredicate<GridCacheEntry<K,V>>... filter)` Internal method that is called from `GridCacheEntryImpl`.
`GridFuture<V>`	`removeAsync(K key, GridPredicate<GridCacheEntry<K,V>>... filter)` Asynchronously removes given key mapping from cache.
`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.
`protected void`	`removeEntry(GridCacheEntryEx<K,V> entry)`
`void`	`removeIfObsolete(K key)`
`boolean`	`removex(K key, GridCacheEntryEx<K,V> entry, GridPredicate<GridCacheEntry<K,V>>... filter)` Internal method that is called from `GridCacheEntryImpl`.
`boolean`	`removex(K key, GridPredicate<GridCacheEntry<K,V>>... filter)` Removes given key mapping from cache.
`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<Boolean>`	`removexAsync(K key, GridPredicate<GridCacheEntry<K,V>>... filter)` Asynchronously removes given key mapping from cache.
`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`	`resetMetrics()` Resets metrics for current cache.
`protected void`	`saveFuture(GridCacheAdapter.FutureHolder holder, GridFuture<?> fut)` Saves future in thread local holder and adds listener that will clear holder when future is finished.
`int`	`size()` Gets size of cache key set.
`List<GridCacheClearAllRunnable<K,V>>`	`splitClearAll()` Split clear all task into multiple runnables.
`void`	`start()` Starts this cache.
`protected String`	`startInfo()` Startup info.
`void`	`stop()` Stops this cache.
`protected String`	`stopInfo()` Stop info.
`Iterator<Map.Entry<K,V>>`	`swapIterator()` Gets iterator over keys and values belonging to this cache swap space on local node.
`long`	`swapKeys()` Gets number of swap entries (keys).
`long`	`swapSize()` Gets size in bytes for swap space.
`ConcurrentMap<K,V>`	`toMap()` Converts this API into standard Java `ConcurrentMap` interface.
`String`	`toString()`
`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.
`void`	`transformAll(Set<? extends K> keys, GridClosure<V,V> transformer)` Stores result of applying the specified transform closure to previous values associated with the specified 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.
`GridFuture<?>`	`transformAllAsync(Set<? extends K> keys, GridClosure<V,V> transformer)` Stores result of applying the specified transform closure to previous values associated with the specified 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)` Stores result of applying `transformer` closure to the previous value associated with given key in cache.
`GridFuture<?>`	`transformAsync(K key, GridClosure<V,V> transformer, GridCacheEntryEx<K,V> entry, long ttl)` Internal method that is called from `GridCacheEntryImpl`.
`GridCacheTx`	`tx()` Gets transaction started by this thread or `null` if this thread does not have a transaction.
`abstract 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)`
`GridCacheTx`	`txStart()` Starts transaction with default isolation, concurrency, timeout, and invalidation policy.
`GridCacheTx`	`txStart(GridCacheTxConcurrency concurrency, GridCacheTxIsolation isolation)` Starts new transaction with the specified concurrency and isolation.
`GridCacheTx`	`txStart(GridCacheTxConcurrency concurrency, GridCacheTxIsolation isolation, long timeout, int txSize)` Starts transaction with specified isolation, concurrency, timeout, invalidation flag, and number of participating entries.
`GridCacheTx`	`txStartAffinity(Object affinityKey, GridCacheTxConcurrency concurrency, GridCacheTxIsolation isolation, long timeout, int txSize)` Starts `affinity-group-locked` transaction based on affinity key.
`GridCacheTx`	`txStartPartition(int partId, GridCacheTxConcurrency concurrency, GridCacheTxIsolation isolation, long timeout, int txSize)` Starts `partition-group-locked` transaction based on partition ID.
`Collection<GridCacheTxSynchronization>`	`txSynchronizations()` Gets registered transaction synchronizations.
`void`	`txSynchronize(GridCacheTxSynchronization syncs)` Registers transactions synchronizations for all transactions started by this cache.
`void`	`txUnsynchronize(GridCacheTxSynchronization syncs)` Removes transaction synchronizations.
`void`	`unlock(K key, GridPredicate<GridCacheEntry<K,V>>... filter)` Unlocks given key only if current thread owns the lock.
`Collection<V>`	`values()` Collection of cached values.
`Collection<V>`	`values(GridPredicate<GridCacheEntry<K,V>>... filter)`
`Set<GridCacheEntryImpl<K,V>>`	`wrappers()` Same as `entrySet()` but for internal use only to avoid casting.
`void`	`writeExternal(ObjectOutput out)`

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.cache.GridCacheProjection
lockAllAsync, unlockAll

Methods inherited from interface org.gridgain.grid.GridMetadataAware
addMeta, addMetaIfAbsent, addMetaIfAbsent, allMeta, copyMeta, copyMeta, hasMeta, hasMeta, meta, putMetaIfAbsent, putMetaIfAbsent, removeMeta, removeMeta, replaceMeta

- Field Detail
  - CLEAR_ALL_SPLIT_THRESHOLD
```
public static final int CLEAR_ALL_SPLIT_THRESHOLD
```
    clearAll() split threshold.
    
    See Also:
    Constant Field Values
  - lastFut
```
protected ThreadLocal<GridCacheAdapter.FutureHolder> lastFut
```
    Last asynchronous future.
  - ctx
```
@GridToStringExclude
protected GridCacheContext<K,V> ctx
```
    Cache configuration.
  - map
```
@GridToStringExclude
protected GridCacheConcurrentMap<K,V> map
```
    Local map.
  - locNodeId
```
@GridToStringExclude
protected UUID locNodeId
```
    Local node ID.
  - cacheCfg
```
@GridToStringExclude
protected GridCacheConfiguration cacheCfg
```
    Cache configuration.
  - gridCfg
```
@GridToStringExclude
protected GridConfiguration gridCfg
```
    Grid configuration.
  - metrics
```
protected volatile GridCacheMetricsAdapter metrics
```
    Cache metrics.
  - beforePessimisticLock
```
protected GridBiClosure<Collection<K>,Boolean,GridFuture<Object>> beforePessimisticLock
```
    Before lock callback.
  - afterPessimisticUnlock
```
protected GridInClosure3<K,Boolean,GridCacheOperation> afterPessimisticUnlock
```
    After lock callback.
  - log
```
protected GridLogger log
```
    Logger.
- Constructor Detail
  - GridCacheAdapter
```
protected GridCacheAdapter()
```
    Empty constructor required by Externalizable.
  - GridCacheAdapter
```
protected GridCacheAdapter(GridCacheContext<K,V> ctx,
                int startSize)
```
    Parameters:
    ctx - Cache context.
    startSize - Start size.
  - GridCacheAdapter
```
protected GridCacheAdapter(GridCacheContext<K,V> ctx,
                GridCacheConcurrentMap<K,V> map)
```
    Parameters:
    ctx - Cache context.
    map - Concurrent map.
- Method Detail
  - name
```
public String name()
```
    Gets name of this cache (null for default cache).
    
    Specified by:
    
    name in interface GridCacheProjection<K,V>
    
    Returns:
    Cache name.
  - gridProjection
```
public GridProjection gridProjection()
```
    Gets grid projection for this cache. This projection includes all nodes which have this cache configured.
    
    Specified by:
    
    gridProjection in interface GridCacheProjection<K,V>
    
    Returns:
    Projection instance.
  - printMemoryStats
```
public void printMemoryStats()
```
    Prints memory stats.
  - map
```
public GridCacheConcurrentMap<K,V> map()
```
    Returns:
    Base map.
  - context
```
public GridCacheContext<K,V> context()
```
    Returns:
    Context.
  - log
```
protected GridLogger log()
```
    Returns:
    Logger.
  - isNear
```
public boolean isNear()
```
    Returns:
    True if this is near cache.
  - isLocal
```
public boolean isLocal()
```
    Returns:
    True if cache is local.
  - isColocated
```
public boolean isColocated()
```
    Returns:
    True if cache is colocated.
  - isDhtAtomic
```
public boolean isDhtAtomic()
```
    Returns:
    True if cache is DHT Atomic.
  - isDht
```
public boolean isDht()
```
    Returns:
    True if cache is DHT.
  - preloader
```
public abstract GridCachePreloader<K,V> preloader()
```
    Returns:
    Preloader.
  - queries
```
public GridCacheQueries<K,V> queries()
```
    Returns queries facade responsible for creating various SQL, TEXT, or SCAN queries.
    
    Specified by:
    
    queries in interface GridCacheProjection<K,V>
    
    Returns:
    Queries facade responsible for creating various SQL, TEXT, or SCAN queries.
  - affinity
```
public GridCacheAffinity<K> affinity()
```
    Gets affinity service to provide information about data partitioning and distribution.
    
    Specified by:
    
    affinity in interface GridCache<K,V>
    
    Returns:
    Cache data affinity service.
  - dataStructures
```
public GridCacheDataStructures dataStructures()
```
    Gets data structures service to provide a gateway for creating various distributed data structures similar in APIs to java.util.concurrent package.
    
    Specified by:
    
    dataStructures in interface GridCache<K,V>
    
    Returns:
    Cache data structures service.
  - cache
```
public <K1,V1> GridCache<K1,V1> cache()
```
    Gets base cache for this projection.
    
    Specified by:
    
    cache in interface GridCacheProjection<K,V>
    
    Type Parameters:
    K1 - Cache key type.
    V1 - Cache value type.
    
    Returns:
    Base cache for this projection.
  - flags
```
public Set<GridCacheFlag> flags()
```
    Gets cache flags enabled on this projection.
    
    Specified by:
    
    flags in interface GridCacheProjection<K,V>
    
    Returns:
    Flags for this projection (empty set if no flags have been set).
  - predicate
```
public GridPredicate<GridCacheEntry<K,V>> predicate()
```
    Gets predicate on which this projection is based on or null if predicate is not defined.
    
    Specified by:
    
    predicate in interface GridCacheProjectionEx<K,V>
    
    Returns:
    Filter on which this projection is based on.
  - forSubjectId
```
public GridCacheProjectionEx<K,V> forSubjectId(UUID subjId)
```
    Creates projection for specified subject ID.
    
    Specified by:
    
    forSubjectId in interface GridCacheProjectionEx<K,V>
    
    Parameters:
    subjId - Client ID.
    
    Returns:
    Internal projection.
  - flagsOn
```
public GridCacheProjection<K,V> flagsOn(@Nullable
                               GridCacheFlag[] flags)
```
    Gets cache projection base on this one, but with the specified flags turned on.
    Cache Flags
    The resulting projection will inherit all the flags from this projection.
    
    Specified by:
    
    flagsOn in interface GridCacheProjection<K,V>
    
    Parameters:
    flags - Flags to turn on (if empty, then no-op).
    
    Returns:
    New projection based on this one, but with the specified flags turned on.
  - beforePessimisticLock
```
public void beforePessimisticLock(GridBiClosure<Collection<K>,Boolean,GridFuture<Object>> beforePessimisticLock)
```
    Sets callback that will be invoked before keys are locked. This callback may return future, in this case further locking process will be completed after this future completes.
    
    Parameters:
    beforePessimisticLock - Before lock callback.
  - beforePessimisticLock
```
public GridBiClosure<Collection<K>,Boolean,GridFuture<Object>> beforePessimisticLock()
```
    Returns:
    Before pessimistic lock callback.
  - flagsOff
```
public GridCacheProjection<K,V> flagsOff(@Nullable
                                GridCacheFlag[] flags)
```
    Gets cache projection base on this but with the specified flags turned off.
    Cache Flags
    The resulting projection will inherit all the flags from this projection except for the ones that were turned off.
    
    Specified by:
    
    flagsOff in interface GridCacheProjection<K,V>
    
    Parameters:
    flags - Flags to turn off (if empty, then all flags will be turned off).
    
    Returns:
    New projection based on this one, but with the specified flags turned off.
  - projection
```
public <K1,V1> GridCacheProjection<K1,V1> projection(Class<? super K1> keyType,
                                            Class<? super V1> valType)
```
    Gets cache projection only for given key and value type. Only non-null key-value pairs that have matching key and value pairs will be used in this projection.
    
    Specified by:
    
    projection in interface GridCacheProjection<K,V>
    
    Type Parameters:
    K1 - Key type.
    V1 - Value type.
    Parameters:
    keyType - Key type.
    valType - Value type.
    
    Returns:
    Cache projection for given key and value types.
  - projection
```
public GridCacheProjection<K,V> projection(GridBiPredicate<K,V> p)
```
    Gets cache projection based on given key-value predicate. Whenever makes sense, this predicate will be used to pre-filter cache operations. If operation passed pre-filtering, this filter will be passed through to cache operations as well.
    For example, for GridCacheProjection.putAll(Map, GridPredicate[]) method only elements that pass the filter will be given to GridCache.putAll(m, filter) where it will be checked once again prior to put.
    
    Specified by:
    
    projection in interface GridCacheProjection<K,V>
    
    Parameters:
    p - Key-value predicate for this projection. If null, then the same projection is returned.
    
    Returns:
    Projection for given key-value predicate.
  - projection
```
public GridCacheProjection<K,V> projection(GridPredicate<GridCacheEntry<K,V>> filter)
```
    Gets cache projection based on given entry filter. This filter will be simply passed through to all cache operations on this projection. Unlike GridCacheProjection.projection(GridBiPredicate) method, this filter will not be used for pre-filtering.
    
    Specified by:
    
    projection in interface GridCacheProjection<K,V>
    
    Parameters:
    filter - Filter to be passed through to all cache operations. If null, then the same projection is returned. If cache operation receives its own filter, then filters will be 'anded'.
    
    Returns:
    Projection based on given filter.
  - configuration
```
public GridCacheConfiguration configuration()
```
    Gets configuration bean for this cache.
    
    Specified by:
    
    configuration in interface GridCache<K,V>
    
    Returns:
    Configuration bean for this cache.
  - txLockAsync
```
public abstract 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)
```
    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 abstract 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)
```
    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.
  - init
```
protected void init()
```
    Post constructor initialization for subclasses.
  - start
```
public void start()
           throws GridException
```
    Starts this cache. Child classes should override this method to provide custom start-up behavior.
    
    Throws:
    
    GridException - If start failed.
  - startInfo
```
protected final String startInfo()
```
    Startup info.
    
    Returns:
    Startup info.
  - stop
```
public void stop()
```
    Stops this cache. Child classes should override this method to provide custom stop behavior.
  - stopInfo
```
protected final String stopInfo()
```
    Stop info.
    
    Returns:
    Stop info.
  - onKernalStart
```
protected void onKernalStart()
                      throws GridException
```
    Kernal start callback.
    
    Throws:
    
    GridException - If callback failed.
  - onKernalStop
```
public void onKernalStop()
```
    Kernal stop callback.
  - isEmpty
```
public boolean isEmpty()
```
    Returns true if this map contains no key-value mappings.
    
    Specified by:
    
    isEmpty in interface GridCacheProjection<K,V>
    
    Returns:
    true if this map contains no key-value mappings.
  - containsKey
```
public boolean containsKey(K key)
```
    Returns true if this cache contains a mapping for the specified key.
    
    Specified by:
    
    containsKey in interface GridCacheProjection<K,V>
    
    Parameters:
    key - key whose presence in this map is to be tested.
    
    Returns:
    true if this map contains a mapping for the specified key.
  - containsValue
```
public boolean containsValue(V val)
```
    Returns true if this cache contains given value.
    
    Specified by:
    
    containsValue in interface GridCacheProjection<K,V>
    
    Parameters:
    val - Value to check.
    
    Returns:
    True if given value is present in cache.
  - peek
```
public V peek(K key)
```
    Peeks at in-memory cached value using default GridCachePeekMode.SMART peek mode.
    This method will not load value from any persistent store or from a remote node.
    Transactions
    This method does not participate in any transactions, however, it will peek at transactional value according to the GridCachePeekMode.SMART mode semantics. If you need to look at global cached value even from within transaction, you can use GridCacheProjection.peek(Object, Collection) method.
    
    Specified by:
    
    peek in interface GridCacheProjection<K,V>
    
    Parameters:
    key - Entry key.
    
    Returns:
    Peeked value.
  - peek
```
public V peek(K key,
     @Nullable
     Collection<GridCachePeekMode> modes)
       throws GridException
```
    Peeks at cached value using optional set of peek modes. This method will sequentially iterate over given peek modes in the order passed in, and try to peek at value using each peek mode. Once a non-null value is found, it will be immediately returned.
    Note that if modes are not provided this method works exactly the same way as GridCacheProjection.peek(Object), implicitly using GridCachePeekMode.SMART mode.
    Transactions
    This method does not participate in any transactions, however, it may peek at transactional value depending on the peek modes used.
    
    Specified by:
    
    peek in interface GridCacheProjection<K,V>
    
    Parameters:
    key - Entry key.
    modes - Optional set of peek modes.
    
    Returns:
    Peeked value.
    
    Throws:
    
    GridException - If peek operation failed.
  - peekAll
```
public Map<K,V> peekAll(@Nullable
               Collection<? extends K> keys,
               @Nullable
               GridPredicate<GridCacheEntry<K,V>>... filter)
```
  - peek0
```
@Nullable
protected GridTuple<V> peek0(boolean failFast,
                          K key,
                          GridCachePeekMode mode,
                          @Nullable
                          GridPredicate<GridCacheEntry<K,V>>... filter)
                      throws GridCacheFilterFailedException
```
    Parameters:
    failFast - Fail fast flag.
    key - Key.
    mode - Peek mode.
    filter - Filter.
    
    Returns:
    Peeked value.
    
    Throws:
    
    GridCacheFilterFailedException - If filter failed.
  - peekAll0
```
protected Map<K,V> peekAll0(@Nullable
                Collection<? extends K> keys,
                @Nullable
                GridPredicate<GridCacheEntry<K,V>>[] filter,
                @Nullable
                Collection<K> skipped)
```
    Parameters:
    keys - Keys.
    filter - Filter.
    skipped - Skipped keys, possibly null.
    
    Returns:
    Peeked map.
  - peek0
```
@Nullable
protected V peek0(K key,
               @Nullable
               Collection<GridCachePeekMode> modes,
               GridCacheTxEx<K,V> tx)
           throws GridException
```
    Parameters:
    key - Key.
    modes - Peek modes.
    tx - Transaction to peek at (if modes contains TX value).
    
    Returns:
    Peeked value.
    
    Throws:
    
    GridException - In case of error.
  - peek0
```
@Nullable
protected GridTuple<V> peek0(boolean failFast,
                          K key,
                          @Nullable
                          Collection<GridCachePeekMode> modes,
                          GridCacheTxEx<K,V> tx)
                      throws GridException,
                             GridCacheFilterFailedException
```
    Parameters:
    failFast - If true, then filter failure will result in exception.
    key - Key.
    modes - Peek modes.
    tx - Transaction to peek at (if modes contains TX value).
    
    Returns:
    Peeked value.
    
    Throws:
    
    GridException - In case of error.
    
    GridCacheFilterFailedException - If filer validation failed.
  - peekAll0
```
protected Map<K,V> peekAll0(@Nullable
                Collection<? extends K> keys,
                @Nullable
                Collection<GridCachePeekMode> modes,
                GridCacheTxEx<K,V> tx,
                @Nullable
                Collection<K> skipped)
                     throws GridException
```
    Parameters:
    keys - Keys.
    modes - Modes.
    tx - Transaction.
    skipped - Keys skipped during filter validation.
    
    Returns:
    Peeked values.
    
    Throws:
    
    GridException - If failed.
  - forEach
```
public void forEach(GridInClosure<GridCacheEntry<K,V>> vis)
```
    Executes visitor closure on each cache element.
    Transactions
    This method is not transactional and will not enlist keys into transaction simply because they were visited. However, if you perform transactional operations on the visited entries, those operations will enlist the entry into transaction.
    
    Specified by:
    
    forEach in interface GridCacheProjection<K,V>
    
    Parameters:
    vis - Closure which will be invoked for each cache entry.
  - forAll
```
public boolean forAll(GridPredicate<GridCacheEntry<K,V>> vis)
```
    Tests whether the predicate holds for all entries. If cache is empty, then true is returned.
    Transactions
    This method is not transactional and will not enlist keys into transaction simply because they were visited. However, if you perform transactional operations on the visited entries, those operations will enlist the entry into transaction.
    
    Specified by:
    
    forAll in interface GridCacheProjection<K,V>
    
    Parameters:
    vis - Predicate to test for each cache entry.
    
    Returns:
    True if the given predicate holds for all visited entries, false otherwise.
  - onUndeploy
```
public void onUndeploy(@Nullable
              UUID leftNodeId,
              ClassLoader ldr)
```
    Undeploys and removes all entries for class loader.
    
    Parameters:
    leftNodeId - Left node ID.
    ldr - Class loader to undeploy.
  - entry
```
@Nullable
public GridCacheEntry<K,V> entry(K key)
```
    Gets entry from cache with the specified key. The returned entry can be used even after entry key has been removed from cache. In that case, every operation on returned entry will result in creation of a new entry.
    Note that this method can return null if projection is configured as pre-filtered and entry key and value don't pass key-value filter of the projection.
    
    Specified by:
    
    entry in interface GridCacheProjection<K,V>
    
    Parameters:
    key - Entry key.
    
    Returns:
    Cache entry or null if projection pre-filtering was not passed.
  - peekEx
```
@Nullable
public GridCacheEntryEx<K,V> peekEx(K key)
```
    Parameters:
    key - Entry key.
    
    Returns:
    Entry or null.
  - entryEx
```
public GridCacheEntryEx<K,V> entryEx(K key)
```
    Parameters:
    key - Entry key.
    
    Returns:
    Entry (never null).
  - entryEx
```
public GridCacheEntryEx<K,V> entryEx(K key,
                            boolean touch)
```
    Parameters:
    key - Entry key.
    touch - Whether created entry should be touched.
    
    Returns:
    Entry (never null).
  - entryEx
```
public GridCacheEntryEx<K,V> entryEx(K key,
                            long topVer)
```
    Parameters:
    topVer - Topology version.
    key - Entry key.
    
    Returns:
    Entry (never null).
  - wrappers
```
public Set<GridCacheEntryImpl<K,V>> wrappers()
```
    Same as entrySet() but for internal use only to avoid casting.
    
    Returns:
    Set of entry wrappers.
  - entries
```
public Set<GridCacheEntryEx<K,V>> entries()
```
    Returns:
    Set of internal cached entry representations, excluding GridCacheInternal keys.
  - allEntries
```
public Set<GridCacheEntryEx<K,V>> allEntries()
```
    Returns:
    Set of internal cached entry representations, including GridCacheInternal keys.
  - entrySet
```
public Set<GridCacheEntry<K,V>> entrySet()
```
    Gets set containing all cache entries. You can remove elements from this set, but you cannot add elements to this set. All removal operation will be reflected on the cache itself.
    If optional filters are provided, then only entries that successfully pass the filters will be included in the resulting set.
    
    Specified by:
    
    entrySet in interface GridCacheProjection<K,V>
    
    Returns:
    Entries that pass through key filter.
  - entrySetx
```
public Set<GridCacheEntry<K,V>> entrySetx(GridPredicate<GridCacheEntry<K,V>>... filter)
```
    Gets entry set containing internal entries.
    
    Specified by:
    
    entrySetx in interface GridCacheProjectionEx<K,V>
    
    Parameters:
    filter - Filter.
    
    Returns:
    Entry set.
  - entrySet
```
public Set<GridCacheEntry<K,V>> entrySet(int part)
```
    Gets set containing cache entries that belong to provided partition or null if partition not found locally.
    
    Specified by:
    
    entrySet in interface GridCacheProjection<K,V>
    
    Parameters:
    part - Partition.
    
    Returns:
    Set containing partition's entries or null if partition not found locally.
  - primaryEntrySet
```
public Set<GridCacheEntry<K,V>> primaryEntrySet()
```
    Gets set containing cache entries for which local node is the primary node. This set is dynamic and may change with grid topology changes. You can remove elements from this set, but you cannot add elements to this set. All removal operation will be reflected on the cache itself.
    If optional filters are provided, then only entries that successfully pass the filters will be included in the resulting set.
    
    Specified by:
    
    primaryEntrySet in interface GridCacheProjection<K,V>
    
    Returns:
    Primary cache entries that pass through key filter.
  - keySet
```
public Set<K> keySet()
```
    Set of cached keys. You can remove elements from this set, but you cannot add elements to this set. All removal operation will be reflected on the cache itself.
    Iterator over this set will not fail if set was concurrently updated by another thread. This means that iterator may or may not return latest keys depending on whether they were added before or after current iterator position.
    
    Specified by:
    
    keySet in interface GridCacheProjection<K,V>
    
    Returns:
    Key set for this cache projection.
  - primaryKeySet
```
public Set<K> primaryKeySet()
```
    Set of cached primary keys for which local node is the primary node. This set is dynamic and may change with grid topology changes. Note that this set will contain mappings for all keys, even if their values are null because they were invalidated. You can remove elements from this set, but you cannot add elements to this set. All removal operation will be reflected on the cache itself.
    Iterator over this set will not fail if set was concurrently updated by another thread. This means that iterator may or may not return latest keys depending on whether they were added before or after current iterator position.
    
    Specified by:
    
    primaryKeySet in interface GridCacheProjection<K,V>
    
    Returns:
    Primary key set for the current node.
  - values
```
public Collection<V> values()
```
    Collection of cached values. Note that this collection will not contain values that are null because they were invalided. You can remove elements from this collection, but you cannot add elements to this collection. All removal operation will be reflected on the cache itself.
    If filter is provided, then only the values for the entries that pass provided filters are returned.
    Iterator over this collection will not fail if collection was concurrently updated by another thread. This means that iterator may or may not return latest values depending on whether they were added before or after current iterator position.
    
    Specified by:
    
    values in interface GridCacheProjection<K,V>
    
    Returns:
    Collection of cached values.
  - values
```
public Collection<V> values(GridPredicate<GridCacheEntry<K,V>>... filter)
```
  - primaryValues
```
public Collection<V> primaryValues()
```
    Collection of primary cached values.for which local node is the primary node. This collection is dynamic and may change with grid topology changes. Note that this collection will not contain values that are null because they were invalided. You can remove elements from this collection, but you cannot add elements to this collection. All removal operation will be reflected on the cache itself.
    If filter is provided, then only the values for the entries that pass provided filters are returned.
    Iterator over this collection will not fail if collection was concurrently updated by another thread. This means that iterator may or may not return latest values depending on whether they were added before or after current iterator position.
    
    Specified by:
    
    primaryValues in interface GridCacheProjection<K,V>
    
    Returns:
    Collection of primary cached values for the current node.
  - removeIfObsolete
```
public void removeIfObsolete(K key)
```
    Parameters:
    key - Entry key.
  - splitClearAll
```
public List<GridCacheClearAllRunnable<K,V>> splitClearAll()
```
    Split clear all task into multiple runnables.
    
    Returns:
    Split runnables.
  - clear
```
public boolean clear(K key)
```
    Clears an entry from this cache and swap storage only if the entry is not currently locked, and is not participating in a transaction.
    If GridCacheConfiguration.isSwapEnabled() is set to true and GridCacheFlag.SKIP_SWAP is not enabled, the evicted entries will also be cleared from swap.
    Note that this operation is local as it merely clears an entry from local cache. It does not remove entries from remote caches or from underlying persistent storage.
    Cache Flags
    This method is not available if any of the following flags are set on projection: GridCacheFlag.READ.
    
    Specified by:
    
    clear in interface GridCacheProjection<K,V>
    
    Parameters:
    key - Key to clear.
    
    Returns:
    True if entry was successfully cleared from cache, false if entry was in use at the time of this method invocation and could not be cleared.
  - clearAll
```
public void clearAll()
```
    Clears all entries from this cache only if the entry is not currently locked or participating in a transaction.
    If GridCacheConfiguration.isSwapEnabled() is set to true and GridCacheFlag.SKIP_SWAP is not enabled, the evicted entries will also be cleared from swap.
    Note that this operation is local as it merely clears entries from local cache. It does not remove entries from remote caches or from underlying persistent storage.
    Cache Flags
    This method is not available if any of the following flags are set on projection: GridCacheFlag.READ.
    
    Specified by:
    
    clearAll in interface GridCacheProjection<K,V>
  - clearAll
```
public void clearAll(Collection<? extends K> keys,
            boolean readers)
```
    Parameters:
    keys - Keys.
    readers - Readers flag.
  - globalClearAll
```
public void globalClearAll()
                    throws GridException
```
    Clears cache on all nodes that store it's data. That is, caches are cleared on remote nodes and local node, as opposed to GridCacheProjection.clearAll() method which only clears local node's cache.
    GridGain will make the best attempt to clear caches on all nodes. If some caches could not be cleared, then exception will be thrown.
    
    Specified by:
    
    globalClearAll in interface GridCacheProjection<K,V>
    
    Throws:
    
    GridException - In case of cache could not be cleared on any of the nodes.
  - compact
```
public boolean compact(K key)
                throws GridException
```
    Clears serialized value bytes from entry (if any) leaving only object representation.
    
    Specified by:
    
    compact in interface GridCacheProjection<K,V>
    
    Parameters:
    key - Key to compact.
    
    Returns:
    true if entry was deleted from cache (i.e. was expired).
    
    Throws:
    
    GridException - If failed to compact.
  - compactAll
```
public void compactAll()
                throws GridException
```
    Clears serialized value bytes from cache entries (if any) leaving only object representation.
    
    Specified by:
    
    compactAll in interface GridCacheProjection<K,V>
    
    Throws:
    
    GridException - If failed to compact.
  - removeEntry
```
protected void removeEntry(GridCacheEntryEx<K,V> entry)
```
    Parameters:
    entry - Removes entry from cache if currently mapped value is the same as passed.
  - get
```
public V get(K key,
    @Nullable
    GridCacheEntryEx<K,V> entry,
    @Nullable
    GridPredicate<GridCacheEntry<K,V>>... filter)
      throws GridException
```
    Specified by:
    
    get in interface GridCacheProjectionEx<K,V>
    
    Parameters:
    key - Key to retrieve the value for.
    entry - Cached entry when called from entry wrapper.
    filter - Filter to check prior to getting the value. Note that filter check together with getting the value is an atomic operation.
    
    Returns:
    Value.
    
    Throws:
    
    GridException - If failed.
  - getForcePrimary
```
public V getForcePrimary(K key)
                  throws GridException
```
    Gets value from cache. Will go to primary node even if this is a backup.
    
    Specified by:
    
    getForcePrimary in interface GridCacheProjectionEx<K,V>
    
    Parameters:
    key - Key to get value for.
    
    Returns:
    Value.
    
    Throws:
    
    GridException - If failed.
  - getForcePrimaryAsync
```
public GridFuture<V> getForcePrimaryAsync(K key)
```
    Asynchronously gets value from cache. Will go to primary node even if this is a backup.
    
    Specified by:
    
    getForcePrimaryAsync in interface GridCacheProjectionEx<K,V>
    
    Parameters:
    key - Key to get value for.
    
    Returns:
    Future with result.
  - getAllOutTx
```
@Nullable
public Map<K,V> getAllOutTx(List<K> keys)
                     throws GridException
```
    Gets values from cache. Will bypass started transaction, if any, i.e. will not enlist entries and will not lock any keys if pessimistic transaction is started by thread.
    
    Specified by:
    
    getAllOutTx in interface GridCacheProjectionEx<K,V>
    
    Parameters:
    keys - Keys to get values for.
    
    Returns:
    Value.
    
    Throws:
    
    GridException - If failed.
  - getAllOutTxAsync
```
public GridFuture<Map<K,V>> getAllOutTxAsync(List<K> keys)
```
    Asynchronously gets values from cache. Will bypass started transaction, if any, i.e. will not enlist entries and will not lock any keys if pessimistic transaction is started by thread.
    
    Specified by:
    
    getAllOutTxAsync in interface GridCacheProjectionEx<K,V>
    
    Parameters:
    keys - Keys to get values for.
    
    Returns:
    Future with result.
  - reload
```
@Nullable
public V reload(K key)
         throws GridException
```
    Reloads a single key from persistent storage. This method delegates to GridCacheStore.load(GridCacheTx, Object) method.
    Transactions
    This method does not participate in transactions, however it does not violate cache integrity and can be used safely with or without transactions.
    
    Specified by:
    
    reload in interface GridCacheProjection<K,V>
    
    Parameters:
    key - Key to reload.
    
    Returns:
    Reloaded value or current value if entry was updated while reloading.
    
    Throws:
    
    GridException - If reloading failed.
  - reloadAsync
```
public GridFuture<V> reloadAsync(K key)
```
    Asynchronously reloads a single key from persistent storage. This method delegates to GridCacheStore.load(GridCacheTx, Object) method.
    Transactions
    This method does not participate in transactions, however it does not violate cache integrity and can be used safely with or without transactions.
    
    Specified by:
    
    reloadAsync in interface GridCacheProjection<K,V>
    
    Parameters:
    key - Key to reload.
    
    Returns:
    Future to be completed whenever the entry is reloaded.
  - reloadAll
```
public void reloadAll(@Nullable
             Collection<? extends K> keys)
               throws GridException
```
    Reloads specified entries from underlying persistent storage.
    Transactions
    This method does not participate in transactions, however it does not violate cache integrity and can be used safely with or without transactions.
    
    Specified by:
    
    reloadAll in interface GridCacheProjection<K,V>
    
    Parameters:
    keys - Keys to reload.
    
    Throws:
    
    GridException - if reloading failed.
  - reloadAllAsync
```
public GridFuture<?> reloadAllAsync(@Nullable
                           Collection<? extends K> keys)
```
    Asynchronously reloads all specified entries from underlying persistent storage.
    Transactions
    This method does not participate in transactions, however it does not violate cache integrity and can be used safely with or without transactions.
    
    Specified by:
    
    reloadAllAsync in interface GridCacheProjection<K,V>
    
    Parameters:
    keys - Keys to reload.
    
    Returns:
    Future which will complete whenever reload completes.
  - reloadAll
```
public void reloadAll()
               throws GridException
```
    Reloads all currently cached keys form persistent storage.
    Transactions
    This method does not participate in transactions, however it does not violate cache integrity and can be used safely with or without transactions.
    
    Specified by:
    
    reloadAll in interface GridCacheProjection<K,V>
    
    Throws:
    
    GridException - If reloading failed.
  - reloadAllAsync
```
public GridFuture<?> reloadAllAsync()
```
    Asynchronously reloads all specified entries from underlying persistent storage.
    Transactions
    This method does not participate in transactions, however it does not violate cache integrity and can be used safely with or without transactions.
    
    Specified by:
    
    reloadAllAsync in interface GridCacheProjection<K,V>
    
    Returns:
    Future which will complete whenever reload completes.
  - readThroughAllAsync
```
public GridFuture<Object> readThroughAllAsync(Collection<? extends K> keys,
                                     boolean reload,
                                     @Nullable
                                     GridCacheTxEx<K,V> tx,
                                     GridPredicate<GridCacheEntry<K,V>>[] filter,
                                     @Nullable
                                     UUID subjId,
                                     GridBiInClosure<K,V> vis)
```
    Parameters:
    keys - Keys.
    reload - Reload flag.
    tx - Transaction.
    filter - Filter.
    vis - Visitor.
    
    Returns:
    Future.
  - reloadAll
```
@Nullable
public Map<K,V> reloadAll(@Nullable
                          Collection<? extends K> keys,
                          boolean ret,
                          @Nullable
                          GridPredicate<GridCacheEntry<K,V>>... filter)
                   throws GridException
```
    Parameters:
    keys - Keys.
    ret - Return flag.
    filter - Optional filter.
    
    Returns:
    Non-null map if return flag is true.
    
    Throws:
    
    GridException - If failed.
  - reloadAllAsync
```
public GridFuture<Map<K,V>> reloadAllAsync(@Nullable
                                  Collection<? extends K> keys,
                                  boolean ret,
                                  @Nullable
                                  UUID subjId,
                                  @Nullable
                                  GridPredicate<GridCacheEntry<K,V>>... filter)
```
    Parameters:
    keys - Keys.
    ret - Return flag.
    filter - Filter.
    
    Returns:
    Future.
  - entryExSafe
```
@Nullable
protected GridCacheEntryEx<K,V> entryExSafe(K key,
                                         long topVer)
```
    Parameters:
    key - Key.
    
    Returns:
    Entry.
  - evict
```
public boolean evict(K key)
```
    Evicts entry associated with given key from cache. Note, that entry will be evicted only if it's not used (not participating in any locks or transactions).
    If GridCacheConfiguration.isSwapEnabled() is set to true and GridCacheFlag.SKIP_SWAP is not enabled, the evicted entry will be swapped to offheap, and then to disk.
    Cache Flags
    This method is not available if any of the following flags are set on projection: GridCacheFlag.READ.
    
    Specified by:
    
    evict in interface GridCacheProjection<K,V>
    
    Parameters:
    key - Key to evict from cache.
    
    Returns:
    True if entry could be evicted, false otherwise.
  - evictAll
```
public void evictAll()
```
    Attempts to evict all cache entries. Note, that entry will be evicted only if it's not used (not participating in any locks or transactions).
    If GridCacheConfiguration.isSwapEnabled() is set to true and GridCacheFlag.SKIP_SWAP is not enabled, the evicted entry will be swapped to offheap, and then to disk.
    Cache Flags
    This method is not available if any of the following flags are set on projection: GridCacheFlag.READ.
    
    Specified by:
    
    evictAll in interface GridCacheProjection<K,V>
  - evictAll
```
public void evictAll(@Nullable
            Collection<? extends K> keys)
```
    Attempts to evict all entries associated with keys. Note, that entry will be evicted only if it's not used (not participating in any locks or transactions).
    If GridCacheConfiguration.isSwapEnabled() is set to true and GridCacheFlag.SKIP_SWAP is not enabled, the evicted entry will be swapped to offheap, and then to disk.
    Cache Flags
    This method is not available if any of the following flags are set on projection: GridCacheFlag.READ.
    
    Specified by:
    
    evictAll in interface GridCacheProjection<K,V>
    
    Parameters:
    keys - Keys to evict.
  - get
```
@Nullable
public V get(K key)
      throws GridException
```
    Retrieves value mapped to the specified key from cache. Value will only be returned if its entry passed the optional filter provided. Filter check is atomic, and therefore the returned value is guaranteed to be consistent with the filter. The return value of null means entry did not pass the provided filter or cache has no mapping for the key.
    If the value is not present in cache, then it will be looked up from swap storage. If it's not present in swap, or if swap is disable, and if read-through is allowed, value will be loaded from GridCacheStore persistent storage via GridCacheStore.load(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 GridCacheFlag.LOCAL flag is set on projection.
    
    Specified by:
    
    get in interface GridCacheProjection<K,V>
    
    Parameters:
    key - Key to retrieve the value for.
    
    Returns:
    Value for the given key.
    
    Throws:
    
    GridException - If get operation failed.
  - getAsync
```
public GridFuture<V> getAsync(K key)
```
    Asynchronously retrieves value mapped to the specified key from cache. Value will only be returned if its entry passed the optional filter provided. Filter check is atomic, and therefore the returned value is guaranteed to be consistent with the filter. The return value of null means entry did not pass the provided filter or cache has no mapping for the key.
    If the value is not present in cache, then it will be looked up from swap storage. If it's not present in swap, or if swap is disabled, and if read-through is allowed, value will be loaded from GridCacheStore persistent storage via GridCacheStore.load(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 GridCacheFlag.LOCAL flag is set on projection.
    
    Specified by:
    
    getAsync in interface GridCacheProjection<K,V>
    
    Parameters:
    key - Key for the value to get.
    
    Returns:
    Future for the get operation.
  - getAll
```
public Map<K,V> getAll(@Nullable
              Collection<? extends K> keys)
                throws GridException
```
    Retrieves values mapped to the specified keys from cache. Value will only be returned if its entry passed the optional filter provided. Filter check is atomic, and therefore the returned value is guaranteed to be consistent with the filter. If requested key-value pair is not present in the returned map, then it means that its entry did not pass the provided filter or cache has no mapping for the key.
    If some value is not present in cache, then it will be looked up from swap storage. If it's not present in swap, or if swap is disabled, and if read-through is allowed, value will be loaded from GridCacheStore persistent storage via GridCacheStore.loadAll(GridCacheTx, Collection, GridBiInClosure) 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 GridCacheFlag.LOCAL flag is set on projection.
    
    Specified by:
    
    getAll in interface GridCacheProjection<K,V>
    
    Parameters:
    keys - Keys to get.
    
    Returns:
    Map of key-value pairs.
    
    Throws:
    
    GridException - If get operation failed.
  - getAllAsync
```
public GridFuture<Map<K,V>> getAllAsync(@Nullable
                               Collection<? extends K> keys)
```
    Asynchronously retrieves values mapped to the specified keys from cache. Value will only be returned if its entry passed the optional filter provided. Filter check is atomic, and therefore the returned value is guaranteed to be consistent with the filter. If requested key-value pair is not present in the returned map, then it means that its entry did not pass the provided filter or cache has no mapping for the key.
    If some value is not present in cache, then it will be looked up from swap storage. If it's not present in swap, or if swap is disabled, and if read-through is allowed, value will be loaded from GridCacheStore persistent storage via GridCacheStore.loadAll(GridCacheTx, Collection, GridBiInClosure) 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 GridCacheFlag.LOCAL flag is set on projection.
    
    Specified by:
    
    getAllAsync in interface GridCacheProjection<K,V>
    
    Parameters:
    keys - Key for the value to get.
    
    Returns:
    Future for the get operation.
  - getAllAsync
```
protected 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)
```
  - getAllAsync
```
public GridFuture<Map<K,V>> getAllAsync(@Nullable
                               Collection<? extends K> keys,
                               @Nullable
                               GridCacheEntryEx<K,V> cached,
                               boolean checkTx,
                               @Nullable
                               UUID subjId,
                               @Nullable
                               GridPredicate<GridCacheEntry<K,V>>... filter)
```
  - put
```
public V put(K key,
    V val,
    @Nullable
    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. 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.putx(Object, Object, GridPredicate[]) 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:
    
    put in interface GridCacheProjection<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:
    Previous value associated with specified key, or null if entry did not pass the filter, or if there was no mapping for the key in swap or in persistent storage.
    
    Throws:
    
    GridException - If put operation failed.
  - put
```
@Nullable
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>
    
    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>
    
    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.
  - putAsync
```
public GridFuture<V> putAsync(K key,
                     V val,
                     @Nullable
                     GridPredicate<GridCacheEntry<K,V>>[] filter)
```
    Asynchronously 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. If cache previously contained value for the given key, then this value is returned. Otherwise, in case of GridCacheMode.REPLICATED caches, the value will be loaded from swap and, if it's not there, and read-through is allowed, from the underlying GridCacheStore storage. 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 and read-through is allowed, 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.putx(Object, Object, GridPredicate[]) 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:
    
    putAsync in interface GridCacheProjection<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:
    Future for the put operation.
  - 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>
    
    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.
  - 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>
    
    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.
  - putAllDr
```
public void putAllDr(Map<? extends K,GridCacheDrInfo<V>> drMap)
              throws GridException
```
    Store DR data.
    
    Specified by:
    
    putAllDr in interface GridCacheProjectionEx<K,V>
    
    Parameters:
    drMap - DR map.
    
    Throws:
    
    GridException - If put operation failed.
  - putAllDrAsync
```
public GridFuture<?> putAllDrAsync(Map<? extends K,GridCacheDrInfo<V>> drMap)
                            throws GridException
```
    Store DR data asynchronously.
    
    Specified by:
    
    putAllDrAsync in interface GridCacheProjectionEx<K,V>
    
    Parameters:
    drMap - DR map.
    
    Returns:
    Future.
    
    Throws:
    
    GridException - If put operation failed.
  - 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>
    
    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>
    
    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.
  - putxAsync
```
public GridFuture<Boolean> putxAsync(K key,
                            V val,
                            @Nullable
                            GridPredicate<GridCacheEntry<K,V>>... filter)
```
    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 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:
    
    putxAsync in interface GridCacheProjection<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:
    Future for the put operation. Future will return true if optional filter passed and value was stored in cache, false otherwise. Note that future will return true if filter is not specified.
  - 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>
    
    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.
  - transformAsync
```
public GridFuture<?> transformAsync(K key,
                           GridClosure<V,V> transformer)
```
    Stores result of applying transformer 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[]) method, 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:
    
    transformAsync in interface GridCacheProjection<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.
    
    Returns:
    Future for the transform operation.
  - 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>
    
    Parameters:
    key - Key.
    transformer - Transformer closure.
    entry - Cached entry.
    ttl - Optional time-to-lve.
    
    Returns:
    Transform operation future.
  - putIfAbsent
```
@Nullable
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>
    
    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>
    
    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>
    
    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>
    
    Parameters:
    key - Key to store in cache.
    val - Value to be associated with the given key.
    
    Returns:
    Future for this put operation.
  - replace
```
@Nullable
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>
    
    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>
    
    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>
    
    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>
    
    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>
    
    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>
    
    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.
  - putAll
```
public void putAll(@Nullable
          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>
    
    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.
  - 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>
    
    Parameters:
    m - Map containing keys and closures to be applied to values.
    
    Throws:
    
    GridException - On any error occurred while storing value in cache.
  - transformAll
```
public void transformAll(@Nullable
                Set<? extends K> keys,
                GridClosure<V,V> transformer)
                  throws GridException
```
    Stores result of applying the specified transform closure to previous values associated with the specified 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 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:
    
    transformAll in interface GridCacheProjection<K,V>
    
    Parameters:
    keys - Keys for entries, to which the transformation closure will be applied. If the collection is null or empty, this method is no-op.
    transformer - Transformation closure to be applied to each value.
    
    Throws:
    
    GridException - On any error occurred while storing value in cache.
  - 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>
    
    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.
  - 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>
    
    Parameters:
    m - Map containing keys and closures to be applied to values.
    
    Returns:
    Future for operation.
  - transformAllAsync
```
public GridFuture<?> transformAllAsync(@Nullable
                              Set<? extends K> keys,
                              GridClosure<V,V> transformer)
                                throws GridException
```
    Stores result of applying the specified transform closure to previous values associated with the specified 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 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:
    
    transformAllAsync in interface GridCacheProjection<K,V>
    
    Parameters:
    keys - Keys for entries, to which the transformation closure will be applied. If the collection is null or empty, this method is no-op.
    transformer - Transformation closure to be applied to each value.
    
    Returns:
    Future for operation.
    
    Throws:
    
    GridException - On any error occurred while storing value in cache.
  - remove
```
@Nullable
public V remove(K key,
                GridPredicate<GridCacheEntry<K,V>>[] filter)
         throws GridException
```
    Removes given key mapping from cache. 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 disk-based 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.removex(Object, GridPredicate[]) 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 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>
    
    Parameters:
    key - Key whose mapping is 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:
    Previous value associated with specified key, or null if there was no value for this key.
    
    Throws:
    
    GridException - If remove operation failed.
  - 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>
    
    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,
                        GridPredicate<GridCacheEntry<K,V>>... filter)
```
    Asynchronously removes given key mapping from cache. 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.removex(Object, GridPredicate[]) 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 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>
    
    Parameters:
    key - Key whose mapping is 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.
  - 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>
    
    Parameters:
    key - Key to remove.
    entry - Optional cached entry.
    filter - Optional filter.
    
    Returns:
    Put operation future.
  - removeAll
```
public void removeAll(@Nullable
             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>
    
    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(@Nullable
                           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>
    
    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,
              GridPredicate<GridCacheEntry<K,V>>... filter)
                throws GridException
```
    Removes given key mapping from cache.
    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:
    
    removex in interface GridCacheProjection<K,V>
    
    Parameters:
    key - Key whose mapping is 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:
    True if filter passed validation and entry was removed, false otherwise. Note that if filter is not specified, this method will return true.
    
    Throws:
    
    GridException - If remove failed.
  - 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>
    
    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,
                               GridPredicate<GridCacheEntry<K,V>>... filter)
```
    Asynchronously removes given key mapping from cache.
    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 GridCacheProjection<K,V>
    
    Parameters:
    key - Key whose mapping is 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 return true if optional filters passed validation and remove did occur, false otherwise. Note that if filter is not specified, this method will return true.
  - 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>
    
    Parameters:
    key - Key to remove.
    entry - Cached entry. If not provided, equivalent to {GridCacheProjection#put}.
    filter - Optional filter.
    
    Returns:
    Putx operation future.
  - 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>
    
    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.
  - removeAllDr
```
public void removeAllDr(Map<? extends K,GridCacheVersion> drMap)
                 throws GridException
```
    Removes DR data.
    
    Specified by:
    
    removeAllDr in interface GridCacheProjectionEx<K,V>
    
    Parameters:
    drMap - DR map.
    
    Throws:
    
    GridException - If remove failed.
  - removeAllDrAsync
```
public GridFuture<?> removeAllDrAsync(Map<? extends K,GridCacheVersion> drMap)
                               throws GridException
```
    Removes DR data asynchronously.
    
    Specified by:
    
    removeAllDrAsync in interface GridCacheProjectionEx<K,V>
    
    Parameters:
    drMap - DR map.
    
    Returns:
    Future.
    
    Throws:
    
    GridException - If remove failed.
  - 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>
    
    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.
  - 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>
    
    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>
    
    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.
  - 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>
    
    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>
    
    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>
    
    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>
    
    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.
  - metrics
```
public GridCacheMetrics metrics()
```
    Gets metrics (statistics) for this cache.
    
    Specified by:
    
    metrics in interface GridCache<K,V>
    
    Returns:
    Cache metrics.
  - drBackupQueueSize
```
protected int drBackupQueueSize()
```
    Returns:
    DR backup queue size.
  - metrics0
```
public GridCacheMetricsAdapter metrics0()
```
    Returns:
    Metrics.
  - tx
```
@Nullable
public GridCacheTx tx()
```
    Gets transaction started by this thread or null if this thread does not have a transaction.
    
    Specified by:
    
    tx in interface GridCacheProjection<K,V>
    
    Returns:
    Transaction started by this thread or null if this thread does not have a transaction.
  - lock
```
public boolean lock(K key,
           long timeout,
           @Nullable
           GridPredicate<GridCacheEntry<K,V>>... filter)
             throws GridException
```
    Synchronously acquires lock on a cached object with given key only if the passed in filter (if any) passes. This method together with filter check will be executed as one atomic operation.
    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.
    
    Specified by:
    
    lock in interface GridCacheProjection<K,V>
    
    Parameters:
    key - Key to lock.
    timeout - Timeout in milliseconds to wait for lock to be acquired ('0' for no expiration), -1 for immediate failure if lock cannot be acquired immediately).
    filter - Optional filter to validate prior to acquiring the lock.
    
    Returns:
    True if all filters passed and lock was acquired, false otherwise.
    
    Throws:
    
    GridException - If lock acquisition resulted in error.
  - lockAll
```
public boolean lockAll(@Nullable
              Collection<? extends K> keys,
              long timeout,
              @Nullable
              GridPredicate<GridCacheEntry<K,V>>... filter)
                throws GridException
```
    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.
    
    Specified by:
    
    lockAll in interface GridCacheProjection<K,V>
    
    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:
    True if all filters passed and locks were acquired before timeout has expired, false otherwise.
    
    Throws:
    
    GridException - If lock acquisition resulted in error.
  - lockAsync
```
public GridFuture<Boolean> lockAsync(K key,
                            long timeout,
                            @Nullable
                            GridPredicate<GridCacheEntry<K,V>>... filter)
```
    Asynchronously acquires lock on a cached object with given key only if the passed in filter (if any) passes. This method together with filter check will be executed as one atomic operation.
    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.
    
    Specified by:
    
    lockAsync in interface GridCacheProjection<K,V>
    
    Parameters:
    key - Key to lock.
    timeout - Timeout in milliseconds to wait for lock to be acquired ('0' for no expiration, -1 for immediate failure if lock cannot be acquired immediately).
    filter - Optional filter to validate prior to acquiring the lock.
    
    Returns:
    Future for the lock operation. The future will return true whenever all filters pass and locks are acquired before timeout is expired, false otherwise.
  - unlock
```
public void unlock(K key,
          GridPredicate<GridCacheEntry<K,V>>... filter)
            throws GridException
```
    Unlocks given key only if current thread owns the lock. If optional filter will not pass, then unlock will not happen. If the key being unlocked was never locked 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.
    
    Specified by:
    
    unlock in interface GridCacheProjection<K,V>
    
    Parameters:
    key - Key to unlock.
    filter - Optional filter that needs to pass prior to unlock taking effect.
    
    Throws:
    
    GridException - If unlock execution resulted in error.
  - isLocked
```
public boolean isLocked(K key)
```
    Checks if any node owns a lock for this key.
    This is a local in-VM operation and does not involve any network trips or access to persistent storage in any way.
    
    Specified by:
    
    isLocked in interface GridCacheProjection<K,V>
    
    Parameters:
    key - Key to check.
    
    Returns:
    True if lock is owned by some node.
  - isLockedByThread
```
public boolean isLockedByThread(K key)
```
    Checks if current thread owns a lock on this key.
    This is a local in-VM operation and does not involve any network trips or access to persistent storage in any way.
    
    Specified by:
    
    isLockedByThread in interface GridCacheProjection<K,V>
    
    Parameters:
    key - Key to check.
    
    Returns:
    True if key is locked by current thread.
  - txStart
```
public GridCacheTx txStart()
                    throws IllegalStateException
```
    Starts transaction with default isolation, concurrency, timeout, and invalidation policy. All defaults are set in GridCacheConfiguration at startup.
    
    Specified by:
    
    txStart in interface GridCacheProjection<K,V>
    
    Returns:
    New transaction
    
    Throws:
    
    IllegalStateException - If transaction is already started by this thread.
  - txStart
```
public GridCacheTx txStart(GridCacheTxConcurrency concurrency,
                  GridCacheTxIsolation isolation)
```
    Starts new transaction with the specified concurrency and isolation.
    
    Specified by:
    
    txStart in interface GridCacheProjection<K,V>
    
    Parameters:
    concurrency - Concurrency.
    isolation - Isolation.
    
    Returns:
    New transaction.
  - txStart
```
public GridCacheTx txStart(GridCacheTxConcurrency concurrency,
                  GridCacheTxIsolation isolation,
                  long timeout,
                  int txSize)
                    throws IllegalStateException
```
    Starts transaction with specified isolation, concurrency, timeout, invalidation flag, and number of participating entries.
    
    Specified by:
    
    txStart in interface GridCacheProjection<K,V>
    
    Parameters:
    concurrency - Concurrency.
    isolation - Isolation.
    timeout - Timeout.
    txSize - Number of entries participating in transaction (may be approximate).
    
    Returns:
    New transaction.
    
    Throws:
    
    IllegalStateException - If transaction is already started by this thread.
  - txStartAffinity
```
public GridCacheTx txStartAffinity(Object affinityKey,
                          GridCacheTxConcurrency concurrency,
                          GridCacheTxIsolation isolation,
                          long timeout,
                          int txSize)
                            throws IllegalStateException,
                                   GridException
```
    Starts affinity-group-locked transaction based on affinity key. In this mode only affinity key is locked and all other entries in transaction are written without locking. However, all keys in such transaction must have the same affinity key. Node on which transaction is started must be primary for the given affinity key (an exception is thrown otherwise).
    Since only affinity key is locked, and no individual keys, it is user's responsibility to make sure there are no other concurrent explicit updates directly on individual keys participating in the transaction. All updates to the keys involved should always go through affinity-group-locked transaction, otherwise cache may be left in inconsistent state.
    If cache sanity check is enabled (GridConfiguration.isCacheSanityCheckEnabled()), the following checks are performed:
    - An exception will be thrown if affinity key differs from one specified on transaction start.
    - An exception is thrown if entry participating in transaction is externally locked at commit.
    Specified by:
    
    txStartAffinity in interface GridCacheProjection<K,V>
    
    Parameters:
    affinityKey - Affinity key for all entries updated by transaction. This node must be primary for this key.
    concurrency - Transaction concurrency control.
    isolation - Cache transaction isolation level.
    timeout - Timeout (0 for default).
    txSize - Number of entries participating in transaction (may be approximate), 0 for default.
    
    Returns:
    Started transaction.
    
    Throws:
    
    IllegalStateException - If transaction is already started by this thread.
    
    GridException - If local node is not primary for any of provided keys.
  - txStartPartition
```
public GridCacheTx txStartPartition(int partId,
                           GridCacheTxConcurrency concurrency,
                           GridCacheTxIsolation isolation,
                           long timeout,
                           int txSize)
                             throws IllegalStateException,
                                    GridException
```
    Starts partition-group-locked transaction based on partition ID. In this mode the whole partition is locked and all other entries in transaction are written without locking. However, all keys in such transaction must belong to the same partition. Node on which transaction is started must be primary for the given partition (an exception is thrown otherwise).
    Since only partition is locked, and no individual keys, it is user's responsibility to make sure there are no other concurrent explicit updates directly on individual keys participating in the transaction. All updates to the keys involved should always go through partition-group-locked transaction, otherwise, cache may be left in inconsistent state.
    If cache sanity check is enabled (GridConfiguration.isCacheSanityCheckEnabled()), the following checks are performed:
    - An exception will be thrown if key partition differs from one specified on transaction start.
    - An exception is thrown if entry participating in transaction is externally locked at commit.
    Specified by:
    
    txStartPartition in interface GridCacheProjection<K,V>
    
    Parameters:
    partId - Partition id for which transaction is started. This node must be primary for this partition.
    concurrency - Transaction concurrency control.
    isolation - Cache transaction isolation level.
    timeout - Timeout (0 for default).
    txSize - Number of entries participating in transaction (may be approximate), 0 for default.
    
    Returns:
    Started transaction.
    
    Throws:
    
    IllegalStateException - If transaction is already started by this thread.
    
    GridException - If local node is not primary for any of provided keys.
  - overflowSize
```
public long overflowSize()
                  throws GridException
```
    Gets size (in bytes) of all entries swapped to disk.
    
    Specified by:
    
    overflowSize in interface GridCache<K,V>
    
    Returns:
    Size (in bytes) of all entries swapped to disk.
    
    Throws:
    
    GridException - In case of error.
  - toMap
```
public ConcurrentMap<K,V> toMap()
```
    Converts this API into standard Java ConcurrentMap interface.
    
    Specified by:
    
    toMap in interface GridCacheProjection<K,V>
    
    Returns:
    ConcurrentMap representation of given cache projection.
  - checkJta
```
protected void checkJta()
                 throws GridException
```
    Checks if cache is working in JTA transaction and enlist cache as XAResource if necessary.
    
    Throws:
    
    GridException - In case of error.
  - txSynchronize
```
public void txSynchronize(GridCacheTxSynchronization syncs)
```
    Registers transactions synchronizations for all transactions started by this cache. Use it whenever you need to get notifications on transaction lifecycle and possibly change its course. It is also particularly useful when integrating cache transactions with some other in-house transactions.
    
    Specified by:
    
    txSynchronize in interface GridCache<K,V>
    
    Parameters:
    syncs - Transaction synchronizations to register.
  - txUnsynchronize
```
public void txUnsynchronize(GridCacheTxSynchronization syncs)
```
    Removes transaction synchronizations.
    
    Specified by:
    
    txUnsynchronize in interface GridCache<K,V>
    
    Parameters:
    syncs - Transactions synchronizations to remove.
    See Also:
    GridCache.txSynchronize(GridCacheTxSynchronization)
  - txSynchronizations
```
public Collection<GridCacheTxSynchronization> txSynchronizations()
```
    Gets registered transaction synchronizations.
    
    Specified by:
    
    txSynchronizations in interface GridCache<K,V>
    
    Returns:
    Registered transaction synchronizations.
    See Also:
    GridCache.txSynchronize(GridCacheTxSynchronization)
  - loadCache
```
public void loadCache(GridBiPredicate<K,V> p,
             long ttl,
             Object[] args)
               throws GridException
```
    Delegates to GridCacheStore.loadCache(GridBiInClosure,Object...) method to load state from the underlying persistent storage. The loaded values will then be given to the optionally passed in predicate, and, if the predicate returns true, will be stored in cache. If predicate is null, then all loaded values will be stored in cache.
    Note that this method does not receive keys as a parameter, so it is up to GridCacheStore implementation to provide all the data to be loaded.
    This method is not transactional and may end up loading a stale value into cache if another thread has updated the value immediately after it has been loaded. It is mostly useful when pre-loading the cache from underlying data store before start, or for read-only caches.
    
    Specified by:
    
    loadCache in interface GridCache<K,V>
    
    Parameters:
    p - Optional predicate (may be null). If provided, will be used to filter values to be put into cache.
    ttl - Time to live for loaded entries (0 for infinity).
    args - Optional user arguments to be passed into GridCacheStore.loadCache(GridBiInClosure, Object...) method.
    
    Throws:
    
    GridException - If loading failed.
  - loadCacheAsync
```
public GridFuture<?> loadCacheAsync(GridBiPredicate<K,V> p,
                           long ttl,
                           Object[] args)
```
    Asynchronously delegates to GridCacheStore.loadCache(GridBiInClosure, Object...) method to reload state from the underlying persistent storage. The reloaded values will then be given to the optionally passed in predicate, and if the predicate returns true, will be stored in cache. If predicate is null, then all reloaded values will be stored in cache.
    Note that this method does not receive keys as a parameter, so it is up to GridCacheStore implementation to provide all the data to be loaded.
    This method is not transactional and may end up loading a stale value into cache if another thread has updated the value immediately after it has been loaded. It is mostly useful when pre-loading the cache from underlying data store before start, or for read-only caches.
    
    Specified by:
    
    loadCacheAsync in interface GridCache<K,V>
    
    Parameters:
    p - Optional predicate (may be null). If provided, will be used to filter values to be put into cache.
    ttl - Time to live for loaded entries (0 for infinity).
    args - Optional user arguments to be passed into GridCacheStore.loadCache(GridBiInClosure,Object...) method.
    
    Returns:
    Future to be completed whenever loading completes.
  - randomEntry
```
@Nullable
public GridCacheEntry<K,V> randomEntry()
```
    Gets a random entry out of cache. In the worst cache scenario this method has complexity of
```
O(S * N/64)
```
    where N is the size of internal hash table and S is the number of hash table buckets to sample, which is 5 by default. However, if the table is pretty dense, with density factor of N/64, which is true for near fully populated caches, this method will generally perform significantly faster with complexity of O(S) where S = 5.
    Note that this method is not available on GridCacheProjection API since it is impossible (or very hard) to deterministically return a number value when pre-filtering and post-filtering is involved (e.g. projection level predicate filters).
    Specified by:
    
    randomEntry in interface GridCache<K,V>
    
    Returns:
    Random entry, or null if cache is empty.
  - size
```
public int size()
```
    Gets size of cache key set. This method will return the count of all cache entries and has O(1) complexity on base GridCache projection. It is essentially the size of cache key set and is semantically identical to {GridCache.keySet().size().
    
    Specified by:
    
    size in interface GridCacheProjection<K,V>
    
    Returns:
    Size of cache key set.
  - nearSize
```
public int nearSize()
```
    Gets size of near cache key set. This method will return count of all entries in near cache including null values and has O(1) complexity on base cache projection.
    Note that for LOCAL caches this method will always return 0
    
    Specified by:
    
    nearSize in interface GridCacheProjection<K,V>
    
    Returns:
    Size of near cache key set or 0 if cache is not GridCacheMode.PARTITIONED.
  - primarySize
```
public int primarySize()
```
    Gets size of all primary keys for this cache. For GridCacheMode.LOCAL mode, this method is identical to GridCacheProjection.size().
    For GridCacheMode.PARTITIONED and GridCacheMode.REPLICATED modes, this method will return number of primary entries in the cache (excluding any backups). The complexity of this method is O(P), where P is the total number of partitions.
    
    Specified by:
    
    primarySize in interface GridCacheProjection<K,V>
    
    Returns:
    Number of primary entries in cache.
  - toString
```
public String toString()
```
    Overrides:
    
    toString in class Object
  - iterator
```
public Iterator<GridCacheEntry<K,V>> iterator()
```
    Specified by:
    
    iterator in interface Iterable<GridCacheEntry<K,V>>
  - promote
```
@Nullable
public V promote(K key)
          throws GridException
```
    This method promotes cache entry from offheap by given key, if any, from offheap or swap storage into memory.
    Transactions
    This method is not transactional.
    Cache Flags
    This method is not available if any of the following flags are set on projection: GridCacheFlag.SKIP_SWAP, GridCacheFlag.READ.
    
    Specified by:
    
    promote in interface GridCacheProjection<K,V>
    
    Parameters:
    key - Key to promote entry for.
    
    Returns:
    Unswapped entry value or null for non-existing key.
    
    Throws:
    
    GridException - If promote failed.
  - promoteAll
```
public void promoteAll(@Nullable
              Collection<? extends K> keys)
                throws GridException
```
    This method unswaps cache entries by given keys, if any, from swap storage into memory.
    Transactions
    This method is not transactional.
    Cache Flags
    This method is not available if any of the following flags are set on projection: GridCacheFlag.SKIP_SWAP, GridCacheFlag.READ.
    
    Specified by:
    
    promoteAll in interface GridCacheProjection<K,V>
    
    Parameters:
    keys - Keys to promote entries for.
    
    Throws:
    
    GridException - If promote failed.
  - swapIterator
```
public Iterator<Map.Entry<K,V>> swapIterator()
                                      throws GridException
```
    Gets iterator over keys and values belonging to this cache swap space on local node. This iterator is thread-safe, which means that cache (and therefore its swap space) may be modified concurrently with iteration over swap.
    Returned iterator supports remove operation which delegates to GridCacheProjection.removex(Object, GridPredicate[]) method.
    Cache Flags
    This method is not available if any of the following flags are set on projection: GridCacheFlag.SKIP_SWAP.
    
    Specified by:
    
    swapIterator in interface GridCache<K,V>
    
    Returns:
    Iterator over keys.
    
    Throws:
    
    GridException - If failed.
    See Also:
    GridCacheProjection.promote(Object)
  - offHeapIterator
```
public Iterator<Map.Entry<K,V>> offHeapIterator()
                                         throws GridException
```
    Gets iterator over keys and values belonging to this cache off-heap memory on local node. This iterator is thread-safe, which means that cache (and therefore its off-heap memory) may be modified concurrently with iteration over off-heap. To achieve better performance the keys and values deserialized on demand, whenever accessed.
    Returned iterator supports remove operation which delegates to GridCacheProjection.removex(Object, GridPredicate[]) method.
    
    Specified by:
    
    offHeapIterator in interface GridCache<K,V>
    
    Returns:
    Iterator over keys.
    
    Throws:
    
    GridException - If failed.
  - offHeapEntriesCount
```
public long offHeapEntriesCount()
```
    Gets number of cache entries stored in off-heap memory.
    
    Specified by:
    
    offHeapEntriesCount in interface GridCache<K,V>
    
    Returns:
    Number of cache entries stored in off-heap memory.
  - offHeapAllocatedSize
```
public long offHeapAllocatedSize()
```
    Gets memory size allocated in off-heap.
    
    Specified by:
    
    offHeapAllocatedSize in interface GridCache<K,V>
    
    Returns:
    Allocated memory size.
  - swapSize
```
public long swapSize()
              throws GridException
```
    Gets size in bytes for swap space.
    
    Specified by:
    
    swapSize in interface GridCache<K,V>
    
    Returns:
    Size in bytes.
    
    Throws:
    
    GridException - If failed.
  - swapKeys
```
public long swapKeys()
              throws GridException
```
    Gets number of swap entries (keys).
    
    Specified by:
    
    swapKeys in interface GridCache<K,V>
    
    Returns:
    Number of entries stored in swap.
    
    Throws:
    
    GridException - If failed.
  - asyncOp
```
protected <T> GridFuture<T> asyncOp(GridCacheTxLocalAdapter<K,V> tx,
                        GridCacheAdapter.AsyncOp<T> op)
```
    Type Parameters:
    T - Return type.
    Parameters:
    tx - Transaction.
    op - Cache operation.
    
    Returns:
    Future.
  - saveFuture
```
protected void saveFuture(GridCacheAdapter.FutureHolder holder,
              GridFuture<?> fut)
```
    Saves future in thread local holder and adds listener that will clear holder when future is finished.
    
    Parameters:
    holder - Future holder.
    fut - Future to save.
  - asyncOpAcquire
```
@Nullable
protected <T> GridFuture<T> asyncOpAcquire()
```
    Tries to acquire asynchronous operations permit, if limited.
    
    Returns:
    Failed future if waiting was interrupted.
  - asyncOpRelease
```
protected void asyncOpRelease()
```
    Releases asynchronous operations permit, if limited.
  - writeExternal
```
public void writeExternal(ObjectOutput out)
                   throws IOException
```
    Specified by:
    
    writeExternal in interface Externalizable
    
    Throws:
    
    IOException
  - readExternal
```
public void readExternal(ObjectInput in)
                  throws IOException,
                         ClassNotFoundException
```
    Specified by:
    
    readExternal in interface Externalizable
    
    Throws:
    
    IOException
    
    ClassNotFoundException
  - readResolve
```
protected Object readResolve()
                      throws ObjectStreamException
```
    Reconstructs object on demarshalling.
    
    Returns:
    Reconstructed object.
    
    Throws:
    
    ObjectStreamException - Thrown in case of demarshalling error.
  - resetMetrics
```
public void resetMetrics()
```
    Resets metrics for current cache.
    
    Specified by:
    
    resetMetrics in interface GridCache<K,V>
  - dgc
```
public void dgc()
```
    Runs DGC procedure on demand using GridCacheConfiguration.getDgcSuspectLockTimeout() to identify suspect locks.
    Method blocks current thread until locks are examined and all DGC requests are sent to remote nodes.
    DGC does not remove locks if GridCacheConfiguration.isDgcRemoveLocks() is set to false.
    
    Specified by:
    
    dgc in interface GridCache<K,V>
  - dgc
```
public void dgc(long suspectLockTimeout,
       boolean global,
       boolean rmvLocks)
```
    Runs DGC procedure on demand using provided parameter to identify suspect locks.
    Method blocks current thread until locks are examined and all DGC requests are sent to remote nodes and (if global is true) all nodes running this cache will get signal to start GC procedure.
    
    Specified by:
    
    dgc in interface GridCache<K,V>
    
    Parameters:
    suspectLockTimeout - Custom suspect lock timeout (should be greater than or equal to 0).
    global - If true then GC procedure will start on all nodes having this cache.
    rmvLocks - If false then DGC does not remove locks, just report them to log.
  - forceRepartition
```
public GridFuture<?> forceRepartition()
```
    Forces this cache node to re-balance its partitions. This method is usually used when GridCacheConfiguration.getPreloadPartitionedDelay() configuration parameter has non-zero value. When many nodes are started or stopped almost concurrently, it is more efficient to delay preloading until the node topology is stable to make sure that no redundant re-partitioning happens.
    In case ofGridCacheMode.PARTITIONED caches, for better efficiency user should usually make sure that new nodes get placed on the same place of consistent hash ring as the left nodes, and that nodes are restarted before preloadDelay expires. To place nodes on the same place in consistent hash ring, use GridCacheConsistentHashAffinityFunction.setHashIdResolver(GridCacheAffinityNodeHashResolver) to make sure that a node maps to the same hash ID if re-started.
    See GridCacheConfiguration.getPreloadPartitionedDelay() for more information on how to configure preload re-partition delay.
    
    Specified by:
    
    forceRepartition in interface GridCache<K,V>
    
    Returns:
    Future that will be completed when preloading is finished.
  - isGgfsDataCache
```
public boolean isGgfsDataCache()
```
    Checks whether this cache is GGFS data cache.
    
    Specified by:
    
    isGgfsDataCache in interface GridCacheProjectionEx<K,V>
    
    Returns:
    True in case this cache is GGFS data cache.
  - ggfsDataSpaceUsed
```
public long ggfsDataSpaceUsed()
```
    Get current amount of used GGFS space in bytes.
    
    Specified by:
    
    ggfsDataSpaceUsed in interface GridCacheProjectionEx<K,V>
    
    Returns:
    Amount of used GGFS space in bytes.
  - ggfsDataSpaceMax
```
public long ggfsDataSpaceMax()
```
    Get maximum space available for GGFS.
    
    Specified by:
    
    ggfsDataSpaceMax in interface GridCacheProjectionEx<K,V>
    
    Returns:
    Amount of space available for GGFS in bytes.
  - isMongoDataCache
```
public boolean isMongoDataCache()
```
    Checks whether this cache is Mongo data cache.
    
    Specified by:
    
    isMongoDataCache in interface GridCacheProjectionEx<K,V>
    
    Returns:
    True if this cache is mongo data cache.
  - isMongoMetaCache
```
public boolean isMongoMetaCache()
```
    Checks whether this cache is Mongo meta cache.
    
    Specified by:
    
    isMongoMetaCache in interface GridCacheProjectionEx<K,V>
    
    Returns:
    True if this cache is mongo meta cache.
  - isDrSystemCache
```
public boolean isDrSystemCache()
```
    Checks whether this cache is DR system cache.
    
    Specified by:
    
    isDrSystemCache in interface GridCacheProjectionEx<K,V>
    
    Returns:
    True if this cache is DR system cache.
  - afterPessimisticUnlock
```
public void afterPessimisticUnlock(GridInClosure3<K,Boolean,GridCacheOperation> afterPessimisticUnlock)
```
    Sets callback that will be invoked after keys are unlocked.
    
    Parameters:
    afterPessimisticUnlock - After unlock callback.
  - afterPessimisticUnlock
```
public GridInClosure3<K,Boolean,GridCacheOperation> afterPessimisticUnlock()
```
    Returns:
    After pessimistic unlock request.
  - drStateTransfer
```
public GridFuture<?> drStateTransfer(Collection<Byte> dataCenterIds)
```
    Starts full state transfer.
    
    Specified by:
    
    drStateTransfer in interface GridCacheProjectionEx<K,V>
    
    Parameters:
    dataCenterIds - Data center IDs for which full state transfer was requested.
    
    Returns:
    Future that will be completed when all replication batches are sent.
  - drListStateTransfers
```
public Collection<GridDrStateTransferDescriptor> drListStateTransfers()
```
    List currently active state transfers.
    
    Specified by:
    
    drListStateTransfers in interface GridCacheProjectionEx<K,V>
    
    Returns:
    Collection of currently active state transfers.
  - drPause
```
public void drPause()
```
    Pauses data center replication for this cache.
    
    Specified by:
    
    drPause in interface GridCacheProjectionEx<K,V>
  - drResume
```
public void drResume()
```
    Resumes data center replication for this cache.
    
    Specified by:
    
    drResume in interface GridCacheProjectionEx<K,V>
  - drPauseState
```
@Nullable
public GridDrStatus drPauseState()
```
    Get DR pause state.
    
    Specified by:
    
    drPauseState in interface GridCacheProjectionEx<K,V>
    
    Returns:
    DR pause state.
  - onGgfsDataSizeChanged
```
public void onGgfsDataSizeChanged(long delta)
```
    Callback invoked when data is added to GGFS cache.
    
    Parameters:
    delta - Size delta.
  - clearAll0
```
public void clearAll0(Collection<? extends K> keys,
             @Nullable
             GridPredicate<GridCacheEntry<K,V>>... filter)
```
    Parameters:
    keys - Keys.
    filter - Filters to evaluate.
  - clear0
```
public boolean clear0(K key,
             @Nullable
             GridPredicate<GridCacheEntry<K,V>>... filter)
```
    Parameters:
    key - Key.
    filter - Filters to evaluate.
    
    Returns:
    True if cleared.
  - compact
```
public boolean compact(K key,
              @Nullable
              GridPredicate<GridCacheEntry<K,V>>... filter)
                throws GridException
```
    Parameters:
    key - Key.
    filter - Filters to evaluate.
    
    Returns:
    True if compacted.
    
    Throws:
    
    GridException - If failed.
  - evict
```
public boolean evict(K key,
            @Nullable
            GridPredicate<GridCacheEntry<K,V>>... filter)
```
    Parameters:
    key - Key.
    filter - Filters to evaluate.
    
    Returns:
    True if evicted.
  - evictAll
```
public void evictAll(Collection<? extends K> keys,
            @Nullable
            GridPredicate<GridCacheEntry<K,V>>... filter)
```
    Parameters:
    keys - Keys.
    filter - Filters to evaluate.
  - containsKey
```
public boolean containsKey(K key,
                  @Nullable
                  GridPredicate<GridCacheEntry<K,V>> filter)
```
    Parameters:
    key - Key.
    filter - Filters to evaluate.
    
    Returns:
    True if contains key.
  - containsAllKeys
```
public boolean containsAllKeys(@Nullable
                      Collection<? extends K> keys,
                      @Nullable
                      GridPredicate<GridCacheEntry<K,V>> filter)
```
    Parameters:
    keys - Keys.
    filter - Filter to evaluate.
    
    Returns:
    True if contains all keys.
  - containsAnyKeys
```
public boolean containsAnyKeys(@Nullable
                      Collection<? extends K> keys,
                      @Nullable
                      GridPredicate<GridCacheEntry<K,V>> filter)
```
    Parameters:
    keys - Keys.
    filter - Filter to evaluate.
    
    Returns:
    True if cache contains any of given keys.
  - containsValue
```
public boolean containsValue(V val,
                    @Nullable
                    GridPredicate<GridCacheEntry<K,V>> filter)
```
    Parameters:
    val - Value.
    filter - Filter to evaluate.
    
    Returns:
    True if contains value.
  - containsAllValues
```
public boolean containsAllValues(@Nullable
                        Collection<? extends V> vals,
                        @Nullable
                        GridPredicate<GridCacheEntry<K,V>> filter)
```
    Parameters:
    vals - Values.
    filter - Filter to evaluate.
    
    Returns:
    True if contains all given values.
  - containsAnyValues
```
public boolean containsAnyValues(@Nullable
                        Collection<? extends V> vals,
                        @Nullable
                        GridPredicate<GridCacheEntry<K,V>> filter)
```
    Parameters:
    vals - Values.
    filter - Filter to evaluate.
    
    Returns:
    True if contains any of given values.
  - peek
```
public V peek(K key,
     @Nullable
     GridPredicate<GridCacheEntry<K,V>> filter)
```
    Parameters:
    key - Key.
    filter - Filter to evaluate.
    
    Returns:
    Peeked value.
  - entrySet
```
public Set<GridCacheEntry<K,V>> entrySet(@Nullable
                                GridPredicate<GridCacheEntry<K,V>>... filter)
```
    Parameters:
    filter - Filters to evaluate.
    
    Returns:
    Entry set.
  - entrySet
```
public Set<GridCacheEntry<K,V>> entrySet(@Nullable
                                Collection<? extends K> keys,
                                @Nullable
                                GridPredicate<K> keyFilter,
                                @Nullable
                                GridPredicate<GridCacheEntry<K,V>>... filter)
```
    Parameters:
    keys - Keys.
    keyFilter - Key filter.
    filter - Entry filter.
    
    Returns:
    Entry set.
  - primaryEntrySet
```
public Set<GridCacheEntry<K,V>> primaryEntrySet(@Nullable
                                       GridPredicate<GridCacheEntry<K,V>>... filter)
```
    Parameters:
    filter - Filters to evaluate.
    
    Returns:
    Primary entry set.
  - keySet
```
public Set<K> keySet(@Nullable
            GridPredicate<GridCacheEntry<K,V>>... filter)
```
    Parameters:
    filter - Filters to evaluate.
    
    Returns:
    Key set.
  - primaryKeySet
```
public Set<K> primaryKeySet(@Nullable
                   GridPredicate<GridCacheEntry<K,V>>... filter)
```
    Parameters:
    filter - Primary key set.
    
    Returns:
    Primary key set.
  - primaryValues
```
public Collection<V> primaryValues(@Nullable
                          GridPredicate<GridCacheEntry<K,V>>... filter)
```
    Parameters:
    filter - Filters to evaluate.
    
    Returns:
    Primary values.
  - compactAll
```
public void compactAll(@Nullable
              Iterable<K> keys,
              @Nullable
              GridPredicate<GridCacheEntry<K,V>>... filter)
                throws GridException
```
    Parameters:
    keys - Keys.
    filter - Filters to evaluate.
    
    Throws:
    
    GridException - If failed.
  - get
```
@Nullable
public V get(K key,
             @Nullable
             GridPredicate<GridCacheEntry<K,V>> filter)
      throws GridException
```
    Parameters:
    key - Key.
    filter - Filter to evaluate.
    
    Returns:
    Cached value.
    
    Throws:
    
    GridException - If failed.
  - getAsync
```
public final GridFuture<V> getAsync(K key,
                     @Nullable
                     GridPredicate<GridCacheEntry<K,V>> filter)
```
    Parameters:
    key - Key.
    filter - Filter to evaluate.
    
    Returns:
    Read operation future.
  - getAll
```
public Map<K,V> getAll(Collection<? extends K> keys,
              GridPredicate<GridCacheEntry<K,V>> filter)
                throws GridException
```
    Parameters:
    keys - Keys.
    filter - Filter to evaluate.
    
    Returns:
    Map of cached values.
    
    Throws:
    
    GridException - If read failed.
  - reload
```
@Nullable
public V reload(K key,
                @Nullable
                GridPredicate<GridCacheEntry<K,V>>... filter)
         throws GridException
```
    Parameters:
    key - Key.
    filter - Filter to evaluate.
    
    Returns:
    Reloaded value.
    
    Throws:
    
    GridException - If failed.
  - reloadAll
```
public void reloadAll(@Nullable
             Collection<? extends K> keys,
             @Nullable
             GridPredicate<GridCacheEntry<K,V>>... filter)
               throws GridException
```
    Parameters:
    keys - Keys.
    filter - Filter to evaluate.
    
    Throws:
    
    GridException - If failed.
  - reloadAllAsync
```
public GridFuture<?> reloadAllAsync(@Nullable
                           Collection<? extends K> keys,
                           @Nullable
                           GridPredicate<GridCacheEntry<K,V>>... filter)
```
    Parameters:
    keys - Keys.
    filter - Filter to evaluate.
    
    Returns:
    Reload future.
  - reloadAsync
```
public GridFuture<V> reloadAsync(K key,
                        @Nullable
                        GridPredicate<GridCacheEntry<K,V>>... filter)
```
    Parameters:
    key - Key.
    filter - Filter to evaluate.
    
    Returns:
    Reload future.
  - reloadAll
```
public final void reloadAll(@Nullable
             GridPredicate<GridCacheEntry<K,V>>... filter)
                     throws GridException
```
    Parameters:
    filter - Filter to evaluate.
    
    Throws:
    
    GridException - If reload failed.
  - reloadAllAsync
```
public GridFuture<?> reloadAllAsync(@Nullable
                           GridPredicate<GridCacheEntry<K,V>> filter)
```
    Parameters:
    filter - Filter to evaluate.
    
    Returns:
    Reload future.
  - getAllAsync
```
public GridFuture<Map<K,V>> getAllAsync(@Nullable
                               Collection<? extends K> keys,
                               @Nullable
                               GridPredicate<GridCacheEntry<K,V>> filter)
```
    Parameters:
    keys - Keys.
    filter - Filter to evaluate.
    
    Returns:
    Read future.
  - onDeferredDelete
```
public abstract void onDeferredDelete(GridCacheEntryEx<K,V> entry,
                    GridCacheVersion ver)
```
    Parameters:
    entry - Entry.
    ver - Version.
  - processCheckPreparedTxRequest
```
protected void processCheckPreparedTxRequest(UUID nodeId,
                                 GridCacheOptimisticCheckPreparedTxRequest<K,V> req)
```
    Parameters:
    nodeId - Node ID.
    req - Request.
  - processCheckPreparedTxResponse
```
protected void processCheckPreparedTxResponse(UUID nodeId,
                                  GridCacheOptimisticCheckPreparedTxResponse<K,V> res)
```
    Parameters:
    nodeId - Node ID.
    res - Response.
  - processCheckCommittedTxRequest
```
protected void processCheckCommittedTxRequest(UUID nodeId,
                                  GridCachePessimisticCheckCommittedTxRequest<K,V> req)
```
    Parameters:
    nodeId - Node ID.
    req - Request.
  - processCheckCommittedTxResponse
```
protected void processCheckCommittedTxResponse(UUID nodeId,
                                   GridCachePessimisticCheckCommittedTxResponse<K,V> res)
```
    Parameters:
    nodeId - Node ID.
    res - Response.

Class GridCacheAdapter<K,V>

Nested Class Summary

Field Summary

Constructor Summary

Method Summary

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

Methods inherited from class java.lang.Object

Methods inherited from interface org.gridgain.grid.cache.GridCacheProjection

Methods inherited from interface org.gridgain.grid.GridMetadataAware

Field Detail

CLEAR_ALL_SPLIT_THRESHOLD

lastFut

ctx

map

locNodeId

cacheCfg

gridCfg

metrics

beforePessimisticLock

afterPessimisticUnlock

log

Constructor Detail

GridCacheAdapter

GridCacheAdapter

GridCacheAdapter

Method Detail

name

gridProjection

printMemoryStats

map

context

log

isNear

isLocal

isColocated

isDhtAtomic

isDht

preloader

queries

affinity

dataStructures

cache

flags

predicate

forSubjectId

flagsOn

Cache Flags

beforePessimisticLock

beforePessimisticLock

flagsOff

Cache Flags

projection

projection

projection

configuration

txLockAsync

newTx

init

start

startInfo

stop

stopInfo

onKernalStart

onKernalStop

isEmpty

containsKey

containsValue

peek

Transactions

peek

Transactions

peekAll

peek0

peekAll0

peek0

peek0

peekAll0

forEach

Transactions

forAll