GridDhtAtomicCache (Ignite 1.1.0-incubating)

java.lang.Object
- org.apache.ignite.internal.processors.cache.GridCacheAdapter<K,V>
- - org.apache.ignite.internal.processors.cache.distributed.GridDistributedCacheAdapter<K,V>
  - - org.apache.ignite.internal.processors.cache.distributed.dht.GridDhtCacheAdapter<K,V>
    - - org.apache.ignite.internal.processors.cache.distributed.dht.atomic.GridDhtAtomicCache<K,V>

All Implemented Interfaces:

Externalizable, Serializable, Iterable<javax.cache.Cache.Entry<K,V>>, IgniteInternalCache<K,V>
```
@GridToStringExclude
public class GridDhtAtomicCache<K,V>
extends GridDhtCacheAdapter<K,V>
```
Non-transactional partitioned cache.

See Also:
Serialized Form

Nested Class Summary
- Nested classes/interfaces inherited from class org.apache.ignite.internal.processors.cache.GridCacheAdapter
  GridCacheAdapter.AsyncOp<T>, GridCacheAdapter.CacheExpiryPolicy, GridCacheAdapter.FutureHolder, GridCacheAdapter.TopologyVersionAwareJob, GridCacheAdapter.UpdateGetTimeStatClosure<T>, GridCacheAdapter.UpdatePutAndGetTimeStatClosure<T>, GridCacheAdapter.UpdatePutTimeStatClosure<T>, GridCacheAdapter.UpdateRemoveTimeStatClosure<T>, GridCacheAdapter.UpdateTimeStatClosure<T>

Field Summary
- Fields inherited from class org.apache.ignite.internal.processors.cache.distributed.dht.GridDhtCacheAdapter
  preldr
- Fields inherited from class org.apache.ignite.internal.processors.cache.GridCacheAdapter
  cacheCfg, CLEAR_ALL_SPLIT_THRESHOLD, ctx, gridCfg, keyCheck, lastFut, locNodeId, log, map, metrics, mxBean, RET2NULL

Constructor Summary

Constructors
Constructor and Description
`GridDhtAtomicCache()` Empty constructor required by `Externalizable`.
`GridDhtAtomicCache(GridCacheContext<K,V> ctx)`
`GridDhtAtomicCache(GridCacheContext<K,V> ctx, GridCacheConcurrentMap map)`

Method Summary

Methods
Modifier and Type	Method and Description
`protected <T> IgniteInternalFuture<T>`	`asyncOp(CO<IgniteInternalFuture<T>> op)`
`IgniteInternalFuture<Map<K,V>>`	`getAllAsync(Collection<? extends K> keys, boolean forcePrimary, boolean skipTx, GridCacheEntryEx entry, UUID subjId, String taskName, boolean deserializePortable, boolean skipVals)` This method is used internally.
`V`	`getAndPut(K key, V val, CacheEntryPredicate[] filter)`
`IgniteInternalFuture<V>`	`getAndPutAsync0(K key, V val, CacheEntryPredicate... filter)`
`V`	`getAndPutIfAbsent(K key, V val)` Stores given key-value pair in cache only if cache had no previous mapping for it.
`IgniteInternalFuture<V>`	`getAndPutIfAbsentAsync(K key, V val)` Asynchronously stores given key-value pair in cache only if cache had no previous mapping for it.
`V`	`getAndRemove(K key)` Removes given key mapping from cache.
`IgniteInternalFuture<V>`	`getAndRemoveAsync(K key)` Asynchronously removes given key mapping from cache.
`V`	`getAndReplace(K key, V val)` Stores given key-value pair in cache only if there is a previous mapping for it.
`IgniteInternalFuture<V>`	`getAndReplaceAsync(K key, V val)` Asynchronously stores given key-value pair in cache only if there is a previous mapping for it.
`protected void`	`init()` Post constructor initialization for subclasses.
`<T> javax.cache.processor.EntryProcessorResult<T>`	`invoke(K key, javax.cache.processor.EntryProcessor<K,V,T> entryProcessor, Object... args)`
`<T> Map<K,javax.cache.processor.EntryProcessorResult<T>>`	`invokeAll(Map<? extends K,? extends javax.cache.processor.EntryProcessor<K,V,T>> map, Object... args)`
`<T> Map<K,javax.cache.processor.EntryProcessorResult<T>>`	`invokeAll(Set<? extends K> keys, javax.cache.processor.EntryProcessor<K,V,T> entryProcessor, Object... args)`
`<T> IgniteInternalFuture<Map<K,javax.cache.processor.EntryProcessorResult<T>>>`	`invokeAllAsync(Map<? extends K,? extends javax.cache.processor.EntryProcessor<K,V,T>> map, Object... args)`
`<T> IgniteInternalFuture<Map<K,javax.cache.processor.EntryProcessorResult<T>>>`	`invokeAllAsync(Set<? extends K> keys, javax.cache.processor.EntryProcessor<K,V,T> entryProcessor, Object... args)`
`<T> IgniteInternalFuture<javax.cache.processor.EntryProcessorResult<T>>`	`invokeAsync(K key, javax.cache.processor.EntryProcessor<K,V,T> entryProcessor, Object... args)`
`boolean`	`isDhtAtomic()`
`IgniteInternalFuture<?>`	`localRemoveAll(CacheEntryPredicate filter)`
`protected IgniteInternalFuture<Boolean>`	`lockAllAsync(Collection<KeyCacheObject> keys, long timeout, IgniteTxLocalEx tx, boolean isInvalidate, boolean isRead, boolean retval, TransactionIsolation isolation, long accessTtl)`
`GridNearCacheAdapter<K,V>`	`near()`
`void`	`near(GridNearAtomicCache<K,V> near)`
`boolean`	`put(K key, V val, CacheEntryPredicate[] filter)`
`void`	`putAll(Map<? extends K,? extends V> m)` Stores given key-value pairs in cache.
`IgniteInternalFuture<?>`	`putAllAsync(Map<? extends K,? extends V> m)` Asynchronously stores given key-value pairs in cache.
`void`	`putAllConflict(Map<KeyCacheObject,GridCacheDrInfo> conflictMap)` Store DR data.
`IgniteInternalFuture<?>`	`putAllConflictAsync(Map<KeyCacheObject,GridCacheDrInfo> conflictMap)` Store DR data asynchronously.
`IgniteInternalFuture<Boolean>`	`putAsync0(K key, V val, CacheEntryPredicate... filter)`
`boolean`	`putIfAbsent(K key, V val)` Stores given key-value pair in cache only if cache had no previous mapping for it.
`IgniteInternalFuture<Boolean>`	`putIfAbsentAsync(K key, V val)` Asynchronously stores given key-value pair in cache only if cache had no previous mapping for it.
`boolean`	`remove(K key)` Removes given key mapping from cache.
`boolean`	`remove(K key, V val)` Removes given key mapping from cache if one exists and value is equal to the passed in value.
`void`	`removeAll(Collection<? extends K> keys)` Removes given key mappings from cache for entries for which the optionally passed in filters do pass.
`IgniteInternalFuture<?>`	`removeAllAsync(Collection<? extends K> keys)` Asynchronously removes given key mappings from cache for entries for which the optionally passed in filters do pass.
`void`	`removeAllConflict(Map<KeyCacheObject,GridCacheVersion> conflictMap)` Removes DR data.
`IgniteInternalFuture<?>`	`removeAllConflictAsync(Map<KeyCacheObject,GridCacheVersion> conflictMap)` Removes DR data asynchronously.
`IgniteInternalFuture<Boolean>`	`removeAsync(K key, CacheEntryPredicate... filter)`
`IgniteInternalFuture<Boolean>`	`removeAsync(K key, V val)` Asynchronously removes given key mapping from cache if one exists and value is equal to the passed in value.
`GridCacheReturn`	`removex(K key, V val)` Removes given key mapping from cache if one exists and value is equal to the passed in value.
`IgniteInternalFuture<GridCacheReturn>`	`removexAsync(K key, V val)` Asynchronously removes given key mapping from cache if one exists and value is equal to the passed in value.
`boolean`	`replace(K key, V val)` Stores given key-value pair in cache only if only if there is a previous mapping for it.
`boolean`	`replace(K key, V oldVal, V newVal)` Stores given key-value pair in cache only if only if the previous value is equal to the `'oldVal'` passed in.
`IgniteInternalFuture<Boolean>`	`replaceAsync(K key, V val)` Asynchronously stores given key-value pair in cache only if only if there is a previous mapping for it.
`IgniteInternalFuture<Boolean>`	`replaceAsync(K key, V oldVal, V newVal)` Asynchronously stores given key-value pair in cache only if only if the previous value is equal to the `'oldVal'` passed in.
`GridCacheReturn`	`replacex(K key, V oldVal, V newVal)` Stores given key-value pair in cache only if only if the previous value is equal to the `'oldVal'` passed in.
`IgniteInternalFuture<GridCacheReturn>`	`replacexAsync(K key, V oldVal, V newVal)` Asynchronously stores given key-value pair in cache only if only if the previous value is equal to the `'oldVal'` passed in.
`void`	`start()` Starts this cache.
`void`	`stop()` Stops this cache.
`String`	`toString()`
`V`	`tryPutIfAbsent(K key, V val)` Tries to put value in cache.
`void`	`updateAllAsyncInternal(UUID nodeId, GridNearAtomicUpdateRequest req, CI2<GridNearAtomicUpdateRequest,GridNearAtomicUpdateResponse> completionCb)` Executes local update.
`void`	`updateAllAsyncInternal0(UUID nodeId, GridNearAtomicUpdateRequest req, CI2<GridNearAtomicUpdateRequest,GridNearAtomicUpdateResponse> completionCb)` Executes local update after preloader fetched values.

Methods inherited from class org.apache.ignite.internal.processors.cache.distributed.dht.GridDhtCacheAdapter
beginMultiUpdate, dhtPreloader, endMultiUpdate, entryEx, entryEx, entryExx, entryExx, entryExx, entrySet, getDhtAsync, localEntriesIterator, localLoad, localLoadCache, multiUpdateFinishFuture, multiUpdateTopologyFuture, onDeferredDelete, onKernalStart, onKernalStop, peekExx, preloader, primarySize, printMemoryStats, processNearGetRequest, sendTtlUpdateRequest, splitClearLocally, topology, unlockAll

Methods inherited from class org.apache.ignite.internal.processors.cache.distributed.GridDistributedCacheAdapter
lockAllAsync, removeAll, removeAllAsync, removeVersionedEntry, txLockAsync

Methods inherited from class org.apache.ignite.internal.processors.cache.GridCacheAdapter
affinity, allEntries, asyncOp, asyncOpAcquire, asyncOpRelease, awaitLastFut, cache, checkJta, clear, clear, clearAll, clearAsync, clearAsync, clearAsync, clearLocally, clearLocally, clearLocally, clearLocally0, clearLocally0, clearLocallyAll, commitTxAsync, configuration, containsKey, containsKeyAsync, containsKeys, containsKeysAsync, context, entries, entryEx, entryEx, entryExSafe, entrySet, entrySet, entrySetx, evict, evictAll, expiry, expiryPolicy, forSubjectId, get, get, getAll, getAll, getAllAsync, getAllAsync, getAllAsync, getAllAsync0, getAllOutTx, getAndPut, getAndPutAsync, getAndPutAsync, getAsync, getAsync, getForcePrimary, getForcePrimaryAsync, igfsDataSpaceMax, igfsDataSpaceUsed, igniteIterator, isColocated, isDht, isEmpty, isIgfsDataCache, isLocal, isLocked, isLockedByThread, isMongoDataCache, isMongoMetaCache, isNear, iterator, iterator, keepPortable, keySet, keySet, loadAll, localEntries, localLoadCacheAsync, localPeek, localSize, lock, lockAll, lockAsync, log, map, metrics, metrics0, mxBean, name, nearSize, offHeapAllocatedSize, offHeapEntriesCount, offHeapIterator, onIgfsDataSizeChanged, onUndeploy, overflowSize, peekEx, peekEx, primaryEntrySet, primaryKeySet, primaryKeySet, promote, promoteAll, put, putAsync, putAsync, randomEntry, readExternal, readResolve, readThroughAllAsync, rebalance, reloadAllAsync0, removeAsync, removeEntry, removeIfObsolete, saveFuture, setSkipStore, size, size, sizeAsync, skipStore, startInfo, stopInfo, swapIterator, swapKeys, swapSize, tx, txStart, txStart, txStartEx, unlock, validateCacheKey, validateCacheKeys, values, values, withExpiryPolicy, writeExternal

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

- Constructor Detail
  - GridDhtAtomicCache
```
public GridDhtAtomicCache()
```
    Empty constructor required by Externalizable.
  - GridDhtAtomicCache
```
public GridDhtAtomicCache(GridCacheContext<K,V> ctx)
```
    Parameters:
    ctx - Cache context.
  - GridDhtAtomicCache
```
public GridDhtAtomicCache(GridCacheContext<K,V> ctx,
                  GridCacheConcurrentMap map)
```
    Parameters:
    ctx - Cache context.
    map - Cache concurrent map.
- Method Detail
  - isDhtAtomic
```
public boolean isDhtAtomic()
```
    Overrides:
    
    isDhtAtomic in class GridCacheAdapter<K,V>
    
    Returns:
    True if cache is DHT Atomic.
  - init
```
protected void init()
```
    Post constructor initialization for subclasses.
    
    Overrides:
    
    init in class GridDhtCacheAdapter<K,V>
  - start
```
public void start()
           throws IgniteCheckedException
```
    Starts this cache. Child classes should override this method to provide custom start-up behavior.
    
    Overrides:
    
    start in class GridDhtCacheAdapter<K,V>
    
    Throws:
    
    IgniteCheckedException - If start failed.
  - stop
```
public void stop()
```
    Stops this cache. Child classes should override this method to provide custom stop behavior.
    
    Overrides:
    
    stop in class GridDhtCacheAdapter<K,V>
  - near
```
public void near(GridNearAtomicCache<K,V> near)
```
    Parameters:
    near - Near cache.
  - near
```
public GridNearCacheAdapter<K,V> near()
```
    Specified by:
    
    near in class GridDhtCacheAdapter<K,V>
    
    Returns:
    Near cache.
  - getAllAsync
```
public IgniteInternalFuture<Map<K,V>> getAllAsync(@Nullable
                                         Collection<? extends K> keys,
                                         boolean forcePrimary,
                                         boolean skipTx,
                                         @Nullable
                                         GridCacheEntryEx entry,
                                         @Nullable
                                         UUID subjId,
                                         String taskName,
                                         boolean deserializePortable,
                                         boolean skipVals)
```
    This method is used internally. Use GridDhtCacheAdapter.getDhtAsync(UUID, long, LinkedHashMap, boolean, boolean, AffinityTopologyVersion, UUID, int, IgniteCacheExpiryPolicy, boolean) method instead to retrieve DHT value.
    
    Overrides:
    
    getAllAsync in class GridDhtCacheAdapter<K,V>
    
    Parameters:
    keys - Keys.
    forcePrimary - Force primary.
    skipTx - Skip tx.
    entry - Entry.
    subjId - Subj Id.
    taskName - Task name.
    deserializePortable - Deserialize portable.
    skipVals - Skip values.
    
    Returns:
    Future for the get operation.
    See Also:
    GridCacheAdapter.getAllAsync(Collection)
  - getAndPut
```
public V getAndPut(K key,
          V val,
          @Nullable
          CacheEntryPredicate[] filter)
            throws IgniteCheckedException
```
    Overrides:
    
    getAndPut in class GridCacheAdapter<K,V>
    
    Parameters:
    key - Key.
    val - Value.
    filter - Optional filter.
    
    Returns:
    Previous value.
    
    Throws:
    
    IgniteCheckedException - If failed.
  - put
```
public boolean put(K key,
          V val,
          CacheEntryPredicate[] filter)
            throws IgniteCheckedException
```
    Overrides:
    
    put in class GridCacheAdapter<K,V>
    
    Parameters:
    key - Key.
    val - Value.
    filter - Filter.
    
    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.
  - getAndPutAsync0
```
public IgniteInternalFuture<V> getAndPutAsync0(K key,
                                      V val,
                                      @Nullable
                                      CacheEntryPredicate... filter)
```
    Overrides:
    
    getAndPutAsync0 in class GridCacheAdapter<K,V>
    
    Parameters:
    key - Key.
    val - Value.
    filter - Optional filter.
    
    Returns:
    Put operation future.
  - putAsync0
```
public IgniteInternalFuture<Boolean> putAsync0(K key,
                                      V val,
                                      @Nullable
                                      CacheEntryPredicate... filter)
```
    Overrides:
    
    putAsync0 in class GridCacheAdapter<K,V>
    
    Parameters:
    key - Key.
    val - Value.
    filter - Optional filter.
    
    Returns:
    Putx operation future.
  - tryPutIfAbsent
```
public V tryPutIfAbsent(K key,
               V val)
                 throws IgniteCheckedException
```
    Tries to put value in cache. Will fail with GridCacheTryPutFailedException if topology exchange is in progress.
    
    Overrides:
    
    tryPutIfAbsent in class GridCacheAdapter<K,V>
    
    Parameters:
    key - Key.
    val - value.
    
    Returns:
    Old value.
    
    Throws:
    
    IgniteCheckedException - In case of error.
  - getAndPutIfAbsent
```
public V getAndPutIfAbsent(K key,
                  V val)
                    throws IgniteCheckedException
```
    Stores given key-value pair in cache only if cache had no previous mapping for it. If cache previously contained value for the given key, then this value is returned. In case of CacheMode.PARTITIONED or CacheMode.REPLICATED caches, the value will be loaded from the primary node, which in its turn may load the value from the swap storage, and consecutively, if it's not in swap, from the underlying persistent storage. If value has to be loaded from persistent storage, CacheStore#load(Transaction, Object) method will be used.
    If the returned value is not needed, method 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 IgniteInternalCache<K,V>
    
    Overrides:
    
    getAndPutIfAbsent in class GridCacheAdapter<K,V>
    
    Parameters:
    key - Key to store in cache.
    val - Value to be associated with the given key.
    
    Returns:
    Previously contained value regardless of whether put happened or not.
    
    Throws:
    
    IgniteCheckedException - If put operation failed.
  - getAndPutIfAbsentAsync
```
public IgniteInternalFuture<V> getAndPutIfAbsentAsync(K key,
                                             V val)
```
    Asynchronously stores given key-value pair in cache only if cache had no previous mapping for it. If cache previously contained value for the given key, then this value is returned. In case of CacheMode.PARTITIONED or CacheMode.REPLICATED caches, the value will be loaded from the primary node, which in its turn may load the value from the swap storage, and consecutively, if it's not in swap, from the underlying persistent storage. If value has to be loaded from persistent storage, CacheStore#load(Transaction, Object) method will be used.
    If the returned value is not needed, method 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 IgniteInternalCache<K,V>
    
    Overrides:
    
    getAndPutIfAbsentAsync in class GridCacheAdapter<K,V>
    
    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(K key,
                  V val)
                    throws IgniteCheckedException
```
    Stores given key-value pair in cache only if cache had no previous mapping for it.
    This method will return true if value is stored in cache and false otherwise. Unlike 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 IgniteInternalCache<K,V>
    
    Overrides:
    
    putIfAbsent in class GridCacheAdapter<K,V>
    
    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 IgniteInternalFuture<Boolean> putIfAbsentAsync(K key,
                                             V val)
```
    Asynchronously stores given key-value pair in cache only if cache had no previous mapping for it.
    This method will return true if value is stored in cache and false otherwise. Unlike 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 IgniteInternalCache<K,V>
    
    Overrides:
    
    putIfAbsentAsync in class GridCacheAdapter<K,V>
    
    Parameters:
    key - Key to store in cache.
    val - Value to be associated with the given key.
    
    Returns:
    Future for this put operation.
  - getAndReplace
```
public V getAndReplace(K key,
              V val)
                throws IgniteCheckedException
```
    Stores given key-value pair in cache only if there is a previous mapping for it. In case of CacheMode.PARTITIONED or CacheMode.REPLICATED caches, the value will be loaded from the primary node, which in its turn may load the value from the swap storage, and consecutively, if it's not in swap, from the underlying persistent storage. If value has to be loaded from persistent storage, CacheStore#load(Transaction, Object) method will be used.
    If the returned value is not needed, method 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 IgniteInternalCache<K,V>
    
    Overrides:
    
    getAndReplace in class GridCacheAdapter<K,V>
    
    Parameters:
    key - Key to store in cache.
    val - Value to be associated with the given key.
    
    Returns:
    Previously contained value regardless of whether replace happened or not.
    
    Throws:
    
    IgniteCheckedException - If replace operation failed.
  - getAndReplaceAsync
```
public IgniteInternalFuture<V> getAndReplaceAsync(K key,
                                         V val)
```
    Asynchronously stores given key-value pair in cache only if there is a previous mapping for it. If cache previously contained value for the given key, then this value is returned.In case of CacheMode.PARTITIONED caches, the value will be loaded from the primary node, which in its turn may load the value from the swap storage, and consecutively, if it's not in swap, from the underlying persistent storage. If value has to be loaded from persistent storage, CacheStore#load(Transaction, Object) method will be used.
    If the returned value is not needed, method 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 IgniteInternalCache<K,V>
    
    Overrides:
    
    getAndReplaceAsync in class GridCacheAdapter<K,V>
    
    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(K key,
              V val)
                throws IgniteCheckedException
```
    Stores given key-value pair in cache only if only if there is a previous mapping for it.
    This method will return true if value is stored in cache and false otherwise. Unlike 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 IgniteInternalCache<K,V>
    
    Overrides:
    
    replace in class GridCacheAdapter<K,V>
    
    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 IgniteInternalFuture<Boolean> replaceAsync(K key,
                                         V val)
```
    Asynchronously stores given key-value pair in cache only if only if there is a previous mapping for it.
    This method will return true if value is stored in cache and false otherwise. Unlike 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 IgniteInternalCache<K,V>
    
    Overrides:
    
    replaceAsync in class GridCacheAdapter<K,V>
    
    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(K key,
              V oldVal,
              V newVal)
                throws IgniteCheckedException
```
    Stores given key-value pair in cache only if only if the previous value is equal to the 'oldVal' passed in.
    This method will return true if value is stored in cache and false otherwise.
    If write-through is enabled, the stored value will be persisted to CacheStore via CacheStore#put(Transaction, Object, Object) method.
    Transactions
    This method is transactional and will enlist the entry into ongoing transaction if there is one.
    
    Specified by:
    
    replace in interface IgniteInternalCache<K,V>
    
    Overrides:
    
    replace in class GridCacheAdapter<K,V>
    
    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 IgniteInternalFuture<Boolean> replaceAsync(K key,
                                         V oldVal,
                                         V newVal)
```
    Asynchronously stores given key-value pair in cache only if only if the previous value is equal to the 'oldVal' passed in.
    This method will return true if value is stored in cache and false otherwise.
    If write-through is enabled, the stored value will be persisted to CacheStore via CacheStore#put(Transaction, Object, Object) method.
    Transactions
    This method is transactional and will enlist the entry into ongoing transaction if there is one.
    
    Specified by:
    
    replaceAsync in interface IgniteInternalCache<K,V>
    
    Overrides:
    
    replaceAsync in class GridCacheAdapter<K,V>
    
    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.
  - removex
```
public GridCacheReturn removex(K key,
                      V val)
                        throws IgniteCheckedException
```
    Removes given key mapping from cache if one exists and value is equal to the passed in value.
    If write-through is enabled, the value will be removed from CacheStore via CacheWriter.delete(Object) method.
    Transactions
    This method is transactional and will enlist the entry into ongoing transaction if there is one.
    
    Specified by:
    
    removex in interface IgniteInternalCache<K,V>
    
    Overrides:
    
    removex in class GridCacheAdapter<K,V>
    
    Parameters:
    key - Key whose mapping is to be removed from cache.
    val - Value to match against currently cached value.
    
    Returns:
    Object containing actual old value and success flag.
    
    Throws:
    
    IgniteCheckedException - If remove failed.
  - replacex
```
public GridCacheReturn replacex(K key,
                       V oldVal,
                       V newVal)
                         throws IgniteCheckedException
```
    Stores given key-value pair in cache only if only if the previous value is equal to the 'oldVal' passed in.
    This method will return true if value is stored in cache and false otherwise.
    If write-through is enabled, the stored value will be persisted to CacheStore via CacheWriter.write(javax.cache.Cache.Entry) method.
    Transactions
    This method is transactional and will enlist the entry into ongoing transaction if there is one.
    
    Specified by:
    
    replacex in interface IgniteInternalCache<K,V>
    
    Overrides:
    
    replacex in class GridCacheAdapter<K,V>
    
    Parameters:
    key - Key to store in cache.
    oldVal - Old value to match.
    newVal - Value to be associated with the given key.
    
    Returns:
    Object containing actual old value and success flag.
    
    Throws:
    
    IgniteCheckedException - If replace operation failed.
  - removexAsync
```
public IgniteInternalFuture<GridCacheReturn> removexAsync(K key,
                                                 V val)
```
    Asynchronously removes given key mapping from cache if one exists and value is equal to the passed in value.
    This method will return true if remove did occur, which means that all optionally provided filters have passed and there was something to remove, false otherwise.
    If write-through is enabled, the value will be removed from CacheStore via CacheWriter.delete(Object) method.
    Transactions
    This method is transactional and will enlist the entry into ongoing transaction if there is one.
    
    Specified by:
    
    removexAsync in interface IgniteInternalCache<K,V>
    
    Overrides:
    
    removexAsync in class GridCacheAdapter<K,V>
    
    Parameters:
    key - Key whose mapping is to be removed from cache.
    val - Value to match against currently cached value.
    
    Returns:
    Future for the remove operation. The future will return object containing actual old value and success flag.
  - replacexAsync
```
public IgniteInternalFuture<GridCacheReturn> replacexAsync(K key,
                                                  V oldVal,
                                                  V newVal)
```
    Asynchronously stores given key-value pair in cache only if only if the previous value is equal to the 'oldVal' passed in.
    This method will return true if value is stored in cache and false otherwise.
    If write-through is enabled, the stored value will be persisted to CacheStore via CacheWriter.write(javax.cache.Cache.Entry) method.
    Transactions
    This method is transactional and will enlist the entry into ongoing transaction if there is one.
    
    Specified by:
    
    replacexAsync in interface IgniteInternalCache<K,V>
    
    Overrides:
    
    replacexAsync in class GridCacheAdapter<K,V>
    
    Parameters:
    key - Key to store in cache.
    oldVal - Old value to match.
    newVal - Value to be associated with the given key.
    
    Returns:
    Future for the replace operation. The future will return object containing actual old value and success flag.
  - putAll
```
public void putAll(Map<? extends K,? extends V> 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 IgniteInternalCache<K,V>
    
    Overrides:
    
    putAll in class GridCacheAdapter<K,V>
    
    Parameters:
    m - Key-value pairs to store in cache.
    
    Throws:
    
    IgniteCheckedException - If put operation failed.
  - putAllAsync
```
public IgniteInternalFuture<?> putAllAsync(Map<? extends K,? extends V> 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 IgniteInternalCache<K,V>
    
    Overrides:
    
    putAllAsync in class GridCacheAdapter<K,V>
    
    Parameters:
    m - Key-value pairs to store in cache.
    
    Returns:
    Future for putAll operation.
  - putAllConflict
```
public void putAllConflict(Map<KeyCacheObject,GridCacheDrInfo> conflictMap)
                    throws IgniteCheckedException
```
    Store DR data.
    
    Specified by:
    
    putAllConflict in interface IgniteInternalCache<K,V>
    
    Overrides:
    
    putAllConflict in class GridCacheAdapter<K,V>
    
    Parameters:
    conflictMap - DR map.
    
    Throws:
    
    IgniteCheckedException - If put operation failed.
  - putAllConflictAsync
```
public IgniteInternalFuture<?> putAllConflictAsync(Map<KeyCacheObject,GridCacheDrInfo> conflictMap)
```
    Store DR data asynchronously.
    
    Specified by:
    
    putAllConflictAsync in interface IgniteInternalCache<K,V>
    
    Overrides:
    
    putAllConflictAsync in class GridCacheAdapter<K,V>
    
    Parameters:
    conflictMap - DR map.
    
    Returns:
    Future.
  - getAndRemove
```
public V getAndRemove(K 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 IgniteInternalCache<K,V>
    
    Overrides:
    
    getAndRemove in class GridCacheAdapter<K,V>
    
    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 IgniteInternalFuture<V> getAndRemoveAsync(K 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 IgniteInternalCache<K,V>
    
    Overrides:
    
    getAndRemoveAsync in class GridCacheAdapter<K,V>
    
    Parameters:
    key - Key whose mapping is to be removed from cache.
    
    Returns:
    Future for the remove operation.
  - removeAll
```
public void removeAll(Collection<? extends K> keys)
               throws IgniteCheckedException
```
    Removes given key mappings from cache for entries for which the optionally passed in filters do pass.
    If write-through is enabled, the values will be removed from CacheStore via @link CacheStore#removeAll(Transaction, Collection) method.
    Transactions
    This method is transactional and will enlist the entry into ongoing transaction if there is one.
    
    Specified by:
    
    removeAll in interface IgniteInternalCache<K,V>
    
    Overrides:
    
    removeAll in class GridCacheAdapter<K,V>
    
    Parameters:
    keys - Keys whose mappings are to be removed from cache.
    
    Throws:
    
    IgniteCheckedException - If remove failed.
  - removeAllAsync
```
public IgniteInternalFuture<?> removeAllAsync(Collection<? extends K> keys)
```
    Asynchronously removes given key mappings from cache for entries for which the optionally passed in filters do pass.
    If write-through is enabled, the values will be removed from CacheStore via @link CacheStore#removeAll(Transaction, Collection) method.
    Transactions
    This method is transactional and will enlist the entry into ongoing transaction if there is one.
    
    Specified by:
    
    removeAllAsync in interface IgniteInternalCache<K,V>
    
    Overrides:
    
    removeAllAsync in class GridCacheAdapter<K,V>
    
    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.
  - remove
```
public boolean remove(K 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 IgniteInternalCache<K,V>
    
    Overrides:
    
    remove in class GridCacheAdapter<K,V>
    
    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 IgniteInternalFuture<Boolean> removeAsync(K key,
                                        @Nullable
                                        CacheEntryPredicate... filter)
```
    Overrides:
    
    removeAsync in class GridCacheAdapter<K,V>
    
    Parameters:
    key - Key to remove.
    filter - Optional filter.
    
    Returns:
    Putx operation future.
  - remove
```
public boolean remove(K key,
             V val)
               throws IgniteCheckedException
```
    Removes given key mapping from cache if one exists and value is equal to the passed in value.
    If write-through is enabled, the value will be removed from CacheStore via CacheStore#remove(Transaction, Object) method.
    Transactions
    This method is transactional and will enlist the entry into ongoing transaction if there is one.
    
    Specified by:
    
    remove in interface IgniteInternalCache<K,V>
    
    Overrides:
    
    remove in class GridCacheAdapter<K,V>
    
    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 IgniteInternalFuture<Boolean> removeAsync(K key,
                                        V val)
```
    Asynchronously removes given key mapping from cache if one exists and value is equal to the passed in value.
    This method will return true if remove did occur, which means that all optionally provided filters have passed and there was something to remove, false otherwise.
    If write-through is enabled, the value will be removed from CacheStore via CacheStore#remove(Transaction, Object) method.
    Transactions
    This method is transactional and will enlist the entry into ongoing transaction if there is one.
    
    Specified by:
    
    removeAsync in interface IgniteInternalCache<K,V>
    
    Overrides:
    
    removeAsync in class GridCacheAdapter<K,V>
    
    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.
  - localRemoveAll
```
public IgniteInternalFuture<?> localRemoveAll(CacheEntryPredicate filter)
```
    Overrides:
    
    localRemoveAll in class GridCacheAdapter<K,V>
    
    Parameters:
    filter - Filter.
    
    Returns:
    Future.
  - removeAllConflict
```
public void removeAllConflict(Map<KeyCacheObject,GridCacheVersion> conflictMap)
                       throws IgniteCheckedException
```
    Removes DR data.
    
    Specified by:
    
    removeAllConflict in interface IgniteInternalCache<K,V>
    
    Overrides:
    
    removeAllConflict in class GridCacheAdapter<K,V>
    
    Parameters:
    conflictMap - DR map.
    
    Throws:
    
    IgniteCheckedException - If remove failed.
  - removeAllConflictAsync
```
public IgniteInternalFuture<?> removeAllConflictAsync(Map<KeyCacheObject,GridCacheVersion> conflictMap)
```
    Removes DR data asynchronously.
    
    Specified by:
    
    removeAllConflictAsync in interface IgniteInternalCache<K,V>
    
    Overrides:
    
    removeAllConflictAsync in class GridCacheAdapter<K,V>
    
    Parameters:
    conflictMap - DR map.
    
    Returns:
    Future.
  - asyncOp
```
protected <T> IgniteInternalFuture<T> asyncOp(CO<IgniteInternalFuture<T>> op)
```
    Parameters:
    op - Operation closure.
    
    Returns:
    Future.
  - lockAllAsync
```
protected IgniteInternalFuture<Boolean> lockAllAsync(Collection<KeyCacheObject> keys,
                                         long timeout,
                                         @Nullable
                                         IgniteTxLocalEx tx,
                                         boolean isInvalidate,
                                         boolean isRead,
                                         boolean retval,
                                         @Nullable
                                         TransactionIsolation isolation,
                                         long accessTtl)
```
    Specified by:
    
    lockAllAsync in class GridDistributedCacheAdapter<K,V>
    
    Parameters:
    keys - Keys to lock.
    timeout - Timeout.
    tx - Transaction
    isInvalidate - Invalidation flag.
    isRead - Indicates whether value is read or written.
    retval - Flag to return value.
    isolation - Transaction isolation.
    accessTtl - TTL for read operation.
    
    Returns:
    Future for locks.
  - invoke
```
public <T> javax.cache.processor.EntryProcessorResult<T> invoke(K key,
                                                       javax.cache.processor.EntryProcessor<K,V,T> entryProcessor,
                                                       Object... args)
                                                     throws IgniteCheckedException
```
    Specified by:
    
    invoke in interface IgniteInternalCache<K,V>
    
    Overrides:
    
    invoke in class GridCacheAdapter<K,V>
    
    Parameters:
    key - Key.
    entryProcessor - Entry processor.
    args - Arguments.
    
    Returns:
    Invoke result.
    
    Throws:
    
    IgniteCheckedException - If failed.
  - invokeAll
```
public <T> Map<K,javax.cache.processor.EntryProcessorResult<T>> invokeAll(Set<? extends K> keys,
                                                                 javax.cache.processor.EntryProcessor<K,V,T> entryProcessor,
                                                                 Object... args)
                                                               throws IgniteCheckedException
```
    Specified by:
    
    invokeAll in interface IgniteInternalCache<K,V>
    
    Overrides:
    
    invokeAll in class GridCacheAdapter<K,V>
    
    Parameters:
    keys - Keys.
    entryProcessor - Entry processor.
    args - Arguments.
    
    Returns:
    Invoke results.
    
    Throws:
    
    IgniteCheckedException - If failed.
  - invokeAsync
```
public <T> IgniteInternalFuture<javax.cache.processor.EntryProcessorResult<T>> invokeAsync(K key,
                                                                                  javax.cache.processor.EntryProcessor<K,V,T> entryProcessor,
                                                                                  Object... args)
```
    Specified by:
    
    invokeAsync in interface IgniteInternalCache<K,V>
    
    Overrides:
    
    invokeAsync in class GridCacheAdapter<K,V>
    
    Parameters:
    key - Key.
    entryProcessor - Entry processor.
    args - Arguments.
    
    Returns:
    Future.
  - invokeAllAsync
```
public <T> IgniteInternalFuture<Map<K,javax.cache.processor.EntryProcessorResult<T>>> invokeAllAsync(Set<? extends K> keys,
                                                                                            javax.cache.processor.EntryProcessor<K,V,T> entryProcessor,
                                                                                            Object... args)
```
    Specified by:
    
    invokeAllAsync in interface IgniteInternalCache<K,V>
    
    Overrides:
    
    invokeAllAsync in class GridCacheAdapter<K,V>
    
    Parameters:
    keys - Keys.
    entryProcessor - Entry processor.
    args - Arguments.
    
    Returns:
    Future.
  - invokeAll
```
public <T> Map<K,javax.cache.processor.EntryProcessorResult<T>> invokeAll(Map<? extends K,? extends javax.cache.processor.EntryProcessor<K,V,T>> map,
                                                                 Object... args)
                                                               throws IgniteCheckedException
```
    Specified by:
    
    invokeAll in interface IgniteInternalCache<K,V>
    
    Overrides:
    
    invokeAll in class GridCacheAdapter<K,V>
    
    Parameters:
    map - Map containing keys and entry processors to be applied to values.
    args - Arguments.
    
    Returns:
    Invoke results.
    
    Throws:
    
    IgniteCheckedException - If failed.
  - invokeAllAsync
```
public <T> IgniteInternalFuture<Map<K,javax.cache.processor.EntryProcessorResult<T>>> invokeAllAsync(Map<? extends K,? extends javax.cache.processor.EntryProcessor<K,V,T>> map,
                                                                                            Object... args)
```
    Specified by:
    
    invokeAllAsync in interface IgniteInternalCache<K,V>
    
    Overrides:
    
    invokeAllAsync in class GridCacheAdapter<K,V>
    
    Parameters:
    map - Map containing keys and entry processors to be applied to values.
    args - Arguments.
    
    Returns:
    Future.
  - updateAllAsyncInternal
```
public void updateAllAsyncInternal(UUID nodeId,
                          GridNearAtomicUpdateRequest req,
                          CI2<GridNearAtomicUpdateRequest,GridNearAtomicUpdateResponse> completionCb)
```
    Executes local update.
    
    Parameters:
    nodeId - Node ID.
    req - Update request.
    completionCb - Completion callback.
  - updateAllAsyncInternal0
```
public void updateAllAsyncInternal0(UUID nodeId,
                           GridNearAtomicUpdateRequest req,
                           CI2<GridNearAtomicUpdateRequest,GridNearAtomicUpdateResponse> completionCb)
```
    Executes local update after preloader fetched values.
    
    Parameters:
    nodeId - Node ID.
    req - Update request.
    completionCb - Completion callback.
  - toString
```
public String toString()
```
    Overrides:
    
    toString in class GridDhtCacheAdapter<K,V>

Class GridDhtAtomicCache<K,V>

Nested Class Summary

Nested classes/interfaces inherited from class org.apache.ignite.internal.processors.cache.GridCacheAdapter

Field Summary

Fields inherited from class org.apache.ignite.internal.processors.cache.distributed.dht.GridDhtCacheAdapter

Fields inherited from class org.apache.ignite.internal.processors.cache.GridCacheAdapter

Constructor Summary

Method Summary

Methods inherited from class org.apache.ignite.internal.processors.cache.distributed.dht.GridDhtCacheAdapter

Methods inherited from class org.apache.ignite.internal.processors.cache.distributed.GridDistributedCacheAdapter

Methods inherited from class org.apache.ignite.internal.processors.cache.GridCacheAdapter

Methods inherited from class java.lang.Object

Constructor Detail

GridDhtAtomicCache

GridDhtAtomicCache

GridDhtAtomicCache

Method Detail

isDhtAtomic

init

start

stop

near

near

getAllAsync

getAndPut

put

getAndPutAsync0

putAsync0

tryPutIfAbsent

getAndPutIfAbsent

Transactions

getAndPutIfAbsentAsync

Transactions

putIfAbsent

Transactions

putIfAbsentAsync

Transactions

getAndReplace

Transactions

getAndReplaceAsync

Transactions

replace

Transactions

replaceAsync

Transactions

replace

Transactions

replaceAsync

Transactions

removex

Transactions

replacex

Transactions

removexAsync

Transactions

replacexAsync

Transactions

putAll

Transactions

putAllAsync

Transactions

putAllConflict

putAllConflictAsync

getAndRemove

Transactions

getAndRemoveAsync

Transactions

removeAll

Transactions

removeAllAsync

Transactions

remove

Transactions

removeAsync

remove

Transactions

removeAsync

Transactions

localRemoveAll

removeAllConflict