HibernateCacheProxy (Ignite 2.7.2)

java.lang.Object
- org.apache.ignite.cache.hibernate.HibernateCacheProxy

All Implemented Interfaces:

Iterable<javax.cache.Cache.Entry<Object,Object>>, org.apache.ignite.internal.processors.cache.IgniteInternalCache<Object,Object>
```
public class HibernateCacheProxy
extends Object
implements org.apache.ignite.internal.processors.cache.IgniteInternalCache<Object,Object>
```
Hibernate cache proxy used to substitute hibernate keys with ignite keys.

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`Affinity`	`affinity()` Gets affinity service to provide information about data partitioning and distribution.
`org.apache.ignite.internal.processors.cache.IgniteInternalCache`	`cache()` Gets base cache for this projection.
`void`	`clear()` Clears cache on all nodes that store it's data.
`void`	`clear(Object key)` Clears key on all nodes that store it's data.
`void`	`clearAll(Set keys)` Clears keys on all nodes that store it's data.
`org.apache.ignite.internal.IgniteInternalFuture<?>`	`clearAllAsync(Set keys)`
`org.apache.ignite.internal.IgniteInternalFuture<?>`	`clearAsync()`
`org.apache.ignite.internal.IgniteInternalFuture<?>`	`clearAsync(Object key)`
`void`	`clearLocally(boolean srv, boolean near, boolean readers)` Clears all entries from this cache only if the entry is not currently locked or participating in a transaction.
`boolean`	`clearLocally(Object key)` Clears an entry from this cache and swap storage only if the entry is not currently locked, and is not participating in a transaction.
`void`	`clearLocallyAll(Set keys, boolean srv, boolean near, boolean readers)` Clears entries from this cache and swap storage only if the entry is not currently locked, and is not participating in a transaction.
`CacheMetrics`	`clusterMetrics()` Gets whole cluster metrics (statistics) for this cache.
`CacheMetrics`	`clusterMetrics(ClusterGroup grp)` Gets cluster group metrics (statistics) for this cache.
`CacheMetricsMXBean`	`clusterMxBean()` Gets whole cluster metrics (statistics) for this cache.
`CacheConfiguration`	`configuration()` Gets configuration bean for this cache.
`boolean`	`containsKey(Object key)`
`org.apache.ignite.internal.IgniteInternalFuture<Boolean>`	`containsKeyAsync(Object key)`
`boolean`	`containsKeys(Collection keys)`
`org.apache.ignite.internal.IgniteInternalFuture<Boolean>`	`containsKeysAsync(Collection keys)`
`org.apache.ignite.internal.processors.cache.GridCacheContext`	`context()`
`Set<javax.cache.Cache.Entry<Object,Object>>`	`entrySet()` Gets set of all entries cached on this node.
`boolean`	`evict(Object key)` Evicts entry associated with given key from cache.
`void`	`evictAll(@Nullable Collection keys)` Attempts to evict all entries associated with keys.
`@Nullable javax.cache.expiry.ExpiryPolicy`	`expiry()`
`org.apache.ignite.internal.processors.cache.IgniteInternalCache`	`forSubjectId(UUID subjId)` Creates projection for specified subject ID.
`@Nullable Object`	`get(Object key)` Retrieves value mapped to the specified key from cache.
`Map`	`getAll(@Nullable Collection keys)` Retrieves values mapped to the specified keys from cache.
`org.apache.ignite.internal.IgniteInternalFuture<Map<Object,Object>>`	`getAllAsync(@Nullable Collection keys)` Asynchronously retrieves values mapped to the specified keys from cache.
`Map`	`getAllOutTx(Set keys)` Gets values from cache.
`org.apache.ignite.internal.IgniteInternalFuture<Map<Object,Object>>`	`getAllOutTxAsync(Set keys)` Gets values from cache.
`@Nullable Object`	`getAndPut(Object key, Object val)` Stores given key-value pair in cache.
`org.apache.ignite.internal.IgniteInternalFuture`	`getAndPutAsync(Object key, Object val)` Asynchronously stores given key-value pair in cache.
`@Nullable Object`	`getAndPutIfAbsent(Object key, Object val)` Stores given key-value pair in cache only if cache had no previous mapping for it.
`org.apache.ignite.internal.IgniteInternalFuture`	`getAndPutIfAbsentAsync(Object key, Object val)` Asynchronously stores given key-value pair in cache only if cache had no previous mapping for it.
`@Nullable Object`	`getAndRemove(Object key)` Removes given key mapping from cache.
`org.apache.ignite.internal.IgniteInternalFuture`	`getAndRemoveAsync(Object key)` Asynchronously removes given key mapping from cache.
`@Nullable Object`	`getAndReplace(Object key, Object val)` Stores given key-value pair in cache only if there is a previous mapping for it.
`org.apache.ignite.internal.IgniteInternalFuture`	`getAndReplaceAsync(Object key, Object val)` Asynchronously stores given key-value pair in cache only if there is a previous mapping for it.
`org.apache.ignite.internal.IgniteInternalFuture`	`getAsync(Object key)` Asynchronously retrieves value mapped to the specified key from cache.
`Collection<CacheEntry<Object,Object>>`	`getEntries(@Nullable Collection keys)` Retrieves values mapped to the specified keys from cache.
`org.apache.ignite.internal.IgniteInternalFuture<Collection<CacheEntry<Object,Object>>>`	`getEntriesAsync(@Nullable Collection keys)` Asynchronously retrieves values mapped to the specified keys from cache.
`@Nullable CacheEntry`	`getEntry(Object key)` Retrieves value mapped to the specified key from cache.
`org.apache.ignite.internal.IgniteInternalFuture<CacheEntry<Object,Object>>`	`getEntryAsync(Object key)` Asynchronously retrieves value mapped to the specified key from cache.
`@Nullable Object`	`getForcePrimary(Object key)` Gets value from cache.
`org.apache.ignite.internal.IgniteInternalFuture`	`getForcePrimaryAsync(Object key)` Asynchronously gets value from cache.
`long`	`igfsDataSpaceUsed()` Get current amount of used IGFS space in bytes.
`@Nullable javax.cache.processor.EntryProcessorResult`	`invoke(@Nullable org.apache.ignite.internal.processors.affinity.AffinityTopologyVersion topVer, Object key, javax.cache.processor.EntryProcessor entryProcessor, Object... args)`
`@Nullable javax.cache.processor.EntryProcessorResult`	`invoke(Object key, javax.cache.processor.EntryProcessor entryProcessor, Object... args)`
`Map`	`invokeAll(Map map, Object... args)`
`Map`	`invokeAll(Set keys, javax.cache.processor.EntryProcessor entryProcessor, Object... args)`
`org.apache.ignite.internal.IgniteInternalFuture<Map>`	`invokeAllAsync(Map map, Object... args)`
`org.apache.ignite.internal.IgniteInternalFuture<Map>`	`invokeAllAsync(Set keys, javax.cache.processor.EntryProcessor entryProcessor, Object... args)`
`org.apache.ignite.internal.IgniteInternalFuture<javax.cache.processor.EntryProcessorResult>`	`invokeAsync(Object key, javax.cache.processor.EntryProcessor entryProcessor, Object... args)`
`boolean`	`isEmpty()` Returns `true` if this map contains no key-value mappings.
`boolean`	`isIgfsDataCache()` Checks whether this cache is IGFS data cache.
`boolean`	`isLocked(Object key)` Checks if any node owns a lock for this key.
`boolean`	`isLockedByThread(Object key)` Checks if current thread owns a lock on this key.
`Iterator`	`iterator()`
`org.apache.ignite.internal.processors.cache.IgniteInternalCache`	`keepBinary()` Creates projection that will operate with binary objects.
`Set`	`keySet()` Set of keys cached on this node.
`HibernateKeyTransformer`	`keyTransformer()`
`Iterable<javax.cache.Cache.Entry<Object,Object>>`	`localEntries(CachePeekMode[] peekModes)`
`void`	`localLoadCache(@Nullable IgniteBiPredicate p, Object... args)` Delegates to `CacheStore.loadCache(IgniteBiInClosure, Object...)` method to load state from the underlying persistent storage.
`org.apache.ignite.internal.IgniteInternalFuture<?>`	`localLoadCacheAsync(@Nullable IgniteBiPredicate p, Object... args)` Asynchronously delegates to `CacheStore.loadCache(IgniteBiInClosure, Object...)` method to reload state from the underlying persistent storage.
`CacheMetrics`	`localMetrics()` Gets local metrics (statistics) for this cache.
`CacheMetricsMXBean`	`localMxBean()` Gets local metrics (statistics) for this cache.
`@Nullable Object`	`localPeek(Object key, CachePeekMode[] peekModes)`
`boolean`	`localPreloadPartition(int part)` Preloads cache partition if it exists on local node.
`int`	`localSize(CachePeekMode[] peekModes)`
`long`	`localSizeLong(CachePeekMode[] peekModes)`
`long`	`localSizeLong(int partition, CachePeekMode[] peekModes)`
`boolean`	`lock(Object key, long timeout)` Synchronously acquires lock on a cached object with given key only if the passed in filter (if any) passes.
`boolean`	`lockAll(@Nullable Collection keys, long timeout)` All or nothing synchronous lock for passed in keys.
`org.apache.ignite.internal.IgniteInternalFuture<Boolean>`	`lockAllAsync(@Nullable Collection keys, long timeout)` All or nothing synchronous lock for passed in keys.
`org.apache.ignite.internal.IgniteInternalFuture<Boolean>`	`lockAsync(Object key, long timeout)` Asynchronously acquires lock on a cached object with given key only if the passed in filter (if any) passes.
`Collection<Integer>`	`lostPartitions()`
`String`	`name()` Gets name of this cache (`null` for default cache).
`int`	`nearSize()` Gets size of near cache key set.
`long`	`offHeapAllocatedSize()` Gets memory size allocated in off-heap.
`long`	`offHeapEntriesCount()` Gets number of cache entries stored in off-heap memory.
`void`	`preloadPartition(int part)` Preload cache partition.
`org.apache.ignite.internal.IgniteInternalFuture<?>`	`preloadPartitionAsync(int part)` Preload cache partition.
`int`	`primarySize()` Gets the number of all primary entries cached on this node.
`long`	`primarySizeLong()` Gets the number of all primary entries cached on this node as a long value.
`boolean`	`put(Object key, Object val)` Stores given key-value pair in cache.
`void`	`putAll(@Nullable Map m)` Stores given key-value pairs in cache.
`org.apache.ignite.internal.IgniteInternalFuture<?>`	`putAllAsync(@Nullable Map m)` Asynchronously stores given key-value pairs in cache.
`void`	`putAllConflict(Map drMap)` Store DR data.
`org.apache.ignite.internal.IgniteInternalFuture<?>`	`putAllConflictAsync(Map drMap)` Store DR data asynchronously.
`org.apache.ignite.internal.IgniteInternalFuture<Boolean>`	`putAsync(Object key, Object val)` Stores given key-value pair in cache.
`boolean`	`putIfAbsent(Object key, Object val)` Stores given key-value pair in cache only if cache had no previous mapping for it.
`org.apache.ignite.internal.IgniteInternalFuture<Boolean>`	`putIfAbsentAsync(Object key, Object val)` Asynchronously stores given key-value pair in cache only if cache had no previous mapping for it.
`org.apache.ignite.internal.IgniteInternalFuture<?>`	`rebalance()` Forces this cache node to re-balance its partitions.
`boolean`	`remove(Object key)` Removes given key mapping from cache.
`boolean`	`remove(Object key, Object val)` Removes given key mapping from cache if one exists and value is equal to the passed in value.
`void`	`removeAll()` Removes mappings from cache.
`void`	`removeAll(@Nullable Collection keys)` Removes given key mappings from cache.
`org.apache.ignite.internal.IgniteInternalFuture<?>`	`removeAllAsync()`
`org.apache.ignite.internal.IgniteInternalFuture<?>`	`removeAllAsync(@Nullable Collection keys)` Asynchronously removes given key mappings from cache for entries.
`void`	`removeAllConflict(Map drMap)` Removes DR data.
`org.apache.ignite.internal.IgniteInternalFuture<?>`	`removeAllConflictAsync(Map drMap)` Removes DR data asynchronously.
`org.apache.ignite.internal.IgniteInternalFuture<Boolean>`	`removeAsync(Object key)` Asynchronously removes given key mapping from cache.
`org.apache.ignite.internal.IgniteInternalFuture<Boolean>`	`removeAsync(Object key, Object val)` Asynchronously removes given key mapping from cache if one exists and value is equal to the passed in value.
`boolean`	`replace(Object key, Object val)` Stores given key-value pair in cache only if only if there is a previous mapping for it.
`boolean`	`replace(Object key, Object oldVal, Object newVal)` Stores given key-value pair in cache only if only if the previous value is equal to the `'oldVal'` passed in.
`org.apache.ignite.internal.IgniteInternalFuture<Boolean>`	`replaceAsync(Object key, Object val)` Asynchronously stores given key-value pair in cache only if only if there is a previous mapping for it.
`org.apache.ignite.internal.IgniteInternalFuture<Boolean>`	`replaceAsync(Object key, Object oldVal, Object newVal)` Asynchronously stores given key-value pair in cache only if only if the previous value is equal to the `'oldVal'` passed in.
`Iterator<javax.cache.Cache.Entry<Object,Object>>`	`scanIterator(boolean keepBinary, @Nullable IgniteBiPredicate p)`
`org.apache.ignite.internal.processors.cache.IgniteInternalCache`	`setSkipStore(boolean skipStore)`
`int`	`size()` Gets the number of all entries cached on this node.
`int`	`size(CachePeekMode[] peekModes)`
`org.apache.ignite.internal.IgniteInternalFuture<Integer>`	`sizeAsync(CachePeekMode[] peekModes)`
`long`	`sizeLong()` Gets the number of all entries cached on this node as a long value.
`long`	`sizeLong(CachePeekMode[] peekModes)`
`long`	`sizeLong(int partition, CachePeekMode[] peekModes)`
`org.apache.ignite.internal.IgniteInternalFuture<Long>`	`sizeLongAsync(CachePeekMode[] peekModes)`
`org.apache.ignite.internal.IgniteInternalFuture<Long>`	`sizeLongAsync(int partition, CachePeekMode[] peekModes)`
`boolean`	`skipStore()`
`@Nullable org.apache.ignite.internal.processors.cache.distributed.near.GridNearTxLocal`	`tx()` Gets transaction started by this thread or `null` if this thread does not have a transaction.
`Transaction`	`txStart(TransactionConcurrency concurrency, TransactionIsolation isolation)` Starts new transaction with the specified concurrency and isolation.
`Transaction`	`txStart(TransactionConcurrency concurrency, TransactionIsolation isolation, long timeout, int txSize)` Starts transaction with specified isolation, concurrency, timeout, invalidation flag, and number of participating entries.
`org.apache.ignite.internal.processors.cache.distributed.near.GridNearTxLocal`	`txStartEx(TransactionConcurrency concurrency, TransactionIsolation isolation)`
`void`	`unlock(Object key)` Unlocks given key only if current thread owns the lock.
`void`	`unlockAll(@Nullable Collection keys)` Unlocks given keys only if current thread owns the locks.
`<K1,V1> org.apache.ignite.internal.processors.cache.IgniteInternalCache<K1,V1>`	`withAllowAtomicOpsInTx()`
`org.apache.ignite.internal.processors.cache.IgniteInternalCache`	`withExpiryPolicy(javax.cache.expiry.ExpiryPolicy plc)`
`org.apache.ignite.internal.processors.cache.IgniteInternalCache`	`withNoRetries()`

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

Methods inherited from interface java.lang.Iterable
forEach, spliterator

- Method Detail
  - keyTransformer
```
public HibernateKeyTransformer keyTransformer()
```
    Returns:
    
    HibernateKeyTransformer
  - name
```
public String name()
```
    Gets name of this cache (null for default cache).
    
    Specified by:
    
    name in interface org.apache.ignite.internal.processors.cache.IgniteInternalCache<Object,Object>
    
    Returns:
    
    Cache name.
  - skipStore
```
public boolean skipStore()
```
    Specified by:
    
    skipStore in interface org.apache.ignite.internal.processors.cache.IgniteInternalCache<Object,Object>
    
    Returns:
    
    Skip store.
  - setSkipStore
```
public org.apache.ignite.internal.processors.cache.IgniteInternalCache setSkipStore(boolean skipStore)
```
    Specified by:
    
    setSkipStore in interface org.apache.ignite.internal.processors.cache.IgniteInternalCache<Object,Object>
    
    Parameters:
    
    skipStore - Skip store flag.
    
    Returns:
    
    New internal cache instance based on this one, but with skip store flag enabled.
  - isEmpty
```
public boolean isEmpty()
```
    Returns true if this map contains no key-value mappings.
    
    Specified by:
    
    isEmpty in interface org.apache.ignite.internal.processors.cache.IgniteInternalCache<Object,Object>
    
    Returns:
    
    true if this map contains no key-value mappings.
  - containsKey
```
public boolean containsKey(Object key)
```
    Specified by:
    
    containsKey in interface org.apache.ignite.internal.processors.cache.IgniteInternalCache<Object,Object>
    
    Parameters:
    
    key - Key.
    
    Returns:
    
    True if cache contains mapping for a given key.
  - containsKeyAsync
```
public org.apache.ignite.internal.IgniteInternalFuture<Boolean> containsKeyAsync(Object key)
```
    Specified by:
    
    containsKeyAsync in interface org.apache.ignite.internal.processors.cache.IgniteInternalCache<Object,Object>
    
    Parameters:
    
    key - Key.
    
    Returns:
    
    Future.
  - containsKeys
```
public boolean containsKeys(Collection keys)
```
    Specified by:
    
    containsKeys in interface org.apache.ignite.internal.processors.cache.IgniteInternalCache<Object,Object>
    
    Parameters:
    
    keys - Keys,
    
    Returns:
    
    True if cache contains all keys.
  - containsKeysAsync
```
public org.apache.ignite.internal.IgniteInternalFuture<Boolean> containsKeysAsync(Collection keys)
```
    Specified by:
    
    containsKeysAsync in interface org.apache.ignite.internal.processors.cache.IgniteInternalCache<Object,Object>
    
    Parameters:
    
    keys - Keys to check.
    
    Returns:
    
    Future.
  - localPeek
```
@Nullable
public @Nullable Object localPeek(Object key,
                                            CachePeekMode[] peekModes)
                                     throws IgniteCheckedException
```
    Specified by:
    
    localPeek in interface org.apache.ignite.internal.processors.cache.IgniteInternalCache<Object,Object>
    
    Parameters:
    
    key - Key.
    
    peekModes - Peek modes.
    
    Returns:
    
    Value.
    
    Throws:
    
    IgniteCheckedException - If failed.
  - localEntries
```
public Iterable<javax.cache.Cache.Entry<Object,Object>> localEntries(CachePeekMode[] peekModes)
                                                              throws IgniteCheckedException
```
    Specified by:
    
    localEntries in interface org.apache.ignite.internal.processors.cache.IgniteInternalCache<Object,Object>
    
    Parameters:
    
    peekModes - Peek modes.
    
    Returns:
    
    Entries iterable.
    
    Throws:
    
    IgniteCheckedException - If failed.
  - get
```
@Nullable
public @Nullable Object get(Object key)
                               throws IgniteCheckedException
```
    Retrieves value mapped to the specified key from cache. Value will only be returned if its entry passed the optional filter provided. Filter check is atomic, and therefore the returned value is guaranteed to be consistent with the filter. The return value of null means entry did not pass the provided filter or cache has no mapping for the key.
    If the value is not present in cache, then it will be looked up from swap storage. If it's not present in swap, or if swap is disable, and if read-through is allowed, value will be loaded from CacheStore persistent storage via CacheStore#load(Transaction, Object) method.
    Transactions
    This method is transactional and will enlist the entry into ongoing transaction if there is one.
    
    Specified by:
    
    get in interface org.apache.ignite.internal.processors.cache.IgniteInternalCache<Object,Object>
    
    Parameters:
    
    key - Key to retrieve the value for.
    
    Returns:
    
    Value for the given key.
    
    Throws:
    
    IgniteCheckedException - If get operation failed.
  - getEntry
```
@Nullable
public @Nullable CacheEntry getEntry(Object key)
                                        throws IgniteCheckedException
```
    Retrieves value mapped to the specified key from cache. Value will only be returned if its entry passed the optional filter provided. Filter check is atomic, and therefore the returned value is guaranteed to be consistent with the filter. The return value of null means entry did not pass the provided filter or cache has no mapping for the key.
    If the value is not present in cache, then it will be looked up from swap storage. If it's not present in swap, or if swap is disable, and if read-through is allowed, value will be loaded from CacheStore persistent storage via CacheStore#load(Transaction, Object) method.
    Transactions
    This method is transactional and will enlist the entry into ongoing transaction if there is one.
    
    Specified by:
    
    getEntry in interface org.apache.ignite.internal.processors.cache.IgniteInternalCache<Object,Object>
    
    Parameters:
    
    key - Key to retrieve the value for.
    
    Returns:
    
    Value for the given key.
    
    Throws:
    
    IgniteCheckedException - If get operation failed.
  - getAsync
```
public org.apache.ignite.internal.IgniteInternalFuture getAsync(Object key)
```
    Asynchronously retrieves value mapped to the specified key from cache. Value will only be returned if its entry passed the optional filter provided. Filter check is atomic, and therefore the returned value is guaranteed to be consistent with the filter. The return value of null means entry did not pass the provided filter or cache has no mapping for the key.
    If the value is not present in cache, then it will be looked up from swap storage. If it's not present in swap, or if swap is disabled, and if read-through is allowed, value will be loaded from CacheStore persistent storage via CacheStore#load(Transaction, Object) method.
    Transactions
    This method is transactional and will enlist the entry into ongoing transaction if there is one.
    
    Specified by:
    
    getAsync in interface org.apache.ignite.internal.processors.cache.IgniteInternalCache<Object,Object>
    
    Parameters:
    
    key - Key for the value to get.
    
    Returns:
    
    Future for the get operation.
  - getEntryAsync
```
public org.apache.ignite.internal.IgniteInternalFuture<CacheEntry<Object,Object>> getEntryAsync(Object key)
```
    Asynchronously retrieves value mapped to the specified key from cache. Value will only be returned if its entry passed the optional filter provided. Filter check is atomic, and therefore the returned value is guaranteed to be consistent with the filter. The return value of null means entry did not pass the provided filter or cache has no mapping for the key.
    If the value is not present in cache, then it will be looked up from swap storage. If it's not present in swap, or if swap is disabled, and if read-through is allowed, value will be loaded from CacheStore persistent storage via CacheStore#load(Transaction, Object) method.
    Transactions
    This method is transactional and will enlist the entry into ongoing transaction if there is one.
    
    Specified by:
    
    getEntryAsync in interface org.apache.ignite.internal.processors.cache.IgniteInternalCache<Object,Object>
    
    Parameters:
    
    key - Key for the value to get.
    
    Returns:
    
    Future for the get operation.
  - getAll
```
public Map getAll(@Nullable
                  @Nullable Collection keys)
           throws IgniteCheckedException
```
    Retrieves values mapped to the specified keys from cache. Value will only be returned if its entry passed the optional filter provided. Filter check is atomic, and therefore the returned value is guaranteed to be consistent with the filter. If requested key-value pair is not present in the returned map, then it means that its entry did not pass the provided filter or cache has no mapping for the key.
    If some value is not present in cache, then it will be looked up from swap storage. If it's not present in swap, or if swap is disabled, and if read-through is allowed, value will be loaded from CacheStore persistent storage via CacheStore#loadAll(Transaction, Collection, org.apache.ignite.lang.IgniteBiInClosure) method.
    Transactions
    This method is transactional and will enlist the entry into ongoing transaction if there is one.
    
    Specified by:
    
    getAll in interface org.apache.ignite.internal.processors.cache.IgniteInternalCache<Object,Object>
    
    Parameters:
    
    keys - Keys to get.
    
    Returns:
    
    Map of key-value pairs.
    
    Throws:
    
    IgniteCheckedException - If get operation failed.
  - getEntries
```
public Collection<CacheEntry<Object,Object>> getEntries(@Nullable
                                                        @Nullable Collection keys)
                                                 throws IgniteCheckedException
```
    Retrieves values mapped to the specified keys from cache. Value will only be returned if its entry passed the optional filter provided. Filter check is atomic, and therefore the returned value is guaranteed to be consistent with the filter. If requested key-value pair is not present in the returned map, then it means that its entry did not pass the provided filter or cache has no mapping for the key.
    If some value is not present in cache, then it will be looked up from swap storage. If it's not present in swap, or if swap is disabled, and if read-through is allowed, value will be loaded from CacheStore persistent storage via CacheStore#loadAll(Transaction, Collection, org.apache.ignite.lang.IgniteBiInClosure) method.
    Transactions
    This method is transactional and will enlist the entry into ongoing transaction if there is one.
    
    Specified by:
    
    getEntries in interface org.apache.ignite.internal.processors.cache.IgniteInternalCache<Object,Object>
    
    Parameters:
    
    keys - Keys to get.
    
    Returns:
    
    Map of key-value pairs.
    
    Throws:
    
    IgniteCheckedException - If get operation failed.
  - getAllAsync
```
public org.apache.ignite.internal.IgniteInternalFuture<Map<Object,Object>> getAllAsync(@Nullable
                                                                                       @Nullable Collection keys)
```
    Asynchronously retrieves values mapped to the specified keys from cache. Value will only be returned if its entry passed the optional filter provided. Filter check is atomic, and therefore the returned value is guaranteed to be consistent with the filter. If requested key-value pair is not present in the returned map, then it means that its entry did not pass the provided filter or cache has no mapping for the key.
    If some value is not present in cache, then it will be looked up from swap storage. If it's not present in swap, or if swap is disabled, and if read-through is allowed, value will be loaded from CacheStore persistent storage via CacheStore#loadAll(Transaction, Collection, org.apache.ignite.lang.IgniteBiInClosure) method.
    Transactions
    This method is transactional and will enlist the entry into ongoing transaction if there is one.
    
    Specified by:
    
    getAllAsync in interface org.apache.ignite.internal.processors.cache.IgniteInternalCache<Object,Object>
    
    Parameters:
    
    keys - Key for the value to get.
    
    Returns:
    
    Future for the get operation.
  - getEntriesAsync
```
public org.apache.ignite.internal.IgniteInternalFuture<Collection<CacheEntry<Object,Object>>> getEntriesAsync(@Nullable
                                                                                                              @Nullable Collection keys)
```
    Asynchronously retrieves values mapped to the specified keys from cache. Value will only be returned if its entry passed the optional filter provided. Filter check is atomic, and therefore the returned value is guaranteed to be consistent with the filter. If requested key-value pair is not present in the returned map, then it means that its entry did not pass the provided filter or cache has no mapping for the key.
    If some value is not present in cache, then it will be looked up from swap storage. If it's not present in swap, or if swap is disabled, and if read-through is allowed, value will be loaded from CacheStore persistent storage via CacheStore#loadAll(Transaction, Collection, org.apache.ignite.lang.IgniteBiInClosure) method.
    Transactions
    This method is transactional and will enlist the entry into ongoing transaction if there is one.
    
    Specified by:
    
    getEntriesAsync in interface org.apache.ignite.internal.processors.cache.IgniteInternalCache<Object,Object>
    
    Parameters:
    
    keys - Key for the value to get.
    
    Returns:
    
    Future for the get operation.
  - getAndPut
```
@Nullable
public @Nullable Object getAndPut(Object key,
                                            Object val)
                                     throws IgniteCheckedException
```
    Stores given key-value pair in cache. If filters are provided, then entries will be stored in cache only if they pass the filter. Note that filter check is atomic, so value stored in cache is guaranteed to be consistent with the filters. If cache previously contained value for the given key, then this value is returned. In case of CacheMode.PARTITIONED or CacheMode.REPLICATED caches, the value will be loaded from the primary node, which in its turn may load the value from the swap storage, and consecutively, if it's not in swap, from the underlying persistent storage. If value has to be loaded from persistent storage, CacheStore#load(Transaction, Object) method will be used.
    If the returned value is not needed, method #putx(Object, Object, org.apache.ignite.lang.IgnitePredicate[]) should always be used instead of this one to avoid the overhead associated with returning of the previous value.
    If write-through is enabled, the stored value will be persisted to CacheStore via CacheStore#put(Transaction, Object, Object) method.
    Transactions
    This method is transactional and will enlist the entry into ongoing transaction if there is one.
    
    Specified by:
    
    getAndPut in interface org.apache.ignite.internal.processors.cache.IgniteInternalCache<Object,Object>
    
    Parameters:
    
    key - Key to store in cache.
    
    val - Value to be associated with the given key.
    
    Returns:
    
    Previous value associated with specified key, or null if entry did not pass the filter, or if there was no mapping for the key in swap or in persistent storage.
    
    Throws:
    
    IgniteCheckedException - If put operation failed.
  - getAndPutAsync
```
public org.apache.ignite.internal.IgniteInternalFuture getAndPutAsync(Object key,
                                                                      Object val)
```
    Asynchronously stores given key-value pair in cache. If filters are provided, then entries will be stored in cache only if they pass the filter. Note that filter check is atomic, so value stored in cache is guaranteed to be consistent with the filters. If cache previously contained value for the given key, then this value is returned. Otherwise, in case of CacheMode.REPLICATED caches, the value will be loaded from swap and, if it's not there, and read-through is allowed, from the underlying CacheStore storage. In case of CacheMode.PARTITIONED caches, the value will be loaded from the primary node, which in its turn may load the value from the swap storage, and consecutively, if it's not in swap and read-through is allowed, from the underlying persistent storage. If value has to be loaded from persistent storage, CacheStore#load(Transaction, Object) method will be used.
    If the returned value is not needed, method #putx(Object, Object, org.apache.ignite.lang.IgnitePredicate[]) should always be used instead of this one to avoid the overhead associated with returning of the previous value.
    If write-through is enabled, the stored value will be persisted to CacheStore via CacheStore#put(Transaction, Object, Object) method.
    Transactions
    This method is transactional and will enlist the entry into ongoing transaction if there is one.
    
    Specified by:
    
    getAndPutAsync in interface org.apache.ignite.internal.processors.cache.IgniteInternalCache<Object,Object>
    
    Parameters:
    
    key - Key to store in cache.
    
    val - Value to be associated with the given key.
    
    Returns:
    
    Future for the put operation.
  - put
```
public boolean put(Object key,
                   Object val)
            throws IgniteCheckedException
```
    Stores given key-value pair in cache. If filters are provided, then entries will be stored in cache only if they pass the filter. Note that filter check is atomic, so value stored in cache is guaranteed to be consistent with the filters.
    This method will return true if value is stored in cache and false otherwise. Unlike #put(Object, Object, org.apache.ignite.lang.IgnitePredicate[]) method, it does not return previous value and, therefore, does not have any overhead associated with returning a value. It should be used whenever return value is not required.
    If write-through is enabled, the stored value will be persisted to CacheStore via CacheStore#put(Transaction, Object, Object) method.
    Transactions
    This method is transactional and will enlist the entry into ongoing transaction if there is one.
    
    Specified by:
    
    put in interface org.apache.ignite.internal.processors.cache.IgniteInternalCache<Object,Object>
    
    Parameters:
    
    key - Key to store in cache.
    
    val - Value to be associated with the given key.
    
    Returns:
    
    True if optional filter passed and value was stored in cache, false otherwise. Note that this method will return true if filter is not specified.
    
    Throws:
    
    IgniteCheckedException - If put operation failed.
  - putAsync
```
public org.apache.ignite.internal.IgniteInternalFuture<Boolean> putAsync(Object key,
                                                                         Object val)
```
    Stores given key-value pair in cache. If filters are provided, then entries will be stored in cache only if they pass the filter. Note that filter check is atomic, so value stored in cache is guaranteed to be consistent with the filters.
    This method will return true if value is stored in cache and false otherwise. Unlike #put(Object, Object, org.apache.ignite.lang.IgnitePredicate[]) method, it does not return previous value and, therefore, does not have any overhead associated with returning of a value. It should always be used whenever return value is not required.
    If write-through is enabled, the stored value will be persisted to CacheStore via CacheStore#put(Transaction, Object, Object) method.
    Transactions
    This method is transactional and will enlist the entry into ongoing transaction if there is one.
    
    Specified by:
    
    putAsync in interface org.apache.ignite.internal.processors.cache.IgniteInternalCache<Object,Object>
    
    Parameters:
    
    key - Key to store in cache.
    
    val - Value to be associated with the given key.
    
    Returns:
    
    Future for the put operation. Future will return true if optional filter passed and value was stored in cache, false otherwise. Note that future will return true if filter is not specified.
  - getAndPutIfAbsent
```
@Nullable
public @Nullable Object getAndPutIfAbsent(Object key,
                                                    Object val)
                                             throws IgniteCheckedException
```
    Stores given key-value pair in cache only if cache had no previous mapping for it. If cache previously contained value for the given key, then this value is returned. In case of CacheMode.PARTITIONED or CacheMode.REPLICATED caches, the value will be loaded from the primary node, which in its turn may load the value from the swap storage, and consecutively, if it's not in swap, from the underlying persistent storage. If value has to be loaded from persistent storage, CacheStore#load(Transaction, Object) method will be used.
    If the returned value is not needed, method IgniteInternalCache.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 CacheStore#put(Transaction, Object, Object) method.
    Transactions
    This method is transactional and will enlist the entry into ongoing transaction if there is one.
    
    Specified by:
    
    getAndPutIfAbsent in interface org.apache.ignite.internal.processors.cache.IgniteInternalCache<Object,Object>
    
    Parameters:
    
    key - Key to store in cache.
    
    val - Value to be associated with the given key.
    
    Returns:
    
    Previously contained value regardless of whether put happened or not.
    
    Throws:
    
    IgniteCheckedException - If put operation failed.
  - getAndPutIfAbsentAsync
```
public org.apache.ignite.internal.IgniteInternalFuture getAndPutIfAbsentAsync(Object key,
                                                                              Object val)
```
    Asynchronously stores given key-value pair in cache only if cache had no previous mapping for it. If cache previously contained value for the given key, then this value is returned. In case of CacheMode.PARTITIONED or CacheMode.REPLICATED caches, the value will be loaded from the primary node, which in its turn may load the value from the swap storage, and consecutively, if it's not in swap, from the underlying persistent storage. If value has to be loaded from persistent storage, CacheStore#load(Transaction, Object) method will be used.
    If the returned value is not needed, method IgniteInternalCache.putIfAbsentAsync(Object, Object) should always be used instead of this one to avoid the overhead associated with returning of the previous value.
    If write-through is enabled, the stored value will be persisted to CacheStore via CacheStore#put(Transaction, Object, Object) method.
    Transactions
    This method is transactional and will enlist the entry into ongoing transaction if there is one.
    
    Specified by:
    
    getAndPutIfAbsentAsync in interface org.apache.ignite.internal.processors.cache.IgniteInternalCache<Object,Object>
    
    Parameters:
    
    key - Key to store in cache.
    
    val - Value to be associated with the given key.
    
    Returns:
    
    Future of put operation which will provide previously contained value regardless of whether put happened or not.
  - putIfAbsent
```
public boolean putIfAbsent(Object key,
                           Object val)
                    throws IgniteCheckedException
```
    Stores given key-value pair in cache only if cache had no previous mapping for it.
    This method will return true if value is stored in cache and false otherwise. Unlike IgniteInternalCache.getAndPutIfAbsent(Object, Object) method, it does not return previous value and, therefore, does not have any overhead associated with returning of a value. It should always be used whenever return value is not required.
    If write-through is enabled, the stored value will be persisted to CacheStore via CacheStore#put(Transaction, Object, Object) method.
    Transactions
    This method is transactional and will enlist the entry into ongoing transaction if there is one.
    
    Specified by:
    
    putIfAbsent in interface org.apache.ignite.internal.processors.cache.IgniteInternalCache<Object,Object>
    
    Parameters:
    
    key - Key to store in cache.
    
    val - Value to be associated with the given key.
    
    Returns:
    
    true if value is stored in cache and false otherwise.
    
    Throws:
    
    IgniteCheckedException - If put operation failed.
  - putIfAbsentAsync
```
public org.apache.ignite.internal.IgniteInternalFuture<Boolean> putIfAbsentAsync(Object key,
                                                                                 Object val)
```
    Asynchronously stores given key-value pair in cache only if cache had no previous mapping for it.
    This method will return true if value is stored in cache and false otherwise. Unlike IgniteInternalCache.getAndPutIfAbsent(Object, Object) method, it does not return previous value and, therefore, does not have any overhead associated with returning of a value. It should always be used whenever return value is not required.
    If write-through is enabled, the stored value will be persisted to CacheStore via CacheStore#put(Transaction, Object, Object) method.
    Transactions
    This method is transactional and will enlist the entry into ongoing transaction if there is one.
    
    Specified by:
    
    putIfAbsentAsync in interface org.apache.ignite.internal.processors.cache.IgniteInternalCache<Object,Object>
    
    Parameters:
    
    key - Key to store in cache.
    
    val - Value to be associated with the given key.
    
    Returns:
    
    Future for this put operation.
  - getAndReplace
```
@Nullable
public @Nullable Object getAndReplace(Object key,
                                                Object val)
                                         throws IgniteCheckedException
```
    Stores given key-value pair in cache only if there is a previous mapping for it. In case of CacheMode.PARTITIONED or CacheMode.REPLICATED caches, the value will be loaded from the primary node, which in its turn may load the value from the swap storage, and consecutively, if it's not in swap, from the underlying persistent storage. If value has to be loaded from persistent storage, CacheStore#load(Transaction, Object) method will be used.
    If the returned value is not needed, method IgniteInternalCache.replace(Object, Object) should always be used instead of this one to avoid the overhead associated with returning of the previous value.
    If write-through is enabled, the stored value will be persisted to CacheStore via CacheStore#put(Transaction, Object, Object) method.
    Transactions
    This method is transactional and will enlist the entry into ongoing transaction if there is one.
    
    Specified by:
    
    getAndReplace in interface org.apache.ignite.internal.processors.cache.IgniteInternalCache<Object,Object>
    
    Parameters:
    
    key - Key to store in cache.
    
    val - Value to be associated with the given key.
    
    Returns:
    
    Previously contained value regardless of whether replace happened or not.
    
    Throws:
    
    IgniteCheckedException - If replace operation failed.
  - getAndReplaceAsync
```
public org.apache.ignite.internal.IgniteInternalFuture getAndReplaceAsync(Object key,
                                                                          Object val)
```
    Asynchronously stores given key-value pair in cache only if there is a previous mapping for it. If cache previously contained value for the given key, then this value is returned.In case of CacheMode.PARTITIONED caches, the value will be loaded from the primary node, which in its turn may load the value from the swap storage, and consecutively, if it's not in swap, from the underlying persistent storage. If value has to be loaded from persistent storage, CacheStore#load(Transaction, Object) method will be used.
    If the returned value is not needed, method IgniteInternalCache.replace(Object, Object) should always be used instead of this one to avoid the overhead associated with returning of the previous value.
    If write-through is enabled, the stored value will be persisted to CacheStore via CacheStore#put(Transaction, Object, Object) method.
    Transactions
    This method is transactional and will enlist the entry into ongoing transaction if there is one.
    
    Specified by:
    
    getAndReplaceAsync in interface org.apache.ignite.internal.processors.cache.IgniteInternalCache<Object,Object>
    
    Parameters:
    
    key - Key to store in cache.
    
    val - Value to be associated with the given key.
    
    Returns:
    
    Future for replace operation.
  - replace
```
public boolean replace(Object key,
                       Object val)
                throws IgniteCheckedException
```
    Stores given key-value pair in cache only if only if there is a previous mapping for it.
    This method will return true if value is stored in cache and false otherwise. Unlike IgniteInternalCache.getAndReplace(Object, Object) method, it does not return previous value and, therefore, does not have any overhead associated with returning of a value. It should always be used whenever return value is not required.
    If write-through is enabled, the stored value will be persisted to CacheStore via CacheStore#put(Transaction, Object, Object) method.
    Transactions
    This method is transactional and will enlist the entry into ongoing transaction if there is one.
    
    Specified by:
    
    replace in interface org.apache.ignite.internal.processors.cache.IgniteInternalCache<Object,Object>
    
    Parameters:
    
    key - Key to store in cache.
    
    val - Value to be associated with the given key.
    
    Returns:
    
    True if replace happened, false otherwise.
    
    Throws:
    
    IgniteCheckedException - If replace operation failed.
  - replaceAsync
```
public org.apache.ignite.internal.IgniteInternalFuture<Boolean> replaceAsync(Object key,
                                                                             Object val)
```
    Asynchronously stores given key-value pair in cache only if only if there is a previous mapping for it.
    This method will return true if value is stored in cache and false otherwise. Unlike IgniteInternalCache.getAndReplaceAsync(Object, Object) method, it does not return previous value and, therefore, does not have any overhead associated with returning of a value. It should always be used whenever return value is not required.
    If write-through is enabled, the stored value will be persisted to CacheStore via CacheStore#put(Transaction, Object, Object) method.
    Transactions
    This method is transactional and will enlist the entry into ongoing transaction if there is one.
    
    Specified by:
    
    replaceAsync in interface org.apache.ignite.internal.processors.cache.IgniteInternalCache<Object,Object>
    
    Parameters:
    
    key - Key to store in cache.
    
    val - Value to be associated with the given key.
    
    Returns:
    
    Future for the replace operation.
  - replace
```
public boolean replace(Object key,
                       Object oldVal,
                       Object newVal)
                throws IgniteCheckedException
```
    Stores given key-value pair in cache only if only if the previous value is equal to the 'oldVal' passed in.
    This method will return true if value is stored in cache and false otherwise.
    If write-through is enabled, the stored value will be persisted to CacheStore via CacheStore#put(Transaction, Object, Object) method.
    Transactions
    This method is transactional and will enlist the entry into ongoing transaction if there is one.
    
    Specified by:
    
    replace in interface org.apache.ignite.internal.processors.cache.IgniteInternalCache<Object,Object>
    
    Parameters:
    
    key - Key to store in cache.
    
    oldVal - Old value to match.
    
    newVal - Value to be associated with the given key.
    
    Returns:
    
    True if replace happened, false otherwise.
    
    Throws:
    
    IgniteCheckedException - If replace operation failed.
  - replaceAsync
```
public org.apache.ignite.internal.IgniteInternalFuture<Boolean> replaceAsync(Object key,
                                                                             Object oldVal,
                                                                             Object newVal)
```
    Asynchronously stores given key-value pair in cache only if only if the previous value is equal to the 'oldVal' passed in.
    This method will return true if value is stored in cache and false otherwise.
    If write-through is enabled, the stored value will be persisted to CacheStore via CacheStore#put(Transaction, Object, Object) method.
    Transactions
    This method is transactional and will enlist the entry into ongoing transaction if there is one.
    
    Specified by:
    
    replaceAsync in interface org.apache.ignite.internal.processors.cache.IgniteInternalCache<Object,Object>
    
    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.
  - putAll
```
public void putAll(@Nullable
                   @Nullable Map m)
            throws IgniteCheckedException
```
    Stores given key-value pairs in cache. If filters are provided, then entries will be stored in cache only if they pass the filter. Note that filter check is atomic, so value stored in cache is guaranteed to be consistent with the filters.
    If write-through is enabled, the stored values will be persisted to CacheStore via CacheStore#putAll(Transaction, Map) method.
    Transactions
    This method is transactional and will enlist the entry into ongoing transaction if there is one.
    
    Specified by:
    
    putAll in interface org.apache.ignite.internal.processors.cache.IgniteInternalCache<Object,Object>
    
    Parameters:
    
    m - Key-value pairs to store in cache.
    
    Throws:
    
    IgniteCheckedException - If put operation failed.
  - putAllAsync
```
public org.apache.ignite.internal.IgniteInternalFuture<?> putAllAsync(@Nullable
                                                                      @Nullable Map m)
```
    Asynchronously stores given key-value pairs in cache. If filters are provided, then entries will be stored in cache only if they pass the filter. Note that filter check is atomic, so value stored in cache is guaranteed to be consistent with the filters.
    If write-through is enabled, the stored values will be persisted to CacheStore via CacheStore#putAll(Transaction, Map) method.
    Transactions
    This method is transactional and will enlist the entry into ongoing transaction if there is one.
    
    Specified by:
    
    putAllAsync in interface org.apache.ignite.internal.processors.cache.IgniteInternalCache<Object,Object>
    
    Parameters:
    
    m - Key-value pairs to store in cache.
    
    Returns:
    
    Future for putAll operation.
  - keySet
```
public Set keySet()
```
    Set of keys cached on this node. You can remove elements from this set, but you cannot add elements to this set. All removal operation will be reflected on the cache itself.
    Iterator over this set will not fail if set was concurrently updated by another thread. This means that iterator may or may not return latest keys depending on whether they were added before or after current iterator position.
    NOTE: this operation is not distributed and returns only the keys cached on this node.
    
    Specified by:
    
    keySet in interface org.apache.ignite.internal.processors.cache.IgniteInternalCache<Object,Object>
    
    Returns:
    
    Key set for this cache projection.
  - entrySet
```
public Set<javax.cache.Cache.Entry<Object,Object>> entrySet()
```
    Gets set of all entries cached on this node. You can remove elements from this set, but you cannot add elements to this set. All removal operation will be reflected on the cache itself.
    NOTE: this operation is not distributed and returns only the entries cached on this node.
    
    Specified by:
    
    entrySet in interface org.apache.ignite.internal.processors.cache.IgniteInternalCache<Object,Object>
    
    Returns:
    
    Entries that pass through key filter.
  - txStart
```
public Transaction txStart(TransactionConcurrency concurrency,
                           TransactionIsolation isolation)
```
    Starts new transaction with the specified concurrency and isolation.
    
    Specified by:
    
    txStart in interface org.apache.ignite.internal.processors.cache.IgniteInternalCache<Object,Object>
    
    Parameters:
    
    concurrency - Concurrency.
    
    isolation - Isolation.
    
    Returns:
    
    New transaction.
  - txStartEx
```
public org.apache.ignite.internal.processors.cache.distributed.near.GridNearTxLocal txStartEx(TransactionConcurrency concurrency,
                                                                                              TransactionIsolation isolation)
```
    Specified by:
    
    txStartEx in interface org.apache.ignite.internal.processors.cache.IgniteInternalCache<Object,Object>
    
    Parameters:
    
    concurrency - Concurrency.
    
    isolation - Isolation.
    
    Returns:
    
    New transaction.
  - txStart
```
public Transaction txStart(TransactionConcurrency concurrency,
                           TransactionIsolation isolation,
                           long timeout,
                           int txSize)
```
    Starts transaction with specified isolation, concurrency, timeout, invalidation flag, and number of participating entries.
    
    Specified by:
    
    txStart in interface org.apache.ignite.internal.processors.cache.IgniteInternalCache<Object,Object>
    
    Parameters:
    
    concurrency - Concurrency.
    
    isolation - Isolation.
    
    timeout - Timeout.
    
    txSize - Number of entries participating in transaction (may be approximate).
    
    Returns:
    
    New transaction.
  - tx
```
@Nullable
public @Nullable org.apache.ignite.internal.processors.cache.distributed.near.GridNearTxLocal tx()
```
    Gets transaction started by this thread or null if this thread does not have a transaction.
    
    Specified by:
    
    tx in interface org.apache.ignite.internal.processors.cache.IgniteInternalCache<Object,Object>
    
    Returns:
    
    Transaction started by this thread or null if this thread does not have a transaction.
  - evict
```
public boolean evict(Object key)
```
    Evicts entry associated with given key from cache. Note, that entry will be evicted only if it's not used (not participating in any locks or transactions).
    
    Specified by:
    
    evict in interface org.apache.ignite.internal.processors.cache.IgniteInternalCache<Object,Object>
    
    Parameters:
    
    key - Key to evict from cache.
    
    Returns:
    
    True if entry could be evicted, false otherwise.
  - evictAll
```
public void evictAll(@Nullable
                     @Nullable Collection 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:
    
    evictAll in interface org.apache.ignite.internal.processors.cache.IgniteInternalCache<Object,Object>
    
    Parameters:
    
    keys - Keys to evict.
  - clearLocally
```
public void clearLocally(boolean srv,
                         boolean near,
                         boolean readers)
```
    Clears all entries from this cache only if the entry is not currently locked or participating in a transaction.
    Note that this operation is local as it merely clears entries from local cache. It does not remove entries from remote caches or from underlying persistent storage.
    
    Specified by:
    
    clearLocally in interface org.apache.ignite.internal.processors.cache.IgniteInternalCache<Object,Object>
    
    Parameters:
    
    srv - Whether to clear server cache.
    
    near - Whether to clear near cache.
    
    readers - Whether to clear readers.
  - clearLocally
```
public boolean clearLocally(Object key)
```
    Clears an entry from this cache and swap storage only if the entry is not currently locked, and is not participating in a transaction.
    Note that this operation is local as it merely clears an entry from local cache. It does not remove entries from remote caches or from underlying persistent storage.
    
    Specified by:
    
    clearLocally in interface org.apache.ignite.internal.processors.cache.IgniteInternalCache<Object,Object>
    
    Parameters:
    
    key - Key to clearLocally.
    
    Returns:
    
    True if entry was successfully cleared from cache, false if entry was in use at the time of this method invocation and could not be cleared.
  - clearLocallyAll
```
public void clearLocallyAll(Set keys,
                            boolean srv,
                            boolean near,
                            boolean readers)
```
    Clears entries from this cache and swap storage only if the entry 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 or from underlying persistent storage.
    
    Specified by:
    
    clearLocallyAll in interface org.apache.ignite.internal.processors.cache.IgniteInternalCache<Object,Object>
    
    Parameters:
    
    keys - Keys to clearLocally.
    
    srv - Whether to clear server cache.
    
    near - Whether to clear near cache.
    
    readers - Whether to clear readers.
  - clear
```
public void clear(Object key)
           throws IgniteCheckedException
```
    Clears key on all nodes that store it's data. That is, caches are cleared on remote nodes and local node, as opposed to IgniteInternalCache.clearLocally(Object) method which only clears local node's cache.
    Ignite will make the best attempt to clear caches on all nodes. If some caches could not be cleared, then exception will be thrown.
    
    Specified by:
    
    clear in interface org.apache.ignite.internal.processors.cache.IgniteInternalCache<Object,Object>
    
    Parameters:
    
    key - Key to clear.
    
    Throws:
    
    IgniteCheckedException - In case of cache could not be cleared on any of the nodes.
  - clearAll
```
public void clearAll(Set keys)
              throws IgniteCheckedException
```
    Clears keys on all nodes that store it's data. That is, caches are cleared on remote nodes and local node, as opposed to IgniteInternalCache.clearLocallyAll(Set, boolean, boolean, boolean) method which only clears local node's cache.
    Ignite will make the best attempt to clear caches on all nodes. If some caches could not be cleared, then exception will be thrown.
    
    Specified by:
    
    clearAll in interface org.apache.ignite.internal.processors.cache.IgniteInternalCache<Object,Object>
    
    Parameters:
    
    keys - Keys to clear.
    
    Throws:
    
    IgniteCheckedException - In case of cache could not be cleared on any of the nodes.
  - clear
```
public void clear()
           throws IgniteCheckedException
```
    Clears cache on all nodes that store it's data. That is, caches are cleared on remote nodes and local node, as opposed to IgniteInternalCache.clearLocally(boolean, boolean, boolean) method which only clears local node's cache.
    Ignite will make the best attempt to clear caches on all nodes. If some caches could not be cleared, then exception will be thrown.
    
    Specified by:
    
    clear in interface org.apache.ignite.internal.processors.cache.IgniteInternalCache<Object,Object>
    
    Throws:
    
    IgniteCheckedException - In case of cache could not be cleared on any of the nodes.
  - clearAsync
```
public org.apache.ignite.internal.IgniteInternalFuture<?> clearAsync()
```
    Specified by:
    
    clearAsync in interface org.apache.ignite.internal.processors.cache.IgniteInternalCache<Object,Object>
    
    Returns:
    
    Clear future.
  - clearAsync
```
public org.apache.ignite.internal.IgniteInternalFuture<?> clearAsync(Object key)
```
    Specified by:
    
    clearAsync in interface org.apache.ignite.internal.processors.cache.IgniteInternalCache<Object,Object>
    
    Parameters:
    
    key - Key to clear.
    
    Returns:
    
    Clear future.
  - clearAllAsync
```
public org.apache.ignite.internal.IgniteInternalFuture<?> clearAllAsync(Set keys)
```
    Specified by:
    
    clearAllAsync in interface org.apache.ignite.internal.processors.cache.IgniteInternalCache<Object,Object>
    
    Parameters:
    
    keys - Keys to clear.
    
    Returns:
    
    Clear future.
  - getAndRemove
```
@Nullable
public @Nullable Object getAndRemove(Object key)
                                        throws IgniteCheckedException
```
    Removes given key mapping from cache. If cache previously contained value for the given key, then this value is returned. In case of CacheMode.PARTITIONED or CacheMode.REPLICATED caches, the value will be loaded from the primary node, which in its turn may load the value from the disk-based swap storage, and consecutively, if it's not in swap, from the underlying persistent storage. If value has to be loaded from persistent storage, CacheStore#load(Transaction, Object) method will be used.
    If the returned value is not needed, method #removex(Object, org.apache.ignite.lang.IgnitePredicate[]) should always be used instead of this one to avoid the overhead associated with returning of the previous value.
    If write-through is enabled, the value will be removed from CacheStore via CacheStore#remove(Transaction, Object) method.
    Transactions
    This method is transactional and will enlist the entry into ongoing transaction if there is one.
    
    Specified by:
    
    getAndRemove in interface org.apache.ignite.internal.processors.cache.IgniteInternalCache<Object,Object>
    
    Parameters:
    
    key - Key whose mapping is to be removed from cache.
    
    Returns:
    
    Previous value associated with specified key, or null if there was no value for this key.
    
    Throws:
    
    IgniteCheckedException - If remove operation failed.
  - getAndRemoveAsync
```
public org.apache.ignite.internal.IgniteInternalFuture getAndRemoveAsync(Object key)
```
    Asynchronously removes given key mapping from cache. If cache previously contained value for the given key, then this value is returned. In case of CacheMode.PARTITIONED or CacheMode.REPLICATED caches, the value will be loaded from the primary node, which in its turn may load the value from the swap storage, and consecutively, if it's not in swap, from the underlying persistent storage. If value has to be loaded from persistent storage, CacheStore#load(Transaction, Object) method will be used.
    If the returned value is not needed, method #removex(Object, org.apache.ignite.lang.IgnitePredicate[]) should always be used instead of this one to avoid the overhead associated with returning of the previous value.
    If write-through is enabled, the value will be removed from CacheStore via CacheStore#remove(Transaction, Object) method.
    Transactions
    This method is transactional and will enlist the entry into ongoing transaction if there is one.
    
    Specified by:
    
    getAndRemoveAsync in interface org.apache.ignite.internal.processors.cache.IgniteInternalCache<Object,Object>
    
    Parameters:
    
    key - Key whose mapping is to be removed from cache.
    
    Returns:
    
    Future for the remove operation.
  - remove
```
public boolean remove(Object key)
               throws IgniteCheckedException
```
    Removes given key mapping from cache.
    This method will return true if remove did occur, which means that all optionally provided filters have passed and there was something to remove, false otherwise.
    If write-through is enabled, the value will be removed from CacheStore via CacheStore#remove(Transaction, Object) method.
    Transactions
    This method is transactional and will enlist the entry into ongoing transaction if there is one.
    
    Specified by:
    
    remove in interface org.apache.ignite.internal.processors.cache.IgniteInternalCache<Object,Object>
    
    Parameters:
    
    key - Key whose mapping is to be removed from cache.
    
    Returns:
    
    True if filter passed validation and entry was removed, false otherwise. Note that if filter is not specified, this method will return true.
    
    Throws:
    
    IgniteCheckedException - If remove failed.
  - removeAsync
```
public org.apache.ignite.internal.IgniteInternalFuture<Boolean> removeAsync(Object key)
```
    Asynchronously removes given key mapping from cache.
    This method will return true if remove did occur, which means that all optionally provided filters have passed and there was something to remove, false otherwise.
    If write-through is enabled, the value will be removed from CacheStore via CacheStore#remove(Transaction, Object) method.
    Transactions
    This method is transactional and will enlist the entry into ongoing transaction if there is one.
    
    Specified by:
    
    removeAsync in interface org.apache.ignite.internal.processors.cache.IgniteInternalCache<Object,Object>
    
    Parameters:
    
    key - Key whose mapping is to be removed from cache.
    
    Returns:
    
    Future for the remove operation. The future will return true if optional filters passed validation and remove did occur, false otherwise. Note that if filter is not specified, this method will return true.
  - remove
```
public boolean remove(Object key,
                      Object val)
               throws IgniteCheckedException
```
    Removes given key mapping from cache if one exists and value is equal to the passed in value.
    If write-through is enabled, the value will be removed from CacheStore via CacheStore#remove(Transaction, Object) method.
    Transactions
    This method is transactional and will enlist the entry into ongoing transaction if there is one.
    
    Specified by:
    
    remove in interface org.apache.ignite.internal.processors.cache.IgniteInternalCache<Object,Object>
    
    Parameters:
    
    key - Key whose mapping is to be removed from cache.
    
    val - Value to match against currently cached value.
    
    Returns:
    
    True if entry was removed and passed in value matched the cached one, false otherwise.
    
    Throws:
    
    IgniteCheckedException - If remove failed.
  - removeAsync
```
public org.apache.ignite.internal.IgniteInternalFuture<Boolean> removeAsync(Object key,
                                                                            Object val)
```
    Asynchronously removes given key mapping from cache if one exists and value is equal to the passed in value.
    This method will return true if remove did occur, which means that all optionally provided filters have passed and there was something to remove, false otherwise.
    If write-through is enabled, the value will be removed from CacheStore via CacheStore#remove(Transaction, Object) method.
    Transactions
    This method is transactional and will enlist the entry into ongoing transaction if there is one.
    
    Specified by:
    
    removeAsync in interface org.apache.ignite.internal.processors.cache.IgniteInternalCache<Object,Object>
    
    Parameters:
    
    key - Key whose mapping is to be removed from cache.
    
    val - Value to match against currently cached value.
    
    Returns:
    
    Future for the remove operation. The future will return true if currently cached value will match the passed in one.
  - removeAll
```
public void removeAll(@Nullable
                      @Nullable Collection keys)
               throws IgniteCheckedException
```
    Removes given key mappings from cache.
    If write-through is enabled, the values will be removed from CacheStore via IgniteDataStreamer.
    Transactions
    This method is transactional and will enlist the entry into ongoing transaction if there is one.
    
    Specified by:
    
    removeAll in interface org.apache.ignite.internal.processors.cache.IgniteInternalCache<Object,Object>
    
    Parameters:
    
    keys - Keys whose mappings are to be removed from cache.
    
    Throws:
    
    IgniteCheckedException - If remove failed.
  - removeAllAsync
```
public org.apache.ignite.internal.IgniteInternalFuture<?> removeAllAsync(@Nullable
                                                                         @Nullable Collection keys)
```
    Asynchronously removes given key mappings from cache for entries.
    If write-through is enabled, the values will be removed from CacheStore via IgniteDataStreamer.
    Transactions
    This method is transactional and will enlist the entry into ongoing transaction if there is one.
    
    Specified by:
    
    removeAllAsync in interface org.apache.ignite.internal.processors.cache.IgniteInternalCache<Object,Object>
    
    Parameters:
    
    keys - Keys whose mappings are to be removed from cache.
    
    Returns:
    
    Future for the remove operation. The future will complete whenever remove operation completes.
  - removeAll
```
public void removeAll()
               throws IgniteCheckedException
```
    Removes mappings from cache.
    USE WITH CARE - if your cache has many entries then transaction will quickly become very heavy and slow.
    If write-through is enabled, the values will be removed from CacheStore via IgniteDataStreamer.
    Transactions
    This method is not transactional.
    
    Specified by:
    
    removeAll in interface org.apache.ignite.internal.processors.cache.IgniteInternalCache<Object,Object>
    
    Throws:
    
    IgniteCheckedException - If remove failed.
  - removeAllAsync
```
public org.apache.ignite.internal.IgniteInternalFuture<?> removeAllAsync()
```
    Specified by:
    
    removeAllAsync in interface org.apache.ignite.internal.processors.cache.IgniteInternalCache<Object,Object>
    
    Returns:
    
    Remove future.
  - lock
```
public boolean lock(Object key,
                    long timeout)
             throws IgniteCheckedException
```
    Synchronously acquires lock on a cached object with given key only if the passed in filter (if any) passes. This method together with filter check will be executed as one atomic operation.
    Transactions
    Locks are not transactional and should not be used from within transactions. If you do need explicit locking within transaction, then you should use TransactionConcurrency.PESSIMISTIC concurrency control for transaction which will acquire explicit locks for relevant cache operations.
    
    Specified by:
    
    lock in interface org.apache.ignite.internal.processors.cache.IgniteInternalCache<Object,Object>
    
    Parameters:
    
    key - Key to lock.
    
    timeout - Timeout in milliseconds to wait for lock to be acquired ('0' for no expiration), -1 for immediate failure if lock cannot be acquired immediately).
    
    Returns:
    
    True if all filters passed and lock was acquired, false otherwise.
    
    Throws:
    
    IgniteCheckedException - If lock acquisition resulted in error.
  - lockAsync
```
public org.apache.ignite.internal.IgniteInternalFuture<Boolean> lockAsync(Object key,
                                                                          long timeout)
```
    Asynchronously acquires lock on a cached object with given key only if the passed in filter (if any) passes. This method together with filter check will be executed as one atomic operation.
    Transactions
    Locks are not transactional and should not be used from within transactions. If you do need explicit locking within transaction, then you should use TransactionConcurrency.PESSIMISTIC concurrency control for transaction which will acquire explicit locks for relevant cache operations.
    
    Specified by:
    
    lockAsync in interface org.apache.ignite.internal.processors.cache.IgniteInternalCache<Object,Object>
    
    Parameters:
    
    key - Key to lock.
    
    timeout - Timeout in milliseconds to wait for lock to be acquired ('0' for no expiration, -1 for immediate failure if lock cannot be acquired immediately).
    
    Returns:
    
    Future for the lock operation. The future will return true whenever all filters pass and locks are acquired before timeout is expired, false otherwise.
  - lockAll
```
public boolean lockAll(@Nullable
                       @Nullable Collection keys,
                       long timeout)
                throws IgniteCheckedException
```
    All or nothing synchronous lock for passed in keys. This method together with filter check will be executed as one atomic operation. If at least one filter validation failed, no locks will be acquired.
    Transactions
    Locks are not transactional and should not be used from within transactions. If you do need explicit locking within transaction, then you should use TransactionConcurrency.PESSIMISTIC concurrency control for transaction which will acquire explicit locks for relevant cache operations.
    
    Specified by:
    
    lockAll in interface org.apache.ignite.internal.processors.cache.IgniteInternalCache<Object,Object>
    
    Parameters:
    
    keys - Keys to lock.
    
    timeout - Timeout in milliseconds to wait for lock to be acquired ('0' for no expiration).
    
    Returns:
    
    True if all filters passed and locks were acquired before timeout has expired, false otherwise.
    
    Throws:
    
    IgniteCheckedException - If lock acquisition resulted in error.
  - lockAllAsync
```
public org.apache.ignite.internal.IgniteInternalFuture<Boolean> lockAllAsync(@Nullable
                                                                             @Nullable Collection keys,
                                                                             long timeout)
```
    All or nothing synchronous lock for passed in keys. This method together with filter check will be executed as one atomic operation. If at least one filter validation failed, no locks will be acquired.
    Transactions
    Locks are not transactional and should not be used from within transactions. If you do need explicit locking within transaction, then you should use TransactionConcurrency.PESSIMISTIC concurrency control for transaction which will acquire explicit locks for relevant cache operations.
    
    Specified by:
    
    lockAllAsync in interface org.apache.ignite.internal.processors.cache.IgniteInternalCache<Object,Object>
    
    Parameters:
    
    keys - Keys to lock.
    
    timeout - Timeout in milliseconds to wait for lock to be acquired ('0' for no expiration).
    
    Returns:
    
    Future for the collection of locks. The future will return true if all filters passed and locks were acquired before timeout has expired, false otherwise.
  - unlock
```
public void unlock(Object key)
            throws IgniteCheckedException
```
    Unlocks given key only if current thread owns the lock. If optional filter will not pass, then unlock will not happen. If the key being unlocked was never locked by current thread, then this method will do nothing.
    Transactions
    Locks are not transactional and should not be used from within transactions. If you do need explicit locking within transaction, then you should use TransactionConcurrency.PESSIMISTIC concurrency control for transaction which will acquire explicit locks for relevant cache operations.
    
    Specified by:
    
    unlock in interface org.apache.ignite.internal.processors.cache.IgniteInternalCache<Object,Object>
    
    Parameters:
    
    key - Key to unlock.
    
    Throws:
    
    IgniteCheckedException - If unlock execution resulted in error.
  - unlockAll
```
public void unlockAll(@Nullable
                      @Nullable Collection keys)
               throws IgniteCheckedException
```
    Unlocks given keys only if current thread owns the locks. Only the keys that have been locked by calling thread and pass through the filter (if any) will be unlocked. If none of the key locks is owned by current thread, then this method will do nothing.
    Transactions
    Locks are not transactional and should not be used from within transactions. If you do need explicit locking within transaction, then you should use TransactionConcurrency.PESSIMISTIC concurrency control for transaction which will acquire explicit locks for relevant cache operations.
    
    Specified by:
    
    unlockAll in interface org.apache.ignite.internal.processors.cache.IgniteInternalCache<Object,Object>
    
    Parameters:
    
    keys - Keys to unlock.
    
    Throws:
    
    IgniteCheckedException - If unlock execution resulted in error.
  - isLocked
```
public boolean isLocked(Object key)
```
    Checks if any node owns a lock for this key.
    This is a local in-VM operation and does not involve any network trips or access to persistent storage in any way.
    
    Specified by:
    
    isLocked in interface org.apache.ignite.internal.processors.cache.IgniteInternalCache<Object,Object>
    
    Parameters:
    
    key - Key to check.
    
    Returns:
    
    True if lock is owned by some node.
  - isLockedByThread
```
public boolean isLockedByThread(Object key)
```
    Checks if current thread owns a lock on this key.
    This is a local in-VM operation and does not involve any network trips or access to persistent storage in any way.
    
    Specified by:
    
    isLockedByThread in interface org.apache.ignite.internal.processors.cache.IgniteInternalCache<Object,Object>
    
    Parameters:
    
    key - Key to check.
    
    Returns:
    
    True if key is locked by current thread.
  - size
```
public int size()
```
    Gets the number of all entries cached on this node. This method will return the count of all cache entries and has O(1) complexity on base IgniteInternalCache. It is essentially the size of cache key set and is semantically identical to {Cache.keySet().size().
    NOTE: this operation is not distributed and returns only the number of entries cached on this node.
    
    Specified by:
    
    size in interface org.apache.ignite.internal.processors.cache.IgniteInternalCache<Object,Object>
    
    Returns:
    
    Size of cache on this node.
  - sizeLong
```
public long sizeLong()
```
    Gets the number of all entries cached on this node as a long value. This method will return the count of all cache entries and has O(1) complexity on base IgniteInternalCache. It is essentially the size of cache key set and is semantically identical to {Cache.keySet().size().
    NOTE: this operation is not distributed and returns only the number of entries cached on this node.
    
    Specified by:
    
    sizeLong in interface org.apache.ignite.internal.processors.cache.IgniteInternalCache<Object,Object>
    
    Returns:
    
    Size of cache on this node.
  - localSize
```
public int localSize(CachePeekMode[] peekModes)
              throws IgniteCheckedException
```
    Specified by:
    
    localSize in interface org.apache.ignite.internal.processors.cache.IgniteInternalCache<Object,Object>
    
    Parameters:
    
    peekModes - Peek modes.
    
    Returns:
    
    Local cache size.
    
    Throws:
    
    IgniteCheckedException - If failed.
  - localSizeLong
```
public long localSizeLong(CachePeekMode[] peekModes)
                   throws IgniteCheckedException
```
    Specified by:
    
    localSizeLong in interface org.apache.ignite.internal.processors.cache.IgniteInternalCache<Object,Object>
    
    Parameters:
    
    peekModes - Peek modes.
    
    Returns:
    
    Local cache size as a long value.
    
    Throws:
    
    IgniteCheckedException - If failed.
  - localSizeLong
```
public long localSizeLong(int partition,
                          CachePeekMode[] peekModes)
                   throws IgniteCheckedException
```
    Specified by:
    
    localSizeLong in interface org.apache.ignite.internal.processors.cache.IgniteInternalCache<Object,Object>
    
    Parameters:
    
    partition - partition.
    
    peekModes - Peek modes.
    
    Returns:
    
    Local cache size as a long value.
    
    Throws:
    
    IgniteCheckedException - If failed.
  - size
```
public int size(CachePeekMode[] peekModes)
         throws IgniteCheckedException
```
    Specified by:
    
    size in interface org.apache.ignite.internal.processors.cache.IgniteInternalCache<Object,Object>
    
    Parameters:
    
    peekModes - Peek modes.
    
    Returns:
    
    Global cache size.
    
    Throws:
    
    IgniteCheckedException - If failed.
  - sizeLong
```
public long sizeLong(CachePeekMode[] peekModes)
              throws IgniteCheckedException
```
    Specified by:
    
    sizeLong in interface org.apache.ignite.internal.processors.cache.IgniteInternalCache<Object,Object>
    
    Parameters:
    
    peekModes - Peek modes.
    
    Returns:
    
    Global cache size as a long value.
    
    Throws:
    
    IgniteCheckedException - If failed.
  - sizeLong
```
public long sizeLong(int partition,
                     CachePeekMode[] peekModes)
              throws IgniteCheckedException
```
    Specified by:
    
    sizeLong in interface org.apache.ignite.internal.processors.cache.IgniteInternalCache<Object,Object>
    
    Parameters:
    
    partition - partition
    
    peekModes - Peek modes.
    
    Returns:
    
    Global cache size as a long value.
    
    Throws:
    
    IgniteCheckedException - If failed.
  - sizeAsync
```
public org.apache.ignite.internal.IgniteInternalFuture<Integer> sizeAsync(CachePeekMode[] peekModes)
```
    Specified by:
    
    sizeAsync in interface org.apache.ignite.internal.processors.cache.IgniteInternalCache<Object,Object>
    
    Parameters:
    
    peekModes - Peek modes.
    
    Returns:
    
    Future.
  - sizeLongAsync
```
public org.apache.ignite.internal.IgniteInternalFuture<Long> sizeLongAsync(CachePeekMode[] peekModes)
```
    Specified by:
    
    sizeLongAsync in interface org.apache.ignite.internal.processors.cache.IgniteInternalCache<Object,Object>
    
    Parameters:
    
    peekModes - Peek modes.
    
    Returns:
    
    Future.
  - sizeLongAsync
```
public org.apache.ignite.internal.IgniteInternalFuture<Long> sizeLongAsync(int partition,
                                                                           CachePeekMode[] peekModes)
```
    Specified by:
    
    sizeLongAsync in interface org.apache.ignite.internal.processors.cache.IgniteInternalCache<Object,Object>
    
    Parameters:
    
    partition - partiton
    
    peekModes - Peek modes.
    
    Returns:
    
    Future.
  - nearSize
```
public int nearSize()
```
    Gets size of near cache key set. This method will return count of all entries in near cache and has O(1) complexity on base cache projection.
    Note that for LOCAL non-distributed caches this method will always return 0
    
    Specified by:
    
    nearSize in interface org.apache.ignite.internal.processors.cache.IgniteInternalCache<Object,Object>
    
    Returns:
    
    Size of near cache key set or 0 if cache is not CacheMode.PARTITIONED.
  - primarySize
```
public int primarySize()
```
    Gets the number of all primary entries cached on this node. For CacheMode.LOCAL non-distributed cache mode, this method is identical to IgniteInternalCache.size().
    For CacheMode.PARTITIONED and CacheMode.REPLICATED modes, this method will return number of primary entries cached on this node (excluding any backups). The complexity of this method is O(P), where P is the total number of partitions.
    NOTE: this operation is not distributed and returns only the number of primary entries cached on this node.
    
    Specified by:
    
    primarySize in interface org.apache.ignite.internal.processors.cache.IgniteInternalCache<Object,Object>
    
    Returns:
    
    Number of primary entries in cache.
  - primarySizeLong
```
public long primarySizeLong()
```
    Gets the number of all primary entries cached on this node as a long value. For CacheMode.LOCAL non-distributed cache mode, this method is identical to IgniteInternalCache.size().
    For CacheMode.PARTITIONED and CacheMode.REPLICATED modes, this method will return number of primary entries cached on this node (excluding any backups). The complexity of this method is O(P), where P is the total number of partitions.
    NOTE: this operation is not distributed and returns only the number of primary entries cached on this node.
    
    Specified by:
    
    primarySizeLong in interface org.apache.ignite.internal.processors.cache.IgniteInternalCache<Object,Object>
    
    Returns:
    
    Number of primary entries in cache.
  - configuration
```
public CacheConfiguration configuration()
```
    Gets configuration bean for this cache.
    
    Specified by:
    
    configuration in interface org.apache.ignite.internal.processors.cache.IgniteInternalCache<Object,Object>
    
    Returns:
    
    Configuration bean for this cache.
  - affinity
```
public Affinity affinity()
```
    Gets affinity service to provide information about data partitioning and distribution.
    
    Specified by:
    
    affinity in interface org.apache.ignite.internal.processors.cache.IgniteInternalCache<Object,Object>
    
    Returns:
    
    Cache data affinity service.
  - clusterMetrics
```
public CacheMetrics clusterMetrics()
```
    Gets whole cluster metrics (statistics) for this cache.
    
    Specified by:
    
    clusterMetrics in interface org.apache.ignite.internal.processors.cache.IgniteInternalCache<Object,Object>
    
    Returns:
    
    Cache metrics.
  - clusterMetrics
```
public CacheMetrics clusterMetrics(ClusterGroup grp)
```
    Gets cluster group metrics (statistics) for this cache.
    
    Specified by:
    
    clusterMetrics in interface org.apache.ignite.internal.processors.cache.IgniteInternalCache<Object,Object>
    
    Parameters:
    
    grp - Cluster group.
    
    Returns:
    
    Cache metrics.
  - localMetrics
```
public CacheMetrics localMetrics()
```
    Gets local metrics (statistics) for this cache.
    
    Specified by:
    
    localMetrics in interface org.apache.ignite.internal.processors.cache.IgniteInternalCache<Object,Object>
    
    Returns:
    
    Cache metrics.
  - clusterMxBean
```
public CacheMetricsMXBean clusterMxBean()
```
    Gets whole cluster metrics (statistics) for this cache.
    
    Specified by:
    
    clusterMxBean in interface org.apache.ignite.internal.processors.cache.IgniteInternalCache<Object,Object>
    
    Returns:
    
    Cache metrics.
  - localMxBean
```
public CacheMetricsMXBean localMxBean()
```
    Gets local metrics (statistics) for this cache.
    
    Specified by:
    
    localMxBean in interface org.apache.ignite.internal.processors.cache.IgniteInternalCache<Object,Object>
    
    Returns:
    
    Cache metrics.
  - offHeapEntriesCount
```
public long offHeapEntriesCount()
```
    Gets number of cache entries stored in off-heap memory.
    
    Specified by:
    
    offHeapEntriesCount in interface org.apache.ignite.internal.processors.cache.IgniteInternalCache<Object,Object>
    
    Returns:
    
    Number of cache entries stored in off-heap memory.
  - offHeapAllocatedSize
```
public long offHeapAllocatedSize()
```
    Gets memory size allocated in off-heap.
    
    Specified by:
    
    offHeapAllocatedSize in interface org.apache.ignite.internal.processors.cache.IgniteInternalCache<Object,Object>
    
    Returns:
    
    Allocated memory size.
  - rebalance
```
public org.apache.ignite.internal.IgniteInternalFuture<?> rebalance()
```
    Forces 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 IgniteConfiguration.setConsistentId(Serializable) 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 org.apache.ignite.internal.processors.cache.IgniteInternalCache<Object,Object>
    
    Returns:
    
    Future that will be completed when rebalancing is finished.
  - forSubjectId
```
public org.apache.ignite.internal.processors.cache.IgniteInternalCache forSubjectId(UUID subjId)
```
    Creates projection for specified subject ID.
    
    Specified by:
    
    forSubjectId in interface org.apache.ignite.internal.processors.cache.IgniteInternalCache<Object,Object>
    
    Parameters:
    
    subjId - Client ID.
    
    Returns:
    
    Internal projection.
  - getForcePrimary
```
@Nullable
public @Nullable Object getForcePrimary(Object key)
                                           throws IgniteCheckedException
```
    Gets value from cache. Will go to primary node even if this is a backup.
    
    Specified by:
    
    getForcePrimary in interface org.apache.ignite.internal.processors.cache.IgniteInternalCache<Object,Object>
    
    Parameters:
    
    key - Key to get value for.
    
    Returns:
    
    Value.
    
    Throws:
    
    IgniteCheckedException - If failed.
  - getForcePrimaryAsync
```
public org.apache.ignite.internal.IgniteInternalFuture getForcePrimaryAsync(Object key)
```
    Asynchronously gets value from cache. Will go to primary node even if this is a backup.
    
    Specified by:
    
    getForcePrimaryAsync in interface org.apache.ignite.internal.processors.cache.IgniteInternalCache<Object,Object>
    
    Parameters:
    
    key - Key to get value for.
    
    Returns:
    
    Future with result.
  - getAllOutTx
```
public Map getAllOutTx(Set 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.
    
    Specified by:
    
    getAllOutTx in interface org.apache.ignite.internal.processors.cache.IgniteInternalCache<Object,Object>
    
    Parameters:
    
    keys - Keys to get values for.
    
    Returns:
    
    Value.
    
    Throws:
    
    IgniteCheckedException - If failed.
  - getAllOutTxAsync
```
public org.apache.ignite.internal.IgniteInternalFuture<Map<Object,Object>> getAllOutTxAsync(Set 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:
    
    getAllOutTxAsync in interface org.apache.ignite.internal.processors.cache.IgniteInternalCache<Object,Object>
    
    Parameters:
    
    keys - Keys to get values for.
    
    Returns:
    
    Future for getAllOutTx operation.
  - isIgfsDataCache
```
public boolean isIgfsDataCache()
```
    Checks whether this cache is IGFS data cache.
    
    Specified by:
    
    isIgfsDataCache in interface org.apache.ignite.internal.processors.cache.IgniteInternalCache<Object,Object>
    
    Returns:
    
    True in case this cache is IGFS data cache.
  - igfsDataSpaceUsed
```
public long igfsDataSpaceUsed()
```
    Get current amount of used IGFS space in bytes.
    
    Specified by:
    
    igfsDataSpaceUsed in interface org.apache.ignite.internal.processors.cache.IgniteInternalCache<Object,Object>
    
    Returns:
    
    Amount of used IGFS space in bytes.
  - expiry
```
@Nullable
public @Nullable javax.cache.expiry.ExpiryPolicy expiry()
```
    Specified by:
    
    expiry in interface org.apache.ignite.internal.processors.cache.IgniteInternalCache<Object,Object>
    
    Returns:
    
    ExpiryPolicy associated with this projection.
  - withExpiryPolicy
```
public org.apache.ignite.internal.processors.cache.IgniteInternalCache withExpiryPolicy(javax.cache.expiry.ExpiryPolicy plc)
```
    Specified by:
    
    withExpiryPolicy in interface org.apache.ignite.internal.processors.cache.IgniteInternalCache<Object,Object>
    
    Parameters:
    
    plc - ExpiryPolicy to associate with this projection.
    
    Returns:
    
    New projection based on this one, but with the specified expiry policy.
  - withNoRetries
```
public org.apache.ignite.internal.processors.cache.IgniteInternalCache withNoRetries()
```
    Specified by:
    
    withNoRetries in interface org.apache.ignite.internal.processors.cache.IgniteInternalCache<Object,Object>
    
    Returns:
    
    Cache with no-retries behavior enabled.
  - withAllowAtomicOpsInTx
```
public <K1,V1> org.apache.ignite.internal.processors.cache.IgniteInternalCache<K1,V1> withAllowAtomicOpsInTx()
```
    Specified by:
    
    withAllowAtomicOpsInTx in interface org.apache.ignite.internal.processors.cache.IgniteInternalCache<Object,Object>
    
    Returns:
    
    New projection based on this one, but with atomic cache operations allowed to be used.
  - context
```
public org.apache.ignite.internal.processors.cache.GridCacheContext context()
```
    Specified by:
    
    context in interface org.apache.ignite.internal.processors.cache.IgniteInternalCache<Object,Object>
    
    Returns:
    
    Context.
  - localLoadCache
```
public void localLoadCache(@Nullable
                           @Nullable IgniteBiPredicate p,
                           @Nullable
                           Object... args)
                    throws IgniteCheckedException
```
    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 org.apache.ignite.internal.processors.cache.IgniteInternalCache<Object,Object>
    
    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.
    
    Throws:
    
    IgniteCheckedException - If loading failed.
  - localLoadCacheAsync
```
public org.apache.ignite.internal.IgniteInternalFuture<?> localLoadCacheAsync(@Nullable
                                                                              @Nullable IgniteBiPredicate p,
                                                                              @Nullable
                                                                              Object... args)
```
    Asynchronously delegates to CacheStore.loadCache(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.
    
    Specified by:
    
    localLoadCacheAsync in interface org.apache.ignite.internal.processors.cache.IgniteInternalCache<Object,Object>
    
    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.
    
    Returns:
    
    Future to be completed whenever loading completes.
  - lostPartitions
```
public Collection<Integer> lostPartitions()
```
    Specified by:
    
    lostPartitions in interface org.apache.ignite.internal.processors.cache.IgniteInternalCache<Object,Object>
    
    Returns:
    
    A collection of lost partitions if a cache is in recovery state.
  - preloadPartition
```
public void preloadPartition(int part)
                      throws IgniteCheckedException
```
    Preload cache partition.
    
    Specified by:
    
    preloadPartition in interface org.apache.ignite.internal.processors.cache.IgniteInternalCache<Object,Object>
    
    Parameters:
    
    part - Partition.
    
    Throws:
    
    IgniteCheckedException - If failed.
  - preloadPartitionAsync
```
public org.apache.ignite.internal.IgniteInternalFuture<?> preloadPartitionAsync(int part)
                                                                         throws IgniteCheckedException
```
    Preload cache partition.
    
    Specified by:
    
    preloadPartitionAsync in interface org.apache.ignite.internal.processors.cache.IgniteInternalCache<Object,Object>
    
    Parameters:
    
    part - Partition.
    
    Returns:
    
    Future to be completed whenever preloading completes.
    
    Throws:
    
    IgniteCheckedException - If failed.
  - localPreloadPartition
```
public boolean localPreloadPartition(int part)
                              throws IgniteCheckedException
```
    Preloads cache partition if it exists on local node.
    
    Specified by:
    
    localPreloadPartition in interface org.apache.ignite.internal.processors.cache.IgniteInternalCache<Object,Object>
    
    Parameters:
    
    part - Partition.
    
    Returns:
    
    True if partition was preloaded, false if it doesn't belong to local node.
    
    Throws:
    
    IgniteCheckedException - If failed.
  - invoke
```
@Nullable
public @Nullable javax.cache.processor.EntryProcessorResult invoke(@Nullable
                                                                             @Nullable org.apache.ignite.internal.processors.affinity.AffinityTopologyVersion topVer,
                                                                             Object key,
                                                                             javax.cache.processor.EntryProcessor entryProcessor,
                                                                             Object... args)
                                                                      throws IgniteCheckedException
```
    Specified by:
    
    invoke in interface org.apache.ignite.internal.processors.cache.IgniteInternalCache<Object,Object>
    
    Parameters:
    
    topVer - Locked topology version.
    
    key - Key.
    
    entryProcessor - Entry processor.
    
    args - Arguments.
    
    Returns:
    
    Invoke result.
    
    Throws:
    
    IgniteCheckedException - If failed.
  - invokeAllAsync
```
public org.apache.ignite.internal.IgniteInternalFuture<Map> invokeAllAsync(Map map,
                                                                           Object... args)
```
    Specified by:
    
    invokeAllAsync in interface org.apache.ignite.internal.processors.cache.IgniteInternalCache<Object,Object>
    
    Parameters:
    
    map - Map containing keys and entry processors to be applied to values.
    
    args - Arguments.
    
    Returns:
    
    Future.
  - invokeAll
```
public Map invokeAll(Map map,
                     Object... args)
              throws IgniteCheckedException
```
    Specified by:
    
    invokeAll in interface org.apache.ignite.internal.processors.cache.IgniteInternalCache<Object,Object>
    
    Parameters:
    
    map - Map containing keys and entry processors to be applied to values.
    
    args - Arguments.
    
    Returns:
    
    Invoke results.
    
    Throws:
    
    IgniteCheckedException - If failed.
  - invokeAllAsync
```
public org.apache.ignite.internal.IgniteInternalFuture<Map> invokeAllAsync(Set keys,
                                                                           javax.cache.processor.EntryProcessor entryProcessor,
                                                                           Object... args)
```
    Specified by:
    
    invokeAllAsync in interface org.apache.ignite.internal.processors.cache.IgniteInternalCache<Object,Object>
    
    Parameters:
    
    keys - Keys.
    
    entryProcessor - Entry processor.
    
    args - Arguments.
    
    Returns:
    
    Future.
  - invokeAll
```
public Map invokeAll(Set keys,
                     javax.cache.processor.EntryProcessor entryProcessor,
                     Object... args)
              throws IgniteCheckedException
```
    Specified by:
    
    invokeAll in interface org.apache.ignite.internal.processors.cache.IgniteInternalCache<Object,Object>
    
    Parameters:
    
    keys - Keys.
    
    entryProcessor - Entry processor.
    
    args - Arguments.
    
    Returns:
    
    Invoke results.
    
    Throws:
    
    IgniteCheckedException - If failed.
  - invokeAsync
```
public org.apache.ignite.internal.IgniteInternalFuture<javax.cache.processor.EntryProcessorResult> invokeAsync(Object key,
                                                                                                               javax.cache.processor.EntryProcessor entryProcessor,
                                                                                                               Object... args)
```
    Specified by:
    
    invokeAsync in interface org.apache.ignite.internal.processors.cache.IgniteInternalCache<Object,Object>
    
    Parameters:
    
    key - Key.
    
    entryProcessor - Entry processor.
    
    args - Arguments.
    
    Returns:
    
    Future.
  - invoke
```
@Nullable
public @Nullable javax.cache.processor.EntryProcessorResult invoke(Object key,
                                                                             javax.cache.processor.EntryProcessor entryProcessor,
                                                                             Object... args)
                                                                      throws IgniteCheckedException
```
    Specified by:
    
    invoke in interface org.apache.ignite.internal.processors.cache.IgniteInternalCache<Object,Object>
    
    Parameters:
    
    key - Key.
    
    entryProcessor - Entry processor.
    
    args - Arguments.
    
    Returns:
    
    Invoke result.
    
    Throws:
    
    IgniteCheckedException - If failed.
  - scanIterator
```
public Iterator<javax.cache.Cache.Entry<Object,Object>> scanIterator(boolean keepBinary,
                                                                     @Nullable
                                                                     @Nullable IgniteBiPredicate p)
                                                              throws IgniteCheckedException
```
    Specified by:
    
    scanIterator in interface org.apache.ignite.internal.processors.cache.IgniteInternalCache<Object,Object>
    
    Parameters:
    
    keepBinary - Keep binary flag.
    
    p - Optional key/value predicate.
    
    Returns:
    
    Scan query iterator.
    
    Throws:
    
    IgniteCheckedException - If failed.
  - removeAllConflictAsync
```
public org.apache.ignite.internal.IgniteInternalFuture<?> removeAllConflictAsync(Map drMap)
                                                                          throws IgniteCheckedException
```
    Removes DR data asynchronously.
    
    Specified by:
    
    removeAllConflictAsync in interface org.apache.ignite.internal.processors.cache.IgniteInternalCache<Object,Object>
    
    Parameters:
    
    drMap - DR map.
    
    Returns:
    
    Future.
    
    Throws:
    
    IgniteCheckedException - If remove failed.
  - removeAllConflict
```
public void removeAllConflict(Map drMap)
                       throws IgniteCheckedException
```
    Removes DR data.
    
    Specified by:
    
    removeAllConflict in interface org.apache.ignite.internal.processors.cache.IgniteInternalCache<Object,Object>
    
    Parameters:
    
    drMap - DR map.
    
    Throws:
    
    IgniteCheckedException - If remove failed.
  - putAllConflictAsync
```
public org.apache.ignite.internal.IgniteInternalFuture<?> putAllConflictAsync(Map drMap)
                                                                       throws IgniteCheckedException
```
    Store DR data asynchronously.
    
    Specified by:
    
    putAllConflictAsync in interface org.apache.ignite.internal.processors.cache.IgniteInternalCache<Object,Object>
    
    Parameters:
    
    drMap - DR map.
    
    Returns:
    
    Future.
    
    Throws:
    
    IgniteCheckedException - If put operation failed.
  - putAllConflict
```
public void putAllConflict(Map drMap)
                    throws IgniteCheckedException
```
    Store DR data.
    
    Specified by:
    
    putAllConflict in interface org.apache.ignite.internal.processors.cache.IgniteInternalCache<Object,Object>
    
    Parameters:
    
    drMap - DR map.
    
    Throws:
    
    IgniteCheckedException - If put operation failed.
  - keepBinary
```
public org.apache.ignite.internal.processors.cache.IgniteInternalCache keepBinary()
```
    Creates projection that will operate with binary objects.
    Projection returned by this method will force cache not to deserialize binary objects, so keys and values will be returned from cache API methods without changes. Therefore, signature of the projection can contain only following types:
    - org.gridgain.grid.binary.BinaryObject for binary 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 binary)
    For example, if you use Integer as a key and Value class as a value (which will be stored in binary format), you should acquire following projection to avoid deserialization:
```
 IgniteInternalCache prj = cache.keepBinary();

 // Value is not deserialized and returned in binary format.
 GridBinaryObject po = prj.get(1);
 
```
    Note that this method makes sense only if cache is working in binary mode (org.apache.ignite.configuration.CacheConfiguration#isBinaryEnabled() returns true. If not, this method is no-op and will return current projection.
    Specified by:
    
    keepBinary in interface org.apache.ignite.internal.processors.cache.IgniteInternalCache<Object,Object>
    
    Returns:
    
    New internal cache instance for binary objects.
  - cache
```
public org.apache.ignite.internal.processors.cache.IgniteInternalCache cache()
```
    Gets base cache for this projection.
    
    Specified by:
    
    cache in interface org.apache.ignite.internal.processors.cache.IgniteInternalCache<Object,Object>
    
    Returns:
    
    Base cache for this projection.
  - iterator
```
public Iterator iterator()
```
    Specified by:
    
    iterator in interface Iterable<javax.cache.Cache.Entry<Object,Object>>

Class HibernateCacheProxy

Method Summary

Methods inherited from class java.lang.Object

Methods inherited from interface java.lang.Iterable

Method Detail

keyTransformer

name

skipStore

setSkipStore

isEmpty

containsKey

containsKeyAsync

containsKeys

containsKeysAsync

localPeek

localEntries

get

Transactions

getEntry

Transactions

getAsync

Transactions

getEntryAsync

Transactions

getAll

Transactions

getEntries

Transactions

getAllAsync

Transactions

getEntriesAsync

Transactions

getAndPut

Transactions

getAndPutAsync

Transactions

put

Transactions

putAsync

Transactions

getAndPutIfAbsent

Transactions

getAndPutIfAbsentAsync

Transactions

putIfAbsent

Transactions

putIfAbsentAsync

Transactions

getAndReplace

Transactions

getAndReplaceAsync

Transactions

replace

Transactions

replaceAsync

Transactions

replace

Transactions

replaceAsync

Transactions

putAll

Transactions

putAllAsync

Transactions

keySet

entrySet

txStart

txStartEx

txStart

tx

evict

evictAll

clearLocally

clearLocally

clearLocallyAll

clear

clearAll

clear

clearAsync

clearAsync