ignite-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From sboi...@apache.org
Subject [38/50] [abbrv] incubator-ignite git commit: #ignite-683: Rename put methods in GridCacheAdapter.
Date Tue, 14 Apr 2015 14:25:54 GMT
#ignite-683: Rename put methods in GridCacheAdapter.


Project: http://git-wip-us.apache.org/repos/asf/incubator-ignite/repo
Commit: http://git-wip-us.apache.org/repos/asf/incubator-ignite/commit/b026f2cc
Tree: http://git-wip-us.apache.org/repos/asf/incubator-ignite/tree/b026f2cc
Diff: http://git-wip-us.apache.org/repos/asf/incubator-ignite/diff/b026f2cc

Branch: refs/heads/ignite-218
Commit: b026f2cc280d8dc5980a1cd0401fbebcc3bc8e87
Parents: bd317ee
Author: ivasilinets <ivasilinets@gridgain.com>
Authored: Mon Apr 13 14:57:25 2015 +0300
Committer: ivasilinets <ivasilinets@gridgain.com>
Committed: Mon Apr 13 14:57:25 2015 +0300

----------------------------------------------------------------------
 .../processors/cache/CacheProjection.java       | 24 +++++------
 .../processors/cache/GridCacheAdapter.java      | 44 ++++++++++----------
 .../cache/GridCacheProjectionImpl.java          | 34 +++++++--------
 .../processors/cache/GridCacheProxyImpl.java    | 32 +++++++-------
 .../processors/cache/IgniteCacheProxy.java      | 16 +++----
 .../CacheDataStructuresManager.java             |  4 +-
 .../dht/atomic/GridDhtAtomicCache.java          | 34 +++++++--------
 .../distributed/near/GridNearAtomicCache.java   | 32 +++++++-------
 .../local/atomic/GridLocalAtomicCache.java      | 36 ++++++++--------
 .../datastructures/DataStructuresProcessor.java | 10 ++---
 .../GridAtomicCacheQueueImpl.java               |  2 +-
 .../datastructures/GridCacheAtomicLongImpl.java | 16 +++----
 .../GridCacheAtomicReferenceImpl.java           |  4 +-
 .../GridCacheAtomicSequenceImpl.java            |  2 +-
 .../GridCacheAtomicStampedImpl.java             |  4 +-
 .../GridCacheCountDownLatchImpl.java            |  2 +-
 .../datastructures/GridCacheSetImpl.java        |  2 +-
 .../GridTransactionalCacheQueueImpl.java        |  2 +-
 .../processors/igfs/IgfsDataManager.java        |  6 +--
 .../processors/igfs/IgfsMetaManager.java        | 32 +++++++-------
 .../handlers/cache/GridCacheCommandHandler.java |  8 ++--
 .../service/GridServiceProcessor.java           |  4 +-
 .../processors/task/GridTaskProcessor.java      |  2 +-
 .../ignite/startup/BasicWarmupClosure.java      |  6 +--
 .../cache/GridCacheAbstractFullApiSelfTest.java | 12 +++---
 ...CacheFullTextQueryMultithreadedSelfTest.java |  2 +-
 .../processors/cache/GridCacheOffHeapTest.java  |  4 +-
 .../cache/IgniteTxMultiNodeAbstractTest.java    |  4 +-
 .../IgniteCacheSystemTransactionsSelfTest.java  |  4 +-
 ...GridCacheDhtEvictionNearReadersSelfTest.java |  2 +-
 .../dht/GridCacheDhtEvictionSelfTest.java       |  4 +-
 .../GridCachePartitionedFullApiSelfTest.java    |  2 +-
 .../GridCacheReplicatedPreloadSelfTest.java     |  4 +-
 .../GridCacheSwapScanQueryAbstractSelfTest.java |  6 +--
 .../query/h2/GridH2IndexingGeoSelfTest.java     | 16 +++----
 .../hadoop/jobtracker/HadoopJobTracker.java     |  2 +-
 .../HibernateAccessStrategyAdapter.java         |  2 +-
 .../hibernate/HibernateGeneralDataRegion.java   |  2 +-
 .../HibernateNonStrictAccessStrategy.java       |  2 +-
 .../HibernateReadOnlyAccessStrategy.java        |  2 +-
 .../HibernateReadWriteAccessStrategy.java       |  6 +--
 .../HibernateTransactionalAccessStrategy.java   |  6 +--
 .../GridCacheAbstractFieldsQuerySelfTest.java   |  8 ++--
 .../cache/GridCacheCrossCacheQuerySelfTest.java |  6 +--
 ...idCacheReduceQueryMultithreadedSelfTest.java |  2 +-
 .../cache/GridIndexingWithNoopSwapSelfTest.java |  2 +-
 46 files changed, 229 insertions(+), 229 deletions(-)
----------------------------------------------------------------------


http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/b026f2cc/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/CacheProjection.java
----------------------------------------------------------------------
diff --git a/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/CacheProjection.java b/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/CacheProjection.java
index bb8d27c..c082114 100644
--- a/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/CacheProjection.java
+++ b/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/CacheProjection.java
@@ -412,7 +412,7 @@ public interface CacheProjection<K, V> extends Iterable<Cache.Entry<K, V>> {
      * @throws NullPointerException If either key or value are {@code null}.
      * @throws IgniteCheckedException If put operation failed.
      */
-    @Nullable public V put(K key, V val)
+    @Nullable public V getAndPut(K key, V val)
         throws IgniteCheckedException;
 
     /**
@@ -442,7 +442,7 @@ public interface CacheProjection<K, V> extends Iterable<Cache.Entry<K, V>> {
      * @return Future for the put operation.
      * @throws NullPointerException If either key or value are {@code null}.
      */
-    public IgniteInternalFuture<V> putAsync(K key, V val);
+    public IgniteInternalFuture<V> getAndPutAsync(K key, V val);
 
     /**
      * Stores given key-value pair in cache. If filters are provided, then entries will
@@ -468,7 +468,7 @@ public interface CacheProjection<K, V> extends Iterable<Cache.Entry<K, V>> {
      * @throws NullPointerException If either key or value are {@code null}.
      * @throws IgniteCheckedException If put operation failed.
      */
-    public boolean putx(K key, V val)
+    public boolean put(K key, V val)
         throws IgniteCheckedException;
 
     /**
@@ -494,7 +494,7 @@ public interface CacheProjection<K, V> extends Iterable<Cache.Entry<K, V>> {
      *      return {@code true} if filter is not specified.
      * @throws NullPointerException If either key or value are {@code null}.
      */
-    public IgniteInternalFuture<Boolean> putxAsync(K key, V val);
+    public IgniteInternalFuture<Boolean> putAsync(K key, V val);
 
     /**
      * Stores given key-value pair in cache only if cache had no previous mapping for it. If cache
@@ -505,7 +505,7 @@ public interface CacheProjection<K, V> extends Iterable<Cache.Entry<K, V>> {
      * from the underlying persistent storage. If value has to be loaded from persistent
      * storage, <code>CacheStore#load(Transaction, Object)</code> method will be used.
      * <p>
-     * If the returned value is not needed, method {@link #putxIfAbsent(Object, Object)} should
+     * If the returned value is not needed, method {@link #putIfAbsent(Object, Object)} should
      * always be used instead of this one to avoid the overhead associated with returning of the
      * previous value.
      * <p>
@@ -521,7 +521,7 @@ public interface CacheProjection<K, V> extends Iterable<Cache.Entry<K, V>> {
      * @throws NullPointerException If either key or value are {@code null}.
      * @throws IgniteCheckedException If put operation failed.
      */
-    @Nullable public V putIfAbsent(K key, V val) throws IgniteCheckedException;
+    @Nullable public V getAndPutIfAbsent(K key, V val) throws IgniteCheckedException;
 
     /**
      * Asynchronously stores given key-value pair in cache only if cache had no previous mapping for it. If cache
@@ -532,7 +532,7 @@ public interface CacheProjection<K, V> extends Iterable<Cache.Entry<K, V>> {
      * from the underlying persistent storage. If value has to be loaded from persistent
      * storage, <code>CacheStore#load(Transaction, Object)</code> method will be used.
      * <p>
-     * If the returned value is not needed, method {@link #putxIfAbsentAsync(Object, Object)} should
+     * If the returned value is not needed, method {@link #putIfAbsentAsync(Object, Object)} should
      * always be used instead of this one to avoid the overhead associated with returning of the
      * previous value.
      * <p>
@@ -548,13 +548,13 @@ public interface CacheProjection<K, V> extends Iterable<Cache.Entry<K, V>> {
      *   regardless of whether put happened or not.
      * @throws NullPointerException If either key or value are {@code null}.
      */
-    public IgniteInternalFuture<V> putIfAbsentAsync(K key, V val);
+    public IgniteInternalFuture<V> getAndPutIfAbsentAsync(K key, V val);
 
     /**
      * Stores given key-value pair in cache only if cache had no previous mapping for it.
      * <p>
      * This method will return {@code true} if value is stored in cache and {@code false} otherwise.
-     * Unlike {@link #putIfAbsent(Object, Object)} method, it does not return previous
+     * Unlike {@link #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.
      * <p>
@@ -570,13 +570,13 @@ public interface CacheProjection<K, V> extends Iterable<Cache.Entry<K, V>> {
      * @throws NullPointerException If either key or value are {@code null}.
      * @throws IgniteCheckedException If put operation failed.
      */
-    public boolean putxIfAbsent(K key, V val) throws IgniteCheckedException;
+    public boolean putIfAbsent(K key, V val) throws IgniteCheckedException;
 
     /**
      * Asynchronously stores given key-value pair in cache only if cache had no previous mapping for it.
      * <p>
      * This method will return {@code true} if value is stored in cache and {@code false} otherwise.
-     * Unlike {@link #putIfAbsent(Object, Object)} method, it does not return previous
+     * Unlike {@link #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.
      * <p>
@@ -591,7 +591,7 @@ public interface CacheProjection<K, V> extends Iterable<Cache.Entry<K, V>> {
      * @return Future for this put operation.
      * @throws NullPointerException If either key or value are {@code null}.
      */
-    public IgniteInternalFuture<Boolean> putxIfAbsentAsync(K key, V val);
+    public IgniteInternalFuture<Boolean> putIfAbsentAsync(K key, V val);
 
     /**
      * Stores given key-value pair in cache only if there is a previous mapping for it.

http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/b026f2cc/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/GridCacheAdapter.java
----------------------------------------------------------------------
diff --git a/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/GridCacheAdapter.java b/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/GridCacheAdapter.java
index e30a233..1aee044 100644
--- a/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/GridCacheAdapter.java
+++ b/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/GridCacheAdapter.java
@@ -1941,8 +1941,8 @@ public abstract class GridCacheAdapter<K, V> implements GridCache<K, V>,
     }
 
     /** {@inheritDoc} */
-    @Override public V put(K key, V val) throws IgniteCheckedException {
-        return put(key, val, CU.empty0());
+    @Override public V getAndPut(K key, V val) throws IgniteCheckedException {
+        return getAndPut(key, val, CU.empty0());
     }
 
     /**
@@ -1952,7 +1952,7 @@ public abstract class GridCacheAdapter<K, V> implements GridCache<K, V>,
      * @return Previous value.
      * @throws IgniteCheckedException If failed.
      */
-    @Nullable public V put(final K key, final V val, @Nullable final CacheEntryPredicate[] filter)
+    @Nullable public V getAndPut(final K key, final V val, @Nullable final CacheEntryPredicate[] filter)
         throws IgniteCheckedException
     {
         boolean statsEnabled = ctx.config().isStatisticsEnabled();
@@ -1983,8 +1983,8 @@ public abstract class GridCacheAdapter<K, V> implements GridCache<K, V>,
     }
 
     /** {@inheritDoc} */
-    @Override public IgniteInternalFuture<V> putAsync(K key, V val) {
-        return putAsync(key, val, CU.empty0());
+    @Override public IgniteInternalFuture<V> getAndPutAsync(K key, V val) {
+        return getAndPutAsync(key, val, CU.empty0());
     }
 
     /**
@@ -1993,12 +1993,12 @@ public abstract class GridCacheAdapter<K, V> implements GridCache<K, V>,
      * @param filter Filter.
      * @return Put operation future.
      */
-    public IgniteInternalFuture<V> putAsync(K key, V val, @Nullable CacheEntryPredicate[] filter) {
+    public IgniteInternalFuture<V> getAndPutAsync(K key, V val, @Nullable CacheEntryPredicate[] filter) {
         final boolean statsEnabled = ctx.config().isStatisticsEnabled();
 
         final long start = statsEnabled ? System.nanoTime() : 0L;
 
-        IgniteInternalFuture<V> fut = putAsync0(key, val, filter);
+        IgniteInternalFuture<V> fut = getAndPutAsync0(key, val, filter);
 
         if (statsEnabled)
             fut.listen(new UpdatePutAndGetTimeStatClosure<V>(metrics0(), start));
@@ -2012,7 +2012,7 @@ public abstract class GridCacheAdapter<K, V> implements GridCache<K, V>,
      * @param filter Optional filter.
      * @return Put operation future.
      */
-    public IgniteInternalFuture<V> putAsync0(final K key, final V val, @Nullable final CacheEntryPredicate... filter) {
+    public IgniteInternalFuture<V> getAndPutAsync0(final K key, final V val, @Nullable final CacheEntryPredicate... filter) {
         A.notNull(key, "key", val, "val");
 
         if (keyCheck)
@@ -2033,8 +2033,8 @@ public abstract class GridCacheAdapter<K, V> implements GridCache<K, V>,
     }
 
     /** {@inheritDoc} */
-    @Override public boolean putx(final K key, final V val) throws IgniteCheckedException {
-        return putx(key, val, CU.empty0());
+    @Override public boolean put(final K key, final V val) throws IgniteCheckedException {
+        return put(key, val, CU.empty0());
     }
 
     /**
@@ -2046,7 +2046,7 @@ public abstract class GridCacheAdapter<K, V> implements GridCache<K, V>,
      *      specified.
      * @throws IgniteCheckedException If put operation failed.
      */
-    public boolean putx(final K key, final V val, final CacheEntryPredicate[] filter)
+    public boolean put(final K key, final V val, final CacheEntryPredicate[] filter)
         throws IgniteCheckedException {
         boolean statsEnabled = ctx.config().isStatisticsEnabled();
 
@@ -2313,8 +2313,8 @@ public abstract class GridCacheAdapter<K, V> implements GridCache<K, V>,
     }
 
     /** {@inheritDoc} */
-    @Override public IgniteInternalFuture<Boolean> putxAsync(K key, V val) {
-        return putxAsync(key, val, CU.empty0());
+    @Override public IgniteInternalFuture<Boolean> putAsync(K key, V val) {
+        return putAsync(key, val, CU.empty0());
     }
 
     /**
@@ -2323,13 +2323,13 @@ public abstract class GridCacheAdapter<K, V> implements GridCache<K, V>,
      * @param filter Filter.
      * @return Put future.
      */
-    public IgniteInternalFuture<Boolean> putxAsync(K key, V val,
-        @Nullable CacheEntryPredicate... filter) {
+    public IgniteInternalFuture<Boolean> putAsync(K key, V val,
+                                                  @Nullable CacheEntryPredicate... filter) {
         final boolean statsEnabled = ctx.config().isStatisticsEnabled();
 
         final long start = statsEnabled ? System.nanoTime() : 0L;
 
-        IgniteInternalFuture<Boolean> fut = putxAsync0(key, val, filter);
+        IgniteInternalFuture<Boolean> fut = putAsync0(key, val, filter);
 
         if (statsEnabled)
             fut.listen(new UpdatePutTimeStatClosure<Boolean>(metrics0(), start));
@@ -2343,8 +2343,8 @@ public abstract class GridCacheAdapter<K, V> implements GridCache<K, V>,
      * @param filter Optional filter.
      * @return Putx operation future.
      */
-    public IgniteInternalFuture<Boolean> putxAsync0(final K key, final V val,
-        @Nullable final CacheEntryPredicate... filter) {
+    public IgniteInternalFuture<Boolean> putAsync0(final K key, final V val,
+                                                   @Nullable final CacheEntryPredicate... filter) {
         A.notNull(key, "key", val, "val");
 
         if (keyCheck)
@@ -2379,7 +2379,7 @@ public abstract class GridCacheAdapter<K, V> implements GridCache<K, V>,
     }
 
     /** {@inheritDoc} */
-    @Nullable @Override public V putIfAbsent(final K key, final V val) throws IgniteCheckedException {
+    @Nullable @Override public V getAndPutIfAbsent(final K key, final V val) throws IgniteCheckedException {
         A.notNull(key, "key", val, "val");
 
         if (keyCheck)
@@ -2399,7 +2399,7 @@ public abstract class GridCacheAdapter<K, V> implements GridCache<K, V>,
     }
 
     /** {@inheritDoc} */
-    @Override public IgniteInternalFuture<V> putIfAbsentAsync(final K key, final V val) {
+    @Override public IgniteInternalFuture<V> getAndPutIfAbsentAsync(final K key, final V val) {
         final boolean statsEnabled = ctx.config().isStatisticsEnabled();
 
         final long start = statsEnabled ? System.nanoTime() : 0L;
@@ -2429,7 +2429,7 @@ public abstract class GridCacheAdapter<K, V> implements GridCache<K, V>,
     }
 
     /** {@inheritDoc} */
-    @Override public boolean putxIfAbsent(final K key, final V val) throws IgniteCheckedException {
+    @Override public boolean putIfAbsent(final K key, final V val) throws IgniteCheckedException {
         boolean statsEnabled = ctx.config().isStatisticsEnabled();
 
         long start = statsEnabled ? System.nanoTime() : 0L;
@@ -2458,7 +2458,7 @@ public abstract class GridCacheAdapter<K, V> implements GridCache<K, V>,
     }
 
     /** {@inheritDoc} */
-    @Override public IgniteInternalFuture<Boolean> putxIfAbsentAsync(final K key, final V val) {
+    @Override public IgniteInternalFuture<Boolean> putIfAbsentAsync(final K key, final V val) {
         final boolean statsEnabled = ctx.config().isStatisticsEnabled();
 
         final long start = statsEnabled ? System.nanoTime() : 0L;

http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/b026f2cc/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/GridCacheProjectionImpl.java
----------------------------------------------------------------------
diff --git a/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/GridCacheProjectionImpl.java b/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/GridCacheProjectionImpl.java
index 8319177..29b0506 100644
--- a/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/GridCacheProjectionImpl.java
+++ b/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/GridCacheProjectionImpl.java
@@ -310,19 +310,19 @@ public class GridCacheProjectionImpl<K, V> implements GridCacheProjectionEx<K, V
     }
 
     /** {@inheritDoc} */
-    @Override public V put(K key, V val)
+    @Override public V getAndPut(K key, V val)
         throws IgniteCheckedException {
-        return putAsync(key, val).get();
+        return getAndPutAsync(key, val).get();
     }
 
     /** {@inheritDoc} */
-    @Override public IgniteInternalFuture<V> putAsync(K key, V val) {
-        return cache.putAsync(key, val);
+    @Override public IgniteInternalFuture<V> getAndPutAsync(K key, V val) {
+        return cache.getAndPutAsync(key, val);
     }
 
     /** {@inheritDoc} */
-    @Override public boolean putx(K key, V val) throws IgniteCheckedException {
-        return cache.putx(key, val);
+    @Override public boolean put(K key, V val) throws IgniteCheckedException {
+        return cache.put(key, val);
     }
 
     /** {@inheritDoc} */
@@ -378,28 +378,28 @@ public class GridCacheProjectionImpl<K, V> implements GridCacheProjectionEx<K, V
     }
 
     /** {@inheritDoc} */
-    @Override public IgniteInternalFuture<Boolean> putxAsync(K key, V val) {
-        return cache.putxAsync(key, val);
+    @Override public IgniteInternalFuture<Boolean> putAsync(K key, V val) {
+        return cache.putAsync(key, val);
     }
 
     /** {@inheritDoc} */
-    @Override public V putIfAbsent(K key, V val) throws IgniteCheckedException {
-        return putIfAbsentAsync(key, val).get();
+    @Override public V getAndPutIfAbsent(K key, V val) throws IgniteCheckedException {
+        return getAndPutIfAbsentAsync(key, val).get();
     }
 
     /** {@inheritDoc} */
-    @Override public IgniteInternalFuture<V> putIfAbsentAsync(K key, V val) {
-        return cache.putIfAbsentAsync(key, val);
+    @Override public IgniteInternalFuture<V> getAndPutIfAbsentAsync(K key, V val) {
+        return cache.getAndPutIfAbsentAsync(key, val);
     }
 
     /** {@inheritDoc} */
-    @Override public boolean putxIfAbsent(K key, V val) throws IgniteCheckedException {
-        return putxIfAbsentAsync(key, val).get();
+    @Override public boolean putIfAbsent(K key, V val) throws IgniteCheckedException {
+        return putIfAbsentAsync(key, val).get();
     }
 
     /** {@inheritDoc} */
-    @Override public IgniteInternalFuture<Boolean> putxIfAbsentAsync(K key, V val) {
-        return cache.putxIfAbsentAsync(key, val);
+    @Override public IgniteInternalFuture<Boolean> putIfAbsentAsync(K key, V val) {
+        return cache.putIfAbsentAsync(key, val);
     }
 
     /** {@inheritDoc} */
@@ -431,7 +431,7 @@ public class GridCacheProjectionImpl<K, V> implements GridCacheProjectionEx<K, V
     @Override public IgniteInternalFuture<Boolean> getAndReplaceAsync(K key, V oldVal, V newVal) {
         CacheEntryPredicate fltr = cctx.equalsValue(oldVal);
 
-        return cache.putxAsync(key, newVal, fltr);
+        return cache.putAsync(key, newVal, fltr);
     }
 
     /** {@inheritDoc} */

http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/b026f2cc/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/GridCacheProxyImpl.java
----------------------------------------------------------------------
diff --git a/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/GridCacheProxyImpl.java b/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/GridCacheProxyImpl.java
index b5fab4b..e629a94 100644
--- a/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/GridCacheProxyImpl.java
+++ b/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/GridCacheProxyImpl.java
@@ -497,12 +497,12 @@ public class GridCacheProxyImpl<K, V> implements GridCacheProxy<K, V>, Externali
     }
 
     /** {@inheritDoc} */
-    @Nullable @Override public V put(K key, V val)
+    @Nullable @Override public V getAndPut(K key, V val)
         throws IgniteCheckedException {
         GridCacheProjectionImpl<K, V> prev = gate.enter(prj);
 
         try {
-            return delegate.put(key, val);
+            return delegate.getAndPut(key, val);
         }
         finally {
             gate.leave(prev);
@@ -510,11 +510,11 @@ public class GridCacheProxyImpl<K, V> implements GridCacheProxy<K, V>, Externali
     }
 
     /** {@inheritDoc} */
-    @Override public IgniteInternalFuture<V> putAsync(K key, V val) {
+    @Override public IgniteInternalFuture<V> getAndPutAsync(K key, V val) {
         GridCacheProjectionImpl<K, V> prev = gate.enter(prj);
 
         try {
-            return delegate.putAsync(key, val);
+            return delegate.getAndPutAsync(key, val);
         }
         finally {
             gate.leave(prev);
@@ -522,12 +522,12 @@ public class GridCacheProxyImpl<K, V> implements GridCacheProxy<K, V>, Externali
     }
 
     /** {@inheritDoc} */
-    @Override public boolean putx(K key, V val)
+    @Override public boolean put(K key, V val)
         throws IgniteCheckedException {
         GridCacheProjectionImpl<K, V> prev = gate.enter(prj);
 
         try {
-            return delegate.putx(key, val);
+            return delegate.put(key, val);
         }
         finally {
             gate.leave(prev);
@@ -645,11 +645,11 @@ public class GridCacheProxyImpl<K, V> implements GridCacheProxy<K, V>, Externali
     }
 
     /** {@inheritDoc} */
-    @Override public IgniteInternalFuture<Boolean> putxAsync(K key, V val) {
+    @Override public IgniteInternalFuture<Boolean> putAsync(K key, V val) {
         GridCacheProjectionImpl<K, V> prev = gate.enter(prj);
 
         try {
-            return delegate.putxAsync(key, val);
+            return delegate.putAsync(key, val);
         }
         finally {
             gate.leave(prev);
@@ -657,11 +657,11 @@ public class GridCacheProxyImpl<K, V> implements GridCacheProxy<K, V>, Externali
     }
 
     /** {@inheritDoc} */
-    @Nullable @Override public V putIfAbsent(K key, V val) throws IgniteCheckedException {
+    @Nullable @Override public V getAndPutIfAbsent(K key, V val) throws IgniteCheckedException {
         GridCacheProjectionImpl<K, V> prev = gate.enter(prj);
 
         try {
-            return delegate.putIfAbsent(key, val);
+            return delegate.getAndPutIfAbsent(key, val);
         }
         finally {
             gate.leave(prev);
@@ -669,11 +669,11 @@ public class GridCacheProxyImpl<K, V> implements GridCacheProxy<K, V>, Externali
     }
 
     /** {@inheritDoc} */
-    @Override public IgniteInternalFuture<V> putIfAbsentAsync(K key, V val) {
+    @Override public IgniteInternalFuture<V> getAndPutIfAbsentAsync(K key, V val) {
         GridCacheProjectionImpl<K, V> prev = gate.enter(prj);
 
         try {
-            return delegate.putIfAbsentAsync(key, val);
+            return delegate.getAndPutIfAbsentAsync(key, val);
         }
         finally {
             gate.leave(prev);
@@ -681,11 +681,11 @@ public class GridCacheProxyImpl<K, V> implements GridCacheProxy<K, V>, Externali
     }
 
     /** {@inheritDoc} */
-    @Override public boolean putxIfAbsent(K key, V val) throws IgniteCheckedException {
+    @Override public boolean putIfAbsent(K key, V val) throws IgniteCheckedException {
         GridCacheProjectionImpl<K, V> prev = gate.enter(prj);
 
         try {
-            return delegate.putxIfAbsent(key, val);
+            return delegate.putIfAbsent(key, val);
         }
         finally {
             gate.leave(prev);
@@ -693,11 +693,11 @@ public class GridCacheProxyImpl<K, V> implements GridCacheProxy<K, V>, Externali
     }
 
     /** {@inheritDoc} */
-    @Override public IgniteInternalFuture<Boolean> putxIfAbsentAsync(K key, V val) {
+    @Override public IgniteInternalFuture<Boolean> putIfAbsentAsync(K key, V val) {
         GridCacheProjectionImpl<K, V> prev = gate.enter(prj);
 
         try {
-            return delegate.putxIfAbsentAsync(key, val);
+            return delegate.putIfAbsentAsync(key, val);
         }
         finally {
             gate.leave(prev);

http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/b026f2cc/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/IgniteCacheProxy.java
----------------------------------------------------------------------
diff --git a/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/IgniteCacheProxy.java b/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/IgniteCacheProxy.java
index 359b47b..06564d7 100644
--- a/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/IgniteCacheProxy.java
+++ b/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/IgniteCacheProxy.java
@@ -265,12 +265,12 @@ public class IgniteCacheProxy<K, V> extends AsyncSupportAdapter<IgniteCache<K, V
 
             try {
                 if (isAsync()) {
-                    setFuture(delegate.putIfAbsentAsync(key, val));
+                    setFuture(delegate.getAndPutIfAbsentAsync(key, val));
 
                     return null;
                 }
                 else
-                    return delegate.putIfAbsent(key, val);
+                    return delegate.getAndPutIfAbsent(key, val);
             }
             finally {
                 gate.leave(prev);
@@ -776,9 +776,9 @@ public class IgniteCacheProxy<K, V> extends AsyncSupportAdapter<IgniteCache<K, V
 
             try {
                 if (isAsync())
-                    setFuture(delegate.putxAsync(key, val));
+                    setFuture(delegate.putAsync(key, val));
                 else
-                    delegate.putx(key, val);
+                    delegate.put(key, val);
             }
             finally {
                 gate.leave(prev);
@@ -796,12 +796,12 @@ public class IgniteCacheProxy<K, V> extends AsyncSupportAdapter<IgniteCache<K, V
 
             try {
                 if (isAsync()) {
-                    setFuture(delegate.putAsync(key, val));
+                    setFuture(delegate.getAndPutAsync(key, val));
 
                     return null;
                 }
                 else
-                    return delegate.put(key, val);
+                    return delegate.getAndPut(key, val);
             }
             finally {
                 gate.leave(prev);
@@ -839,12 +839,12 @@ public class IgniteCacheProxy<K, V> extends AsyncSupportAdapter<IgniteCache<K, V
 
             try {
                 if (isAsync()) {
-                    setFuture(delegate.putxIfAbsentAsync(key, val));
+                    setFuture(delegate.putIfAbsentAsync(key, val));
 
                     return false;
                 }
                 else
-                    return delegate.putxIfAbsent(key, val);
+                    return delegate.putIfAbsent(key, val);
             }
             finally {
                 gate.leave(prev);

http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/b026f2cc/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/datastructures/CacheDataStructuresManager.java
----------------------------------------------------------------------
diff --git a/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/datastructures/CacheDataStructuresManager.java b/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/datastructures/CacheDataStructuresManager.java
index c889667..7ebc9a4 100644
--- a/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/datastructures/CacheDataStructuresManager.java
+++ b/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/datastructures/CacheDataStructuresManager.java
@@ -165,7 +165,7 @@ public class CacheDataStructuresManager extends GridCacheManagerAdapter {
             if (create) {
                 hdr = new GridCacheQueueHeader(IgniteUuid.randomUuid(), cap, colloc, 0, 0, null);
 
-                GridCacheQueueHeader old = queueHdrView.putIfAbsent(key, hdr);
+                GridCacheQueueHeader old = queueHdrView.getAndPutIfAbsent(key, hdr);
 
                 if (old != null) {
                     if (old.capacity() != cap || old.collocated() != colloc)
@@ -507,7 +507,7 @@ public class CacheDataStructuresManager extends GridCacheManagerAdapter {
         throws IgniteCheckedException {
         return DataStructuresProcessor.retry(log, new Callable<T>() {
             @Nullable @Override public T call() throws Exception {
-                return (T)cache.putIfAbsent(key, val);
+                return (T)cache.getAndPutIfAbsent(key, val);
             }
         });
     }

http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/b026f2cc/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/distributed/dht/atomic/GridDhtAtomicCache.java
----------------------------------------------------------------------
diff --git a/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/distributed/dht/atomic/GridDhtAtomicCache.java b/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/distributed/dht/atomic/GridDhtAtomicCache.java
index d53543c..7e67032 100644
--- a/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/distributed/dht/atomic/GridDhtAtomicCache.java
+++ b/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/distributed/dht/atomic/GridDhtAtomicCache.java
@@ -290,18 +290,18 @@ public class GridDhtAtomicCache<K, V> extends GridDhtCacheAdapter<K, V> {
     }
 
     /** {@inheritDoc} */
-    @Override public V put(K key, V val, @Nullable CacheEntryPredicate[] filter) throws IgniteCheckedException {
-        return putAsync0(key, val, filter).get();
+    @Override public V getAndPut(K key, V val, @Nullable CacheEntryPredicate[] filter) throws IgniteCheckedException {
+        return getAndPutAsync0(key, val, filter).get();
     }
 
     /** {@inheritDoc} */
-    @Override public boolean putx(K key, V val, CacheEntryPredicate[] filter) throws IgniteCheckedException {
-        return putxAsync(key, val, filter).get();
+    @Override public boolean put(K key, V val, CacheEntryPredicate[] filter) throws IgniteCheckedException {
+        return putAsync(key, val, filter).get();
     }
 
     /** {@inheritDoc} */
     @SuppressWarnings("unchecked")
-    @Override public IgniteInternalFuture<V> putAsync0(K key, V val, @Nullable CacheEntryPredicate... filter) {
+    @Override public IgniteInternalFuture<V> getAndPutAsync0(K key, V val, @Nullable CacheEntryPredicate... filter) {
         A.notNull(key, "key");
 
         return updateAllAsync0(F0.asMap(key, val),
@@ -317,7 +317,7 @@ public class GridDhtAtomicCache<K, V> extends GridDhtCacheAdapter<K, V> {
 
     /** {@inheritDoc} */
     @SuppressWarnings("unchecked")
-    @Override public IgniteInternalFuture<Boolean> putxAsync0(K key, V val, @Nullable CacheEntryPredicate... filter) {
+    @Override public IgniteInternalFuture<Boolean> putAsync0(K key, V val, @Nullable CacheEntryPredicate... filter) {
         A.notNull(key, "key");
 
         return updateAllAsync0(F0.asMap(key, val),
@@ -347,27 +347,27 @@ public class GridDhtAtomicCache<K, V> extends GridDhtCacheAdapter<K, V> {
     }
 
     /** {@inheritDoc} */
-    @Override public V putIfAbsent(K key, V val) throws IgniteCheckedException {
-        return putIfAbsentAsync(key, val).get();
+    @Override public V getAndPutIfAbsent(K key, V val) throws IgniteCheckedException {
+        return getAndPutIfAbsentAsync(key, val).get();
     }
 
     /** {@inheritDoc} */
-    @Override public IgniteInternalFuture<V> putIfAbsentAsync(K key, V val) {
+    @Override public IgniteInternalFuture<V> getAndPutIfAbsentAsync(K key, V val) {
         A.notNull(key, "key", val, "val");
 
-        return putAsync(key, val, ctx.noValArray());
+        return getAndPutAsync(key, val, ctx.noValArray());
     }
 
     /** {@inheritDoc} */
-    @Override public boolean putxIfAbsent(K key, V val) throws IgniteCheckedException {
-        return putxIfAbsentAsync(key, val).get();
+    @Override public boolean putIfAbsent(K key, V val) throws IgniteCheckedException {
+        return putIfAbsentAsync(key, val).get();
     }
 
     /** {@inheritDoc} */
-    @Override public IgniteInternalFuture<Boolean> putxIfAbsentAsync(K key, V val) {
+    @Override public IgniteInternalFuture<Boolean> putIfAbsentAsync(K key, V val) {
         A.notNull(key, "key", val, "val");
 
-        return putxAsync(key, val, ctx.noValArray());
+        return putAsync(key, val, ctx.noValArray());
     }
 
     /** {@inheritDoc} */
@@ -379,7 +379,7 @@ public class GridDhtAtomicCache<K, V> extends GridDhtCacheAdapter<K, V> {
     @Override public IgniteInternalFuture<V> getAndReplaceAsync(K key, V val) {
         A.notNull(key, "key", val, "val");
 
-        return putAsync(key, val, ctx.hasValArray());
+        return getAndPutAsync(key, val, ctx.hasValArray());
     }
 
     /** {@inheritDoc} */
@@ -391,7 +391,7 @@ public class GridDhtAtomicCache<K, V> extends GridDhtCacheAdapter<K, V> {
     @Override public IgniteInternalFuture<Boolean> replaceAsync(K key, V val) {
         A.notNull(key, "key", val, "val");
 
-        return putxAsync(key, val, ctx.hasValArray());
+        return putAsync(key, val, ctx.hasValArray());
     }
 
     /** {@inheritDoc} */
@@ -403,7 +403,7 @@ public class GridDhtAtomicCache<K, V> extends GridDhtCacheAdapter<K, V> {
     @Override public IgniteInternalFuture<Boolean> getAndReplaceAsync(K key, V oldVal, V newVal) {
         A.notNull(key, "key", oldVal, "oldVal", newVal, "newVal");
 
-        return putxAsync(key, newVal, ctx.equalsValArray(oldVal));
+        return putAsync(key, newVal, ctx.equalsValArray(oldVal));
     }
 
     /** {@inheritDoc} */

http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/b026f2cc/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/distributed/near/GridNearAtomicCache.java
----------------------------------------------------------------------
diff --git a/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/distributed/near/GridNearAtomicCache.java b/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/distributed/near/GridNearAtomicCache.java
index 3f643e7..e650f77 100644
--- a/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/distributed/near/GridNearAtomicCache.java
+++ b/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/distributed/near/GridNearAtomicCache.java
@@ -388,45 +388,45 @@ public class GridNearAtomicCache<K, V> extends GridNearCacheAdapter<K, V> {
     }
 
     /** {@inheritDoc} */
-    @Override public V put(K key, V val, @Nullable CacheEntryPredicate[] filter) throws IgniteCheckedException {
-        return dht.put(key, val, filter);
+    @Override public V getAndPut(K key, V val, @Nullable CacheEntryPredicate[] filter) throws IgniteCheckedException {
+        return dht.getAndPut(key, val, filter);
     }
 
     /** {@inheritDoc} */
-    @Override public boolean putx(K key, V val, CacheEntryPredicate[] filter) throws IgniteCheckedException {
-        return dht.putx(key, val, filter);
+    @Override public boolean put(K key, V val, CacheEntryPredicate[] filter) throws IgniteCheckedException {
+        return dht.put(key, val, filter);
     }
 
     /** {@inheritDoc} */
     @SuppressWarnings("unchecked")
-    @Override public IgniteInternalFuture<V> putAsync0(K key, V val, @Nullable CacheEntryPredicate... filter) {
-        return dht.putAsync0(key, val, filter);
+    @Override public IgniteInternalFuture<V> getAndPutAsync0(K key, V val, @Nullable CacheEntryPredicate... filter) {
+        return dht.getAndPutAsync0(key, val, filter);
     }
 
     /** {@inheritDoc} */
     @SuppressWarnings("unchecked")
-    @Override public IgniteInternalFuture<Boolean> putxAsync0(K key, V val, @Nullable CacheEntryPredicate... filter) {
-        return dht.putxAsync0(key, val, filter);
+    @Override public IgniteInternalFuture<Boolean> putAsync0(K key, V val, @Nullable CacheEntryPredicate... filter) {
+        return dht.putAsync0(key, val, filter);
     }
 
     /** {@inheritDoc} */
-    @Override public V putIfAbsent(K key, V val) throws IgniteCheckedException {
-        return dht.putIfAbsent(key, val);
+    @Override public V getAndPutIfAbsent(K key, V val) throws IgniteCheckedException {
+        return dht.getAndPutIfAbsent(key, val);
     }
 
     /** {@inheritDoc} */
-    @Override public IgniteInternalFuture<V> putIfAbsentAsync(K key, V val) {
-        return dht.putIfAbsentAsync(key, val);
+    @Override public IgniteInternalFuture<V> getAndPutIfAbsentAsync(K key, V val) {
+        return dht.getAndPutIfAbsentAsync(key, val);
     }
 
     /** {@inheritDoc} */
-    @Override public boolean putxIfAbsent(K key, V val) throws IgniteCheckedException {
-        return dht.putxIfAbsent(key, val);
+    @Override public boolean putIfAbsent(K key, V val) throws IgniteCheckedException {
+        return dht.putIfAbsent(key, val);
     }
 
     /** {@inheritDoc} */
-    @Override public IgniteInternalFuture<Boolean> putxIfAbsentAsync(K key, V val) {
-        return dht.putxIfAbsentAsync(key, val);
+    @Override public IgniteInternalFuture<Boolean> putIfAbsentAsync(K key, V val) {
+        return dht.putIfAbsentAsync(key, val);
     }
 
     /** {@inheritDoc} */

http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/b026f2cc/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/local/atomic/GridLocalAtomicCache.java
----------------------------------------------------------------------
diff --git a/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/local/atomic/GridLocalAtomicCache.java b/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/local/atomic/GridLocalAtomicCache.java
index 4539a0f..6a0a219 100644
--- a/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/local/atomic/GridLocalAtomicCache.java
+++ b/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/local/atomic/GridLocalAtomicCache.java
@@ -100,7 +100,7 @@ public class GridLocalAtomicCache<K, V> extends GridCacheAdapter<K, V> {
 
     /** {@inheritDoc} */
     @SuppressWarnings("unchecked")
-    @Override public V put(K key, V val, @Nullable CacheEntryPredicate[] filter) throws IgniteCheckedException {
+    @Override public V getAndPut(K key, V val, @Nullable CacheEntryPredicate[] filter) throws IgniteCheckedException {
         A.notNull(key, "key", val, "val");
 
         return (V)updateAllInternal(UPDATE,
@@ -115,7 +115,7 @@ public class GridLocalAtomicCache<K, V> extends GridCacheAdapter<K, V> {
     }
 
     /** {@inheritDoc} */
-    @Override public boolean putx(K key, V val, CacheEntryPredicate[] filter) throws IgniteCheckedException {
+    @Override public boolean put(K key, V val, CacheEntryPredicate[] filter) throws IgniteCheckedException {
         A.notNull(key, "key", val, "val");
 
         return (Boolean)updateAllInternal(UPDATE,
@@ -131,7 +131,7 @@ public class GridLocalAtomicCache<K, V> extends GridCacheAdapter<K, V> {
 
     /** {@inheritDoc} */
     @SuppressWarnings("unchecked")
-    @Override public IgniteInternalFuture<V> putAsync0(K key, V val, @Nullable CacheEntryPredicate... filter) {
+    @Override public IgniteInternalFuture<V> getAndPutAsync0(K key, V val, @Nullable CacheEntryPredicate... filter) {
         A.notNull(key, "key", val, "val");
 
         return updateAllAsync0(F0.asMap(key, val),
@@ -144,7 +144,7 @@ public class GridLocalAtomicCache<K, V> extends GridCacheAdapter<K, V> {
 
     /** {@inheritDoc} */
     @SuppressWarnings("unchecked")
-    @Override public IgniteInternalFuture<Boolean> putxAsync0(K key, V val, @Nullable CacheEntryPredicate... filter) {
+    @Override public IgniteInternalFuture<Boolean> putAsync0(K key, V val, @Nullable CacheEntryPredicate... filter) {
         A.notNull(key, "key", val, "val");
 
         return updateAllAsync0(F0.asMap(key, val),
@@ -157,56 +157,56 @@ public class GridLocalAtomicCache<K, V> extends GridCacheAdapter<K, V> {
 
     /** {@inheritDoc} */
     @SuppressWarnings("unchecked")
-    @Override public V putIfAbsent(K key, V val) throws IgniteCheckedException {
-        return put(key, val, ctx.noValArray());
+    @Override public V getAndPutIfAbsent(K key, V val) throws IgniteCheckedException {
+        return getAndPut(key, val, ctx.noValArray());
     }
 
     /** {@inheritDoc} */
-    @Override public IgniteInternalFuture<V> putIfAbsentAsync(K key, V val) {
-        return putAsync(key, val, ctx.noValArray());
+    @Override public IgniteInternalFuture<V> getAndPutIfAbsentAsync(K key, V val) {
+        return getAndPutAsync(key, val, ctx.noValArray());
     }
 
     /** {@inheritDoc} */
-    @Override public boolean putxIfAbsent(K key, V val) throws IgniteCheckedException {
-        return putx(key, val, ctx.noValArray());
+    @Override public boolean putIfAbsent(K key, V val) throws IgniteCheckedException {
+        return put(key, val, ctx.noValArray());
     }
 
     /** {@inheritDoc} */
-    @Override public IgniteInternalFuture<Boolean> putxIfAbsentAsync(K key, V val) {
-        return putxAsync(key, val, ctx.noValArray());
+    @Override public IgniteInternalFuture<Boolean> putIfAbsentAsync(K key, V val) {
+        return putAsync(key, val, ctx.noValArray());
     }
 
     /** {@inheritDoc} */
     @SuppressWarnings("unchecked")
     @Override public V getAndReplace(K key, V val) throws IgniteCheckedException {
-        return put(key, val, ctx.hasValArray());
+        return getAndPut(key, val, ctx.hasValArray());
     }
 
     /** {@inheritDoc} */
     @Override public IgniteInternalFuture<V> getAndReplaceAsync(K key, V val) {
-        return putAsync(key, val, ctx.hasValArray());
+        return getAndPutAsync(key, val, ctx.hasValArray());
     }
 
     /** {@inheritDoc} */
     @Override public boolean replace(K key, V val) throws IgniteCheckedException {
-        return putx(key, val, ctx.hasValArray());
+        return put(key, val, ctx.hasValArray());
     }
 
     /** {@inheritDoc} */
     @Override public IgniteInternalFuture<Boolean> replaceAsync(K key, V val) {
-        return putxAsync(key, val, ctx.hasValArray());
+        return putAsync(key, val, ctx.hasValArray());
     }
 
     /** {@inheritDoc} */
     @Override public boolean getAndReplace(K key, V oldVal, V newVal) throws IgniteCheckedException {
         A.notNull(oldVal, "oldVal");
 
-        return putx(key, newVal, ctx.equalsValArray(oldVal));
+        return put(key, newVal, ctx.equalsValArray(oldVal));
     }
 
     /** {@inheritDoc} */
     @Override public IgniteInternalFuture<Boolean> getAndReplaceAsync(K key, V oldVal, V newVal) {
-        return putxAsync(key, newVal, ctx.equalsValArray(oldVal));
+        return putAsync(key, newVal, ctx.equalsValArray(oldVal));
     }
 
     /** {@inheritDoc} */

http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/b026f2cc/modules/core/src/main/java/org/apache/ignite/internal/processors/datastructures/DataStructuresProcessor.java
----------------------------------------------------------------------
diff --git a/modules/core/src/main/java/org/apache/ignite/internal/processors/datastructures/DataStructuresProcessor.java b/modules/core/src/main/java/org/apache/ignite/internal/processors/datastructures/DataStructuresProcessor.java
index 7ddbf73..3e06b5e 100644
--- a/modules/core/src/main/java/org/apache/ignite/internal/processors/datastructures/DataStructuresProcessor.java
+++ b/modules/core/src/main/java/org/apache/ignite/internal/processors/datastructures/DataStructuresProcessor.java
@@ -207,7 +207,7 @@ public final class DataStructuresProcessor extends GridProcessorAdapter {
                     }
 
                     // Update global counter.
-                    dsView.putx(key, seqVal);
+                    dsView.put(key, seqVal);
 
                     // Only one thread can be in the transaction scope and create sequence.
                     seq = new GridCacheAtomicSequenceImpl(name,
@@ -311,7 +311,7 @@ public final class DataStructuresProcessor extends GridProcessorAdapter {
                     if (val == null) {
                         val = new GridCacheAtomicLongValue(initVal);
 
-                        dsView.putx(key, val);
+                        dsView.put(key, val);
                     }
 
                     a = new GridCacheAtomicLongImpl(name, key, atomicLongView, dsCacheCtx);
@@ -516,7 +516,7 @@ public final class DataStructuresProcessor extends GridProcessorAdapter {
                     if (val == null) {
                         val = new GridCacheAtomicReferenceValue(initVal);
 
-                        dsView.putx(key, val);
+                        dsView.put(key, val);
                     }
 
                     ref = new GridCacheAtomicReferenceImpl(name, key, atomicRefView, dsCacheCtx);
@@ -617,7 +617,7 @@ public final class DataStructuresProcessor extends GridProcessorAdapter {
                     if (val == null) {
                         val = new GridCacheAtomicStampedValue(initVal, initStamp);
 
-                        dsView.putx(key, val);
+                        dsView.put(key, val);
                     }
 
                     stmp = new GridCacheAtomicStampedImpl(name, key, atomicStampedView, dsCacheCtx);
@@ -924,7 +924,7 @@ public final class DataStructuresProcessor extends GridProcessorAdapter {
                     if (val == null) {
                         val = new GridCacheCountDownLatchValue(cnt, autoDel);
 
-                        dsView.putx(key, val);
+                        dsView.put(key, val);
                     }
 
                     latch = new GridCacheCountDownLatchImpl(name, val.get(), val.initialCount(),

http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/b026f2cc/modules/core/src/main/java/org/apache/ignite/internal/processors/datastructures/GridAtomicCacheQueueImpl.java
----------------------------------------------------------------------
diff --git a/modules/core/src/main/java/org/apache/ignite/internal/processors/datastructures/GridAtomicCacheQueueImpl.java b/modules/core/src/main/java/org/apache/ignite/internal/processors/datastructures/GridAtomicCacheQueueImpl.java
index 1437590..3072b7d 100644
--- a/modules/core/src/main/java/org/apache/ignite/internal/processors/datastructures/GridAtomicCacheQueueImpl.java
+++ b/modules/core/src/main/java/org/apache/ignite/internal/processors/datastructures/GridAtomicCacheQueueImpl.java
@@ -58,7 +58,7 @@ public class GridAtomicCacheQueueImpl<T> extends GridCacheQueueAdapter<T> {
 
             while (true) {
                 try {
-                    cache.put(key, item);
+                    cache.getAndPut(key, item);
 
                     break;
                 }

http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/b026f2cc/modules/core/src/main/java/org/apache/ignite/internal/processors/datastructures/GridCacheAtomicLongImpl.java
----------------------------------------------------------------------
diff --git a/modules/core/src/main/java/org/apache/ignite/internal/processors/datastructures/GridCacheAtomicLongImpl.java b/modules/core/src/main/java/org/apache/ignite/internal/processors/datastructures/GridCacheAtomicLongImpl.java
index 3d1ba58..6f0b4da 100644
--- a/modules/core/src/main/java/org/apache/ignite/internal/processors/datastructures/GridCacheAtomicLongImpl.java
+++ b/modules/core/src/main/java/org/apache/ignite/internal/processors/datastructures/GridCacheAtomicLongImpl.java
@@ -90,7 +90,7 @@ public final class GridCacheAtomicLongImpl implements GridCacheAtomicLongEx, Ext
 
                 val.set(retVal);
 
-                atomicView.putx(key, val);
+                atomicView.put(key, val);
 
                 tx.commit();
 
@@ -117,7 +117,7 @@ public final class GridCacheAtomicLongImpl implements GridCacheAtomicLongEx, Ext
 
                 val.set(retVal + 1);
 
-                atomicView.putx(key, val);
+                atomicView.put(key, val);
 
                 tx.commit();
 
@@ -144,7 +144,7 @@ public final class GridCacheAtomicLongImpl implements GridCacheAtomicLongEx, Ext
 
                 val.set(retVal);
 
-                atomicView.putx(key, val);
+                atomicView.put(key, val);
 
                 tx.commit();
 
@@ -171,7 +171,7 @@ public final class GridCacheAtomicLongImpl implements GridCacheAtomicLongEx, Ext
 
                 val.set(retVal - 1);
 
-                atomicView.putx(key, val);
+                atomicView.put(key, val);
 
                 tx.commit();
 
@@ -390,7 +390,7 @@ public final class GridCacheAtomicLongImpl implements GridCacheAtomicLongEx, Ext
 
                     val.set(retVal);
 
-                    atomicView.putx(key, val);
+                    atomicView.put(key, val);
 
                     tx.commit();
 
@@ -424,7 +424,7 @@ public final class GridCacheAtomicLongImpl implements GridCacheAtomicLongEx, Ext
 
                     val.set(retVal + l);
 
-                    atomicView.putx(key, val);
+                    atomicView.put(key, val);
 
                     tx.commit();
 
@@ -458,7 +458,7 @@ public final class GridCacheAtomicLongImpl implements GridCacheAtomicLongEx, Ext
 
                     val.set(l);
 
-                    atomicView.putx(key, val);
+                    atomicView.put(key, val);
 
                     tx.commit();
 
@@ -495,7 +495,7 @@ public final class GridCacheAtomicLongImpl implements GridCacheAtomicLongEx, Ext
                     if (retVal) {
                         val.set(newVal);
 
-                        atomicView.put(key, val);
+                        atomicView.getAndPut(key, val);
 
                         tx.commit();
                     }

http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/b026f2cc/modules/core/src/main/java/org/apache/ignite/internal/processors/datastructures/GridCacheAtomicReferenceImpl.java
----------------------------------------------------------------------
diff --git a/modules/core/src/main/java/org/apache/ignite/internal/processors/datastructures/GridCacheAtomicReferenceImpl.java b/modules/core/src/main/java/org/apache/ignite/internal/processors/datastructures/GridCacheAtomicReferenceImpl.java
index 4a4efdd..c3d8a25 100644
--- a/modules/core/src/main/java/org/apache/ignite/internal/processors/datastructures/GridCacheAtomicReferenceImpl.java
+++ b/modules/core/src/main/java/org/apache/ignite/internal/processors/datastructures/GridCacheAtomicReferenceImpl.java
@@ -228,7 +228,7 @@ public final class GridCacheAtomicReferenceImpl<T> implements GridCacheAtomicRef
 
                     ref.set(val);
 
-                    atomicView.putx(key, ref);
+                    atomicView.put(key, ref);
 
                     tx.commit();
 
@@ -269,7 +269,7 @@ public final class GridCacheAtomicReferenceImpl<T> implements GridCacheAtomicRef
                     else {
                         ref.set(newValClos.apply(ref.get()));
 
-                        atomicView.put(key, ref);
+                        atomicView.getAndPut(key, ref);
 
                         tx.commit();
 

http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/b026f2cc/modules/core/src/main/java/org/apache/ignite/internal/processors/datastructures/GridCacheAtomicSequenceImpl.java
----------------------------------------------------------------------
diff --git a/modules/core/src/main/java/org/apache/ignite/internal/processors/datastructures/GridCacheAtomicSequenceImpl.java b/modules/core/src/main/java/org/apache/ignite/internal/processors/datastructures/GridCacheAtomicSequenceImpl.java
index 5855fd5..52f762a 100644
--- a/modules/core/src/main/java/org/apache/ignite/internal/processors/datastructures/GridCacheAtomicSequenceImpl.java
+++ b/modules/core/src/main/java/org/apache/ignite/internal/processors/datastructures/GridCacheAtomicSequenceImpl.java
@@ -496,7 +496,7 @@ public final class GridCacheAtomicSequenceImpl implements GridCacheAtomicSequenc
                     // Global counter must be more than reserved upper bound.
                     seq.set(newUpBound + 1);
 
-                    seqView.putx(key, seq);
+                    seqView.put(key, seq);
 
                     tx.commit();
 

http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/b026f2cc/modules/core/src/main/java/org/apache/ignite/internal/processors/datastructures/GridCacheAtomicStampedImpl.java
----------------------------------------------------------------------
diff --git a/modules/core/src/main/java/org/apache/ignite/internal/processors/datastructures/GridCacheAtomicStampedImpl.java b/modules/core/src/main/java/org/apache/ignite/internal/processors/datastructures/GridCacheAtomicStampedImpl.java
index 64f32fc..1694fe9 100644
--- a/modules/core/src/main/java/org/apache/ignite/internal/processors/datastructures/GridCacheAtomicStampedImpl.java
+++ b/modules/core/src/main/java/org/apache/ignite/internal/processors/datastructures/GridCacheAtomicStampedImpl.java
@@ -264,7 +264,7 @@ public final class GridCacheAtomicStampedImpl<T, S> implements GridCacheAtomicSt
 
                     stmp.set(val, stamp);
 
-                    atomicView.putx(key, stmp);
+                    atomicView.put(key, stmp);
 
                     tx.commit();
 
@@ -308,7 +308,7 @@ public final class GridCacheAtomicStampedImpl<T, S> implements GridCacheAtomicSt
                     else {
                         stmp.set(newValClos.apply(stmp.value()), newStampClos.apply(stmp.stamp()));
 
-                        atomicView.put(key, stmp);
+                        atomicView.getAndPut(key, stmp);
 
                         tx.commit();
 

http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/b026f2cc/modules/core/src/main/java/org/apache/ignite/internal/processors/datastructures/GridCacheCountDownLatchImpl.java
----------------------------------------------------------------------
diff --git a/modules/core/src/main/java/org/apache/ignite/internal/processors/datastructures/GridCacheCountDownLatchImpl.java b/modules/core/src/main/java/org/apache/ignite/internal/processors/datastructures/GridCacheCountDownLatchImpl.java
index 0febc22..cb85136 100644
--- a/modules/core/src/main/java/org/apache/ignite/internal/processors/datastructures/GridCacheCountDownLatchImpl.java
+++ b/modules/core/src/main/java/org/apache/ignite/internal/processors/datastructures/GridCacheCountDownLatchImpl.java
@@ -382,7 +382,7 @@ public final class GridCacheCountDownLatchImpl implements GridCacheCountDownLatc
 
                 latchVal.set(retVal);
 
-                latchView.putx(key, latchVal);
+                latchView.put(key, latchVal);
 
                 tx.commit();
 

http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/b026f2cc/modules/core/src/main/java/org/apache/ignite/internal/processors/datastructures/GridCacheSetImpl.java
----------------------------------------------------------------------
diff --git a/modules/core/src/main/java/org/apache/ignite/internal/processors/datastructures/GridCacheSetImpl.java b/modules/core/src/main/java/org/apache/ignite/internal/processors/datastructures/GridCacheSetImpl.java
index b456586..7d7b028 100644
--- a/modules/core/src/main/java/org/apache/ignite/internal/processors/datastructures/GridCacheSetImpl.java
+++ b/modules/core/src/main/java/org/apache/ignite/internal/processors/datastructures/GridCacheSetImpl.java
@@ -165,7 +165,7 @@ public class GridCacheSetImpl<T> extends AbstractCollection<T> implements Ignite
 
         return retry(new Callable<Boolean>() {
             @Override public Boolean call() throws Exception {
-                return cache.putxIfAbsent(key, true);
+                return cache.putIfAbsent(key, true);
             }
         });
     }

http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/b026f2cc/modules/core/src/main/java/org/apache/ignite/internal/processors/datastructures/GridTransactionalCacheQueueImpl.java
----------------------------------------------------------------------
diff --git a/modules/core/src/main/java/org/apache/ignite/internal/processors/datastructures/GridTransactionalCacheQueueImpl.java b/modules/core/src/main/java/org/apache/ignite/internal/processors/datastructures/GridTransactionalCacheQueueImpl.java
index 1990016..1304326 100644
--- a/modules/core/src/main/java/org/apache/ignite/internal/processors/datastructures/GridTransactionalCacheQueueImpl.java
+++ b/modules/core/src/main/java/org/apache/ignite/internal/processors/datastructures/GridTransactionalCacheQueueImpl.java
@@ -60,7 +60,7 @@ public class GridTransactionalCacheQueueImpl<T> extends GridCacheQueueAdapter<T>
                         if (idx != null) {
                             checkRemoved(idx);
 
-                            cache.put(itemKey(idx), item);
+                            cache.getAndPut(itemKey(idx), item);
 
                             retVal = true;
                         }

http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/b026f2cc/modules/core/src/main/java/org/apache/ignite/internal/processors/igfs/IgfsDataManager.java
----------------------------------------------------------------------
diff --git a/modules/core/src/main/java/org/apache/ignite/internal/processors/igfs/IgfsDataManager.java b/modules/core/src/main/java/org/apache/ignite/internal/processors/igfs/IgfsDataManager.java
index 4b09375..29680b4 100644
--- a/modules/core/src/main/java/org/apache/ignite/internal/processors/igfs/IgfsDataManager.java
+++ b/modules/core/src/main/java/org/apache/ignite/internal/processors/igfs/IgfsDataManager.java
@@ -689,7 +689,7 @@ public class IgfsDataManager extends IgfsManager {
                                 byte[] val = vals.get(colocatedKey);
 
                                 if (val != null) {
-                                    dataCachePrj.putx(key, val);
+                                    dataCachePrj.put(key, val);
 
                                     tx.commit();
                                 }
@@ -1117,7 +1117,7 @@ public class IgfsDataManager extends IgfsManager {
 
         // If writing from block beginning, just put and return.
         if (startOff == 0) {
-            dataCachePrj.putx(colocatedKey, data);
+            dataCachePrj.put(colocatedKey, data);
 
             return;
         }
@@ -1208,7 +1208,7 @@ public class IgfsDataManager extends IgfsManager {
         Runnable task = new Runnable() {
             @Override public void run() {
                 try {
-                    dataCachePrj.putx(key, data);
+                    dataCachePrj.put(key, data);
                 }
                 catch (IgniteCheckedException e) {
                     U.warn(log, "Failed to put IGFS data block into cache [key=" + key + ", err=" + e + ']');

http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/b026f2cc/modules/core/src/main/java/org/apache/ignite/internal/processors/igfs/IgfsMetaManager.java
----------------------------------------------------------------------
diff --git a/modules/core/src/main/java/org/apache/ignite/internal/processors/igfs/IgfsMetaManager.java b/modules/core/src/main/java/org/apache/ignite/internal/processors/igfs/IgfsMetaManager.java
index 4c5c248..4765594 100644
--- a/modules/core/src/main/java/org/apache/ignite/internal/processors/igfs/IgfsMetaManager.java
+++ b/modules/core/src/main/java/org/apache/ignite/internal/processors/igfs/IgfsMetaManager.java
@@ -347,7 +347,7 @@ public class IgfsMetaManager extends IgfsManager {
 
                 // Force root ID always exist in cache.
                 if (info == null && ROOT_ID.equals(fileId))
-                    id2InfoPrj.putxIfAbsent(ROOT_ID, info = new IgfsFileInfo());
+                    id2InfoPrj.putIfAbsent(ROOT_ID, info = new IgfsFileInfo());
 
                 return info;
             }
@@ -381,7 +381,7 @@ public class IgfsMetaManager extends IgfsManager {
                 if (fileIds.contains(ROOT_ID) && !map.containsKey(ROOT_ID)) {
                     IgfsFileInfo info = new IgfsFileInfo();
 
-                    id2InfoPrj.putxIfAbsent(ROOT_ID, info);
+                    id2InfoPrj.putIfAbsent(ROOT_ID, info);
 
                     map = new GridLeanMap<>(map);
 
@@ -422,7 +422,7 @@ public class IgfsMetaManager extends IgfsManager {
 
                     IgfsFileInfo newInfo = lockInfo(oldInfo);
 
-                    boolean put = metaCache.putx(fileId, newInfo);
+                    boolean put = metaCache.put(fileId, newInfo);
 
                     assert put : "Value was not stored in cache [fileId=" + fileId + ", newInfo=" + newInfo + ']';
 
@@ -509,7 +509,7 @@ public class IgfsMetaManager extends IgfsManager {
 
                     IgfsFileInfo newInfo = new IgfsFileInfo(oldInfo, null, modificationTime);
 
-                    boolean put = metaCache.putx(fileId, newInfo);
+                    boolean put = metaCache.put(fileId, newInfo);
 
                     assert put : "Value was not stored in cache [fileId=" + fileId + ", newInfo=" + newInfo + ']';
 
@@ -565,7 +565,7 @@ public class IgfsMetaManager extends IgfsManager {
         if (keys.contains(ROOT_ID) && !map.containsKey(ROOT_ID)) {
             IgfsFileInfo info = new IgfsFileInfo();
 
-            id2InfoPrj.putxIfAbsent(ROOT_ID, info);
+            id2InfoPrj.putIfAbsent(ROOT_ID, info);
 
             map = new GridLeanMap<>(map);
 
@@ -758,7 +758,7 @@ public class IgfsMetaManager extends IgfsManager {
 
         IgniteUuid fileId = newFileInfo.id();
 
-        if (!id2InfoPrj.putxIfAbsent(fileId, newFileInfo))
+        if (!id2InfoPrj.putIfAbsent(fileId, newFileInfo))
             throw fsException("Failed to add file details into cache: " + newFileInfo);
 
         assert metaCache.get(parentId) != null;
@@ -1073,7 +1073,7 @@ public class IgfsMetaManager extends IgfsManager {
 
             // Ensure trash directory existence.
             if (id2InfoPrj.get(TRASH_ID) == null)
-                id2InfoPrj.put(TRASH_ID, new IgfsFileInfo(TRASH_ID));
+                id2InfoPrj.getAndPut(TRASH_ID, new IgfsFileInfo(TRASH_ID));
 
             Map<String, IgfsListingEntry> rootListing = rootInfo.listing();
 
@@ -1095,7 +1095,7 @@ public class IgfsMetaManager extends IgfsManager {
 
                 IgfsFileInfo newInfo = new IgfsFileInfo(transferListing);
 
-                id2InfoPrj.put(newInfo.id(), newInfo);
+                id2InfoPrj.getAndPut(newInfo.id(), newInfo);
 
                 // Add new info to trash listing.
                 id2InfoPrj.invoke(TRASH_ID, new UpdateListing(newInfo.id().toString(),
@@ -1113,7 +1113,7 @@ public class IgfsMetaManager extends IgfsManager {
         else {
             // Ensure trash directory existence.
             if (id2InfoPrj.get(TRASH_ID) == null)
-                id2InfoPrj.put(TRASH_ID, new IgfsFileInfo(TRASH_ID));
+                id2InfoPrj.getAndPut(TRASH_ID, new IgfsFileInfo(TRASH_ID));
 
             moveNonTx(id, name, parentId, id.toString(), TRASH_ID);
 
@@ -1190,7 +1190,7 @@ public class IgfsMetaManager extends IgfsManager {
                         }
 
                         // Update parent listing.
-                        id2InfoPrj.putx(parentId, new IgfsFileInfo(newListing, parentInfo));
+                        id2InfoPrj.put(parentId, new IgfsFileInfo(newListing, parentInfo));
                     }
 
                     tx.commit();
@@ -1364,7 +1364,7 @@ public class IgfsMetaManager extends IgfsManager {
 
             IgfsFileInfo newInfo = new IgfsFileInfo(oldInfo, tmp);
 
-            id2InfoPrj.putx(fileId, newInfo);
+            id2InfoPrj.put(fileId, newInfo);
 
             if (parentId != null) {
                 IgfsListingEntry entry = new IgfsListingEntry(newInfo);
@@ -1533,7 +1533,7 @@ public class IgfsMetaManager extends IgfsManager {
                 IgniteInternalTx tx = metaCache.txStartEx(PESSIMISTIC, REPEATABLE_READ);
 
                 try {
-                    Object prev = val != null ? metaCache.put(sampling, val) : metaCache.getAndRemove(sampling);
+                    Object prev = val != null ? metaCache.getAndPut(sampling, val) : metaCache.getAndRemove(sampling);
 
                     tx.commit();
 
@@ -1676,7 +1676,7 @@ public class IgfsMetaManager extends IgfsManager {
                                 IgfsFileInfo oldInfo = info(oldId);
 
                                 id2InfoPrj.remove(oldId); // Remove the old one.
-                                id2InfoPrj.putx(newInfo.id(), newInfo); // Put the new one.
+                                id2InfoPrj.put(newInfo.id(), newInfo); // Put the new one.
 
                                 id2InfoPrj.invoke(parentInfo.id(),
                                     new UpdateListing(path.name(), parentInfo.listing().get(path.name()), true));
@@ -1798,7 +1798,7 @@ public class IgfsMetaManager extends IgfsManager {
                             // Set lock and return.
                             info = lockInfo(info);
 
-                            metaCache.putx(info.id(), info);
+                            metaCache.put(info.id(), info);
 
                             return new IgfsSecondaryOutputStreamDescriptor(infos.get(path.parent()).id(), info, out);
                         }
@@ -2570,7 +2570,7 @@ public class IgfsMetaManager extends IgfsManager {
         V oldVal = cache.get(key);
         V newVal = c.apply(oldVal);
 
-        return newVal == null ? cache.remove(key) : cache.putx(key, newVal);
+        return newVal == null ? cache.remove(key) : cache.put(key, newVal);
     }
 
     /**
@@ -2636,7 +2636,7 @@ public class IgfsMetaManager extends IgfsManager {
                         accessTime == -1 ? fileInfo.accessTime() : accessTime,
                         modificationTime == -1 ? fileInfo.modificationTime() : modificationTime);
 
-                    id2InfoPrj.putx(fileId, updated);
+                    id2InfoPrj.put(fileId, updated);
 
                     id2InfoPrj.invoke(parentId, new UpdateListingEntry(fileId, fileName, 0, accessTime,
                         modificationTime));

http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/b026f2cc/modules/core/src/main/java/org/apache/ignite/internal/processors/rest/handlers/cache/GridCacheCommandHandler.java
----------------------------------------------------------------------
diff --git a/modules/core/src/main/java/org/apache/ignite/internal/processors/rest/handlers/cache/GridCacheCommandHandler.java b/modules/core/src/main/java/org/apache/ignite/internal/processors/rest/handlers/cache/GridCacheCommandHandler.java
index 646c3dc..697c92b 100644
--- a/modules/core/src/main/java/org/apache/ignite/internal/processors/rest/handlers/cache/GridCacheCommandHandler.java
+++ b/modules/core/src/main/java/org/apache/ignite/internal/processors/rest/handlers/cache/GridCacheCommandHandler.java
@@ -412,7 +412,7 @@ public class GridCacheCommandHandler extends GridRestCommandHandlerAdapter {
                     Object newVal = appendOrPrepend(curVal, val, !prepend);
 
                     // Put new value asynchronously.
-                    cache.putx(key, newVal);
+                    cache.put(key, newVal);
 
                     tx.commit();
                 }
@@ -835,7 +835,7 @@ public class GridCacheCommandHandler extends GridRestCommandHandlerAdapter {
         /** {@inheritDoc} */
         @Override public IgniteInternalFuture<?> applyx(CacheProjection<Object, Object> c, GridKernalContext ctx) {
             return exp == null && val == null ? c.removeAsync(key) :
-                exp == null ? c.putxIfAbsentAsync(key, val) :
+                exp == null ? c.putIfAbsentAsync(key, val) :
                     val == null ? c.removeAsync(key, exp) :
                         c.getAndReplaceAsync(key, exp, val);
         }
@@ -874,7 +874,7 @@ public class GridCacheCommandHandler extends GridRestCommandHandlerAdapter {
                 c = ((GridCacheProjectionEx<Object, Object>)c).withExpiryPolicy(new ModifiedExpiryPolicy(duration));
             }
 
-            return c.putxAsync(key, val);
+            return c.putAsync(key, val);
         }
     }
 
@@ -911,7 +911,7 @@ public class GridCacheCommandHandler extends GridRestCommandHandlerAdapter {
                 c = ((GridCacheProjectionEx<Object, Object>)c).withExpiryPolicy(new ModifiedExpiryPolicy(duration));
             }
 
-            return c.putxIfAbsentAsync(key, val);
+            return c.putIfAbsentAsync(key, val);
         }
     }
 

http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/b026f2cc/modules/core/src/main/java/org/apache/ignite/internal/processors/service/GridServiceProcessor.java
----------------------------------------------------------------------
diff --git a/modules/core/src/main/java/org/apache/ignite/internal/processors/service/GridServiceProcessor.java b/modules/core/src/main/java/org/apache/ignite/internal/processors/service/GridServiceProcessor.java
index 25c73ce..f4898fa 100644
--- a/modules/core/src/main/java/org/apache/ignite/internal/processors/service/GridServiceProcessor.java
+++ b/modules/core/src/main/java/org/apache/ignite/internal/processors/service/GridServiceProcessor.java
@@ -333,7 +333,7 @@ public class GridServiceProcessor extends GridProcessorAdapter {
                     ctx.cache().context().deploy().ignoreOwnership(true);
 
                 try {
-                    GridServiceDeployment dep = (GridServiceDeployment)cache.putIfAbsent(key,
+                    GridServiceDeployment dep = (GridServiceDeployment)cache.getAndPutIfAbsent(key,
                         new GridServiceDeployment(ctx.localNodeId(), cfg));
 
                     if (dep != null) {
@@ -713,7 +713,7 @@ public class GridServiceProcessor extends GridProcessorAdapter {
 
                 assigns.assigns(cnts);
 
-                cache.put(key, assigns);
+                cache.getAndPut(key, assigns);
 
                 tx.commit();
 

http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/b026f2cc/modules/core/src/main/java/org/apache/ignite/internal/processors/task/GridTaskProcessor.java
----------------------------------------------------------------------
diff --git a/modules/core/src/main/java/org/apache/ignite/internal/processors/task/GridTaskProcessor.java b/modules/core/src/main/java/org/apache/ignite/internal/processors/task/GridTaskProcessor.java
index 963da48..d537e08 100644
--- a/modules/core/src/main/java/org/apache/ignite/internal/processors/task/GridTaskProcessor.java
+++ b/modules/core/src/main/java/org/apache/ignite/internal/processors/task/GridTaskProcessor.java
@@ -713,7 +713,7 @@ public class GridTaskProcessor extends GridProcessorAdapter {
         String existingName = tasksMetaCache.get(key);
 
         if (existingName == null)
-            existingName = tasksMetaCache.putIfAbsent(key, taskName);
+            existingName = tasksMetaCache.getAndPutIfAbsent(key, taskName);
 
         if (existingName != null && !F.eq(existingName, taskName))
             throw new IgniteCheckedException("Task name hash collision for security-enabled node " +

http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/b026f2cc/modules/core/src/main/java/org/apache/ignite/startup/BasicWarmupClosure.java
----------------------------------------------------------------------
diff --git a/modules/core/src/main/java/org/apache/ignite/startup/BasicWarmupClosure.java b/modules/core/src/main/java/org/apache/ignite/startup/BasicWarmupClosure.java
index a32059a..3d2f0ad 100644
--- a/modules/core/src/main/java/org/apache/ignite/startup/BasicWarmupClosure.java
+++ b/modules/core/src/main/java/org/apache/ignite/startup/BasicWarmupClosure.java
@@ -468,7 +468,7 @@ public class BasicWarmupClosure implements IgniteInClosure<IgniteConfiguration>
 
         /** {@inheritDoc} */
         @Override protected void operation(int key) throws Exception {
-            cache.put(key, key);
+            cache.getAndPut(key, key);
         }
     }
 
@@ -485,7 +485,7 @@ public class BasicWarmupClosure implements IgniteInClosure<IgniteConfiguration>
 
         /** {@inheritDoc} */
         @Override protected void operation(int key) throws Exception {
-            cache.putx(key, key);
+            cache.put(key, key);
         }
     }
 
@@ -536,7 +536,7 @@ public class BasicWarmupClosure implements IgniteInClosure<IgniteConfiguration>
 
         /** {@inheritDoc} */
         @Override protected void operation(int key) throws Exception {
-            cache.putIfAbsent(key, key);
+            cache.getAndPutIfAbsent(key, key);
         }
     }
 

http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/b026f2cc/modules/core/src/test/java/org/apache/ignite/internal/processors/cache/GridCacheAbstractFullApiSelfTest.java
----------------------------------------------------------------------
diff --git a/modules/core/src/test/java/org/apache/ignite/internal/processors/cache/GridCacheAbstractFullApiSelfTest.java b/modules/core/src/test/java/org/apache/ignite/internal/processors/cache/GridCacheAbstractFullApiSelfTest.java
index 89a1e28..952479b 100644
--- a/modules/core/src/test/java/org/apache/ignite/internal/processors/cache/GridCacheAbstractFullApiSelfTest.java
+++ b/modules/core/src/test/java/org/apache/ignite/internal/processors/cache/GridCacheAbstractFullApiSelfTest.java
@@ -3398,9 +3398,9 @@ public abstract class GridCacheAbstractFullApiSelfTest extends GridCacheAbstract
         String k2 = keys.get(1);
         String k3 = keys.get(2);
 
-        cache.put(k1, 1);
-        cache.put(k2, 2);
-        cache.put(k3, 3);
+        cache.getAndPut(k1, 1);
+        cache.getAndPut(k2, 2);
+        cache.getAndPut(k3, 3);
 
         final AtomicInteger swapEvts = new AtomicInteger(0);
         final AtomicInteger unswapEvts = new AtomicInteger(0);
@@ -3498,9 +3498,9 @@ public abstract class GridCacheAbstractFullApiSelfTest extends GridCacheAbstract
         cache.clear();
 
         // Check with multiple arguments.
-        cache.put(k1, 1);
-        cache.put(k2, 2);
-        cache.put(k3, 3);
+        cache.getAndPut(k1, 1);
+        cache.getAndPut(k2, 2);
+        cache.getAndPut(k3, 3);
 
         swapEvts.set(0);
         unswapEvts.set(0);

http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/b026f2cc/modules/core/src/test/java/org/apache/ignite/internal/processors/cache/GridCacheFullTextQueryMultithreadedSelfTest.java
----------------------------------------------------------------------
diff --git a/modules/core/src/test/java/org/apache/ignite/internal/processors/cache/GridCacheFullTextQueryMultithreadedSelfTest.java b/modules/core/src/test/java/org/apache/ignite/internal/processors/cache/GridCacheFullTextQueryMultithreadedSelfTest.java
index 614b05d..736d571 100644
--- a/modules/core/src/test/java/org/apache/ignite/internal/processors/cache/GridCacheFullTextQueryMultithreadedSelfTest.java
+++ b/modules/core/src/test/java/org/apache/ignite/internal/processors/cache/GridCacheFullTextQueryMultithreadedSelfTest.java
@@ -79,7 +79,7 @@ public class GridCacheFullTextQueryMultithreadedSelfTest extends GridCacheAbstra
         IgniteInternalFuture<?> fut1 = multithreadedAsync(new Callable() {
                 @Override public Object call() throws Exception {
                     for (int i = 0; i < keyCnt; i++) {
-                        c.put(i, new H2TextValue(txt));
+                        c.getAndPut(i, new H2TextValue(txt));
 
                         if (i % logFreq == 0)
                             X.println("Stored values: " + i);

http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/b026f2cc/modules/core/src/test/java/org/apache/ignite/internal/processors/cache/GridCacheOffHeapTest.java
----------------------------------------------------------------------
diff --git a/modules/core/src/test/java/org/apache/ignite/internal/processors/cache/GridCacheOffHeapTest.java b/modules/core/src/test/java/org/apache/ignite/internal/processors/cache/GridCacheOffHeapTest.java
index 44ed9bc..d69f7fa 100644
--- a/modules/core/src/test/java/org/apache/ignite/internal/processors/cache/GridCacheOffHeapTest.java
+++ b/modules/core/src/test/java/org/apache/ignite/internal/processors/cache/GridCacheOffHeapTest.java
@@ -187,7 +187,7 @@ public class GridCacheOffHeapTest extends GridCommonAbstractTest {
             long start = System.currentTimeMillis();
 
             for (int i = 0; i < max; i++) {
-                cache.put(i, i);
+                cache.getAndPut(i, i);
 
                 if (i % 100000 == 0) {
                     long cur = System.currentTimeMillis();
@@ -224,7 +224,7 @@ public class GridCacheOffHeapTest extends GridCommonAbstractTest {
                         int val = keyGen.addAndGet(reserveSize); // Reserve keys.
 
                         for (int i = val - reserveSize; i < val; i++) {
-                            c.put(i, i);
+                            c.getAndPut(i, i);
 
                             if (i % 500000 == 0) {
                                 long dur = System.currentTimeMillis() - start;

http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/b026f2cc/modules/core/src/test/java/org/apache/ignite/internal/processors/cache/IgniteTxMultiNodeAbstractTest.java
----------------------------------------------------------------------
diff --git a/modules/core/src/test/java/org/apache/ignite/internal/processors/cache/IgniteTxMultiNodeAbstractTest.java b/modules/core/src/test/java/org/apache/ignite/internal/processors/cache/IgniteTxMultiNodeAbstractTest.java
index 07dcad3..a9aa484 100644
--- a/modules/core/src/test/java/org/apache/ignite/internal/processors/cache/IgniteTxMultiNodeAbstractTest.java
+++ b/modules/core/src/test/java/org/apache/ignite/internal/processors/cache/IgniteTxMultiNodeAbstractTest.java
@@ -710,11 +710,11 @@ public abstract class IgniteTxMultiNodeAbstractTest extends GridCommonAbstractTe
             GridCacheAdapter<String, Integer> cache = ((IgniteKernal)grid(0)).internalCache(null);
 
             // Store counter.
-            cache.put(RMVD_CNTR_KEY, 0);
+            cache.getAndPut(RMVD_CNTR_KEY, 0);
 
             // Store values.
             for (int i = 1; i <= GRID_CNT * RETRIES; i++)
-                cache.put(String.valueOf(i), i);
+                cache.getAndPut(String.valueOf(i), i);
 
             for (int j = 0; j < GRID_CNT; j++)
                 assertEquals(0, grid(j).cache(null).get(RMVD_CNTR_KEY));

http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/b026f2cc/modules/core/src/test/java/org/apache/ignite/internal/processors/cache/distributed/IgniteCacheSystemTransactionsSelfTest.java
----------------------------------------------------------------------
diff --git a/modules/core/src/test/java/org/apache/ignite/internal/processors/cache/distributed/IgniteCacheSystemTransactionsSelfTest.java b/modules/core/src/test/java/org/apache/ignite/internal/processors/cache/distributed/IgniteCacheSystemTransactionsSelfTest.java
index 7c3d31a..d78add6 100644
--- a/modules/core/src/test/java/org/apache/ignite/internal/processors/cache/distributed/IgniteCacheSystemTransactionsSelfTest.java
+++ b/modules/core/src/test/java/org/apache/ignite/internal/processors/cache/distributed/IgniteCacheSystemTransactionsSelfTest.java
@@ -77,14 +77,14 @@ public class IgniteCacheSystemTransactionsSelfTest extends GridCacheAbstractSelf
 
             GridCacheAdapter<Object, Object> utilityCache = ignite.context().cache().utilityCache();
 
-            utilityCache.putIfAbsent("2", "2");
+            utilityCache.getAndPutIfAbsent("2", "2");
 
             try (IgniteInternalTx itx = utilityCache.txStartEx(PESSIMISTIC, REPEATABLE_READ)) {
                 assertEquals(null, utilityCache.get("1"));
                 assertEquals("2", utilityCache.get("2"));
                 assertEquals(null, utilityCache.get("3"));
 
-                utilityCache.put("3", "3");
+                utilityCache.getAndPut("3", "3");
 
                 itx.commit();
             }

http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/b026f2cc/modules/core/src/test/java/org/apache/ignite/internal/processors/cache/distributed/dht/GridCacheDhtEvictionNearReadersSelfTest.java
----------------------------------------------------------------------
diff --git a/modules/core/src/test/java/org/apache/ignite/internal/processors/cache/distributed/dht/GridCacheDhtEvictionNearReadersSelfTest.java b/modules/core/src/test/java/org/apache/ignite/internal/processors/cache/distributed/dht/GridCacheDhtEvictionNearReadersSelfTest.java
index 442f598..aff5512 100644
--- a/modules/core/src/test/java/org/apache/ignite/internal/processors/cache/distributed/dht/GridCacheDhtEvictionNearReadersSelfTest.java
+++ b/modules/core/src/test/java/org/apache/ignite/internal/processors/cache/distributed/dht/GridCacheDhtEvictionNearReadersSelfTest.java
@@ -228,7 +228,7 @@ public class GridCacheDhtEvictionNearReadersSelfTest extends GridCommonAbstractT
         String val = "v1";
 
         // Put on primary node.
-        nearPrimary.put(key, val);
+        nearPrimary.getAndPut(key, val);
 
         GridDhtCacheEntry entryPrimary = (GridDhtCacheEntry)dhtPrimary.peekEx(key);
         GridDhtCacheEntry entryBackup = (GridDhtCacheEntry)dhtBackup.peekEx(key);

http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/b026f2cc/modules/core/src/test/java/org/apache/ignite/internal/processors/cache/distributed/dht/GridCacheDhtEvictionSelfTest.java
----------------------------------------------------------------------
diff --git a/modules/core/src/test/java/org/apache/ignite/internal/processors/cache/distributed/dht/GridCacheDhtEvictionSelfTest.java b/modules/core/src/test/java/org/apache/ignite/internal/processors/cache/distributed/dht/GridCacheDhtEvictionSelfTest.java
index 39ef872..97e8657 100644
--- a/modules/core/src/test/java/org/apache/ignite/internal/processors/cache/distributed/dht/GridCacheDhtEvictionSelfTest.java
+++ b/modules/core/src/test/java/org/apache/ignite/internal/processors/cache/distributed/dht/GridCacheDhtEvictionSelfTest.java
@@ -208,7 +208,7 @@ public class GridCacheDhtEvictionSelfTest extends GridCommonAbstractTest {
         String val = "v1";
 
         // Put on primary node.
-        nearPrimary.put(key, val, null);
+        nearPrimary.getAndPut(key, val, null);
 
         assertEquals(val, localPeek(nearPrimary, key));
         assertEquals(val, localPeek(dhtPrimary, key));
@@ -276,7 +276,7 @@ public class GridCacheDhtEvictionSelfTest extends GridCommonAbstractTest {
 
         // Put on primary node.
         for (Integer key : keys)
-            nearPrimary.put(key, "v" + key, null);
+            nearPrimary.getAndPut(key, "v" + key, null);
 
         for (Integer key : keys) {
             String val = "v" + key;

http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/b026f2cc/modules/core/src/test/java/org/apache/ignite/internal/processors/cache/distributed/near/GridCachePartitionedFullApiSelfTest.java
----------------------------------------------------------------------
diff --git a/modules/core/src/test/java/org/apache/ignite/internal/processors/cache/distributed/near/GridCachePartitionedFullApiSelfTest.java b/modules/core/src/test/java/org/apache/ignite/internal/processors/cache/distributed/near/GridCachePartitionedFullApiSelfTest.java
index 76b8036..7e16ac7 100644
--- a/modules/core/src/test/java/org/apache/ignite/internal/processors/cache/distributed/near/GridCachePartitionedFullApiSelfTest.java
+++ b/modules/core/src/test/java/org/apache/ignite/internal/processors/cache/distributed/near/GridCachePartitionedFullApiSelfTest.java
@@ -64,7 +64,7 @@ public class GridCachePartitionedFullApiSelfTest extends GridCacheAbstractFullAp
         for (int i = 0; i < 100; i++) {
             String key = String.valueOf(i);
 
-            cache.put(key, i);
+            cache.getAndPut(key, i);
         }
 
         Affinity aff = grid(0).affinity(cache.name());

http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/b026f2cc/modules/core/src/test/java/org/apache/ignite/internal/processors/cache/distributed/replicated/preloader/GridCacheReplicatedPreloadSelfTest.java
----------------------------------------------------------------------
diff --git a/modules/core/src/test/java/org/apache/ignite/internal/processors/cache/distributed/replicated/preloader/GridCacheReplicatedPreloadSelfTest.java b/modules/core/src/test/java/org/apache/ignite/internal/processors/cache/distributed/replicated/preloader/GridCacheReplicatedPreloadSelfTest.java
index 2bec185..0f4d24d 100644
--- a/modules/core/src/test/java/org/apache/ignite/internal/processors/cache/distributed/replicated/preloader/GridCacheReplicatedPreloadSelfTest.java
+++ b/modules/core/src/test/java/org/apache/ignite/internal/processors/cache/distributed/replicated/preloader/GridCacheReplicatedPreloadSelfTest.java
@@ -156,8 +156,8 @@ public class GridCacheReplicatedPreloadSelfTest extends GridCommonAbstractTest {
 
             GridCacheAdapter<Integer, String> cache1 = ((IgniteKernal)g1).internalCache(null);
 
-            cache1.put(1, "val1");
-            cache1.put(2, "val2");
+            cache1.getAndPut(1, "val1");
+            cache1.getAndPut(2, "val2");
 
             GridCacheEntryEx e1 = cache1.peekEx(1);
 

http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/b026f2cc/modules/core/src/test/java/org/apache/ignite/internal/processors/cache/query/GridCacheSwapScanQueryAbstractSelfTest.java
----------------------------------------------------------------------
diff --git a/modules/core/src/test/java/org/apache/ignite/internal/processors/cache/query/GridCacheSwapScanQueryAbstractSelfTest.java b/modules/core/src/test/java/org/apache/ignite/internal/processors/cache/query/GridCacheSwapScanQueryAbstractSelfTest.java
index 3c95046..597f115 100644
--- a/modules/core/src/test/java/org/apache/ignite/internal/processors/cache/query/GridCacheSwapScanQueryAbstractSelfTest.java
+++ b/modules/core/src/test/java/org/apache/ignite/internal/processors/cache/query/GridCacheSwapScanQueryAbstractSelfTest.java
@@ -129,7 +129,7 @@ public abstract class GridCacheSwapScanQueryAbstractSelfTest extends GridCommonA
         final int ENTRY_CNT = 500;
 
         for (int i = 0; i < ENTRY_CNT; i++)
-            cache.put(new Key(i), new Person("p-" + i, i));
+            cache.getAndPut(new Key(i), new Person("p-" + i, i));
 
         try {
             CacheQuery<Map.Entry<Key, Person>> qry = cache.queries().createScanQuery(
@@ -221,7 +221,7 @@ public abstract class GridCacheSwapScanQueryAbstractSelfTest extends GridCommonA
         final int ENTRY_CNT = 500;
 
         for (int i = 0; i < ENTRY_CNT; i++)
-            cache.put(String.valueOf(i), (long) i);
+            cache.getAndPut(String.valueOf(i), (long) i);
 
         try {
             CacheQuery<Map.Entry<String, Long>> qry = cache.queries().createScanQuery(
@@ -277,7 +277,7 @@ public abstract class GridCacheSwapScanQueryAbstractSelfTest extends GridCommonA
         final int ENTRY_CNT = 100;
 
         for (int i = 0; i < ENTRY_CNT; i++)
-            cache.put(i, new byte[i]);
+            cache.getAndPut(i, new byte[i]);
 
         try {
             CacheQuery<Map.Entry<Integer, byte[]>> qry = cache.queries().createScanQuery(


Mime
View raw message