org.apache.ignite.internal.processors.cache

## Class IgniteCacheProxy<K,V>

- 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
`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)` Determines if the `Cache` contains entries for the specified 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)`
`Map<K,V>` `getAllOutTx(Set<? extends K> keys)` Gets values from cache.
`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()` Removes all of the mappings from this cache.
`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>`

#### getAllOutTx

    public Map<K,V> getAllOutTx(Set<? extends K> keys)

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

Specified by:
  `getAllOutTx` in interface `IgniteCache<K,V>`
Parameters:
  `keys` - The keys whose associated values are to be returned.
Returns:
  A map of entries that were found for the given keys.

#### 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)

Determines if the `Cache` contains entries for the specified keys.

Specified by:
  `containsKeys` in interface `IgniteCache<K,V>`
Parameters:
  `keys` - Key whose presence in this cache is to be tested.
Returns:
  `True` if this cache contains a mapping for the specified keys.

#### 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()

Removes all of the mappings from this cache.

The order that the individual entries are removed is undefined.

For every mapping that exists the following are called:

- any registered `CacheEntryRemovedListener`s
- if the cache is a write-through cache, the `CacheWriter`

If the cache is empty, the `CacheWriter` is not called.

This operation is not transactional. It calls broadcast closure that deletes all primary keys from remote nodes.

This is potentially an expensive operation as listeners are invoked. Use `IgniteCache.clear()` to avoid this.

Specified by:
  `removeAll` in interface `javax.cache.Cache<K,V>`
Specified by:
  `removeAll` in interface `IgniteCache<K,V>`
See Also:
  `IgniteCache.clear()`, `CacheWriter.deleteAll(java.util.Collection<?>)`

#### clear

    public void clear(K key)

Clear entry from the cache and swap storage, without notifying listeners or `CacheWriter`s. 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 `CacheWriter`s. 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 `CacheWriter`s. 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 `CacheWriter`s. 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.Entry`s 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 `EntryProcessorResult`s, 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 `EntryProcessorResult`s of the processing per key, if any, defined by the `CacheEntryProcessor` implementation. No mappings will be returned for `CacheEntryProcessor`s 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 `EntryProcessorResult`s of the processing per key, if any, defined by the `EntryProcessor` implementation. No mappings will be returned for `EntryProcessor`s 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 `String`s
- `UUID` and array of `UUID`s
- `Date` and array of `Date`s
- `Timestamp` and array of `Timestamp`s
- 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<Integer, GridPortableObject> 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 of`CacheMode.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`

2015 Copyright © Apache Software Foundation

Follow @ApacheIgnite

Ignite Fabric | : ver. 1.2.0-incubating
Release Date | : June 16 2015