org.apache.ignite.internal.processors.cache

## Interface GridCacheProjectionEx<K,V>

All Superinterfaces:
  CacheProjection<K,V>, Iterable<javax.cache.Cache.Entry<K,V>>

All Known Subinterfaces:
  GridCacheProxy<K,V>

All Known Implementing Classes:
  GridCacheAdapter, GridCacheProjectionImpl, GridCacheProxyImpl, GridDhtAtomicCache, GridDhtCache, GridDhtCacheAdapter, GridDhtColocatedCache, GridDhtTransactionalCacheAdapter, GridDistributedCacheAdapter, GridLocalAtomicCache, GridLocalCache, GridNearAtomicCache, GridNearCacheAdapter, GridNearTransactionalCache

    public interface GridCacheProjectionEx<K,V>
    extends CacheProjection<K,V>

Internal projection interface.

### Method Summary

Methods
`GridCacheContext<K,V>` `context()`
`Set<javax.cache.Cache.Entry<K,V>>` `entrySetx(CacheEntryPredicate... filter)` Gets entry set containing internal entries.
`javax.cache.expiry.ExpiryPolicy` `expiry()`
`GridCacheProjectionEx<K,V>` `forSubjectId(UUID subjId)` Creates projection for specified subject ID.
`V` `get(K key, GridCacheEntryEx entry, boolean deserializePortable, CacheEntryPredicate... filter)`
`Map<K,V>` `getAllOutTx(List<K> keys)` Gets values from cache.
`IgniteInternalFuture<Map<K,V>>` `getAllOutTxAsync(List<K> keys)` Asynchronously gets values from cache.
`V` `getForcePrimary(K key)` Gets value from cache.
`IgniteInternalFuture<V>` `getForcePrimaryAsync(K key)` Asynchronously gets value from cache.
`long` `igfsDataSpaceMax()` Get maximum space available for IGFS.
`long` `igfsDataSpaceUsed()` Get current amount of used IGFS space in bytes.
`<T> javax.cache.processor.EntryProcessorResult<T>` `invoke(K key, javax.cache.processor.EntryProcessor<K,V,T> entryProcessor, Object... args)`
`<T> Map<K,javax.cache.processor.EntryProcessorResult<T>>` `invokeAll(Map<? extends K,? extends javax.cache.processor.EntryProcessor<K,V,T>> map, Object... args)`
`<T> Map<K,javax.cache.processor.EntryProcessorResult<T>>` `invokeAll(Set<? extends K> keys, javax.cache.processor.EntryProcessor<K,V,T> entryProcessor, Object... args)`
`<T> IgniteInternalFuture<Map<K,javax.cache.processor.EntryProcessorResult<T>>>` `invokeAllAsync(Map<? extends K,? extends javax.cache.processor.EntryProcessor<K,V,T>> map, Object... args)`
`<T> IgniteInternalFuture<Map<K,javax.cache.processor.EntryProcessorResult<T>>>` `invokeAllAsync(Set<? extends K> keys, javax.cache.processor.EntryProcessor<K,V,T> entryProcessor, Object... args)`
`<T> IgniteInternalFuture<javax.cache.processor.EntryProcessorResult<T>>` `invokeAsync(K key, javax.cache.processor.EntryProcessor<K,V,T> entryProcessor, Object... args)`
`boolean` `isIgfsDataCache()` Checks whether this cache is IGFS data cache.
`boolean` `isMongoDataCache()` Checks whether this cache is Mongo data cache.
`boolean` `isMongoMetaCache()` Checks whether this cache is Mongo meta cache.
`void` `localLoadCache(IgniteBiPredicate<K,V> p, Object... args)` Delegates to `CacheStore.loadCache(org.apache.ignite.lang.IgniteBiInClosure,Object...)` method to load state from the underlying persistent storage.
`IgniteInternalFuture<?>` `localLoadCacheAsync(IgniteBiPredicate<K,V> p, Object... args)` Asynchronously delegates to `CacheStore.loadCache(org.apache.ignite.lang.IgniteBiInClosure, Object...)` method to reload state from the underlying persistent storage.
`CacheEntryPredicate` `predicate()` Gets predicate on which this projection is based on or `null` if predicate is not defined.
`Set<javax.cache.Cache.Entry<K,V>>` `primaryEntrySetx(CacheEntryPredicate... filter)` Gets set of primary entries containing internal entries.
`V` `put(K key, V val, GridCacheEntryEx entry, long ttl, CacheEntryPredicate... filter)` Internal method that is called from `CacheEntryImpl`.
`void` `putAllConflict(Map<KeyCacheObject,GridCacheDrInfo> drMap)` Store DR data.
`IgniteInternalFuture<?>` `putAllConflictAsync(Map<KeyCacheObject,GridCacheDrInfo> drMap)` Store DR data asynchronously.
`IgniteInternalFuture<V>` `putAsync(K key, V val, GridCacheEntryEx entry, long ttl, CacheEntryPredicate... filter)` Internal method that is called from `CacheEntryImpl`.
`boolean` `putx(K key, V val, GridCacheEntryEx entry, long ttl, CacheEntryPredicate... filter)` Internal method that is called from `CacheEntryImpl`.
`IgniteInternalFuture<Boolean>` `putxAsync(K key, V val, GridCacheEntryEx entry, long ttl, CacheEntryPredicate... filter)` Internal method that is called from `CacheEntryImpl`.
`V` `remove(K key, GridCacheEntryEx entry, CacheEntryPredicate... filter)` Internal method that is called from `CacheEntryImpl`.
`void` `removeAllConflict(Map<KeyCacheObject,GridCacheVersion> drMap)` Removes DR data.
`IgniteInternalFuture<?>` `removeAllConflictAsync(Map<KeyCacheObject,GridCacheVersion> drMap)` Removes DR data asynchronously.
`IgniteInternalFuture<V>` `removeAsync(K key, GridCacheEntryEx entry, CacheEntryPredicate... filter)` Internal method that is called from `CacheEntryImpl`.
`boolean` `removex(K key, GridCacheEntryEx entry, CacheEntryPredicate... filter)` Internal method that is called from `CacheEntryImpl`.
`GridCacheReturn` `removex(K key, V val)` Removes given key mapping from cache if one exists and value is equal to the passed in value.
`IgniteInternalFuture<Boolean>` `removexAsync(K key, GridCacheEntryEx entry, CacheEntryPredicate... filter)` Internal method that is called from `CacheEntryImpl`.
`IgniteInternalFuture<GridCacheReturn>` `removexAsync(K key, V val)` Asynchronously removes given key mapping from cache if one exists and value is equal to the passed in value.
`GridCacheReturn` `replacex(K key, V oldVal, V newVal)` Stores given key-value pair in cache only if only if the previous value is equal to the `'oldVal'` passed in.
`IgniteInternalFuture<GridCacheReturn>` `replacexAsync(K key, V oldVal, V newVal)` Asynchronously stores given key-value pair in cache only if only if the previous value is equal to the `'oldVal'` passed in.
`GridCacheProjectionEx<K,V>` `withExpiryPolicy(javax.cache.expiry.ExpiryPolicy plc)`

### Methods inherited from interface org.apache.ignite.internal.processors.cache.CacheProjection

`cache, clear, clear, clear, clearAll, clearAsync, clearAsync, clearAsync, clearLocally, clearLocally, clearLocallyAll, containsKey, containsKeyAsync, containsKeys, containsKeysAsync, containsValue, entry, entrySet, entrySet, evict, evictAll, evictAll, flags, flagsOff, flagsOn, get, getAll, getAllAsync, getAsync, globalPrimarySize, globalSize, gridProjection, isEmpty, isLocked, isLockedByThread, keepPortable, keySet, keySet, localEntries, localPeek, localRemoveAll, localSize, lock, lockAll, lockAllAsync, lockAsync, name, nearSize, peek, peek, primaryEntrySet, primaryKeySet, primarySize, primaryValues, projection, projection, promote, promoteAll, put, putAll, putAllAsync, putAsync, putIfAbsent, putIfAbsentAsync, putx, putxAsync, putxIfAbsent, putxIfAbsentAsync, queries, reload, reloadAsync, remove, remove, removeAll, removeAll, removeAllAsync, removeAllAsync, removeAsync, removeAsync, removex, removexAsync, replace, replace, replaceAsync, replaceAsync, replacex, replacexAsync, size, size, sizeAsync, toMap, tx, txStart, txStart, txStart, txStartEx, unlock, unlockAll, values`

### Methods inherited from interface java.lang.Iterable

`iterator`

### Method Detail

#### forSubjectId

    GridCacheProjectionEx<K,V> forSubjectId(UUID subjId)

Creates projection for specified subject ID.

Parameters:
  `subjId` - Client ID.
Returns:
  Internal projection.

#### predicate

    @Nullable
    CacheEntryPredicate predicate()

Gets predicate on which this projection is based on or `null` if predicate is not defined.

Returns:
  Filter on which this projection is based on.

#### put

    @Nullable
    V put(K key,
                 V val,
                 @Nullable
                 GridCacheEntryEx entry,
                 long ttl,
                 @Nullable
                 CacheEntryPredicate... filter)
          throws IgniteCheckedException

Internal method that is called from `CacheEntryImpl`.

Parameters:
  `key` - Key.
  `val` - Value.
  `entry` - Cached entry. If not provided, equivalent to {CacheProjection#put}.
  `ttl` - Optional time-to-live. If negative, leaves ttl value unchanged.
  `filter` - Optional filter.
Returns:
  Previous value.
Throws:
  `IgniteCheckedException` - If failed.

#### putAsync

    IgniteInternalFuture<V> putAsync(K key,
                                   V val,
                                   @Nullable
                                   GridCacheEntryEx entry,
                                   long ttl,
                                   @Nullable
                                   CacheEntryPredicate... filter)

Internal method that is called from `CacheEntryImpl`.

Parameters:
  `key` - Key.
  `val` - Value.
  `entry` - Optional cached entry.
  `ttl` - Optional time-to-live value. If negative, leaves ttl value unchanged.
  `filter` - Optional filter.
Returns:
  Put operation future.

#### putx

    boolean putx(K key,
               V val,
               @Nullable
               GridCacheEntryEx entry,
               long ttl,
               @Nullable
               CacheEntryPredicate... filter)
                 throws IgniteCheckedException

Internal method that is called from `CacheEntryImpl`.

Parameters:
  `key` - Key.
  `val` - Value.
  `entry` - Cached entry. If not provided, equivalent to {CacheProjection#put}.
  `ttl` - Optional time-to-live. If negative, leaves ttl value unchanged.
  `filter` - Optional filter.
Returns:
  Previous value.
Throws:
  `IgniteCheckedException` - If failed.

#### putxAsync

    IgniteInternalFuture<Boolean> putxAsync(K key,
                                          V val,
                                          @Nullable
                                          GridCacheEntryEx entry,
                                          long ttl,
                                          @Nullable
                                          CacheEntryPredicate... filter)

Internal method that is called from `CacheEntryImpl`.

Parameters:
  `key` - Key.
  `val` - Value.
  `entry` - Cached entry. If not provided, equivalent to {CacheProjection#put}.
  `ttl` - Optional time-to-live. If negative, leave ttl value unchanged.
  `filter` - Optional filter.
Returns:
  Putx operation future.

#### putAllConflict

    void putAllConflict(Map<KeyCacheObject,GridCacheDrInfo> drMap)
                        throws IgniteCheckedException

Store DR data.

Parameters:
  `drMap` - DR map.
Throws:
  `IgniteCheckedException` - If put operation failed.
  `CacheFlagException` - If projection flags validation failed.

#### putAllConflictAsync

    IgniteInternalFuture<?> putAllConflictAsync(Map<KeyCacheObject,GridCacheDrInfo> drMap)
                                                throws IgniteCheckedException

Store DR data asynchronously.

Parameters:
  `drMap` - DR map.
Returns:
  Future.
Throws:
  `IgniteCheckedException` - If put operation failed.
  `CacheFlagException` - If projection flags validation failed.

#### remove

    @Nullable
    V remove(K key,
                    @Nullable
                    GridCacheEntryEx entry,
                    @Nullable
                    CacheEntryPredicate... filter)
             throws IgniteCheckedException

Internal method that is called from `CacheEntryImpl`.

Parameters:
  `key` - Key to remove.
  `entry` - Cached entry. If not provided, equivalent to {CacheProjection#put}.
  `filter` - Optional filter.
Returns:
  Previous value.
Throws:
  `IgniteCheckedException` - If failed.

#### removeAsync

    IgniteInternalFuture<V> removeAsync(K key,
                                      @Nullable
                                      GridCacheEntryEx entry,
                                      @Nullable
                                      CacheEntryPredicate... filter)

Internal method that is called from `CacheEntryImpl`.

Parameters:
  `key` - Key to remove.
  `entry` - Optional cached entry.
  `filter` - Optional filter.
Returns:
  Put operation future.

#### removeAllConflict

    void removeAllConflict(Map<KeyCacheObject,GridCacheVersion> drMap)
                           throws IgniteCheckedException

Removes DR data.

Parameters:
  `drMap` - DR map.
Throws:
  `IgniteCheckedException` - If remove failed.
  `CacheFlagException` - If projection flags validation failed.

#### removeAllConflictAsync

    IgniteInternalFuture<?> removeAllConflictAsync(Map<KeyCacheObject,GridCacheVersion> drMap)
                                                   throws IgniteCheckedException

Removes DR data asynchronously.

Parameters:
  `drMap` - DR map.
Returns:
  Future.
Throws:
  `IgniteCheckedException` - If remove failed.
  `CacheFlagException` - If projection flags validation failed.

#### removex

    boolean removex(K key,
                  @Nullable
                  GridCacheEntryEx entry,
                  @Nullable
                  CacheEntryPredicate... filter)
                    throws IgniteCheckedException

Internal method that is called from `CacheEntryImpl`.

Parameters:
  `key` - Key to remove.
  `entry` - Cached entry. If not provided, equivalent to {CacheProjection#put}.
  `filter` - Optional filter.
Returns:
  Previous value.
Throws:
  `IgniteCheckedException` - If failed.

#### removexAsync

    IgniteInternalFuture<Boolean> removexAsync(K key,
                                             @Nullable
                                             GridCacheEntryEx entry,
                                             @Nullable
                                             CacheEntryPredicate... filter)

Internal method that is called from `CacheEntryImpl`.

Parameters:
  `key` - Key to remove.
  `entry` - Cached entry. If not provided, equivalent to {CacheProjection#put}.
  `filter` - Optional filter.
Returns:
  Putx operation future.

#### replacexAsync

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

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

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

If write-through is enabled, the stored value will be persisted to `CacheStore` via `CacheWriter.write(javax.cache.Cache.Entry)` 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. The future will return object containing actual old value and success flag.
Throws:
  `NullPointerException` - If either key or value are `null`.
  `CacheFlagException` - If projection flags validation failed.

#### replacex

    GridCacheReturn replacex(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 `CacheWriter.write(javax.cache.Cache.Entry)` 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:
  Object containing actual old value and success flag.
Throws:
  `NullPointerException` - If either key or value are `null`.
  `IgniteCheckedException` - If replace operation failed.
  `CacheFlagException` - If projection flags validation failed.

#### removex

    GridCacheReturn removex(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 `CacheWriter.delete(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:
  Object containing actual old value and success flag.
Throws:
  `NullPointerException` - if the key or value is `null`.
  `IgniteCheckedException` - If remove failed.
  `CacheFlagException` - If projection flags validation failed.

#### removexAsync

    IgniteInternalFuture<GridCacheReturn> removexAsync(K key,
                                                     V val)

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

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

If write-through is enabled, the value will be removed from `CacheStore` via `CacheWriter.delete(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 object containing actual old value and success flag.
Throws:
  `NullPointerException` - if the key or value is `null`.
  `CacheFlagException` - If projection flags validation failed.

#### get

    @Nullable
    V get(K key,
                 @Nullable
                 GridCacheEntryEx entry,
                 boolean deserializePortable,
                 @Nullable
                 CacheEntryPredicate... filter)
          throws IgniteCheckedException

Parameters:
  `key` - Key to retrieve the value for.
  `entry` - Cached entry when called from entry wrapper.
  `filter` - Filter to check prior to getting the value. Note that filter check together with getting the value is an atomic operation.
Returns:
  Value.
Throws:
  `IgniteCheckedException` - If failed.

#### getForcePrimary

    @Nullable
    V getForcePrimary(K key)
                      throws IgniteCheckedException

Gets value from cache. Will go to primary node even if this is a backup.

Parameters:
  `key` - Key to get value for.
Returns:
  Value.
Throws:
  `IgniteCheckedException` - If failed.

#### getForcePrimaryAsync

    IgniteInternalFuture<V> getForcePrimaryAsync(K key)

Asynchronously gets value from cache. Will go to primary node even if this is a backup.

Parameters:
  `key` - Key to get value for.
Returns:
  Future with result.

#### getAllOutTx

    @Nullable
    Map<K,V> getAllOutTx(List<K> keys)
                         throws IgniteCheckedException

Gets values from cache. Will bypass started transaction, if any, i.e. will not enlist entries and will not lock any keys if pessimistic transaction is started by thread.

Parameters:
  `keys` - Keys to get values for.
Returns:
  Value.
Throws:
  `IgniteCheckedException` - If failed.

#### getAllOutTxAsync

    IgniteInternalFuture<Map<K,V>> getAllOutTxAsync(List<K> keys)

Asynchronously gets values from cache. Will bypass started transaction, if any, i.e. will not enlist entries and will not lock any keys if pessimistic transaction is started by thread.

Parameters:
  `keys` - Keys to get values for.
Returns:
  Future with result.

#### isIgfsDataCache

    boolean isIgfsDataCache()

Checks whether this cache is IGFS data cache.

Returns:
  `True` in case this cache is IGFS data cache.

#### igfsDataSpaceUsed

    long igfsDataSpaceUsed()

Get current amount of used IGFS space in bytes.

Returns:
  Amount of used IGFS space in bytes.

#### igfsDataSpaceMax

    long igfsDataSpaceMax()

Get maximum space available for IGFS.

Returns:
  Amount of space available for IGFS in bytes.

#### isMongoDataCache

    boolean isMongoDataCache()

Checks whether this cache is Mongo data cache.

Returns:
  `True` if this cache is mongo data cache.

#### isMongoMetaCache

    boolean isMongoMetaCache()

Checks whether this cache is Mongo meta cache.

Returns:
  `True` if this cache is mongo meta cache.

#### entrySetx

    Set<javax.cache.Cache.Entry<K,V>> entrySetx(CacheEntryPredicate... filter)

Gets entry set containing internal entries.

Parameters:
  `filter` - Filter.
Returns:
  Entry set.

#### primaryEntrySetx

    Set<javax.cache.Cache.Entry<K,V>> primaryEntrySetx(CacheEntryPredicate... filter)

Gets set of primary entries containing internal entries.

Parameters:
  `filter` - Optional filter.
Returns:
  Primary entry set.

#### expiry

    @Nullable
    javax.cache.expiry.ExpiryPolicy expiry()

Returns:
  `ExpiryPolicy` associated with this projection.

#### withExpiryPolicy

    GridCacheProjectionEx<K,V> withExpiryPolicy(javax.cache.expiry.ExpiryPolicy plc)

Parameters:
  `plc` - `ExpiryPolicy` to associate with this projection.
Returns:
  New projection based on this one, but with the specified expiry policy.

#### invoke

    @Nullable
    <T> javax.cache.processor.EntryProcessorResult<T> invoke(K key,
                                                                    javax.cache.processor.EntryProcessor<K,V,T> entryProcessor,
                                                                    Object... args)
                                                         throws IgniteCheckedException

Parameters:
  `key` - Key.
  `entryProcessor` - Entry processor.
  `args` - Arguments.
Returns:
  Invoke result.
Throws:
  `IgniteCheckedException` - If failed.

#### invokeAsync

    <T> IgniteInternalFuture<javax.cache.processor.EntryProcessorResult<T>> invokeAsync(K key,
                                                                                      javax.cache.processor.EntryProcessor<K,V,T> entryProcessor,
                                                                                      Object... args)

Parameters:
  `key` - Key.
  `entryProcessor` - Entry processor.
  `args` - Arguments.
Returns:
  Future.

#### invokeAll

    <T> Map<K,javax.cache.processor.EntryProcessorResult<T>> invokeAll(Set<? extends K> keys,
                                                                     javax.cache.processor.EntryProcessor<K,V,T> entryProcessor,
                                                                     Object... args)
                                                                   throws IgniteCheckedException

Parameters:
  `keys` - Keys.
  `entryProcessor` - Entry processor.
  `args` - Arguments.
Returns:
  Invoke results.
Throws:
  `IgniteCheckedException` - If failed.

#### invokeAllAsync

    <T> IgniteInternalFuture<Map<K,javax.cache.processor.EntryProcessorResult<T>>> invokeAllAsync(Set<? extends K> keys,
                                                                                                javax.cache.processor.EntryProcessor<K,V,T> entryProcessor,
                                                                                                Object... args)

Parameters:
  `keys` - Keys.
  `entryProcessor` - Entry processor.
  `args` - Arguments.
Returns:
  Future.

#### invokeAll

    <T> Map<K,javax.cache.processor.EntryProcessorResult<T>> invokeAll(Map<? extends K,? extends javax.cache.processor.EntryProcessor<K,V,T>> map,
                                                                     Object... args)
                                                                   throws IgniteCheckedException

Parameters:
  `map` - Map containing keys and entry processors to be applied to values.
  `args` - Arguments.
Returns:
  Invoke results.
Throws:
  `IgniteCheckedException` - If failed.

#### invokeAllAsync

    <T> IgniteInternalFuture<Map<K,javax.cache.processor.EntryProcessorResult<T>>> invokeAllAsync(Map<? extends K,? extends javax.cache.processor.EntryProcessor<K,V,T>> map,
                                                                                                Object... args)

Parameters:
  `map` - Map containing keys and entry processors to be applied to values.
  `args` - Arguments.
Returns:
  Future.

#### context

    GridCacheContext<K,V> context()

Returns:
  Context.

#### localLoadCache

    void localLoadCache(@Nullable
                      IgniteBiPredicate<K,V> p,
                      @Nullable
                      Object... args)
                        throws IgniteCheckedException

Delegates to `CacheStore.loadCache(org.apache.ignite.lang.IgniteBiInClosure,Object...)` method to load state from the underlying persistent storage. The loaded values will then be given to the optionally passed in predicate, and, if the predicate returns `true`, will be stored in cache. If predicate is `null`, then all loaded values will be stored in cache.

Note that this method does not receive keys as a parameter, so it is up to `CacheStore` implementation to provide all the data to be loaded.

This method is not transactional and may end up loading a stale value into cache if another thread has updated the value immediately after it has been loaded. It is mostly useful when pre-loading the cache from underlying data store before start, or for read-only caches.

Parameters:
  `p` - Optional predicate (may be `null`). If provided, will be used to filter values to be put into cache.
  `args` - Optional user arguments to be passed into `CacheStore.loadCache(org.apache.ignite.lang.IgniteBiInClosure, Object...)` method.
Throws:
  `IgniteCheckedException` - If loading failed.

#### localLoadCacheAsync

    IgniteInternalFuture<?> localLoadCacheAsync(@Nullable
                                              IgniteBiPredicate<K,V> p,
                                              @Nullable
                                              Object... args)

Asynchronously delegates to `CacheStore.loadCache(org.apache.ignite.lang.IgniteBiInClosure, Object...)` method to reload state from the underlying persistent storage. The reloaded values will then be given to the optionally passed in predicate, and if the predicate returns `true`, will be stored in cache. If predicate is `null`, then all reloaded values will be stored in cache.

Note that this method does not receive keys as a parameter, so it is up to `CacheStore` implementation to provide all the data to be loaded.

This method is not transactional and may end up loading a stale value into cache if another thread has updated the value immediately after it has been loaded. It is mostly useful when pre-loading the cache from underlying data store before start, or for read-only caches.

Parameters:
  `p` - Optional predicate (may be `null`). If provided, will be used to filter values to be put into cache.
  `args` - Optional user arguments to be passed into `CacheStore.loadCache(org.apache.ignite.lang.IgniteBiInClosure,Object...)` method.
Returns:
  Future to be completed whenever loading completes.

2015 Copyright © Apache Software Foundation

Follow @ApacheIgnite

Ignite Fabric | : ver. 1.0.0
Release Date | : March 31 2015