IgniteCacheProxy (Ignite 1.1.0-incubating)

java.lang.Object
- org.apache.ignite.internal.AsyncSupportAdapter<IgniteCache<K,V>>
- - org.apache.ignite.internal.processors.cache.IgniteCacheProxy<K,V>

All Implemented Interfaces:

Closeable, Externalizable, Serializable, AutoCloseable, Iterable<javax.cache.Cache.Entry<K,V>>, javax.cache.Cache<K,V>, IgniteCache<K,V>, IgniteAsyncSupport
```
public class IgniteCacheProxy<K,V>
extends AsyncSupportAdapter<IgniteCache<K,V>>
implements IgniteCache<K,V>, Externalizable
```
Cache proxy.

See Also:
Serialized Form

Nested Class Summary
- Nested classes/interfaces inherited from interface javax.cache.Cache
  javax.cache.Cache.Entry<K,V>

Field Summary
- Fields inherited from class org.apache.ignite.internal.AsyncSupportAdapter
  curFut

Constructor Summary

Constructors
Constructor and Description
`IgniteCacheProxy()` Empty constructor required for `Externalizable`.
`IgniteCacheProxy(GridCacheContext<K,V> ctx, IgniteInternalCache<K,V> delegate, CacheOperationContext opCtx, boolean async)`

Method Summary

Methods
Modifier and Type	Method and Description
`IgniteCacheProxy<K,V>`	`cacheNoGate()` Gets cache proxy which does not acquire read lock on gateway enter, should be used only if grid read lock is externally acquired.
`void`	`clear()`
`void`	`clear(K key)` Clear entry from the cache and swap storage, without notifying listeners or `CacheWriter`s.
`void`	`clearAll(Set<? extends K> keys)` Clear entries from the cache and swap storage, without notifying listeners or `CacheWriter`s.
`void`	`close()` Completely deletes the cache with all its data from the system on all cluster nodes.
`boolean`	`containsKey(K key)`
`boolean`	`containsKeys(Set<? extends K> keys)`
`GridCacheContext<K,V>`	`context()`
`protected IgniteCache<K,V>`	`createAsyncInstance()` Creates component with asynchronous mode enabled.
`IgniteInternalCache`	`delegate()`
`void`	`deregisterCacheEntryListener(javax.cache.configuration.CacheEntryListenerConfiguration<K,V> lsnrCfg)`
`Set<javax.cache.Cache.Entry<K,V>>`	`entrySetx(CacheEntryPredicate... filter)` Gets entry set containing internal entries.
`GridCacheGateway<K,V>`	`gate()`
`V`	`get(K key)`
`Map<K,V>`	`getAll(Collection<? extends K> keys)`
`Map<K,V>`	`getAll(Set<? extends K> keys)`
`V`	`getAndPut(K key, V val)`
`V`	`getAndPutIfAbsent(K key, V val)` Stores given key-value pair in cache only if cache had no previous mapping for it.
`V`	`getAndRemove(K key)`
`V`	`getAndReplace(K key, V val)`
`CacheManager`	`getCacheManager()`
`<C extends javax.cache.configuration.Configuration<K,V>> C`	`getConfiguration(Class<C> clazz)`
`String`	`getName()`
`GridCacheProxyImpl<K,V>`	`internalProxy()`
`<T> T`	`invoke(K key, CacheEntryProcessor<K,V,T> entryProcessor, Object... args)` Invokes an `CacheEntryProcessor` against the `Cache.Entry` specified by the provided key.
`<T> 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, CacheEntryProcessor<K,V,T> entryProcessor, Object... args)` Invokes an `CacheEntryProcessor` against the set of `Cache.Entry`s specified by the set of keys.
`<T> Map<K,javax.cache.processor.EntryProcessorResult<T>>`	`invokeAll(Set<? extends K> keys, javax.cache.processor.EntryProcessor<K,V,T> entryProcessor, Object... args)`
`boolean`	`isClosed()`
`boolean`	`isLocalLocked(K key, boolean byCurrThread)` Checks if specified key is locked.
`Iterator<javax.cache.Cache.Entry<K,V>>`	`iterator()`
`<K1,V1> IgniteCache<K1,V1>`	`keepPortable()` Creates projection that will operate with portable objects.
`void`	`loadAll(Set<? extends K> keys, boolean replaceExisting, javax.cache.integration.CompletionListener completionLsnr)`
`void`	`loadCache(IgniteBiPredicate<K,V> p, Object... args)` Executes `IgniteCache.localLoadCache(IgniteBiPredicate, Object...)` on all cache nodes.
`void`	`localClear(K key)` Clear entry from the cache and swap storage, without notifying listeners or `CacheWriter`s.
`void`	`localClearAll(Set<? extends K> keys)` Clear entries from the cache and swap storage, without notifying listeners or `CacheWriter`s.
`Iterable<javax.cache.Cache.Entry<K,V>>`	`localEntries(CachePeekMode... peekModes)` Allows for iteration over local cache entries.
`void`	`localEvict(Collection<? extends K> keys)` Attempts to evict all entries associated with keys.
`void`	`localLoadCache(IgniteBiPredicate<K,V> p, Object... args)` Delegates to `CacheStore.loadCache(IgniteBiInClosure,Object...)` method to load state from the underlying persistent storage.
`V`	`localPeek(K key, CachePeekMode... peekModes)` Peeks at in-memory cached value using default optinal peek mode.
`void`	`localPromote(Set<? extends K> keys)` This method unswaps cache entries by given keys, if any, from swap storage into memory.
`int`	`localSize(CachePeekMode... peekModes)` Gets the number of all entries cached on this node.
`Lock`	`lock(K key)` Creates a `Lock` instance associated with passed key.
`Lock`	`lockAll(Collection<? extends K> keys)` Creates a `Lock` instance associated with passed keys.
`CacheMetrics`	`metrics()` Gets snapshot metrics (statistics) for this cache.
`CacheMetrics`	`metrics(ClusterGroup grp)` Gets snapshot metrics for caches in cluster group.
`CacheMetricsMXBean`	`mxBean()` Gets MxBean for this cache.
`void`	`put(K key, V val)`
`void`	`putAll(Map<? extends K,? extends V> map)`
`boolean`	`putIfAbsent(K key, V val)`
`<R> QueryCursor<R>`	`query(Query<R> qry)` Queries cache.
`QueryMetrics`	`queryMetrics()` Gets query metrics.
`javax.cache.Cache.Entry<K,V>`	`randomEntry()` Gets a random entry out of cache.
`void`	`readExternal(ObjectInput in)`
`IgniteFuture<?>`	`rebalance()` This cache node to re-balance its partitions.
`void`	`registerCacheEntryListener(javax.cache.configuration.CacheEntryListenerConfiguration<K,V> lsnrCfg)`
`boolean`	`remove(K key)`
`boolean`	`remove(K key, V oldVal)`
`void`	`removeAll()`
`void`	`removeAll(Set<? extends K> keys)`
`boolean`	`replace(K key, V val)`
`boolean`	`replace(K key, V oldVal, V newVal)`
`void`	`setCacheManager(CacheManager cacheMgr)`
`int`	`size(CachePeekMode... peekModes)` Gets the number of all entries cached across all nodes.
`IgniteCache<K,V>`	`skipStore()`
`String`	`toString()`
`<T> T`	`unwrap(Class<T> clazz)`
`IgniteCache<K,V>`	`withExpiryPolicy(javax.cache.expiry.ExpiryPolicy plc)` Returns cache with the specified expired policy set.
`IgniteCache<K,V>`	`withSkipStore()`
`void`	`writeExternal(ObjectOutput out)`

Methods inherited from class org.apache.ignite.internal.AsyncSupportAdapter
createFuture, future, future, isAsync, saveOrGet, withAsync

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait

Methods inherited from interface org.apache.ignite.IgniteCache
withAsync

Methods inherited from interface org.apache.ignite.lang.IgniteAsyncSupport
future, isAsync

- Constructor Detail
  - IgniteCacheProxy
```
public IgniteCacheProxy()
```
    Empty constructor required for Externalizable.
  - IgniteCacheProxy
```
public IgniteCacheProxy(GridCacheContext<K,V> ctx,
                IgniteInternalCache<K,V> delegate,
                CacheOperationContext opCtx,
                boolean async)
```
    Parameters:
    ctx - Context.
    delegate - Delegate.
    opCtx - Operation context.
    async - Async support flag.
- Method Detail
  - cacheNoGate
```
public IgniteCacheProxy<K,V> cacheNoGate()
```
    Gets cache proxy which does not acquire read lock on gateway enter, should be used only if grid read lock is externally acquired.
    
    Returns:
    Ignite cache proxy with simple gate.
  - context
```
public GridCacheContext<K,V> context()
```
    Returns:
    Context.
  - gate
```
public GridCacheGateway<K,V> gate()
```
    Returns:
    Gateway.
  - metrics
```
public CacheMetrics metrics()
```
    Gets snapshot metrics (statistics) for this cache.
    
    Specified by:
    
    metrics in interface IgniteCache<K,V>
    
    Returns:
    Cache metrics.
  - metrics
```
public CacheMetrics metrics(ClusterGroup grp)
```
    Gets snapshot metrics for caches in cluster group.
    
    Specified by:
    
    metrics in interface IgniteCache<K,V>
    
    Parameters:
    grp - Cluster group.
    
    Returns:
    Cache metrics.
  - mxBean
```
public CacheMetricsMXBean mxBean()
```
    Gets MxBean for this cache.
    
    Specified by:
    
    mxBean in interface IgniteCache<K,V>
    
    Returns:
    MxBean.
  - getConfiguration
```
public <C extends javax.cache.configuration.Configuration<K,V>> C getConfiguration(Class<C> clazz)
```
    Specified by:
    
    getConfiguration in interface javax.cache.Cache<K,V>
    
    Specified by:
    
    getConfiguration in interface IgniteCache<K,V>
  - randomEntry
```
@Nullable
public javax.cache.Cache.Entry<K,V> randomEntry()
```
    Gets a random entry out of cache. In the worst cache scenario this method has complexity of
```
O(S * N/64)
```
    where N is the size of internal hash table and S is the number of hash table buckets to sample, which is 5 by default. However, if the table is pretty dense, with density factor of N/64, which is true for near fully populated caches, this method will generally perform significantly faster with complexity of O(S) where S = 5.
    Specified by:
    
    randomEntry in interface IgniteCache<K,V>
    
    Returns:
    Random entry, or null if cache is empty.
  - withExpiryPolicy
```
public IgniteCache<K,V> withExpiryPolicy(javax.cache.expiry.ExpiryPolicy plc)
```
    Returns cache with the specified expired policy set. This policy will be used for each operation invoked on the returned cache.
    This method does not modify existing cache instance.
    
    Specified by:
    
    withExpiryPolicy in interface IgniteCache<K,V>
    
    Parameters:
    plc - Expire policy to use.
    
    Returns:
    Cache instance with the specified expiry policy set.
  - withSkipStore
```
public IgniteCache<K,V> withSkipStore()
```
    Specified by:
    
    withSkipStore in interface IgniteCache<K,V>
    
    Returns:
    Cache with read-through write-through behavior disabled.
  - loadCache
```
public void loadCache(@Nullable
             IgniteBiPredicate<K,V> p,
             @Nullable
             Object... args)
```
    Executes IgniteCache.localLoadCache(IgniteBiPredicate, Object...) on all cache nodes.
    
    Specified by:
    
    loadCache in interface IgniteCache<K,V>
    
    Parameters:
    p - Optional predicate (may be null). If provided, will be used to filter values loaded from storage before they are put into cache.
    args - Optional user arguments to be passed into CacheStore.loadCache(IgniteBiInClosure, Object...) method.
  - localLoadCache
```
public void localLoadCache(@Nullable
                  IgniteBiPredicate<K,V> p,
                  @Nullable
                  Object... args)
```
    Delegates to CacheStore.loadCache(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.
    
    Specified by:
    
    localLoadCache in interface IgniteCache<K,V>
    
    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(IgniteBiInClosure, Object...) method.
  - getAndPutIfAbsent
```
@Nullable
public V getAndPutIfAbsent(K key,
                           V val)
                    throws javax.cache.CacheException
```
    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, CacheLoader.load(Object) method will be used.
    If the returned value is not needed, method IgniteCache.putIfAbsent(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 CacheWriter.write(javax.cache.Cache.Entry) method.
    Transactions
    This method is transactional and will enlist the entry into ongoing transaction if there is one.
    
    Specified by:
    
    getAndPutIfAbsent in interface IgniteCache<K,V>
    
    Parameters:
    key - Key to store in cache.
    val - Value to be associated with the given key.
    
    Returns:
    Previously contained value regardless of whether put happened or not (null if there was no previous value).
    
    Throws:
    
    javax.cache.CacheException - If put operation failed.
  - lock
```
public Lock lock(K key)
          throws javax.cache.CacheException
```
    Creates a Lock instance associated with passed key. This method does not acquire lock immediately, you have to call appropriate method on returned instance. Returned lock does not support Lock.newCondition() method, other methods defined in Lock are supported.
    
    Specified by:
    
    lock in interface IgniteCache<K,V>
    
    Parameters:
    key - Key for lock.
    
    Returns:
    New lock instance associated with passed key.
    
    Throws:
    
    javax.cache.CacheException
    See Also:
    Lock.lock(), Lock.tryLock(long, TimeUnit)
  - lockAll
```
public Lock lockAll(Collection<? extends K> keys)
```
    Creates a Lock instance associated with passed keys. This method does not acquire lock immediately, you have to call appropriate method on returned instance. Returned lock does not support Lock.newCondition() method, other methods defined in Lock are supported.
    
    Specified by:
    
    lockAll in interface IgniteCache<K,V>
    
    Parameters:
    keys - Keys for lock.
    
    Returns:
    New lock instance associated with passed key.
    See Also:
    Lock.lock(), Lock.tryLock(long, TimeUnit)
  - isLocalLocked
```
public boolean isLocalLocked(K key,
                    boolean byCurrThread)
```
    Checks if specified key is locked.
    This is a local in-VM operation and does not involve any network trips or access to persistent storage in any way.
    
    Specified by:
    
    isLocalLocked in interface IgniteCache<K,V>
    
    Parameters:
    key - Key to check.
    byCurrThread - If true method will check that current thread owns a lock on this key, other vise will check that any thread on any node owns a lock on this key.
    
    Returns:
    True if lock is owned by some node.
  - query
```
public <R> QueryCursor<R> query(Query<R> qry)
```
    Queries cache. Accepts any subclass of Query interface.
    
    Specified by:
    
    query in interface IgniteCache<K,V>
    
    Parameters:
    qry - Query.
    
    Returns:
    Cursor.
    See Also:
    ScanQuery, SqlQuery, TextQuery, SpiQuery
  - localEntries
```
public Iterable<javax.cache.Cache.Entry<K,V>> localEntries(CachePeekMode... peekModes)
                                                    throws javax.cache.CacheException
```
    Allows for iteration over local cache entries.
    
    Specified by:
    
    localEntries in interface IgniteCache<K,V>
    
    Parameters:
    peekModes - Peek modes.
    
    Returns:
    Iterable over local cache entries.
    
    Throws:
    
    javax.cache.CacheException - If failed.
  - queryMetrics
```
public QueryMetrics queryMetrics()
```
    Gets query metrics.
    
    Specified by:
    
    queryMetrics in interface IgniteCache<K,V>
    
    Returns:
    Metrics.
  - localEvict
```
public void localEvict(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).
    
    Specified by:
    
    localEvict in interface IgniteCache<K,V>
    
    Parameters:
    keys - Keys to evict.
  - localPeek
```
@Nullable
public V localPeek(K key,
                   CachePeekMode... peekModes)
```
    Peeks at in-memory cached value using default optinal 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.
    
    Specified by:
    
    localPeek in interface IgniteCache<K,V>
    
    Parameters:
    key - Entry key.
    
    Returns:
    Peeked value, or null if not found.
  - localPromote
```
public void localPromote(Set<? extends K> keys)
                  throws javax.cache.CacheException
```
    This method unswaps cache entries by given keys, if any, from swap storage into memory.
    Transactions
    This method is not transactional.
    
    Specified by:
    
    localPromote in interface IgniteCache<K,V>
    
    Parameters:
    keys - Keys to promote entries for.
    
    Throws:
    
    javax.cache.CacheException - If promote failed.
  - size
```
public int size(CachePeekMode... peekModes)
         throws javax.cache.CacheException
```
    Gets the number of all entries cached across all nodes. By default, if peekModes value isn't defined, only size of primary copies across all nodes will be returned. This behavior is identical to calling this method with CachePeekMode.PRIMARY peek mode.
    NOTE: this operation is distributed and will query all participating nodes for their cache sizes.
    
    Specified by:
    
    size in interface IgniteCache<K,V>
    
    Parameters:
    peekModes - Optional peek modes. If not provided, then total cache size is returned.
    
    Returns:
    Cache size across all nodes.
    
    Throws:
    
    javax.cache.CacheException
  - localSize
```
public int localSize(CachePeekMode... peekModes)
```
    Gets the number of all entries cached on this node. By default, if peekModes value isn't defined, only size of primary copies will be returned. This behavior is identical to calling this method with CachePeekMode.PRIMARY peek mode.
    
    Specified by:
    
    localSize in interface IgniteCache<K,V>
    
    Parameters:
    peekModes - Optional peek modes. If not provided, then total cache size is returned.
    
    Returns:
    Cache size on this node.
  - get
```
public V get(K key)
```
    Specified by:
    
    get in interface javax.cache.Cache<K,V>
    
    Specified by:
    
    get in interface IgniteCache<K,V>
  - getAll
```
public Map<K,V> getAll(Set<? extends K> keys)
```
    Specified by:
    
    getAll in interface javax.cache.Cache<K,V>
    
    Specified by:
    
    getAll in interface IgniteCache<K,V>
  - getAll
```
public Map<K,V> getAll(Collection<? extends K> keys)
```
    Parameters:
    keys - Keys.
    
    Returns:
    Values map.
  - entrySetx
```
public Set<javax.cache.Cache.Entry<K,V>> entrySetx(CacheEntryPredicate... filter)
```
    Gets entry set containing internal entries.
    
    Parameters:
    filter - Filter.
    
    Returns:
    Entry set.
  - containsKey
```
public boolean containsKey(K key)
```
    Specified by:
    
    containsKey in interface javax.cache.Cache<K,V>
    
    Specified by:
    
    containsKey in interface IgniteCache<K,V>
  - containsKeys
```
public boolean containsKeys(Set<? extends K> keys)
```
    Specified by:
    
    containsKeys in interface IgniteCache<K,V>
  - loadAll
```
public void loadAll(Set<? extends K> keys,
           boolean replaceExisting,
           @Nullable
           javax.cache.integration.CompletionListener completionLsnr)
```
    Specified by:
    
    loadAll in interface javax.cache.Cache<K,V>
  - put
```
public void put(K key,
       V val)
```
    Specified by:
    
    put in interface javax.cache.Cache<K,V>
    
    Specified by:
    
    put in interface IgniteCache<K,V>
  - getAndPut
```
public V getAndPut(K key,
          V val)
```
    Specified by:
    
    getAndPut in interface javax.cache.Cache<K,V>
    
    Specified by:
    
    getAndPut in interface IgniteCache<K,V>
  - putAll
```
public void putAll(Map<? extends K,? extends V> map)
```
    Specified by:
    
    putAll in interface javax.cache.Cache<K,V>
    
    Specified by:
    
    putAll in interface IgniteCache<K,V>
  - putIfAbsent
```
public boolean putIfAbsent(K key,
                  V val)
```
    Specified by:
    
    putIfAbsent in interface javax.cache.Cache<K,V>
    
    Specified by:
    
    putIfAbsent in interface IgniteCache<K,V>
  - remove
```
public boolean remove(K key)
```
    Specified by:
    
    remove in interface javax.cache.Cache<K,V>
    
    Specified by:
    
    remove in interface IgniteCache<K,V>
  - remove
```
public boolean remove(K key,
             V oldVal)
```
    Specified by:
    
    remove in interface javax.cache.Cache<K,V>
    
    Specified by:
    
    remove in interface IgniteCache<K,V>
  - getAndRemove
```
public V getAndRemove(K key)
```
    Specified by:
    
    getAndRemove in interface javax.cache.Cache<K,V>
    
    Specified by:
    
    getAndRemove in interface IgniteCache<K,V>
  - replace
```
public boolean replace(K key,
              V oldVal,
              V newVal)
```
    Specified by:
    
    replace in interface javax.cache.Cache<K,V>
    
    Specified by:
    
    replace in interface IgniteCache<K,V>
  - replace
```
public boolean replace(K key,
              V val)
```
    Specified by:
    
    replace in interface javax.cache.Cache<K,V>
    
    Specified by:
    
    replace in interface IgniteCache<K,V>
  - getAndReplace
```
public V getAndReplace(K key,
              V val)
```
    Specified by:
    
    getAndReplace in interface javax.cache.Cache<K,V>
    
    Specified by:
    
    getAndReplace in interface IgniteCache<K,V>
  - removeAll
```
public void removeAll(Set<? extends K> keys)
```
    Specified by:
    
    removeAll in interface javax.cache.Cache<K,V>
    
    Specified by:
    
    removeAll in interface IgniteCache<K,V>
  - removeAll
```
public void removeAll()
```
    Specified by:
    
    removeAll in interface javax.cache.Cache<K,V>
    
    Specified by:
    
    removeAll in interface IgniteCache<K,V>
  - clear
```
public void clear(K key)
```
    Clear entry from the cache and swap storage, without notifying listeners or CacheWriters. Entry is cleared only if it is not currently locked, and is not participating in a transaction.
    
    Specified by:
    
    clear in interface IgniteCache<K,V>
    
    Parameters:
    key - Key to clear.
  - clearAll
```
public void clearAll(Set<? extends K> keys)
```
    Clear entries from the cache and swap storage, without notifying listeners or CacheWriters. Entry is cleared only if it is not currently locked, and is not participating in a transaction.
    
    Specified by:
    
    clearAll in interface IgniteCache<K,V>
    
    Parameters:
    keys - Keys to clear.
  - clear
```
public void clear()
```
    Specified by:
    
    clear in interface javax.cache.Cache<K,V>
    
    Specified by:
    
    clear in interface IgniteCache<K,V>
  - localClear
```
public void localClear(K key)
```
    Clear entry from the cache and swap storage, without notifying listeners or CacheWriters. Entry is cleared only if it is not currently locked, and is not participating in a transaction.
    Note that this operation is local as it merely clears an entry from local cache, it does not remove entries from remote caches.
    
    Specified by:
    
    localClear in interface IgniteCache<K,V>
    
    Parameters:
    key - Key to clear.
  - localClearAll
```
public void localClearAll(Set<? extends K> keys)
```
    Clear entries from the cache and swap storage, without notifying listeners or CacheWriters. Entry is cleared only if it is not currently locked, and is not participating in a transaction.
    Note that this operation is local as it merely clears an entry from local cache, it does not remove entries from remote caches.
    
    Specified by:
    
    localClearAll in interface IgniteCache<K,V>
    
    Parameters:
    keys - Keys to clear.
  - invoke
```
public <T> T invoke(K key,
           javax.cache.processor.EntryProcessor<K,V,T> entryProcessor,
           Object... args)
         throws javax.cache.processor.EntryProcessorException
```
    Specified by:
    
    invoke in interface javax.cache.Cache<K,V>
    
    Specified by:
    
    invoke in interface IgniteCache<K,V>
    
    Throws:
    
    javax.cache.processor.EntryProcessorException
  - invoke
```
public <T> T invoke(K key,
           CacheEntryProcessor<K,V,T> entryProcessor,
           Object... args)
         throws javax.cache.processor.EntryProcessorException
```
    Invokes an CacheEntryProcessor against the Cache.Entry specified by the provided key. If an Cache.Entry does not exist for the specified key, an attempt is made to load it (if a loader is configured) or a surrogate Cache.Entry, consisting of the key with a null value is used instead. This method different
    
    Specified by:
    
    invoke in interface IgniteCache<K,V>
    
    Parameters:
    key - the key to the entry
    entryProcessor - the CacheEntryProcessor to invoke
    args - additional arguments to pass to the CacheEntryProcessor
    
    Returns:
    the result of the processing, if any, defined by the CacheEntryProcessor implementation
    
    Throws:
    
    javax.cache.processor.EntryProcessorException - if an exception is thrown by the CacheEntryProcessor, a Caching Implementation must wrap any Exception thrown wrapped in an EntryProcessorException.
    See Also:
    CacheEntryProcessor
  - invokeAll
```
public <T> Map<K,javax.cache.processor.EntryProcessorResult<T>> invokeAll(Set<? extends K> keys,
                                                                 javax.cache.processor.EntryProcessor<K,V,T> entryProcessor,
                                                                 Object... args)
```
    Specified by:
    
    invokeAll in interface javax.cache.Cache<K,V>
    
    Specified by:
    
    invokeAll in interface IgniteCache<K,V>
  - invokeAll
```
public <T> Map<K,javax.cache.processor.EntryProcessorResult<T>> invokeAll(Set<? extends K> keys,
                                                                 CacheEntryProcessor<K,V,T> entryProcessor,
                                                                 Object... args)
```
    Invokes an CacheEntryProcessor against the set of Cache.Entrys specified by the set of keys.
    If an Cache.Entry does not exist for the specified key, an attempt is made to load it (if a loader is configured) or a surrogate Cache.Entry, consisting of the key and a value of null is provided.
    The order that the entries for the keys are processed is undefined. Implementations may choose to process the entries in any order, including concurrently. Furthermore there is no guarantee implementations will use the same CacheEntryProcessor instance to process each entry, as the case may be in a non-local cache topology.
    The result of executing the CacheEntryProcessor is returned as a Map of EntryProcessorResults, one result per key. Should the CacheEntryProcessor or Caching implementation throw an exception, the exception is wrapped and re-thrown when a call to EntryProcessorResult.get() is made.
    
    Specified by:
    
    invokeAll in interface IgniteCache<K,V>
    
    Parameters:
    keys - the set of keys for entries to process
    entryProcessor - the CacheEntryProcessor to invoke
    args - additional arguments to pass to the CacheEntryProcessor
    
    Returns:
    the map of EntryProcessorResults of the processing per key, if any, defined by the CacheEntryProcessor implementation. No mappings will be returned for CacheEntryProcessors that return a null value for a key.
    See Also:
    CacheEntryProcessor
  - invokeAll
```
public <T> Map<K,javax.cache.processor.EntryProcessorResult<T>> invokeAll(Map<? extends K,? extends javax.cache.processor.EntryProcessor<K,V,T>> map,
                                                                 Object... args)
```
    Specified by:
    
    invokeAll in interface IgniteCache<K,V>
    
    Parameters:
    map - Map containing keys and entry processors to be applied to values.
    args - Additional arguments to pass to the EntryProcessor.
    
    Returns:
    The map of EntryProcessorResults of the processing per key, if any, defined by the EntryProcessor implementation. No mappings will be returned for EntryProcessors that return a null value for a key.
  - getName
```
public String getName()
```
    Specified by:
    
    getName in interface javax.cache.Cache<K,V>
  - getCacheManager
```
public CacheManager getCacheManager()
```
    Specified by:
    
    getCacheManager in interface javax.cache.Cache<K,V>
  - setCacheManager
```
public void setCacheManager(CacheManager cacheMgr)
```
    Parameters:
    cacheMgr - Cache manager.
  - close
```
public void close()
```
    Completely deletes the cache with all its data from the system on all cluster nodes.
    
    Specified by:
    
    close in interface Closeable
    
    Specified by:
    
    close in interface AutoCloseable
    
    Specified by:
    
    close in interface javax.cache.Cache<K,V>
    
    Specified by:
    
    close in interface IgniteCache<K,V>
  - isClosed
```
public boolean isClosed()
```
    Specified by:
    
    isClosed in interface javax.cache.Cache<K,V>
  - delegate
```
public IgniteInternalCache delegate()
```
    Returns:
    Proxy delegate.
  - unwrap
```
public <T> T unwrap(Class<T> clazz)
```
    Specified by:
    
    unwrap in interface javax.cache.Cache<K,V>
  - registerCacheEntryListener
```
public void registerCacheEntryListener(javax.cache.configuration.CacheEntryListenerConfiguration<K,V> lsnrCfg)
```
    Specified by:
    
    registerCacheEntryListener in interface javax.cache.Cache<K,V>
  - deregisterCacheEntryListener
```
public void deregisterCacheEntryListener(javax.cache.configuration.CacheEntryListenerConfiguration<K,V> lsnrCfg)
```
    Specified by:
    
    deregisterCacheEntryListener in interface javax.cache.Cache<K,V>
  - iterator
```
public Iterator<javax.cache.Cache.Entry<K,V>> iterator()
```
    Specified by:
    
    iterator in interface Iterable<javax.cache.Cache.Entry<K,V>>
    
    Specified by:
    
    iterator in interface javax.cache.Cache<K,V>
  - createAsyncInstance
```
protected IgniteCache<K,V> createAsyncInstance()
```
    Creates component with asynchronous mode enabled.
    
    Overrides:
    
    createAsyncInstance in class AsyncSupportAdapter<IgniteCache<K,V>>
    
    Returns:
    Component with asynchronous mode enabled.
  - keepPortable
```
public <K1,V1> IgniteCache<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:
    - 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:
```
 IgniteInternalCache 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 (CacheConfiguration#isPortableEnabled() returns true. If not, this method is no-op and will return current projection.
    Returns:
    Projection for portable objects.
  - skipStore
```
public IgniteCache<K,V> skipStore()
```
    Returns:
    Cache with skip store enabled.
  - internalProxy
```
public GridCacheProxyImpl<K,V> internalProxy()
```
    Returns:
    Internal proxy.
  - writeExternal
```
public void writeExternal(ObjectOutput out)
                   throws IOException
```
    Specified by:
    
    writeExternal in interface Externalizable
    
    Throws:
    
    IOException
  - readExternal
```
public void readExternal(ObjectInput in)
                  throws IOException,
                         ClassNotFoundException
```
    Specified by:
    
    readExternal in interface Externalizable
    
    Throws:
    
    IOException
    
    ClassNotFoundException
  - rebalance
```
public IgniteFuture<?> rebalance()
```
    This cache node to re-balance its partitions. This method is usually used when CacheConfiguration.getRebalanceDelay() configuration parameter has non-zero value. When many nodes are started or stopped almost concurrently, it is more efficient to delay rebalancing until the node topology is stable to make sure that no redundant re-partitioning happens.
    In case ofCacheMode.PARTITIONED caches, for better efficiency user should usually make sure that new nodes get placed on the same place of consistent hash ring as the left nodes, and that nodes are restarted before rebalanceDelay expires. To place nodes on the same place in consistent hash ring, use RendezvousAffinityFunction.setHashIdResolver(AffinityNodeHashResolver) to make sure that a node maps to the same hash ID if re-started.
    See CacheConfiguration.getRebalanceDelay() for more information on how to configure rebalance re-partition delay.
    
    Specified by:
    
    rebalance in interface IgniteCache<K,V>
    
    Returns:
    Future that will be completed when rebalancing is finished.
  - toString
```
public String toString()
```
    Overrides:
    
    toString in class Object

Class IgniteCacheProxy<K,V>

Nested Class Summary

Nested classes/interfaces inherited from interface javax.cache.Cache

Field Summary

Fields inherited from class org.apache.ignite.internal.AsyncSupportAdapter

Constructor Summary

Method Summary

Methods inherited from class org.apache.ignite.internal.AsyncSupportAdapter

Methods inherited from class java.lang.Object

Methods inherited from interface org.apache.ignite.IgniteCache

Methods inherited from interface org.apache.ignite.lang.IgniteAsyncSupport

Constructor Detail

IgniteCacheProxy

IgniteCacheProxy

Method Detail

cacheNoGate

context

gate

metrics

metrics

mxBean

getConfiguration

randomEntry

withExpiryPolicy

withSkipStore

loadCache

localLoadCache

getAndPutIfAbsent

Transactions

lock

lockAll

isLocalLocked

query

localEntries

queryMetrics

localEvict

localPeek

Transactions

localPromote

Transactions

size

localSize

get

getAll

getAll

entrySetx

containsKey

containsKeys

loadAll

put

getAndPut

putAll

putIfAbsent

remove

remove

getAndRemove

replace

replace

getAndReplace

removeAll

removeAll

clear

clearAll

clear

localClear

localClearAll

invoke

invoke

invokeAll

invokeAll

invokeAll

getName

getCacheManager

setCacheManager

close

isClosed

delegate

unwrap

registerCacheEntryListener

deregisterCacheEntryListener