GridCacheProjection (gridgain-core 6.1.9 API)

All Superinterfaces:

GridMetadataAware, Iterable<GridCacheEntry<K,V>>, Serializable

All Known Subinterfaces:

GridCache<K,V>, GridCacheProjectionEx<K,V>, GridCacheProxy<K,V>

All Known Implementing Classes:

GridCacheAdapter, GridCacheProjectionImpl, GridCacheProxyImpl, GridDhtAtomicCache, GridDhtCache, GridDhtCacheAdapter, GridDhtColocatedCache, GridDhtTransactionalCacheAdapter, GridDistributedCacheAdapter, GridLocalAtomicCache, GridLocalCache, GridNearAtomicCache, GridNearCacheAdapter, GridNearTransactionalCache
```
public interface GridCacheProjection<K,V>
extends Iterable<GridCacheEntry<K,V>>, GridMetadataAware
```
This interface provides a rich API for working with distributed caches. It includes the following main functionality:
- Various 'get(..)' methods to synchronously or asynchronously get values from cache. All 'get(..)' methods are transactional and will participate in an ongoing transaction if there is one.
- Various 'put(..)', 'putIfAbsent(..)', and 'replace(..)' methods to synchronously or asynchronously put single or multiple entries into cache. All these methods are transactional and will participate in an ongoing transaction if there is one.
- Various 'remove(..)' methods to synchronously or asynchronously remove single or multiple keys from cache. All 'remove(..)' methods are transactional and will participate in an ongoing transaction if there is one.
- Various 'contains(..)' method to check if cache contains certain keys or values locally.
- Various 'forEach(..)', 'forAny(..)', and 'reduce(..)' methods to visit every local cache entry within this projection.
- Various flagsOn(..)', 'flagsOff(..)', and 'projection(..)' methods to set specific flags and filters on a cache projection.
- Methods like 'keySet(..)', 'values(..)', and 'entrySet(..)' to provide views on cache keys, values, and entries.
- Various 'peek(..)' methods to peek at values in global or transactional memory, swap storage, or persistent storage.
- Various 'reload(..)' methods to reload latest values from persistent storage.
- Various 'promote(..)' methods to load specified keys from swap storage into global cache memory.
- Various 'lock(..)', 'unlock(..)', and 'isLocked(..)' methods to acquire, release, and check on distributed locks on a single or multiple keys in cache. All locking methods are not transactional and will not enlist keys into ongoing transaction, if any.
- Various 'clear(..)' methods to clear elements from cache, and optionally from swap storage. All 'clear(..)' methods are not transactional and will not enlist cleared keys into ongoing transaction, if any.
- Various 'evict(..)' methods to evict elements from cache, and optionally store them in underlying swap storage for later access. All 'evict(..)' methods are not transactional and will not enlist evicted keys into ongoing transaction, if any.
- Various 'txStart(..)' methods to perform various cache operations within a transaction (see GridCacheTx for more information).
- queries() method to get an instance of GridCacheQueries service for working with distributed cache queries.
- Various 'gridProjection(..)' methods which provide GridProjection only for nodes on which given keys reside. All 'gridProjection(..)' methods are not transactional and will not enlist keys into ongoing transaction.
- Method toMap() to convert this interface into standard Java ConcurrentMap interface.
Extended Put And Remove Methods
All methods that end with 'x' provide the same functionality as their sibling methods that don't end with 'x', however instead of returning a previous value they return a boolean flag indicating whether operation succeeded or not. Returning a previous value may involve a network trip or a persistent store lookup and should be avoided whenever not needed.
Predicate Filters
All filters passed into methods on this API are checked atomically. In other words the value returned by the methods is guaranteed to be consistent with the filters passed in. Note that filters are optional, and if not passed in, then methods will still work as is without filter validation.
Transactions
Cache API supports distributed transactions. All 'get(..)', 'put(..)', 'replace(..)', and 'remove(..)' operations are transactional and will participate in an ongoing transaction, if any. Other methods like 'peek(..)' or various 'contains(..)' methods may be transaction-aware, i.e. check in-transaction entries first, but will not affect the current state of transaction. See GridCacheTx documentation for more information about transactions.
Group Locking
Group Locking is a feature where instead of acquiring individual locks, GridGain will lock multiple keys with one lock to save on locking overhead. There are 2 types of Group Locking: affinity-based, and partitioned-based.
With affinity-based-group-locking the keys are grouped by affinity-key. This means that only keys with identical affinity-key (see GridCacheAffinityKeyMapped) can participate in the transaction, and only one lock on the affinity-key will be acquired for the whole transaction. Affinity-group-locked transactions are started via txStartAffinity(Object, GridCacheTxConcurrency, GridCacheTxIsolation, long, int) method.
With partition-based-group-locking the keys are grouped by partition ID. This means that only keys belonging to identical partition (see GridCacheAffinity.partition(Object)) can participate in the transaction, and only one lock on the whole partition will be acquired for the whole transaction. Partition-group-locked transactions are started via txStartPartition(int, GridCacheTxConcurrency, GridCacheTxIsolation, long, int) method.
Group locking should always be used for transactions whenever possible. If your requirements fit either affinity-based or partition-based scenarios outlined above then group-locking can significantly improve performance of your application, often by an order of magnitude.
Null Keys or Values
Neither null keys or values are allowed to be stored in cache. If a null value happens to be in cache (e.g. after invalidation or remove), then cache will treat this case as there is no value at all.
Peer Class Loading
If peer-class-loading is enabled, all classes passed into cache API will be automatically deployed to any participating grid nodes. However, in case of redeployment, caches will be cleared and all entries will be removed. This behavior is useful during development, but should not be used in production.

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.
`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.
`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.
`V`	`get(K key)` Retrieves value mapped to the specified key from cache.
`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.
`GridFuture<V>`	`getAsync(K key)` Asynchronously retrieves value mapped to the specified key from cache.
`void`	`globalClearAll()` Clears cache on all nodes that store it's data.
`GridProjection`	`gridProjection()` Gets grid projection for this cache.
`boolean`	`isEmpty()` Returns `true` if this map contains no key-value mappings.
`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.
`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.
`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, 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.
`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, GridPredicate<GridCacheEntry<K,V>>... filter)` Stores given key-value pair in cache.
`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.
`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, 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.
`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, GridPredicate<GridCacheEntry<K,V>>... filter)` Removes given key mapping from cache.
`GridFuture<Boolean>`	`removexAsync(K key, GridPredicate<GridCacheEntry<K,V>>... filter)` Asynchronously removes given key mapping from cache.
`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.
`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.
`int`	`size()` Gets size of cache key set.
`ConcurrentMap<K,V>`	`toMap()` Converts this API into standard Java `ConcurrentMap` interface.
`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.
`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.

Methods inherited from interface java.lang.Iterable
iterator

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

- Method Detail
  - name
```
String name()
```
    Gets name of this cache (null for default cache).
    
    Returns:
    Cache name.
  - gridProjection
```
GridProjection gridProjection()
```
    Gets grid projection for this cache. This projection includes all nodes which have this cache configured.
    
    Returns:
    Projection instance.
  - cache
```
<K1,V1> GridCache<K1,V1> cache()
```
    Gets base cache for this projection.
    
    Type Parameters:
    K1 - Cache key type.
    V1 - Cache value type.
    
    Returns:
    Base cache for this projection.
  - flags
```
Set<GridCacheFlag> flags()
```
    Gets cache flags enabled on this projection.
    
    Returns:
    Flags for this projection (empty set if no flags have been set).
  - queries
```
GridCacheQueries<K,V> queries()
```
    Returns queries facade responsible for creating various SQL, TEXT, or SCAN queries.
    
    Returns:
    Queries facade responsible for creating various SQL, TEXT, or SCAN queries.
  - projection
```
<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.
    
    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
```
GridCacheProjection<K,V> projection(@Nullable
                                  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 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.
    
    Parameters:
    p - Key-value predicate for this projection. If null, then the same projection is returned.
    
    Returns:
    Projection for given key-value predicate.
  - projection
```
GridCacheProjection<K,V> projection(@Nullable
                                  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 projection(GridBiPredicate) method, this filter will not be used for pre-filtering.
    
    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
```
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.
    
    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
```
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.
    
    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.
  - isEmpty
```
boolean isEmpty()
```
    Returns true if this map contains no key-value mappings.
    
    Returns:
    true if this map contains no key-value mappings.
  - toMap
```
ConcurrentMap<K,V> toMap()
```
    Converts this API into standard Java ConcurrentMap interface.
    
    Returns:
    ConcurrentMap representation of given cache projection.
  - containsKey
```
boolean containsKey(K key)
```
    Returns true if this cache contains a mapping for the specified key.
    
    Parameters:
    key - key whose presence in this map is to be tested.
    
    Returns:
    true if this map contains a mapping for the specified key.
    
    Throws:
    
    NullPointerException - if the key is null.
  - containsValue
```
boolean containsValue(V val)
```
    Returns true if this cache contains given value.
    
    Parameters:
    val - Value to check.
    
    Returns:
    True if given value is present in cache.
    
    Throws:
    
    NullPointerException - if the value is null.
  - forEach
```
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.
    
    Parameters:
    vis - Closure which will be invoked for each cache entry.
  - forAll
```
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.
    
    Parameters:
    vis - Predicate to test for each cache entry.
    
    Returns:
    True if the given predicate holds for all visited entries, false otherwise.
  - reload
```
@Nullable
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.
    
    Parameters:
    key - Key to reload.
    
    Returns:
    Reloaded value or current value if entry was updated while reloading.
    
    Throws:
    
    GridException - If reloading failed.
  - reloadAsync
```
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.
    
    Parameters:
    key - Key to reload.
    
    Returns:
    Future to be completed whenever the entry is reloaded.
  - reloadAll
```
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.
    
    Throws:
    
    GridException - If reloading failed.
  - reloadAllAsync
```
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.
    
    Returns:
    Future which will complete whenever reload completes.
  - reloadAll
```
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.
    
    Parameters:
    keys - Keys to reload.
    
    Throws:
    
    GridException - if reloading failed.
  - reloadAllAsync
```
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.
    
    Parameters:
    keys - Keys to reload.
    
    Returns:
    Future which will complete whenever reload completes.
  - peek
```
@Nullable
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 peek(Object, Collection) method.
    
    Parameters:
    key - Entry key.
    
    Returns:
    Peeked value.
    
    Throws:
    
    NullPointerException - If key is null.
  - peek
```
@Nullable
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 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.
    
    Parameters:
    key - Entry key.
    modes - Optional set of peek modes.
    
    Returns:
    Peeked value.
    
    Throws:
    
    GridException - If peek operation failed.
    
    NullPointerException - If key is null.
  - get
```
@Nullable
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.
    
    Parameters:
    key - Key to retrieve the value for.
    
    Returns:
    Value for the given key.
    
    Throws:
    
    GridException - If get operation failed.
    
    GridCacheFlagException - If failed projection flags validation.
    
    NullPointerException - if the key is null.
  - getAsync
```
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.
    
    Parameters:
    key - Key for the value to get.
    
    Returns:
    Future for the get operation.
    
    Throws:
    
    NullPointerException - if the key is null.
    
    GridCacheFlagException - If projection flags validation failed.
  - getAll
```
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.
    
    Parameters:
    keys - Keys to get.
    
    Returns:
    Map of key-value pairs.
    
    Throws:
    
    GridException - If get operation failed.
    
    GridCacheFlagException - If failed projection flags validation.
  - getAllAsync
```
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.
    
    Parameters:
    keys - Key for the value to get.
    
    Returns:
    Future for the get operation.
    
    Throws:
    
    GridCacheFlagException - If projection flags validation failed.
  - put
```
@Nullable
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 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.
    
    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:
    
    NullPointerException - If either key or value are null.
    
    GridException - If put operation failed.
    
    GridCacheFlagException - If projection flags validation failed.
  - putAsync
```
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 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.
    
    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.
    
    Throws:
    
    NullPointerException - If either key or value are null.
    
    GridCacheFlagException - If projection flags validation failed.
  - putx
```
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 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.
    
    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:
    
    NullPointerException - If either key or value are null.
    
    GridException - If put operation failed.
    
    GridCacheFlagException - If projection flags validation failed.
  - putxAsync
```
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 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.
    
    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.
    
    Throws:
    
    NullPointerException - If either key or value are null.
    
    GridCacheFlagException - If projection flags validation failed.
  - transform
```
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 putx(Object, Object, GridPredicate[]) or 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.
    
    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:
    
    NullPointerException - If either key or transform closure is null.
    
    GridException - On any error occurred while storing value in cache.
  - transformAndCompute
```
<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.
    
    Parameters:
    key - Key to store in cache.
    transformer - Closure to be applied to the previous value in cache.
    
    Returns:
    Value computed by the closure.
    
    Throws:
    
    GridException - On any error occurred while storing value in cache.
  - transformAsync
```
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 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.
    
    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.
    
    Throws:
    
    NullPointerException - If either key or transform closure is null.
  - putIfAbsent
```
@Nullable
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 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.
    
    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:
    
    NullPointerException - If either key or value are null.
    
    GridException - If put operation failed.
    
    GridCacheFlagException - If projection flags validation failed.
  - putIfAbsentAsync
```
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 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.
    
    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.
    
    Throws:
    
    NullPointerException - If either key or value are null.
    
    GridCacheFlagException - If projection flags validation failed.
  - putxIfAbsent
```
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 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.
    
    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:
    
    NullPointerException - If either key or value are null.
    
    GridException - If put operation failed.
    
    GridCacheFlagException - If projection flags validation failed.
  - putxIfAbsentAsync
```
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 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.
    
    Parameters:
    key - Key to store in cache.
    val - Value to be associated with the given key.
    
    Returns:
    Future for this put operation.
    
    Throws:
    
    NullPointerException - If either key or value are null.
    
    GridCacheFlagException - If projection flags validation failed.
  - replace
```
@Nullable
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 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.
    
    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:
    
    NullPointerException - If either key or value are null.
    
    GridException - If replace operation failed.
    
    GridCacheFlagException - If projection flags validation failed.
  - replaceAsync
```
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 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.
    
    Parameters:
    key - Key to store in cache.
    val - Value to be associated with the given key.
    
    Returns:
    Future for replace operation.
    
    Throws:
    
    NullPointerException - If either key or value are null.
    
    GridCacheFlagException - If projection flags validation failed.
  - replacex
```
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 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.
    
    Parameters:
    key - Key to store in cache.
    val - Value to be associated with the given key.
    
    Returns:
    True if replace happened, false otherwise.
    
    Throws:
    
    NullPointerException - If either key or value are null.
    
    GridException - If replace operation failed.
    
    GridCacheFlagException - If projection flags validation failed.
  - replacexAsync
```
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 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.
    
    Parameters:
    key - Key to store in cache.
    val - Value to be associated with the given key.
    
    Returns:
    Future for the replace operation.
    
    Throws:
    
    NullPointerException - If either key or value are null.
    
    GridCacheFlagException - If projection flags validation failed.
  - replace
```
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.
    
    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:
    
    NullPointerException - If either key or value are null.
    
    GridException - If replace operation failed.
    
    GridCacheFlagException - If projection flags validation failed.
  - replaceAsync
```
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.
    
    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.
    
    Throws:
    
    NullPointerException - If either key or value are null.
    
    GridCacheFlagException - If projection flags validation failed.
  - putAll
```
void putAll(@Nullable
          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.
    
    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.
    
    GridCacheFlagException - If projection flags validation failed.
  - transformAll
```
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 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.
    
    Parameters:
    m - Map containing keys and closures to be applied to values.
    
    Throws:
    
    GridException - On any error occurred while storing value in cache.
  - transformAll
```
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 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.
    
    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
```
GridFuture<?> putAllAsync(@Nullable
                        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.
    
    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.
    
    Throws:
    
    GridCacheFlagException - If projection flags validation failed.
  - transformAllAsync
```
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 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.
    
    Parameters:
    m - Map containing keys and closures to be applied to values.
    
    Returns:
    Future for operation.
  - transformAllAsync
```
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 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.
    
    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
```
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.
    
    Returns:
    Key set for this cache projection.
  - primaryKeySet
```
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.
    
    Returns:
    Primary key set for the current node.
  - values
```
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.
    
    Returns:
    Collection of cached values.
  - primaryValues
```
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.
    
    Returns:
    Collection of primary cached values for the current node.
  - entrySet
```
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.
    
    Returns:
    Entries that pass through key filter.
  - entrySet
```
@Nullable
Set<GridCacheEntry<K,V>> entrySet(int part)
```
    Gets set containing cache entries that belong to provided partition or null if partition not found locally.
    
    Parameters:
    part - Partition.
    
    Returns:
    Set containing partition's entries or null if partition not found locally.
  - primaryEntrySet
```
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.
    
    Returns:
    Primary cache entries that pass through key filter.
  - txStart
```
GridCacheTx txStart()
                    throws IllegalStateException
```
    Starts transaction with default isolation, concurrency, timeout, and invalidation policy. All defaults are set in GridCacheConfiguration at startup.
    
    Returns:
    New transaction
    
    Throws:
    
    IllegalStateException - If transaction is already started by this thread.
    
    UnsupportedOperationException - If cache is GridCacheAtomicityMode.ATOMIC.
  - txStart
```
GridCacheTx txStart(GridCacheTxConcurrency concurrency,
                  GridCacheTxIsolation isolation)
```
    Starts new transaction with the specified concurrency and isolation.
    
    Parameters:
    concurrency - Concurrency.
    isolation - Isolation.
    
    Returns:
    New transaction.
    
    Throws:
    
    IllegalStateException - If transaction is already started by this thread.
    
    UnsupportedOperationException - If cache is GridCacheAtomicityMode.ATOMIC.
  - txStart
```
GridCacheTx txStart(GridCacheTxConcurrency concurrency,
                  GridCacheTxIsolation isolation,
                  long timeout,
                  int txSize)
```
    Starts transaction with specified isolation, concurrency, timeout, invalidation flag, and number of participating entries.
    
    Parameters:
    concurrency - Concurrency.
    isolation - Isolation.
    timeout - Timeout.
    txSize - Number of entries participating in transaction (may be approximate).
    
    Returns:
    New transaction.
    
    Throws:
    
    IllegalStateException - If transaction is already started by this thread.
    
    UnsupportedOperationException - If cache is GridCacheAtomicityMode.ATOMIC.
  - txStartAffinity
```
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.
    Parameters:
    affinityKey - Affinity key for all entries updated by transaction. This node must be primary for this key.
    timeout - Timeout (0 for default).
    txSize - Number of entries participating in transaction (may be approximate), 0 for default.
    concurrency - Transaction concurrency control.
    isolation - Cache transaction isolation level.
    
    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.
    
    UnsupportedOperationException - If cache is GridCacheAtomicityMode.ATOMIC.
  - txStartPartition
```
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.
    Parameters:
    partId - Partition id for which transaction is started. This node must be primary for this partition.
    timeout - Timeout (0 for default).
    txSize - Number of entries participating in transaction (may be approximate), 0 for default.
    concurrency - Transaction concurrency control.
    isolation - Cache transaction isolation level.
    
    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.
    
    UnsupportedOperationException - If cache is GridCacheAtomicityMode.ATOMIC.
  - tx
```
@Nullable
GridCacheTx tx()
```
    Gets transaction started by this thread or null if this thread does not have a transaction.
    
    Returns:
    Transaction started by this thread or null if this thread does not have a transaction.
  - entry
```
@Nullable
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.
    
    Parameters:
    key - Entry key.
    
    Returns:
    Cache entry or null if projection pre-filtering was not passed.
  - evict
```
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.
    
    Parameters:
    key - Key to evict from cache.
    
    Returns:
    True if entry could be evicted, false otherwise.
  - evictAll
```
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.
  - evictAll
```
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.
    
    Parameters:
    keys - Keys to evict.
  - clearAll
```
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.
  - clear
```
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.
    
    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.
  - globalClearAll
```
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 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.
    
    Throws:
    
    GridException - In case of cache could not be cleared on any of the nodes.
  - compact
```
boolean compact(K key)
                throws GridException
```
    Clears serialized value bytes from entry (if any) leaving only object representation.
    
    Parameters:
    key - Key to compact.
    
    Returns:
    true if entry was deleted from cache (i.e. was expired).
    
    Throws:
    
    GridException - If failed to compact.
  - compactAll
```
void compactAll()
                throws GridException
```
    Clears serialized value bytes from cache entries (if any) leaving only object representation.
    
    Throws:
    
    GridException - If failed to compact.
  - remove
```
@Nullable
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 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.
    
    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:
    
    NullPointerException - If key is null.
    
    GridException - If remove operation failed.
    
    GridCacheFlagException - If projection flags validation failed.
  - removeAsync
```
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 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.
    
    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.
    
    Throws:
    
    NullPointerException - if the key is null.
    
    GridCacheFlagException - If projection flags validation failed.
  - removex
```
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.
    
    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:
    
    NullPointerException - if the key is null.
    
    GridException - If remove failed.
    
    GridCacheFlagException - If projection flags validation failed.
  - removexAsync
```
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.
    
    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.
    
    Throws:
    
    NullPointerException - if the key is null.
    
    GridCacheFlagException - If projection flags validation failed.
  - remove
```
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.
    
    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:
    
    NullPointerException - if the key or value is null.
    
    GridException - If remove failed.
    
    GridCacheFlagException - If projection flags validation failed.
  - removeAsync
```
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.
    
    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.
    
    Throws:
    
    NullPointerException - if the key or value is null.
    
    GridCacheFlagException - If projection flags validation failed.
  - removeAll
```
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.
    
    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.
    
    GridCacheFlagException - If flags validation failed.
  - removeAllAsync
```
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.
    
    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.
    
    Throws:
    
    GridCacheFlagException - If flags validation failed.
  - removeAll
```
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.
    
    Parameters:
    filter - Filter used to supply keys for remove operation (if null, then nothing will be removed).
    
    Throws:
    
    GridException - If remove failed.
    
    GridCacheFlagException - If flags validation failed.
  - removeAllAsync
```
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.
    
    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.
    
    Throws:
    
    GridCacheFlagException - If flags validation failed.
  - lock
```
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.
    
    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.
    
    GridCacheFlagException - If flags validation failed.
  - lockAsync
```
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.
    
    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.
    
    Throws:
    
    GridCacheFlagException - If flags validation failed.
  - lockAll
```
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.
    
    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.
    
    GridCacheFlagException - If flags validation failed.
  - lockAllAsync
```
GridFuture<Boolean> lockAllAsync(@Nullable
                               Collection<? extends K> keys,
                               long timeout,
                               @Nullable
                               GridPredicate<GridCacheEntry<K,V>>... filter)
```
    All or nothing synchronous lock for passed in keys. This method together with filter check will be executed as one atomic operation. If at least one filter validation failed, no locks will be acquired.
    Transactions
    Locks are not transactional and should not be used from within transactions. If you do need explicit locking within transaction, then you should use GridCacheTxConcurrency.PESSIMISTIC concurrency control for transaction which will acquire explicit locks for relevant cache operations.
    Cache Flags
    This method is not available if any of the following flags are set on projection: GridCacheFlag.LOCAL, GridCacheFlag.READ.
    
    Parameters:
    keys - Keys to lock.
    timeout - Timeout in milliseconds to wait for lock to be acquired ('0' for no expiration).
    filter - Optional filter that needs to atomically pass in order for the locks to be acquired.
    
    Returns:
    Future for the collection of locks. The future will return true if all filters passed and locks were acquired before timeout has expired, false otherwise.
    
    Throws:
    
    GridCacheFlagException - If flags validation failed.
  - unlock
```
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.
    
    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.
    
    GridCacheFlagException - If flags validation failed.
  - unlockAll
```
void unlockAll(@Nullable
             Collection<? extends K> keys,
             @Nullable
             GridPredicate<GridCacheEntry<K,V>>... filter)
               throws GridException
```
    Unlocks given keys only if current thread owns the locks. Only the keys that have been locked by calling thread and pass through the filter (if any) will be unlocked. If none of the key locks is owned by current thread, then this method will do nothing.
    Transactions
    Locks are not transactional and should not be used from within transactions. If you do need explicit locking within transaction, then you should use GridCacheTxConcurrency.PESSIMISTIC concurrency control for transaction which will acquire explicit locks for relevant cache operations.
    Cache Flags
    This method is not available if any of the following flags are set on projection: GridCacheFlag.LOCAL, GridCacheFlag.READ.
    
    Parameters:
    keys - Keys to unlock.
    filter - Optional filter which needs to pass for individual entries to be unlocked.
    
    Throws:
    
    GridException - If unlock execution resulted in error.
    
    GridCacheFlagException - If flags validation failed.
  - isLocked
```
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.
    
    Parameters:
    key - Key to check.
    
    Returns:
    True if lock is owned by some node.
  - isLockedByThread
```
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.
    
    Parameters:
    key - Key to check.
    
    Returns:
    True if key is locked by current thread.
  - size
```
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().
    
    Returns:
    Size of cache key set.
  - nearSize
```
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
    
    Returns:
    Size of near cache key set or 0 if cache is not GridCacheMode.PARTITIONED.
  - primarySize
```
int primarySize()
```
    Gets size of all primary keys for this cache. For GridCacheMode.LOCAL mode, this method is identical to 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.
    
    Returns:
    Number of primary entries in cache.
  - promote
```
@Nullable
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.
    
    Parameters:
    key - Key to promote entry for.
    
    Returns:
    Unswapped entry value or null for non-existing key.
    
    Throws:
    
    GridException - If promote failed.
    
    GridCacheFlagException - If flags validation failed.
  - promoteAll
```
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.
    
    Parameters:
    keys - Keys to promote entries for.
    
    Throws:
    
    GridException - If promote failed.
    
    GridCacheFlagException - If flags validation failed.

Interface GridCacheProjection<K,V>

Extended Put And Remove Methods

Predicate Filters

Transactions

Group Locking

Null Keys or Values

Peer Class Loading

Method Summary

Methods inherited from interface java.lang.Iterable

Methods inherited from interface org.gridgain.grid.GridMetadataAware

Method Detail

name

gridProjection

cache

flags

queries

projection

projection

projection

flagsOn

Cache Flags

flagsOff

Cache Flags

isEmpty

toMap

containsKey

containsValue

forEach

Transactions

forAll

Transactions

reload

Transactions

reloadAsync

Transactions

reloadAll

Transactions

reloadAllAsync

Transactions

reloadAll

Transactions

reloadAllAsync

Transactions

peek

Transactions

peek

Transactions

get

Transactions

Cache Flags

getAsync

Transactions

Cache Flags

getAll

Transactions

Cache Flags

getAllAsync

Transactions

Cache Flags

put

Transactions

Cache Flags

putAsync

Transactions

Cache Flags

putx

Transactions

Cache Flags

putxAsync

Transactions

Cache Flags

transform

Transactions

Cache Flags

transformAndCompute

Transactions

Cache Flags

transformAsync

Transactions

Cache Flags