CacheProjection (Ignite 1.0.0-RC3)

All Superinterfaces:

Iterable<javax.cache.Cache.Entry<K,V>>

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 CacheProjection<K,V>
extends Iterable<javax.cache.Cache.Entry<K,V>>
```
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 Transaction for more information).
- queries() method to get an instance of CacheQueries service for working with distributed cache queries.
- Various 'gridProjection(..)' methods which provide ClusterGroup 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 Transaction documentation for more information about transactions.
Group Locking
Group Locking is a feature where instead of acquiring individual locks, Ignite 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 CacheAffinityKeyMapped) 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, TransactionConcurrency, TransactionIsolation, 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 CacheAffinity.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, TransactionConcurrency, TransactionIsolation, 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.
Portable Objects
If an object is defined as portable Ignite cache will automatically store it in portable (i.e. binary) format. User can choose to work either with the portable format or with the deserialized form (assuming that class definitions are present in the classpath). By default, cache works with deserialized form (example shows the case when Integer is used as a key for a portable object):
```
 CacheProjection prj = Ignition.grid().cache(null);

 // Value will be serialized and stored in cache in portable format.
 prj.put(1, new Value());

 // Value will be deserialized since it's stored in portable format.
 Value val = prj.get(1);
 
```
You won't be able to work with deserialized form if class definition for the Value is not on classpath. Even if you have the class definition, you should always avoid full deserialization if it's not needed for performance reasons. To work with portable format directly you should create special projection using keepPortable() method:
```
 CacheProjection prj = Ignition.grid().cache(null).keepPortable();

 // Value is not deserialized and returned in portable format.
 GridPortableObject po = prj.get(1);
 
```
See keepPortable() method JavaDoc for more details.

Method Summary

Methods
Modifier and Type	Method and Description
`<K1,V1> GridCache<K1,V1>`	`cache()` Gets base cache for this projection.
`void`	`clear()` Deprecated. Deprecated in favor of `clear(long)` method.
`void`	`clear(K key)` Clears key on all nodes that store it's data.
`void`	`clear(long timeout)` Clears cache on all nodes that store it's data.
`void`	`clearAll(Set<K> keys)` Clears keys on all nodes that store it's data.
`IgniteInternalFuture<?>`	`clearAsync()`
`IgniteInternalFuture<?>`	`clearAsync(K key)`
`IgniteInternalFuture<?>`	`clearAsync(Set<K> keys)`
`void`	`clearLocally()` Clears all entries from this cache only if the entry is not currently locked or participating in a transaction.
`boolean`	`clearLocally(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`	`clearLocallyAll(Set<K> keys)` Clears entries from this cache and swap storage only if the entry is not currently locked, and is not participating in a transaction.
`boolean`	`containsKey(K key)`
`IgniteInternalFuture<Boolean>`	`containsKeyAsync(K key)`
`boolean`	`containsKeys(Collection<? extends K> keys)`
`IgniteInternalFuture<Boolean>`	`containsKeysAsync(Collection<? extends K> keys)`
`boolean`	`containsValue(V val)` Returns `true` if this cache contains given value.
`javax.cache.Cache.Entry<K,V>`	`entry(K key)` Gets entry from cache with the specified key.
`Set<javax.cache.Cache.Entry<K,V>>`	`entrySet()` Gets set of all entries cached on this node.
`Set<javax.cache.Cache.Entry<K,V>>`	`entrySet(int part)` Gets set containing cache entries that belong to provided partition or `null` if partition is 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<CacheFlag>`	`flags()` Gets cache flags enabled on this projection.
`CacheProjection<K,V>`	`flagsOff(CacheFlag... flags)` Gets cache projection base on this but with the specified flags turned off.
`CacheProjection<K,V>`	`flagsOn(CacheFlag... flags)` Gets cache projection base on this one, but with the specified flags turned on.
`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.
`IgniteInternalFuture<Map<K,V>>`	`getAllAsync(Collection<? extends K> keys)` Asynchronously retrieves values mapped to the specified keys from cache.
`IgniteInternalFuture<V>`	`getAsync(K key)` Asynchronously retrieves value mapped to the specified key from cache.
`int`	`globalPrimarySize()` Gets the number of all primary entries cached across all nodes (excluding backups).
`int`	`globalSize()` Gets the number of all entries cached across all nodes.
`ClusterGroup`	`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.
`<K1,V1> CacheProjection<K1,V1>`	`keepPortable()` Creates projection that will operate with portable objects.
`Set<K>`	`keySet()` Set of keys cached on this node.
`Set<K>`	`keySet(CacheEntryPredicate... filter)` Set of keys cached on this node.
`Iterable<javax.cache.Cache.Entry<K,V>>`	`localEntries(CachePeekMode[] peekModes)`
`V`	`localPeek(K key, CachePeekMode[] peekModes, IgniteCacheExpiryPolicy plc)`
`void`	`localRemoveAll()`
`int`	`localSize(CachePeekMode[] peekModes)`
`boolean`	`lock(K key, long timeout, CacheEntryPredicate... 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, CacheEntryPredicate... filter)` All or nothing synchronous lock for passed in keys.
`IgniteInternalFuture<Boolean>`	`lockAllAsync(Collection<? extends K> keys, long timeout, CacheEntryPredicate... filter)` All or nothing synchronous lock for passed in keys.
`IgniteInternalFuture<Boolean>`	`lockAsync(K key, long timeout, CacheEntryPredicate... 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<javax.cache.Cache.Entry<K,V>>`	`primaryEntrySet()` Gets set of cache entries for which this node is primary.
`Set<K>`	`primaryKeySet()` Set of keys for which this node is primary.
`int`	`primarySize()` Gets the number of all primary entries cached on this node.
`Collection<V>`	`primaryValues()` Collection of cached values for which this node is primary.
`CacheProjection<K,V>`	`projection(CacheEntryPredicate filter)` Gets cache projection based on given entry filter.
`<K1,V1> CacheProjection<K1,V1>`	`projection(Class<? super K1> keyType, Class<? super V1> valType)` Gets cache projection only for given key and value type.
`V`	`promote(K key)` This method promotes cache entry 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, CacheEntryPredicate... filter)` Stores given key-value pair in cache.
`void`	`putAll(Map<? extends K,? extends V> m, CacheEntryPredicate... filter)` Stores given key-value pairs in cache.
`IgniteInternalFuture<?>`	`putAllAsync(Map<? extends K,? extends V> m, CacheEntryPredicate... filter)` Asynchronously stores given key-value pairs in cache.
`IgniteInternalFuture<V>`	`putAsync(K key, V val, CacheEntryPredicate... 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.
`IgniteInternalFuture<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, CacheEntryPredicate... filter)` Stores given key-value pair in cache.
`IgniteInternalFuture<Boolean>`	`putxAsync(K key, V val, CacheEntryPredicate... 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.
`IgniteInternalFuture<Boolean>`	`putxIfAbsentAsync(K key, V val)` Asynchronously stores given key-value pair in cache only if cache had no previous mapping for it.
`CacheQueries<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.
`IgniteInternalFuture<V>`	`reloadAsync(K key)` Asynchronously reloads a single key from persistent storage.
`V`	`remove(K key, CacheEntryPredicate... 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()` Removes mappings from cache for entries for which the optionally passed in filters do pass.
`void`	`removeAll(Collection<? extends K> keys, CacheEntryPredicate... filter)` Removes given key mappings from cache for entries for which the optionally passed in filters do pass.
`IgniteInternalFuture<?>`	`removeAllAsync()`
`IgniteInternalFuture<?>`	`removeAllAsync(Collection<? extends K> keys, CacheEntryPredicate... filter)` Asynchronously removes given key mappings from cache for entries for which the optionally passed in filters do pass.
`IgniteInternalFuture<V>`	`removeAsync(K key, CacheEntryPredicate... filter)` Asynchronously removes given key mapping from cache.
`IgniteInternalFuture<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, CacheEntryPredicate... filter)` Removes given key mapping from cache.
`IgniteInternalFuture<Boolean>`	`removexAsync(K key, CacheEntryPredicate... filter)` Asynchronously removes given key mapping from cache.
`V`	`replace(K key, V val)` Stores given key-value pair in cache only 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.
`IgniteInternalFuture<V>`	`replaceAsync(K key, V val)` Asynchronously stores given key-value pair in cache only if there is a previous mapping for it.
`IgniteInternalFuture<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.
`IgniteInternalFuture<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 the number of all entries cached on this node.
`int`	`size(CachePeekMode[] peekModes)`
`IgniteInternalFuture<Integer>`	`sizeAsync(CachePeekMode[] peekModes)`
`ConcurrentMap<K,V>`	`toMap()` Converts this API into standard Java `ConcurrentMap` interface.
`Transaction`	`tx()` Gets transaction started by this thread or `null` if this thread does not have a transaction.
`Transaction`	`txStart()` Starts transaction with default isolation, concurrency, timeout, and invalidation policy.
`Transaction`	`txStart(TransactionConcurrency concurrency, TransactionIsolation isolation)` Starts new transaction with the specified concurrency and isolation.
`Transaction`	`txStart(TransactionConcurrency concurrency, TransactionIsolation isolation, long timeout, int txSize)` Starts transaction with specified isolation, concurrency, timeout, invalidation flag, and number of participating entries.
`IgniteInternalTx`	`txStartEx(TransactionConcurrency concurrency, TransactionIsolation isolation)`
`void`	`unlock(K key, CacheEntryPredicate... filter)` Unlocks given key only if current thread owns the lock.
`void`	`unlockAll(Collection<? extends K> keys, CacheEntryPredicate... filter)` Unlocks given keys only if current thread owns the locks.
`Collection<V>`	`values()` Collection of values cached on this node.

Methods inherited from interface java.lang.Iterable
iterator

- Method Detail
  - name
```
String name()
```
    Gets name of this cache (null for default cache).
    
    Returns:
    Cache name.
  - gridProjection
```
ClusterGroup 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<CacheFlag> flags()
```
    Gets cache flags enabled on this projection.
    
    Returns:
    Flags for this projection (empty set if no flags have been set).
  - queries
```
CacheQueries<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> CacheProjection<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
```
CacheProjection<K,V> projection(@Nullable
                              CacheEntryPredicate 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(org.apache.ignite.lang.IgniteBiPredicate) 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
```
CacheProjection<K,V> flagsOn(@Nullable
                           CacheFlag... 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
```
CacheProjection<K,V> flagsOff(@Nullable
                            CacheFlag... 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.
  - keepPortable
```
<K1,V1> CacheProjection<K1,V1> keepPortable()
```
    Creates projection that will operate with portable objects.
    Projection returned by this method will force cache not to deserialize portable objects, so keys and values will be returned from cache API methods without changes. Therefore, signature of the projection can contain only following types:
    - org.gridgain.grid.portables.PortableObject for portable classes
    - All primitives (byte, int, ...) and there boxed versions (Byte, Integer, ...)
    - Arrays of primitives (byte[], int[], ...)
    - String and array of Strings
    - UUID and array of UUIDs
    - Date and array of Dates
    - Timestamp and array of Timestamps
    - Enums and array of enums
    - Maps, collections and array of objects (but objects inside them will still be converted if they are portable)
    For example, if you use Integer as a key and Value class as a value (which will be stored in portable format), you should acquire following projection to avoid deserialization:
```
 CacheProjection prj = cache.keepPortable();

 // Value is not deserialized and returned in portable format.
 GridPortableObject po = prj.get(1);
 
```
    Note that this method makes sense only if cache is working in portable mode (org.apache.ignite.configuration.CacheConfiguration#isPortableEnabled() returns true. If not, this method is no-op and will return current projection.
    Returns:
    Projection for portable objects.
  - 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)
```
    Parameters:
    key - Key.
    
    Returns:
    True if cache contains mapping for a given key.
  - containsKeyAsync
```
IgniteInternalFuture<Boolean> containsKeyAsync(K key)
```
    Parameters:
    key - Key.
    
    Returns:
    Future.
  - containsKeys
```
boolean containsKeys(Collection<? extends K> keys)
```
    Parameters:
    keys - Keys,
    
    Returns:
    True if cache contains all keys.
  - containsKeysAsync
```
IgniteInternalFuture<Boolean> containsKeysAsync(Collection<? extends K> keys)
```
    Parameters:
    keys - Keys to check.
    
    Returns:
    Future.
  - 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.
  - reload
```
@Nullable
V reload(K key)
         throws IgniteCheckedException
```
    Reloads a single key from persistent storage. This method delegates to CacheStore#load(Transaction, 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:
    
    IgniteCheckedException - If reloading failed.
  - reloadAsync
```
IgniteInternalFuture<V> reloadAsync(K key)
```
    Asynchronously reloads a single key from persistent storage. This method delegates to CacheStore#load(Transaction, 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.
  - 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.
  - localPeek
```
@Nullable
V localPeek(K key,
                   CachePeekMode[] peekModes,
                   @Nullable
                   IgniteCacheExpiryPolicy plc)
            throws IgniteCheckedException
```
    Parameters:
    key - Key.
    peekModes - Peek modes.
    plc - Expiry policy if TTL should be updated.
    
    Returns:
    Value.
    
    Throws:
    
    IgniteCheckedException - If failed.
  - localEntries
```
Iterable<javax.cache.Cache.Entry<K,V>> localEntries(CachePeekMode[] peekModes)
                                                    throws IgniteCheckedException
```
    Parameters:
    peekModes - Peek modes.
    
    Returns:
    Entries iterable.
    
    Throws:
    
    IgniteCheckedException - If failed.
  - peek
```
@Nullable
V peek(K key,
              @Nullable
              Collection<GridCachePeekMode> modes)
       throws IgniteCheckedException
```
    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:
    
    IgniteCheckedException - If peek operation failed.
    
    NullPointerException - If key is null.
  - get
```
@Nullable
V get(K key)
      throws IgniteCheckedException
```
    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 CacheStore persistent storage via CacheStore#load(Transaction, 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 CacheFlag.LOCAL flag is set on projection.
    
    Parameters:
    key - Key to retrieve the value for.
    
    Returns:
    Value for the given key.
    
    Throws:
    
    IgniteCheckedException - If get operation failed.
    
    CacheFlagException - If failed projection flags validation.
    
    NullPointerException - if the key is null.
  - getAsync
```
IgniteInternalFuture<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 CacheStore persistent storage via CacheStore#load(Transaction, 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 CacheFlag.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.
    
    CacheFlagException - If projection flags validation failed.
  - getAll
```
Map<K,V> getAll(@Nullable
              Collection<? extends K> keys)
                throws IgniteCheckedException
```
    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 CacheStore persistent storage via CacheStore#loadAll(Transaction, Collection, org.apache.ignite.lang.IgniteBiInClosure) 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 CacheFlag.LOCAL flag is set on projection.
    
    Parameters:
    keys - Keys to get.
    
    Returns:
    Map of key-value pairs.
    
    Throws:
    
    IgniteCheckedException - If get operation failed.
    
    CacheFlagException - If failed projection flags validation.
  - getAllAsync
```
IgniteInternalFuture<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 CacheStore persistent storage via CacheStore#loadAll(Transaction, Collection, org.apache.ignite.lang.IgniteBiInClosure) 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 CacheFlag.LOCAL flag is set on projection.
    
    Parameters:
    keys - Key for the value to get.
    
    Returns:
    Future for the get operation.
    
    Throws:
    
    CacheFlagException - If projection flags validation failed.
  - put
```
@Nullable
V put(K key,
             V val,
             @Nullable
             CacheEntryPredicate... filter)
      throws IgniteCheckedException
```
    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 CacheMode.PARTITIONED or CacheMode.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, CacheStore#load(Transaction, Object) method will be used.
    If the returned value is not needed, method #putx(Object, Object, org.apache.ignite.lang.IgnitePredicate[]) 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 CacheStore via CacheStore#put(Transaction, 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: CacheFlag.LOCAL, CacheFlag.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.
    
    IgniteCheckedException - If put operation failed.
    
    CacheFlagException - If projection flags validation failed.
  - putAsync
```
IgniteInternalFuture<V> putAsync(K key,
                               V val,
                               @Nullable
                               CacheEntryPredicate... 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 CacheMode.REPLICATED caches, the value will be loaded from swap and, if it's not there, and read-through is allowed, from the underlying CacheStore storage. In case of CacheMode.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, CacheStore#load(Transaction, Object) method will be used.
    If the returned value is not needed, method #putx(Object, Object, org.apache.ignite.lang.IgnitePredicate[]) 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 CacheStore via CacheStore#put(Transaction, 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: CacheFlag.LOCAL, CacheFlag.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.
    
    CacheFlagException - If projection flags validation failed.
  - putx
```
boolean putx(K key,
           V val,
           @Nullable
           CacheEntryPredicate... filter)
             throws IgniteCheckedException
```
    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, org.apache.ignite.lang.IgnitePredicate[]) 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 CacheStore via CacheStore#put(Transaction, 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: CacheFlag.LOCAL, CacheFlag.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.
    
    IgniteCheckedException - If put operation failed.
    
    CacheFlagException - If projection flags validation failed.
  - putxAsync
```
IgniteInternalFuture<Boolean> putxAsync(K key,
                                      V val,
                                      @Nullable
                                      CacheEntryPredicate... 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, org.apache.ignite.lang.IgnitePredicate[]) 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 CacheStore via CacheStore#put(Transaction, 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: CacheFlag.LOCAL, CacheFlag.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.
    
    CacheFlagException - If projection flags validation failed.
  - putIfAbsent
```
@Nullable
V putIfAbsent(K key,
                     V val)
              throws IgniteCheckedException
```
    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 CacheMode.PARTITIONED or CacheMode.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, CacheStore#load(Transaction, 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 CacheStore via CacheStore#put(Transaction, 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: CacheFlag.LOCAL, CacheFlag.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.
    
    IgniteCheckedException - If put operation failed.
    
    CacheFlagException - If projection flags validation failed.
  - putIfAbsentAsync
```
IgniteInternalFuture<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 CacheMode.PARTITIONED or CacheMode.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, CacheStore#load(Transaction, 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 CacheStore via CacheStore#put(Transaction, 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: CacheFlag.LOCAL, CacheFlag.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.
    
    CacheFlagException - If projection flags validation failed.
  - putxIfAbsent
```
boolean putxIfAbsent(K key,
                   V val)
                     throws IgniteCheckedException
```
    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 CacheStore via CacheStore#put(Transaction, 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: CacheFlag.LOCAL, CacheFlag.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.
    
    IgniteCheckedException - If put operation failed.
    
    CacheFlagException - If projection flags validation failed.
  - putxIfAbsentAsync
```
IgniteInternalFuture<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 CacheStore via CacheStore#put(Transaction, 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: CacheFlag.LOCAL, CacheFlag.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.
    
    CacheFlagException - If projection flags validation failed.
  - replace
```
@Nullable
V replace(K key,
                 V val)
          throws IgniteCheckedException
```
    Stores given key-value pair in cache only if there is a previous mapping for it. In case of CacheMode.PARTITIONED or CacheMode.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, CacheStore#load(Transaction, 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 CacheStore via CacheStore#put(Transaction, 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: CacheFlag.LOCAL, CacheFlag.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.
    
    IgniteCheckedException - If replace operation failed.
    
    CacheFlagException - If projection flags validation failed.
  - replaceAsync
```
IgniteInternalFuture<V> replaceAsync(K key,
                                   V val)
```
    Asynchronously stores given key-value pair in cache only 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 CacheMode.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, CacheStore#load(Transaction, 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 CacheStore via CacheStore#put(Transaction, 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: CacheFlag.LOCAL, CacheFlag.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.
    
    CacheFlagException - If projection flags validation failed.
  - replacex
```
boolean replacex(K key,
               V val)
                 throws IgniteCheckedException
```
    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 CacheStore via CacheStore#put(Transaction, 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: CacheFlag.LOCAL, CacheFlag.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.
    
    IgniteCheckedException - If replace operation failed.
    
    CacheFlagException - If projection flags validation failed.
  - replacexAsync
```
IgniteInternalFuture<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 CacheStore via CacheStore#put(Transaction, 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: CacheFlag.LOCAL, CacheFlag.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.
    
    CacheFlagException - If projection flags validation failed.
  - replace
```
boolean replace(K key,
              V oldVal,
              V newVal)
                throws IgniteCheckedException
```
    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 CacheStore via CacheStore#put(Transaction, 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: CacheFlag.LOCAL, CacheFlag.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.
    
    IgniteCheckedException - If replace operation failed.
    
    CacheFlagException - If projection flags validation failed.
  - replaceAsync
```
IgniteInternalFuture<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 CacheStore via CacheStore#put(Transaction, 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: CacheFlag.LOCAL, CacheFlag.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.
    
    CacheFlagException - If projection flags validation failed.
  - putAll
```
void putAll(@Nullable
          Map<? extends K,? extends V> m,
          @Nullable
          CacheEntryPredicate... filter)
            throws IgniteCheckedException
```
    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 CacheStore via CacheStore#putAll(Transaction, 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: CacheFlag.LOCAL, CacheFlag.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:
    
    IgniteCheckedException - If put operation failed.
    
    CacheFlagException - If projection flags validation failed.
  - putAllAsync
```
IgniteInternalFuture<?> putAllAsync(@Nullable
                                  Map<? extends K,? extends V> m,
                                  @Nullable
                                  CacheEntryPredicate... 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 CacheStore via CacheStore#putAll(Transaction, 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: CacheFlag.LOCAL, CacheFlag.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:
    
    CacheFlagException - If projection flags validation failed.
  - keySet
```
Set<K> keySet()
```
    Set of keys cached on this node. 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.
    NOTE: this operation is not distributed and returns only the keys cached on this node.
    
    Returns:
    Key set for this cache projection.
  - keySet
```
Set<K> keySet(@Nullable
            CacheEntryPredicate... filter)
```
    Set of keys cached on this node. 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.
    NOTE: this operation is not distributed and returns only the keys cached on this node.
    
    Parameters:
    filter - Optional filter to check prior to getting key form cache. Note that filter is checked atomically together with get operation.
    
    Returns:
    Key set for this cache projection.
  - primaryKeySet
```
Set<K> primaryKeySet()
```
    Set of keys for which this node is primary. 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.
    NOTE: this operation is not distributed and returns only the keys cached on this node.
    
    Returns:
    Primary key set for the current node.
  - values
```
Collection<V> values()
```
    Collection of values cached on this node. 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.
    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.
    NOTE: this operation is not distributed and returns only the values cached on this node.
    
    Returns:
    Collection of cached values.
  - primaryValues
```
Collection<V> primaryValues()
```
    Collection of cached values for which this node is primary. 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.
    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.
    NOTE: this operation is not distributed and returns only the values cached on this node.
    
    Returns:
    Collection of primary cached values for the current node.
  - entrySet
```
Set<javax.cache.Cache.Entry<K,V>> entrySet()
```
    Gets set of all entries cached on this node. 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.
    NOTE: this operation is not distributed and returns only the entries cached on this node.
    
    Returns:
    Entries that pass through key filter.
  - entrySet
```
@Nullable
Set<javax.cache.Cache.Entry<K,V>> entrySet(int part)
```
    Gets set containing cache entries that belong to provided partition or null if partition is not found locally.
    NOTE: this operation is not distributed and returns only the entries cached on this node.
    
    Parameters:
    part - Partition.
    
    Returns:
    Set containing partition's entries or null if partition is not found locally.
  - primaryEntrySet
```
Set<javax.cache.Cache.Entry<K,V>> primaryEntrySet()
```
    Gets set of cache entries for which this node is primary. 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.
    NOTE: this operation is not distributed and returns only the entries cached on this node.
    
    Returns:
    Primary cache entries that pass through key filter.
  - txStart
```
Transaction txStart()
                    throws IllegalStateException
```
    Starts transaction with default isolation, concurrency, timeout, and invalidation policy. All defaults are set in CacheConfiguration at startup.
    
    Returns:
    New transaction
    
    Throws:
    
    IllegalStateException - If transaction is already started by this thread.
    
    UnsupportedOperationException - If cache is CacheAtomicityMode.ATOMIC.
  - txStart
```
Transaction txStart(TransactionConcurrency concurrency,
                  TransactionIsolation 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 CacheAtomicityMode.ATOMIC.
  - txStartEx
```
IgniteInternalTx txStartEx(TransactionConcurrency concurrency,
                         TransactionIsolation isolation)
```
    Parameters:
    concurrency - Concurrency.
    isolation - Isolation.
    
    Returns:
    New transaction.
  - txStart
```
Transaction txStart(TransactionConcurrency concurrency,
                  TransactionIsolation 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 CacheAtomicityMode.ATOMIC.
  - tx
```
@Nullable
Transaction 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
javax.cache.Cache.Entry<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 CacheConfiguration.isSwapEnabled() is set to true and CacheFlag.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: CacheFlag.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 CacheConfiguration.isSwapEnabled() is set to true and CacheFlag.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: CacheFlag.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 CacheConfiguration.isSwapEnabled() is set to true and CacheFlag.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: CacheFlag.READ.
    
    Parameters:
    keys - Keys to evict.
  - clearLocally
```
void clearLocally()
```
    Clears all entries from this cache only if the entry is not currently locked or participating in a transaction.
    If CacheConfiguration.isSwapEnabled() is set to true and CacheFlag.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: CacheFlag.READ.
  - clearLocally
```
boolean clearLocally(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 CacheConfiguration.isSwapEnabled() is set to true and CacheFlag.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: CacheFlag.READ.
    
    Parameters:
    key - Key to clearLocally.
    
    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.
  - clearLocallyAll
```
void clearLocallyAll(Set<K> keys)
```
    Clears entries from this cache and swap storage only if the entry is not currently locked, and is not participating in a transaction.
    If CacheConfiguration.isSwapEnabled() is set to true and CacheFlag.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: CacheFlag.READ.
    
    Parameters:
    keys - Keys to clearLocally.
  - clear
```
void clear(K key)
           throws IgniteCheckedException
```
    Clears key on all nodes that store it's data. That is, caches are cleared on remote nodes and local node, as opposed to clearLocally(Object) method which only clears local node's cache.
    Ignite will make the best attempt to clear caches on all nodes. If some caches could not be cleared, then exception will be thrown.
    
    Parameters:
    key - Key to clear.
    
    Throws:
    
    IgniteCheckedException - In case of cache could not be cleared on any of the nodes.
  - clearAll
```
void clearAll(Set<K> keys)
              throws IgniteCheckedException
```
    Clears keys on all nodes that store it's data. That is, caches are cleared on remote nodes and local node, as opposed to clearLocallyAll(Set) method which only clears local node's cache.
    Ignite will make the best attempt to clear caches on all nodes. If some caches could not be cleared, then exception will be thrown.
    
    Parameters:
    keys - Keys to clear.
    
    Throws:
    
    IgniteCheckedException - In case of cache could not be cleared on any of the nodes.
  - clear
```
void clear()
           throws IgniteCheckedException
```
    Deprecated. Deprecated in favor of clear(long) method.
    
    Clears cache on all nodes that store it's data. That is, caches are cleared on remote nodes and local node, as opposed to clearLocally() method which only clears local node's cache.
    Ignite will make the best attempt to clear caches on all nodes. If some caches could not be cleared, then exception will be thrown.
    This method is identical to calling clear(0).
    
    Throws:
    
    IgniteCheckedException - In case of cache could not be cleared on any of the nodes.
  - clearAsync
```
IgniteInternalFuture<?> clearAsync()
```
    Returns:
    Clear future.
  - clearAsync
```
IgniteInternalFuture<?> clearAsync(K key)
```
    Parameters:
    key - Key to clear.
    
    Returns:
    Clear future.
  - clearAsync
```
IgniteInternalFuture<?> clearAsync(Set<K> keys)
```
    Parameters:
    keys - Keys to clear.
    
    Returns:
    Clear future.
  - clear
```
void clear(long timeout)
           throws IgniteCheckedException
```
    Clears cache on all nodes that store it's data. That is, caches are cleared on remote nodes and local node, as opposed to clearLocally() method which only clears local node's cache.
    Ignite will make the best attempt to clearLocally caches on all nodes. If some caches could not be cleared, then exception will be thrown.
    
    Parameters:
    timeout - Timeout for clearLocally all task in milliseconds (0 for never). Set it to larger value for large caches.
    
    Throws:
    
    IgniteCheckedException - In case of cache could not be cleared on any of the nodes.
  - remove
```
@Nullable
V remove(K key,
                @Nullable
                CacheEntryPredicate... filter)
         throws IgniteCheckedException
```
    Removes given key mapping from cache. If cache previously contained value for the given key, then this value is returned. In case of CacheMode.PARTITIONED or CacheMode.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, CacheStore#load(Transaction, Object) method will be used.
    If the returned value is not needed, method #removex(Object, org.apache.ignite.lang.IgnitePredicate[]) 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 CacheStore via CacheStore#remove(Transaction, 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: CacheFlag.LOCAL, CacheFlag.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.
    
    IgniteCheckedException - If remove operation failed.
    
    CacheFlagException - If projection flags validation failed.
  - removeAsync
```
IgniteInternalFuture<V> removeAsync(K key,
                                  CacheEntryPredicate... 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 CacheMode.PARTITIONED or CacheMode.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, CacheStore#load(Transaction, Object) method will be used.
    If the returned value is not needed, method #removex(Object, org.apache.ignite.lang.IgnitePredicate[]) 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 CacheStore via CacheStore#remove(Transaction, 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: CacheFlag.LOCAL, CacheFlag.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.
    
    CacheFlagException - If projection flags validation failed.
  - removex
```
boolean removex(K key,
              @Nullable
              CacheEntryPredicate... filter)
                throws IgniteCheckedException
```
    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 CacheStore via CacheStore#remove(Transaction, 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: CacheFlag.LOCAL, CacheFlag.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.
    
    IgniteCheckedException - If remove failed.
    
    CacheFlagException - If projection flags validation failed.
  - removexAsync
```
IgniteInternalFuture<Boolean> removexAsync(K key,
                                         @Nullable
                                         CacheEntryPredicate... 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 CacheStore via CacheStore#remove(Transaction, 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: CacheFlag.LOCAL, CacheFlag.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.
    
    CacheFlagException - If projection flags validation failed.
  - remove
```
boolean remove(K key,
             V val)
               throws IgniteCheckedException
```
    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 CacheStore via CacheStore#remove(Transaction, 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: CacheFlag.LOCAL, CacheFlag.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.
    
    IgniteCheckedException - If remove failed.
    
    CacheFlagException - If projection flags validation failed.
  - removeAsync
```
IgniteInternalFuture<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 CacheStore via CacheStore#remove(Transaction, 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: CacheFlag.LOCAL, CacheFlag.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.
    
    CacheFlagException - If projection flags validation failed.
  - removeAll
```
void removeAll(@Nullable
             Collection<? extends K> keys,
             @Nullable
             CacheEntryPredicate... filter)
               throws IgniteCheckedException
```
    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 CacheStore via CacheStore#removeAll(Transaction, 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: CacheFlag.LOCAL, CacheFlag.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:
    
    IgniteCheckedException - If remove failed.
    
    CacheFlagException - If flags validation failed.
  - removeAllAsync
```
IgniteInternalFuture<?> removeAllAsync(@Nullable
                                     Collection<? extends K> keys,
                                     @Nullable
                                     CacheEntryPredicate... 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 CacheStore via CacheStore#removeAll(Transaction, 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: CacheFlag.LOCAL, CacheFlag.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:
    
    CacheFlagException - If flags validation failed.
  - removeAll
```
void removeAll()
               throws IgniteCheckedException
```
    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 CacheStore via CacheStore#removeAll(Transaction, 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: CacheFlag.LOCAL, CacheFlag.READ.
    
    Throws:
    
    IgniteCheckedException - If remove failed.
    
    CacheFlagException - If flags validation failed.
  - removeAllAsync
```
IgniteInternalFuture<?> removeAllAsync()
```
    Returns:
    Remove future.
  - localRemoveAll
```
void localRemoveAll()
                    throws IgniteCheckedException
```
    Throws:
    
    IgniteCheckedException - If failed.
  - lock
```
boolean lock(K key,
           long timeout,
           @Nullable
           CacheEntryPredicate... filter)
             throws IgniteCheckedException
```
    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 TransactionConcurrency.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: CacheFlag.LOCAL, CacheFlag.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:
    
    IgniteCheckedException - If lock acquisition resulted in error.
    
    CacheFlagException - If flags validation failed.
  - lockAsync
```
IgniteInternalFuture<Boolean> lockAsync(K key,
                                      long timeout,
                                      @Nullable
                                      CacheEntryPredicate... 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 TransactionConcurrency.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: CacheFlag.LOCAL, CacheFlag.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:
    
    CacheFlagException - If flags validation failed.
  - lockAll
```
boolean lockAll(@Nullable
              Collection<? extends K> keys,
              long timeout,
              @Nullable
              CacheEntryPredicate... filter)
                throws IgniteCheckedException
```
    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 TransactionConcurrency.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: CacheFlag.LOCAL, CacheFlag.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:
    
    IgniteCheckedException - If lock acquisition resulted in error.
    
    CacheFlagException - If flags validation failed.
  - lockAllAsync
```
IgniteInternalFuture<Boolean> lockAllAsync(@Nullable
                                         Collection<? extends K> keys,
                                         long timeout,
                                         @Nullable
                                         CacheEntryPredicate... 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 TransactionConcurrency.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: CacheFlag.LOCAL, CacheFlag.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:
    
    CacheFlagException - If flags validation failed.
  - unlock
```
void unlock(K key,
          CacheEntryPredicate... filter)
            throws IgniteCheckedException
```
    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 TransactionConcurrency.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: CacheFlag.LOCAL, CacheFlag.READ.
    
    Parameters:
    key - Key to unlock.
    filter - Optional filter that needs to pass prior to unlock taking effect.
    
    Throws:
    
    IgniteCheckedException - If unlock execution resulted in error.
    
    CacheFlagException - If flags validation failed.
  - unlockAll
```
void unlockAll(@Nullable
             Collection<? extends K> keys,
             @Nullable
             CacheEntryPredicate... filter)
               throws IgniteCheckedException
```
    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 TransactionConcurrency.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: CacheFlag.LOCAL, CacheFlag.READ.
    
    Parameters:
    keys - Keys to unlock.
    filter - Optional filter which needs to pass for individual entries to be unlocked.
    
    Throws:
    
    IgniteCheckedException - If unlock execution resulted in error.
    
    CacheFlagException - 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 the number of all entries cached on this node. 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 {Cache.keySet().size().
    NOTE: this operation is not distributed and returns only the number of entries cached on this node.
    
    Returns:
    Size of cache on this node.
  - localSize
```
int localSize(CachePeekMode[] peekModes)
              throws IgniteCheckedException
```
    Parameters:
    peekModes - Peek modes.
    
    Returns:
    Local cache size.
    
    Throws:
    
    IgniteCheckedException - If failed.
  - size
```
int size(CachePeekMode[] peekModes)
         throws IgniteCheckedException
```
    Parameters:
    peekModes - Peek modes.
    
    Returns:
    Global cache size.
    
    Throws:
    
    IgniteCheckedException - If failed.
  - sizeAsync
```
IgniteInternalFuture<Integer> sizeAsync(CachePeekMode[] peekModes)
```
    Parameters:
    peekModes - Peek modes.
    
    Returns:
    Future.
  - globalSize
```
int globalSize()
               throws IgniteCheckedException
```
    Gets the number of all entries cached across all nodes.
    NOTE: this operation is distributed and will query all participating nodes for their cache sizes.
    
    Returns:
    Total cache size across all nodes.
    
    Throws:
    
    IgniteCheckedException
  - nearSize
```
int nearSize()
```
    Gets size of near cache key set. This method will return count of all entries in near cache and has O(1) complexity on base cache projection.
    Note that for LOCAL non-distributed caches this method will always return 0
    
    Returns:
    Size of near cache key set or 0 if cache is not CacheMode.PARTITIONED.
  - primarySize
```
int primarySize()
```
    Gets the number of all primary entries cached on this node. For CacheMode.LOCAL non-distributed cache mode, this method is identical to size().
    For CacheMode.PARTITIONED and CacheMode.REPLICATED modes, this method will return number of primary entries cached on this node (excluding any backups). The complexity of this method is O(P), where P is the total number of partitions.
    NOTE: this operation is not distributed and returns only the number of primary entries cached on this node.
    
    Returns:
    Number of primary entries in cache.
  - globalPrimarySize
```
int globalPrimarySize()
                      throws IgniteCheckedException
```
    Gets the number of all primary entries cached across all nodes (excluding backups).
    NOTE: this operation is distributed and will query all participating nodes for their primary cache sizes.
    
    Returns:
    Total primary cache size across all nodes.
    
    Throws:
    
    IgniteCheckedException
  - promote
```
@Nullable
V promote(K key)
          throws IgniteCheckedException
```
    This method promotes cache entry 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: CacheFlag.SKIP_SWAP, CacheFlag.READ.
    
    Parameters:
    key - Key to promote entry for.
    
    Returns:
    Unswapped entry value or null for non-existing key.
    
    Throws:
    
    IgniteCheckedException - If promote failed.
    
    CacheFlagException - If flags validation failed.
  - promoteAll
```
void promoteAll(@Nullable
              Collection<? extends K> keys)
                throws IgniteCheckedException
```
    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: CacheFlag.SKIP_SWAP, CacheFlag.READ.
    
    Parameters:
    keys - Keys to promote entries for.
    
    Throws:
    
    IgniteCheckedException - If promote failed.
    
    CacheFlagException - If flags validation failed.

Interface CacheProjection<K,V>

Extended Put And Remove Methods

Predicate Filters

Transactions

Group Locking

Null Keys or Values

Peer Class Loading

Portable Objects

Method Summary

Methods inherited from interface java.lang.Iterable

Method Detail

name

gridProjection

cache

flags

queries

projection

projection

flagsOn

Cache Flags

flagsOff

Cache Flags

keepPortable

isEmpty

toMap

containsKey

containsKeyAsync

containsKeys

containsKeysAsync

containsValue

reload

Transactions

reloadAsync

Transactions

peek

Transactions

localPeek

localEntries

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

putIfAbsent

Transactions

Cache Flags

putIfAbsentAsync

Transactions

Cache Flags

putxIfAbsent

Transactions

Cache Flags

putxIfAbsentAsync

Transactions

Cache Flags

replace

Transactions

Cache Flags

replaceAsync