GridCacheProjectionImpl (gridgain-core 6.1.9 API)

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

All Implemented Interfaces:

Externalizable, Serializable, Iterable<GridCacheEntry<K,V>>, GridCacheProjection<K,V>, GridMetadataAware, GridCacheProjectionEx<K,V>
```
public class GridCacheProjectionImpl<K,V>
extends GridMetadataAwareAdapter
implements GridCacheProjectionEx<K,V>, Externalizable
```
Cache projection.

See Also:
Serialized Form

Constructor Summary

Constructors
Constructor and Description
`GridCacheProjectionImpl()` Empty constructor required for `Externalizable`.
`GridCacheProjectionImpl(GridCacheProjection<K,V> parent, GridCacheContext<K,V> cctx, GridBiPredicate<K,V> kvFilter, GridPredicate<? super GridCacheEntry<K,V>> entryFilter, Set<GridCacheFlag> flags, UUID subjId)`

Method Summary

Methods
Modifier and Type	Method and Description
`<K1,V1> GridCache<K1,V1>`	`cache()` Gets base cache for this projection.
`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.
`void`	`clearAll()` Clears all entries from this cache only if the entry is not currently locked or participating in a transaction.
`boolean`	`compact(K key)` Clears serialized value bytes from entry (if any) leaving only object representation.
`void`	`compactAll()` Clears serialized value bytes from cache entries (if any) leaving only object representation.
`boolean`	`containsKey(K key)` Returns `true` if this cache contains a mapping for the specified key.
`boolean`	`containsValue(V val)` Returns `true` if this cache contains given value.
`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.
`GridCacheEntry<K,V>`	`entry(K key)` Gets entry from cache with the specified key.
`Set<GridCacheEntry<K,V>>`	`entrySet()` Gets set containing all cache entries.
`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.
`void`	`evictAll()` Attempts to evict all cache entries.
`void`	`evictAll(Collection<? extends K> keys)` Attempts to evict all entries associated with keys.
`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.
`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)`
`Map<K,V>`	`getAll(Collection<? extends K> keys)` Retrieves values mapped to the specified keys from cache.
`GridFuture<Map<K,V>>`	`getAllAsync(Collection<? extends K> keys)` Asynchronously retrieves values mapped to the specified keys from cache.
`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.
`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.
`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`	`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.
`Iterator<GridCacheEntry<K,V>>`	`iterator()`
`Set<K>`	`keySet()` Set of cached keys.
`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>`	`lockAllAsync(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.
`String`	`name()` Gets name of this cache (`null` for default cache).
`int`	`nearSize()` Gets size of near cache key set.
`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.
`GridPredicate<GridCacheEntry<K,V>>`	`predicate()` Gets predicate on which this projection is based on or `null` if predicate is not defined.
`Set<GridCacheEntry<K,V>>`	`primaryEntrySet()` Gets set containing cache entries for which local node is the primary node.
`Set<K>`	`primaryKeySet()` Set of cached primary keys for which local node is the primary node.
`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.
`<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> entry, 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> entry, 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.
`void`	`readExternal(ObjectInput in)`
`V`	`reload(K key)` Reloads a single key from persistent storage.
`void`	`reloadAll()` Reloads all currently cached keys form persistent storage.
`void`	`reloadAll(Collection<? extends K> keys)` Reloads specified entries from underlying persistent storage.
`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<V>`	`reloadAsync(K key)` Asynchronously reloads a single key from persistent storage.
`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.
`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.
`int`	`size()` Gets size of cache key set.
`UUID`	`subjectId()` Gets client ID for which this projection was created.
`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.
`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.
`void`	`unlock(K key, GridPredicate<GridCacheEntry<K,V>>[] filter)` Unlocks given key only if current thread owns the lock.
`void`	`unlockAll(Collection<? extends K> keys, GridPredicate<GridCacheEntry<K,V>>[] filter)` Unlocks given keys only if current thread owns the locks.
`Collection<V>`	`values()` Collection of cached values.
`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.GridMetadataAware
addMeta, addMetaIfAbsent, addMetaIfAbsent, allMeta, copyMeta, copyMeta, hasMeta, hasMeta, meta, putMetaIfAbsent, putMetaIfAbsent, removeMeta, removeMeta, replaceMeta

- Constructor Detail
  - GridCacheProjectionImpl
```
public GridCacheProjectionImpl()
```
    Empty constructor required for Externalizable.
  - GridCacheProjectionImpl
```
public GridCacheProjectionImpl(GridCacheProjection<K,V> parent,
                       GridCacheContext<K,V> cctx,
                       @Nullable
                       GridBiPredicate<K,V> kvFilter,
                       @Nullable
                       GridPredicate<? super GridCacheEntry<K,V>> entryFilter,
                       @Nullable
                       Set<GridCacheFlag> flags,
                       @Nullable
                       UUID subjId)
```
    Parameters:
    parent - Parent projection.
    cctx - Cache context.
    kvFilter - Key-value filter.
    entryFilter - Entry filter.
    flags - Flags for new projection
- Method Detail
  - 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.
  - 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.
  - 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.
  - subjectId
```
@Nullable
public UUID subjectId()
```
    Gets client ID for which this projection was created.
    
    Returns:
    Client ID.
  - 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.
  - 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.
  - 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.
  - 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.
  - 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.
  - 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.
  - reload
```
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()
               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.
  - 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.
  - get
```
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.
  - 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.
  - 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.
  - 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.
  - 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.
  - 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.
  - 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
```
public V put(K key,
    V val,
    @Nullable
    GridCacheEntryEx<K,V> entry,
    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.
    entry - 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,
           @Nullable
           GridCacheEntryEx<K,V> entry,
           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.
    entry - 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
           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.
  - putIfAbsent
```
public V putIfAbsent(K key,
            V val)
              throws GridException
```
    Stores given key-value pair in cache only if cache had no previous mapping for it. If cache previously contained value for the given key, then this value is returned. In case of GridCacheMode.PARTITIONED or GridCacheMode.REPLICATED caches, the value will be loaded from the primary node, which in its turn may load the value from the swap storage, and consecutively, if it's not in swap, from the underlying persistent storage. If value has to be loaded from persistent storage, GridCacheStore.load(GridCacheTx, Object) method will be used.
    If the returned value is not needed, method GridCacheProjection.putxIfAbsent(Object, Object) should always be used instead of this one to avoid the overhead associated with returning of the previous value.
    If write-through is enabled, the stored value will be persisted to GridCacheStore via GridCacheStore.put(GridCacheTx, Object, Object) method.
    Transactions
    This method is transactional and will enlist the entry into ongoing transaction if there is one.
    Cache Flags
    This method is not available if any of the following flags are set on projection: GridCacheFlag.LOCAL, GridCacheFlag.READ.
    
    Specified by:
    
    putIfAbsent in interface GridCacheProjection<K,V>
    
    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.
  - 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.
  - replace
```
public V replace(K key,
        V val)
          throws GridException
```
    Stores given key-value pair in cache only if if there is a previous mapping for it. In case of GridCacheMode.PARTITIONED or GridCacheMode.REPLICATED caches, the value will be loaded from the primary node, which in its turn may load the value from the swap storage, and consecutively, if it's not in swap, from the underlying persistent storage. If value has to be loaded from persistent storage, GridCacheStore.load(GridCacheTx, Object) method will be used.
    If the returned value is not needed, method GridCacheProjection.replacex(Object, Object) should always be used instead of this one to avoid the overhead associated with returning of the previous value.
    If write-through is enabled, the stored value will be persisted to GridCacheStore via GridCacheStore.put(GridCacheTx, Object, Object) method.
    Transactions
    This method is transactional and will enlist the entry into ongoing transaction if there is one.
    Cache Flags
    This method is not available if any of the following flags are set on projection: GridCacheFlag.LOCAL, GridCacheFlag.READ.
    
    Specified by:
    
    replace in interface GridCacheProjection<K,V>
    
    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(Map<? extends K,? extends V> m,
          @Nullable
          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.
  - 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.
  - 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.
  - 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.
  - 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.
  - 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.
  - 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.
  - 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.
  - 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(@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.
  - 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>
  - 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>
  - 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.
  - 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.
  - 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.
  - remove
```
public V remove(K key,
       @Nullable
       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.
  - removex
```
public boolean removex(K key,
              @Nullable
              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.
  - 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.
  - 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,
                               @Nullable
                               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.
  - 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.
  - 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.
  - 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.
  - 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.
  - 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(@Nullable
             Collection<? extends K> keys,
             @Nullable
             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,
                           @Nullable
                           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.
  - removeAll
```
public void removeAll(@Nullable
             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(@Nullable
                           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.
  - 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.
  - 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.
  - 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.
  - lockAllAsync
```
public GridFuture<Boolean> lockAllAsync(@Nullable
                               Collection<? extends K> keys,
                               long timeout,
                               @Nullable
                               GridPredicate<GridCacheEntry<K,V>>[] filter)
```
    All or nothing synchronous lock for passed in keys. This method together with filter check will be executed as one atomic operation. If at least one filter validation failed, no locks will be acquired.
    Transactions
    Locks are not transactional and should not be used from within transactions. If you do need explicit locking within transaction, then you should use GridCacheTxConcurrency.PESSIMISTIC concurrency control for transaction which will acquire explicit locks for relevant cache operations.
    Cache Flags
    This method is not available if any of the following flags are set on projection: GridCacheFlag.LOCAL, GridCacheFlag.READ.
    
    Specified by:
    
    lockAllAsync 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:
    Future for the collection of locks. The future will return true if all filters passed and locks were acquired before timeout has expired, false otherwise.
  - 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.
  - unlockAll
```
public void unlockAll(@Nullable
             Collection<? extends K> keys,
             @Nullable
             GridPredicate<GridCacheEntry<K,V>>[] filter)
               throws GridException
```
    Unlocks given keys only if current thread owns the locks. Only the keys that have been locked by calling thread and pass through the filter (if any) will be unlocked. If none of the key locks is owned by current thread, then this method will do nothing.
    Transactions
    Locks are not transactional and should not be used from within transactions. If you do need explicit locking within transaction, then you should use GridCacheTxConcurrency.PESSIMISTIC concurrency control for transaction which will acquire explicit locks for relevant cache operations.
    Cache Flags
    This method is not available if any of the following flags are set on projection: GridCacheFlag.LOCAL, GridCacheFlag.READ.
    
    Specified by:
    
    unlockAll in interface GridCacheProjection<K,V>
    
    Parameters:
    keys - Keys to unlock.
    filter - Optional filter which needs to pass for individual entries to be unlocked.
    
    Throws:
    
    GridException - If unlock execution resulted in error.
  - 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.
  - promote
```
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.
  - 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)
```
    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.
  - 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.
  - tx
```
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.
  - 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.
  - iterator
```
public Iterator<GridCacheEntry<K,V>> iterator()
```
    Specified by:
    
    iterator in interface Iterable<GridCacheEntry<K,V>>
  - 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.
  - 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
  - toString
```
public String toString()
```
    Overrides:
    
    toString in class Object

Class GridCacheProjectionImpl<K,V>

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

Constructor Detail

GridCacheProjectionImpl

GridCacheProjectionImpl

Method Detail

cache

queries

forSubjectId

subjectId

projection

projection

projection

flagsOn

Cache Flags

flagsOff

Cache Flags

size

nearSize

primarySize

isEmpty

containsKey

containsValue

forEach

Transactions

forAll

Transactions

reload

Transactions

reloadAsync

Transactions

reloadAll

Transactions

reloadAllAsync

Transactions

reloadAll

Transactions

reloadAllAsync

Transactions

get

Transactions

Cache Flags

get

getAsync

Transactions

Cache Flags

getForcePrimary

getForcePrimaryAsync

getAllOutTx

getAllOutTxAsync

isGgfsDataCache

ggfsDataSpaceUsed

ggfsDataSpaceMax

isMongoDataCache

isMongoMetaCache

isDrSystemCache

getAll

Transactions

Cache Flags

getAllAsync

Transactions

Cache Flags

put

Transactions

Cache Flags

put

putAsync

Transactions

Cache Flags

putAsync

putx

putx

Transactions

Cache Flags

putAllDr

putAllDrAsync