ignite-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From sboi...@apache.org
Subject incubator-ignite git commit: #ignite-683: remove Filters from CacheProjection.
Date Mon, 06 Apr 2015 12:18:26 GMT
Repository: incubator-ignite
Updated Branches:
  refs/heads/ignite-683 ad77798de -> 6ecc11647


#ignite-683: remove Filters from CacheProjection.


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

Branch: refs/heads/ignite-683
Commit: 6ecc11647e779b3960995369788df14a7e2881a0
Parents: ad77798
Author: ivasilinets <ivasilinets@gridgain.com>
Authored: Mon Apr 6 16:18:16 2015 +0300
Committer: ivasilinets <ivasilinets@gridgain.com>
Committed: Mon Apr 6 16:18:16 2015 +0300

----------------------------------------------------------------------
 .../processors/cache/CacheProjection.java       |  85 +---
 .../processors/cache/GridCacheAdapter.java      | 394 +++++++++++++++++--
 .../cache/GridCacheProjectionImpl.java          |  71 ++--
 .../processors/cache/GridCacheProxyImpl.java    |  67 ++--
 4 files changed, 426 insertions(+), 191 deletions(-)
----------------------------------------------------------------------


http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/6ecc1164/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 b17fdac..dcd3062 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
@@ -458,15 +458,13 @@ public interface CacheProjection<K, V> extends Iterable<Cache.Entry<K, V>> {
      *
      * @param key Key to store in cache.
      * @param val Value to be associated with the given key.
-     * @param filter Optional filter to check prior to putting value in cache. Note
-     *      that filter check is atomic with put operation.
      * @return Previous value associated with specified key, or {@code null}
      *  if entry did not pass the filter, or if there was no mapping for the key in swap
      *  or in persistent storage.
      * @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 CacheEntryPredicate... filter)
+    @Nullable public V put(K key, V val)
         throws IgniteCheckedException;
 
     /**
@@ -493,22 +491,15 @@ public interface CacheProjection<K, V> extends Iterable<Cache.Entry<K, V>> {
      *
      * @param key Key to store in cache.
      * @param val Value to be associated with the given key.
-     * @param filter Optional filter to check prior to putting value in cache. Note
-     *      that filter check is atomic with put operation.
      * @return Future for the put operation.
      * @throws NullPointerException If either key or value are {@code null}.
      */
-    public IgniteInternalFuture<V> putAsync(K key, V val, @Nullable CacheEntryPredicate... filter);
+    public IgniteInternalFuture<V> putAsync(K key, V val);
 
     /**
-     * Stores given key-value pair in cache. If filters are provided, then entries will
-     * be stored in cache only if they pass the filter. Note that filter check is atomic,
-     * so value stored in cache is guaranteed to be consistent with the filters.
+     * Stores given key-value pair in cache.
      * <p>
      * This method will return {@code true} if value is stored in cache and {@code false} otherwise.
-     * Unlike <code>#put(Object, Object, org.apache.ignite.lang.IgnitePredicate[])</code> method, it does not return previous
-     * value and, therefore, does not have any overhead associated with returning a value. It
-     * should be used whenever return value is not required.
      * <p>
      * If write-through is enabled, the stored value will be persisted to {@link CacheStore}
      * via <code>CacheStore#put(Transaction, Object, Object)</code> method.
@@ -518,26 +509,19 @@ public interface CacheProjection<K, V> extends Iterable<Cache.Entry<K, V>> {
      *
      * @param key Key to store in cache.
      * @param val Value to be associated with the given key.
-     * @param filter Optional filter to check prior to putting value in cache. Note
-     *      that filter check is atomic with put operation.
      * @return {@code True} if optional filter passed and value was stored in cache,
      *      {@code false} otherwise. Note that this method will return {@code true} if filter is not
      *      specified.
      * @throws NullPointerException If either key or value are {@code null}.
      * @throws IgniteCheckedException If put operation failed.
      */
-    public boolean putx(K key, V val, @Nullable CacheEntryPredicate... filter)
+    public boolean putx(K key, V val)
         throws IgniteCheckedException;
 
     /**
-     * Stores given key-value pair in cache. If filters are provided, then entries will
-     * be stored in cache only if they pass the filter. Note that filter check is atomic,
-     * so value stored in cache is guaranteed to be consistent with the filters.
+     * Stores given key-value pair in cache.
      * <p>
      * This method will return {@code true} if value is stored in cache and {@code false} otherwise.
-     * Unlike <code>#put(Object, Object, org.apache.ignite.lang.IgnitePredicate[])</code> 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>
      * If write-through is enabled, the stored value will be persisted to {@link CacheStore}
      * via <code>CacheStore#put(Transaction, Object, Object)</code> method.
@@ -547,14 +531,11 @@ public interface CacheProjection<K, V> extends Iterable<Cache.Entry<K, V>> {
      *
      * @param key Key to store in cache.
      * @param val Value to be associated with the given key.
-     * @param filter Optional filter to check prior to putting value in cache. Note
-     *      that filter check is atomic with put operation.
-     * @return Future for the put operation. Future will return {@code true} if optional filter
-     *      passed and value was stored in cache, {@code false} otherwise. Note that future will
-     *      return {@code true} if filter is not specified.
+     * @return Future for the put operation. Future will return {@code true} value was stored in cache,
+     * {@code false} otherwise.
      * @throws NullPointerException If either key or value are {@code null}.
      */
-    public IgniteInternalFuture<Boolean> putxAsync(K key, V val, @Nullable CacheEntryPredicate... filter);
+    public IgniteInternalFuture<Boolean> putxAsync(K key, V val);
 
     /**
      * Stores given key-value pair in cache only if cache had no previous mapping for it. If cache
@@ -800,12 +781,9 @@ public interface CacheProjection<K, V> extends Iterable<Cache.Entry<K, V>> {
      * if there is one.
      *
      * @param m Key-value pairs to store in cache.
-     * @param filter Optional entry filter. If provided, then entry will
-     *      be stored only if the filter returned {@code true}.
      * @throws IgniteCheckedException If put operation failed.
      */
-    public void putAll(@Nullable Map<? extends K, ? extends V> m,
-        @Nullable CacheEntryPredicate... filter) throws IgniteCheckedException;
+    public void putAll(@Nullable Map<? extends K, ? extends V> m) throws IgniteCheckedException;
 
     /**
      * Asynchronously stores given key-value pairs in cache. If filters are provided, then entries will
@@ -819,12 +797,9 @@ public interface CacheProjection<K, V> extends Iterable<Cache.Entry<K, V>> {
      * if there is one.
      *
      * @param m Key-value pairs to store in cache.
-     * @param filter Optional entry filter. If provided, then entry will
-     *      be stored only if the filter returned {@code true}.
      * @return Future for putAll operation.
      */
-    public IgniteInternalFuture<?> putAllAsync(@Nullable Map<? extends K, ? extends V> m,
-        @Nullable CacheEntryPredicate... filter);
+    public IgniteInternalFuture<?> putAllAsync(@Nullable Map<? extends K, ? extends V> m);
 
     /**
      * Set of keys cached on this node. You can remove elements from this set, but you cannot add elements
@@ -842,23 +817,6 @@ public interface CacheProjection<K, V> extends Iterable<Cache.Entry<K, V>> {
     public Set<K> keySet();
 
     /**
-     * Set of keys cached on this node. You can remove elements from this set, but you cannot add elements
-     * to this set. All removal operation will be reflected on the cache itself.
-     * <p>
-     * Iterator over this set will not fail if set was concurrently updated
-     * by another thread. This means that iterator may or may not return latest
-     * keys depending on whether they were added before or after current
-     * iterator position.
-     * <p>
-     * NOTE: this operation is not distributed and returns only the keys cached on this node.
-     *
-     * @param filter Optional filter to check prior to getting key form cache. Note
-     * that filter is checked atomically together with get operation.
-     * @return Key set for this cache projection.
-     */
-    public Set<K> keySet(@Nullable CacheEntryPredicate... filter);
-
-    /**
      * Set of keys for which this node is primary.
      * This set is dynamic and may change with grid topology changes.
      * Note that this set will contain mappings for all keys, even if their values are
@@ -1184,14 +1142,12 @@ public interface CacheProjection<K, V> extends Iterable<Cache.Entry<K, V>> {
      * if there is one.
      *
      * @param key Key whose mapping is to be removed from cache.
-     * @param filter Optional filter to check prior to removing value form cache. Note
-     *      that filter is checked atomically together with remove operation.
      * @return Previous value associated with specified key, or {@code null}
      *      if there was no value for this key.
      * @throws NullPointerException If key is {@code null}.
      * @throws IgniteCheckedException If remove operation failed.
      */
-    @Nullable public V remove(K key, @Nullable CacheEntryPredicate... filter)
+    @Nullable public V remove(K key)
         throws IgniteCheckedException;
 
     /**
@@ -1213,12 +1169,10 @@ public interface CacheProjection<K, V> extends Iterable<Cache.Entry<K, V>> {
      * if there is one.
      *
      * @param key Key whose mapping is to be removed from cache.
-     * @param filter Optional filter to check prior to removing value form cache. Note
-     *      that filter is checked atomically together with remove operation.
      * @return Future for the remove operation.
      * @throws NullPointerException if the key is {@code null}.
      */
-    public IgniteInternalFuture<V> removeAsync(K key, CacheEntryPredicate... filter);
+    public IgniteInternalFuture<V> removeAsync(K key);
 
     /**
      * Removes given key mapping from cache.
@@ -1233,14 +1187,12 @@ public interface CacheProjection<K, V> extends Iterable<Cache.Entry<K, V>> {
      * if there is one.
      *
      * @param key Key whose mapping is to be removed from cache.
-     * @param filter Optional filter to check prior to removing value form cache. Note
-     *      that filter is checked atomically together with remove operation.
      * @return {@code True} if filter passed validation and entry was removed, {@code false} otherwise.
      *      Note that if filter is not specified, this method will return {@code true}.
      * @throws NullPointerException if the key is {@code null}.
      * @throws IgniteCheckedException If remove failed.
      */
-    public boolean removex(K key, @Nullable CacheEntryPredicate... filter)
+    public boolean removex(K key)
         throws IgniteCheckedException;
 
     /**
@@ -1256,15 +1208,12 @@ public interface CacheProjection<K, V> extends Iterable<Cache.Entry<K, V>> {
      * if there is one.
      *
      * @param key Key whose mapping is to be removed from cache.
-     * @param filter Optional filter to check prior to removing value form cache. Note
-     *      that filter is checked atomically together with remove operation.
      * @return Future for the remove operation. The future will return {@code true}
      *      if optional filters passed validation and remove did occur, {@code false} otherwise.
      *      Note that if filter is not specified, this method will return {@code true}.
      * @throws NullPointerException if the key is {@code null}.
      */
-    public IgniteInternalFuture<Boolean> removexAsync(K key,
-        @Nullable CacheEntryPredicate... filter);
+    public IgniteInternalFuture<Boolean> removexAsync(K key);
 
     /**
      * Removes given key mapping from cache if one exists and value is equal to the passed in value.
@@ -1319,8 +1268,7 @@ public interface CacheProjection<K, V> extends Iterable<Cache.Entry<K, V>> {
      *      that filter is checked atomically together with remove operation.
      * @throws IgniteCheckedException If remove failed.
      */
-    public void removeAll(@Nullable Collection<? extends K> keys,
-        @Nullable CacheEntryPredicate... filter) throws IgniteCheckedException;
+    public void removeAll(@Nullable Collection<? extends K> keys) throws IgniteCheckedException;
 
     /**
      * Asynchronously removes given key mappings from cache for entries for which the optionally
@@ -1338,8 +1286,7 @@ public interface CacheProjection<K, V> extends Iterable<Cache.Entry<K, V>> {
      * @return Future for the remove operation. The future will complete whenever
      *      remove operation completes.
      */
-    public IgniteInternalFuture<?> removeAllAsync(@Nullable Collection<? extends K> keys,
-        @Nullable CacheEntryPredicate... filter);
+    public IgniteInternalFuture<?> removeAllAsync(@Nullable Collection<? extends K> keys);
 
     /**
      * Removes mappings from cache for entries for which the optionally passed in filters do

http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/6ecc1164/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 976c045..7145a39 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
@@ -946,7 +946,7 @@ public abstract class GridCacheAdapter<K, V> implements GridCache<K, V>,
 
     /** {@inheritDoc} */
     @Override public Set<Cache.Entry<K, V>> entrySet() {
-        return entrySet((CacheEntryPredicate[])null);
+        return entrySet((CacheEntryPredicate[]) null);
     }
 
     /** {@inheritDoc} */
@@ -969,22 +969,22 @@ public abstract class GridCacheAdapter<K, V> implements GridCache<K, V>,
 
     /** {@inheritDoc} */
     @Override public Set<Cache.Entry<K, V>> primaryEntrySet() {
-        return primaryEntrySet((CacheEntryPredicate[])null);
+        return primaryEntrySet((CacheEntryPredicate[]) null);
     }
 
     /** {@inheritDoc} */
     @Override public Set<K> keySet() {
-        return keySet((CacheEntryPredicate[])null);
+        return keySet((CacheEntryPredicate[]) null);
     }
 
     /** {@inheritDoc} */
     @Override public Set<K> primaryKeySet() {
-        return primaryKeySet((CacheEntryPredicate[])null);
+        return primaryKeySet((CacheEntryPredicate[]) null);
     }
 
     /** {@inheritDoc} */
     @Override public Collection<V> values() {
-        return values((CacheEntryPredicate[])null);
+        return values((CacheEntryPredicate[]) null);
     }
 
     /**
@@ -1325,7 +1325,8 @@ public abstract class GridCacheAdapter<K, V> implements GridCache<K, V>,
 
         return getAllAsync(Collections.singletonList(key), /*force primary*/true, /*skip tx*/false, null, null,
             taskName, true, false).chain(new CX1<IgniteInternalFuture<Map<K, V>>, V>() {
-            @Override public V applyx(IgniteInternalFuture<Map<K, V>> e) throws IgniteCheckedException {
+            @Override
+            public V applyx(IgniteInternalFuture<Map<K, V>> e) throws IgniteCheckedException {
                 return e.get().get(key);
             }
         });
@@ -1550,7 +1551,7 @@ public abstract class GridCacheAdapter<K, V> implements GridCache<K, V>,
 
     /** {@inheritDoc} */
     @Override public void evictAll(Collection<? extends K> keys) {
-        evictAll(keys, (CacheEntryPredicate[])null);
+        evictAll(keys, (CacheEntryPredicate[]) null);
     }
 
     /** {@inheritDoc} */
@@ -1584,8 +1585,9 @@ public abstract class GridCacheAdapter<K, V> implements GridCache<K, V>,
 
         if (ctx.config().getInterceptor() != null)
             fut =  fut.chain(new CX1<IgniteInternalFuture<V>, V>() {
-                @Override public V applyx(IgniteInternalFuture<V> f) throws IgniteCheckedException {
-                    return (V)ctx.config().getInterceptor().onGet(key, f.get());
+                @Override
+                public V applyx(IgniteInternalFuture<V> f) throws IgniteCheckedException {
+                    return (V) ctx.config().getInterceptor().onGet(key, f.get());
                 }
             });
 
@@ -2016,7 +2018,42 @@ public abstract class GridCacheAdapter<K, V> implements GridCache<K, V>,
     }
 
     /** {@inheritDoc} */
-    @Override public V put(final K key, final V val, @Nullable final CacheEntryPredicate... filter)
+    @Override public V put(final K key, final V val)
+        throws IgniteCheckedException {
+        return put(key, val, null);
+    }
+
+    /**
+     * Stores given key-value pair in cache. If filters are provided, then entries will
+     * be stored in cache only if they pass the filter. Note that filter check is atomic,
+     * so value stored in cache is guaranteed to be consistent with the filters. If cache
+     * previously contained value for the given key, then this value is returned.
+     * In case of {@link CacheMode#PARTITIONED} or {@link 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,  <code>CacheStore#load(Transaction, Object)</code> method will be used.
+     * <p>
+     * If the returned value is not needed, method <code>#putx(Object, Object, org.apache.ignite.lang.IgnitePredicate[])</code> should
+     * always be used instead of this one to avoid the overhead associated with returning of the previous value.
+     * <p>
+     * If write-through is enabled, the stored value will be persisted to {@link org.apache.ignite.cache.store.CacheStore}
+     * via <code>CacheStore#put(Transaction, Object, Object)</code> method.
+     * <h2 class="header">Transactions</h2>
+     * This method is transactional and will enlist the entry into ongoing transaction
+     * if there is one.
+     *
+     * @param key Key to store in cache.
+     * @param val Value to be associated with the given key.
+     * @param filter Optional filter to check prior to putting value in cache. Note
+     *      that filter check is atomic with put operation.
+     * @return Previous value associated with specified key, or {@code null}
+     *  if entry did not pass the filter, or if there was no mapping for the key in swap
+     *  or in persistent storage.
+     * @throws NullPointerException If either key or value are {@code null}.
+     * @throws IgniteCheckedException If put operation failed.
+     */
+    public V put(final K key, final V val, @Nullable final CacheEntryPredicate... filter)
         throws IgniteCheckedException {
         boolean statsEnabled = ctx.config().isStatisticsEnabled();
 
@@ -2046,7 +2083,39 @@ public abstract class GridCacheAdapter<K, V> implements GridCache<K, V>,
     }
 
     /** {@inheritDoc} */
-    @Override public IgniteInternalFuture<V> putAsync(final K key, final V val,
+    @Override public IgniteInternalFuture<V> putAsync(final K key, final V val) {
+        return putAsync(key, val, null);
+    }
+    /**
+     * Asynchronously stores given key-value pair in cache. If filters are provided, then entries will
+     * be stored in cache only if they pass the filter. Note that filter check is atomic,
+     * so value stored in cache is guaranteed to be consistent with the filters. If cache
+     * previously contained value for the given key, then this value is returned. Otherwise,
+     * in case of {@link CacheMode#REPLICATED} caches, the value will be loaded from swap
+     * and, if it's not there, and read-through is allowed, from the underlying
+     * {@link org.apache.ignite.cache.store.CacheStore} storage. In case of {@link CacheMode#PARTITIONED} caches,
+     * the value will be loaded from the primary node, which in its turn may load the value
+     * from the swap storage, and consecutively, if it's not in swap and read-through is allowed,
+     * from the underlying persistent storage. If value has to be loaded from persistent
+     * storage,  <code>CacheStore#load(Transaction, Object)</code> method will be used.
+     * <p>
+     * If the returned value is not needed, method <code>#putx(Object, Object, org.apache.ignite.lang.IgnitePredicate[])</code> should
+     * always be used instead of this one to avoid the overhead associated with returning of the previous value.
+     * <p>
+     * If write-through is enabled, the stored value will be persisted to {@link org.apache.ignite.cache.store.CacheStore}
+     * via <code>CacheStore#put(Transaction, Object, Object)</code> method.
+     * <h2 class="header">Transactions</h2>
+     * This method is transactional and will enlist the entry into ongoing transaction
+     * if there is one.
+     *
+     * @param key Key to store in cache.
+     * @param val Value to be associated with the given key.
+     * @param filter Optional filter to check prior to putting value in cache. Note
+     *      that filter check is atomic with put operation.
+     * @return Future for the put operation.
+     * @throws NullPointerException If either key or value are {@code null}.
+     */
+    public IgniteInternalFuture<V> putAsync(final K key, final V val,
         @Nullable final CacheEntryPredicate[] filter) {
         final boolean statsEnabled = ctx.config().isStatisticsEnabled();
 
@@ -2077,7 +2146,37 @@ public abstract class GridCacheAdapter<K, V> implements GridCache<K, V>,
     }
 
     /** {@inheritDoc} */
-    @Override public boolean putx(final K key, final V val,
+    @Override public boolean putx(final K key, final V val) throws IgniteCheckedException {
+        return putx(key, val, null);
+    }
+
+    /**
+     * Stores given key-value pair in cache. If filters are provided, then entries will
+     * be stored in cache only if they pass the filter. Note that filter check is atomic,
+     * so value stored in cache is guaranteed to be consistent with the filters.
+     * <p>
+     * This method will return {@code true} if value is stored in cache and {@code false} otherwise.
+     * Unlike <code>#put(Object, Object, org.apache.ignite.lang.IgnitePredicate[])</code> method, it does not return previous
+     * value and, therefore, does not have any overhead associated with returning a value. It
+     * should be used whenever return value is not required.
+     * <p>
+     * If write-through is enabled, the stored value will be persisted to {@link org.apache.ignite.cache.store.CacheStore}
+     * via <code>CacheStore#put(Transaction, Object, Object)</code> method.
+     * <h2 class="header">Transactions</h2>
+     * This method is transactional and will enlist the entry into ongoing transaction
+     * if there is one.
+     *
+     * @param key Key to store in cache.
+     * @param val Value to be associated with the given key.
+     * @param filter Optional filter to check prior to putting value in cache. Note
+     *      that filter check is atomic with put operation.
+     * @return {@code True} if optional filter passed and value was stored in cache,
+     *      {@code false} otherwise. Note that this method will return {@code true} if filter is not
+     *      specified.
+     * @throws NullPointerException If either key or value are {@code null}.
+     * @throws IgniteCheckedException If put operation failed.
+     */
+    public boolean putx(final K key, final V val,
         final CacheEntryPredicate[] filter) throws IgniteCheckedException {
         boolean statsEnabled = ctx.config().isStatisticsEnabled();
 
@@ -2134,11 +2233,13 @@ public abstract class GridCacheAdapter<K, V> implements GridCache<K, V>,
         ctx.dr().onReceiveCacheEntriesReceived(drMap.size());
 
         return asyncOp(new AsyncInOp(drMap.keySet()) {
-            @Override public IgniteInternalFuture<?> inOp(IgniteTxLocalAdapter tx) {
+            @Override
+            public IgniteInternalFuture<?> inOp(IgniteTxLocalAdapter tx) {
                 return tx.putAllDrAsync(ctx, drMap);
             }
 
-            @Override public String toString() {
+            @Override
+            public String toString() {
                 return "putAllConflictAsync [drMap=" + drMap + ']';
             }
         });
@@ -2187,14 +2288,17 @@ public abstract class GridCacheAdapter<K, V> implements GridCache<K, V>,
             validateCacheKeys(keys);
 
         return syncOp(new SyncOp<Map<K, EntryProcessorResult<T>>>(keys.size() == 1) {
-            @Nullable @Override public Map<K, EntryProcessorResult<T>> op(IgniteTxLocalAdapter tx)
+            @Nullable
+            @Override
+            public Map<K, EntryProcessorResult<T>> op(IgniteTxLocalAdapter tx)
                 throws IgniteCheckedException {
                 Map<? extends K, EntryProcessor<K, V, Object>> invokeMap = F.viewAsMap(keys,
-                        new C1<K, EntryProcessor<K, V, Object>>() {
-                            @Override public EntryProcessor apply(K k) {
-                                return entryProcessor;
-                            }
-                        });
+                    new C1<K, EntryProcessor<K, V, Object>>() {
+                        @Override
+                        public EntryProcessor apply(K k) {
+                            return entryProcessor;
+                        }
+                    });
 
                 IgniteInternalFuture<GridCacheReturn> fut = tx.invokeAsync(ctx, invokeMap, args);
 
@@ -2312,8 +2416,9 @@ public abstract class GridCacheAdapter<K, V> implements GridCache<K, V>,
         IgniteInternalFuture<GridCacheReturn> fut0 = (IgniteInternalFuture<GridCacheReturn>)fut;
 
         return fut0.chain(new CX1<IgniteInternalFuture<GridCacheReturn>, Map<K, EntryProcessorResult<T>>>() {
-            @Override public Map<K, EntryProcessorResult<T>> applyx(IgniteInternalFuture<GridCacheReturn> fut)
-                    throws IgniteCheckedException {
+            @Override
+            public Map<K, EntryProcessorResult<T>> applyx(IgniteInternalFuture<GridCacheReturn> fut)
+                throws IgniteCheckedException {
                 GridCacheReturn ret = fut.get();
 
                 assert ret != null;
@@ -2344,7 +2449,36 @@ public abstract class GridCacheAdapter<K, V> implements GridCache<K, V>,
     }
 
     /** {@inheritDoc} */
-    @Override public IgniteInternalFuture<Boolean> putxAsync(final K key, final V val,
+    @Override public IgniteInternalFuture<Boolean> putxAsync(K key, V val) {
+        return putxAsync(key, val, null);
+    }
+
+    /**
+     * Stores given key-value pair in cache. If filters are provided, then entries will
+     * be stored in cache only if they pass the filter. Note that filter check is atomic,
+     * so value stored in cache is guaranteed to be consistent with the filters.
+     * <p>
+     * This method will return {@code true} if value is stored in cache and {@code false} otherwise.
+     * Unlike <code>#put(Object, Object, org.apache.ignite.lang.IgnitePredicate[])</code> 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>
+     * If write-through is enabled, the stored value will be persisted to {@link org.apache.ignite.cache.store.CacheStore}
+     * via <code>CacheStore#put(Transaction, Object, Object)</code> method.
+     * <h2 class="header">Transactions</h2>
+     * This method is transactional and will enlist the entry into ongoing transaction
+     * if there is one.
+     *
+     * @param key Key to store in cache.
+     * @param val Value to be associated with the given key.
+     * @param filter Optional filter to check prior to putting value in cache. Note
+     *      that filter check is atomic with put operation.
+     * @return Future for the put operation. Future will return {@code true} if optional filter
+     *      passed and value was stored in cache, {@code false} otherwise. Note that future will
+     *      return {@code true} if filter is not specified.
+     * @throws NullPointerException If either key or value are {@code null}.
+     */
+    public IgniteInternalFuture<Boolean> putxAsync(final K key, final V val,
         @Nullable final CacheEntryPredicate... filter) {
         final boolean statsEnabled = ctx.config().isStatisticsEnabled();
 
@@ -2660,7 +2794,28 @@ public abstract class GridCacheAdapter<K, V> implements GridCache<K, V>,
     }
 
     /** {@inheritDoc} */
-    @Override public void putAll(@Nullable final Map<? extends K, ? extends V> m,
+    @Override public void putAll(@Nullable final Map<? extends K, ? extends V> m)
+        throws IgniteCheckedException {
+        putAll(m, null);
+    }
+
+    /**
+     * 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.
+     * <p>
+     * If write-through is enabled, the stored values will be persisted to {@link org.apache.ignite.cache.store.CacheStore}
+     * via <code>CacheStore#putAll(Transaction, Map)</code> method.
+     * <h2 class="header">Transactions</h2>
+     * This method is transactional and will enlist the entry into ongoing transaction
+     * if there is one.
+     *
+     * @param m Key-value pairs to store in cache.
+     * @param filter Optional entry filter. If provided, then entry will
+     *      be stored only if the filter returned {@code true}.
+     * @throws IgniteCheckedException If put operation failed.
+     */
+    public void putAll(@Nullable final Map<? extends K, ? extends V> m,
         final CacheEntryPredicate[] filter) throws IgniteCheckedException {
         boolean statsEnabled = ctx.config().isStatisticsEnabled();
 
@@ -2689,7 +2844,27 @@ public abstract class GridCacheAdapter<K, V> implements GridCache<K, V>,
     }
 
     /** {@inheritDoc} */
-    @Override public IgniteInternalFuture<?> putAllAsync(final Map<? extends K, ? extends V> m,
+    @Override public IgniteInternalFuture<?> putAllAsync(final Map<? extends K, ? extends V> m) {
+        return putAllAsync(m, null);
+    }
+
+    /**
+     * 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.
+     * <p>
+     * If write-through is enabled, the stored values will be persisted to {@link org.apache.ignite.cache.store.CacheStore}
+     * via <code>CacheStore#putAll(Transaction, Map)</code> method.
+     * <h2 class="header">Transactions</h2>
+     * This method is transactional and will enlist the entry into ongoing transaction
+     * if there is one.
+     *
+     * @param m Key-value pairs to store in cache.
+     * @param filter Optional entry filter. If provided, then entry will
+     *      be stored only if the filter returned {@code true}.
+     * @return Future for putAll operation.
+     */
+    public IgniteInternalFuture<?> putAllAsync(final Map<? extends K, ? extends V> m,
         @Nullable final CacheEntryPredicate... filter) {
         if (F.isEmpty(m))
             return new GridFinishedFuture<Object>();
@@ -2710,13 +2885,44 @@ public abstract class GridCacheAdapter<K, V> implements GridCache<K, V>,
         });
     }
 
-    /** {@inheritDoc} */
-    @Nullable @Override public V remove(K key, CacheEntryPredicate[] filter)
+    /**
+     * Removes given key mapping from cache. If cache previously contained value for the given key,
+     * then this value is returned. In case of {@link CacheMode#PARTITIONED} or {@link 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, <code>CacheStore#load(Transaction, Object)</code> method will be used.
+     * <p>
+     * If the returned value is not needed, method <code>#removex(Object, org.apache.ignite.lang.IgnitePredicate[])</code> should
+     * always be used instead of this one to avoid the overhead associated with returning of the
+     * previous value.
+     * <p>
+     * If write-through is enabled, the value will be removed from {@link org.apache.ignite.cache.store.CacheStore}
+     * via <code>CacheStore#remove(Transaction, Object)</code> method.
+     * <h2 class="header">Transactions</h2>
+     * This method is transactional and will enlist the entry into ongoing transaction
+     * if there is one.
+     *
+     * @param key Key whose mapping is to be removed from cache.
+     * @param filter Optional filter to check prior to removing value form cache. Note
+     *      that filter is checked atomically together with remove operation.
+     * @return Previous value associated with specified key, or {@code null}
+     *      if there was no value for this key.
+     * @throws NullPointerException If key is {@code null}.
+     * @throws IgniteCheckedException If remove operation failed.
+     */
+    @Nullable public V remove(K key, CacheEntryPredicate[] filter)
         throws IgniteCheckedException {
         return remove(key, null, filter);
     }
 
     /** {@inheritDoc} */
+    @Nullable @Override public V remove(K key)
+        throws IgniteCheckedException {
+        return remove(key, (CacheEntryPredicate[])null);
+    }
+
+    /** {@inheritDoc} */
     @Override public V remove(final K key, @Nullable final GridCacheEntryEx entry,
         @Nullable final CacheEntryPredicate... filter) throws IgniteCheckedException {
         boolean statsEnabled = ctx.config().isStatisticsEnabled();
@@ -2749,8 +2955,31 @@ public abstract class GridCacheAdapter<K, V> implements GridCache<K, V>,
         return prevVal;
     }
 
-    /** {@inheritDoc} */
-    @Override public IgniteInternalFuture<V> removeAsync(K key, CacheEntryPredicate... filter) {
+    /**
+     * Asynchronously removes given key mapping from cache. If cache previously contained value for the given key,
+     * then this value is returned. In case of {@link CacheMode#PARTITIONED} or {@link 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, <code>CacheStore#load(Transaction, Object)</code> method will be used.
+     * <p>
+     * If the returned value is not needed, method <code>#removex(Object, org.apache.ignite.lang.IgnitePredicate[])</code> should
+     * always be used instead of this one to avoid the overhead associated with returning of the
+     * previous value.
+     * <p>
+     * If write-through is enabled, the value will be removed from {@link org.apache.ignite.cache.store.CacheStore}
+     * via <code>CacheStore#remove(Transaction, Object)</code> method.
+     * <h2 class="header">Transactions</h2>
+     * This method is transactional and will enlist the entry into ongoing transaction
+     * if there is one.
+     *
+     * @param key Key whose mapping is to be removed from cache.
+     * @param filter Optional filter to check prior to removing value form cache. Note
+     *      that filter is checked atomically together with remove operation.
+     * @return Future for the remove operation.
+     * @throws NullPointerException if the key is {@code null}.
+     */
+    public IgniteInternalFuture<V> removeAsync(K key, CacheEntryPredicate... filter) {
         final boolean statsEnabled = ctx.config().isStatisticsEnabled();
 
         final long start = statsEnabled ? System.nanoTime() : 0L;
@@ -2764,6 +2993,11 @@ public abstract class GridCacheAdapter<K, V> implements GridCache<K, V>,
     }
 
     /** {@inheritDoc} */
+    @Override public IgniteInternalFuture<V> removeAsync(K key) {
+        return removeAsync(key, (CacheEntryPredicate[]) null);
+    }
+
+    /** {@inheritDoc} */
     @Override public IgniteInternalFuture<V> removeAsync(final K key, @Nullable final GridCacheEntryEx entry,
         @Nullable final CacheEntryPredicate... filter) {
         final boolean statsEnabled = ctx.config().isStatisticsEnabled();
@@ -2793,8 +3027,22 @@ public abstract class GridCacheAdapter<K, V> implements GridCache<K, V>,
         return fut;
     }
 
-    /** {@inheritDoc} */
-    @Override public void removeAll(final Collection<? extends K> keys,
+    /**
+     * Removes given key mappings from cache for entries for which the optionally passed in filters do
+     * pass.
+     * <p>
+     * If write-through is enabled, the values will be removed from {@link org.apache.ignite.cache.store.CacheStore}
+     * via <code>@link CacheStore#removeAll(Transaction, Collection)</code> method.
+     * <h2 class="header">Transactions</h2>
+     * This method is transactional and will enlist the entry into ongoing transaction
+     * if there is one.
+     *
+     * @param keys Keys whose mappings are to be removed from cache.
+     * @param filter Optional filter to check prior to removing value form cache. Note
+     *      that filter is checked atomically together with remove operation.
+     * @throws IgniteCheckedException If remove failed.
+     */
+    public void removeAll(final Collection<? extends K> keys,
         final CacheEntryPredicate... filter) throws IgniteCheckedException {
         boolean statsEnabled = ctx.config().isStatisticsEnabled();
 
@@ -2823,7 +3071,27 @@ public abstract class GridCacheAdapter<K, V> implements GridCache<K, V>,
     }
 
     /** {@inheritDoc} */
-    @Override public IgniteInternalFuture<?> removeAllAsync(@Nullable final Collection<? extends K> keys,
+    @Override public void removeAll(final Collection<? extends K> keys) throws IgniteCheckedException {
+        removeAll(keys, (CacheEntryPredicate[]) null);
+    }
+
+    /**
+     * Asynchronously removes given key mappings from cache for entries for which the optionally
+     * passed in filters do pass.
+     * <p>
+     * If write-through is enabled, the values will be removed from {@link org.apache.ignite.cache.store.CacheStore}
+     * via <code>@link CacheStore#removeAll(Transaction, Collection)</code> method.
+     * <h2 class="header">Transactions</h2>
+     * This method is transactional and will enlist the entry into ongoing transaction
+     * if there is one.
+     *
+     * @param keys Keys whose mappings are to be removed from cache.
+     * @param filter Optional filter to check prior to removing value form cache. Note
+     *      that filter is checked atomically together with remove operation.
+     * @return Future for the remove operation. The future will complete whenever
+     *      remove operation completes.
+     */
+    public IgniteInternalFuture<?> removeAllAsync(@Nullable final Collection<? extends K> keys,
         final CacheEntryPredicate... filter) {
         final boolean statsEnabled = ctx.config().isStatisticsEnabled();
 
@@ -2852,7 +3120,31 @@ public abstract class GridCacheAdapter<K, V> implements GridCache<K, V>,
     }
 
     /** {@inheritDoc} */
-    @Override public boolean removex(final K key, final CacheEntryPredicate... filter)
+    @Override public IgniteInternalFuture<?> removeAllAsync(@Nullable final Collection<? extends K> keys) {
+        return removeAllAsync(keys, null);
+    }
+
+    /**
+     * Removes given key mapping from cache.
+     * <p>
+     * This method will return {@code true} if remove did occur, which means that all optionally
+     * provided filters have passed and there was something to remove, {@code false} otherwise.
+     * <p>
+     * If write-through is enabled, the value will be removed from {@link org.apache.ignite.cache.store.CacheStore}
+     * via <code>CacheStore#remove(Transaction, Object)</code> method.
+     * <h2 class="header">Transactions</h2>
+     * This method is transactional and will enlist the entry into ongoing transaction
+     * if there is one.
+     *
+     * @param key Key whose mapping is to be removed from cache.
+     * @param filter Optional filter to check prior to removing value form cache. Note
+     *      that filter is checked atomically together with remove operation.
+     * @return {@code True} if filter passed validation and entry was removed, {@code false} otherwise.
+     *      Note that if filter is not specified, this method will return {@code true}.
+     * @throws NullPointerException if the key is {@code null}.
+     * @throws IgniteCheckedException If remove failed.
+     */
+    public boolean removex(final K key, final CacheEntryPredicate... filter)
         throws IgniteCheckedException {
         boolean statsEnabled = ctx.config().isStatisticsEnabled();
 
@@ -2867,6 +3159,12 @@ public abstract class GridCacheAdapter<K, V> implements GridCache<K, V>,
     }
 
     /** {@inheritDoc} */
+    @Override public boolean removex(final K key)
+        throws IgniteCheckedException {
+        return removex(key, (CacheEntryPredicate[]) null);
+    }
+
+    /** {@inheritDoc} */
     @Override public boolean removex(final K key, @Nullable final GridCacheEntryEx entry,
         @Nullable final CacheEntryPredicate... filter) throws IgniteCheckedException {
         boolean statsEnabled = ctx.config().isStatisticsEnabled();
@@ -2894,14 +3192,38 @@ public abstract class GridCacheAdapter<K, V> implements GridCache<K, V>,
         return rmv;
     }
 
-    /** {@inheritDoc} */
-    @Override public IgniteInternalFuture<Boolean> removexAsync(K key, CacheEntryPredicate... filter) {
+    /**
+     * Asynchronously removes given key mapping from cache.
+     * <p>
+     * This method will return {@code true} if remove did occur, which means that all optionally
+     * provided filters have passed and there was something to remove, {@code false} otherwise.
+     * <p>
+     * If write-through is enabled, the value will be removed from {@link org.apache.ignite.cache.store.CacheStore}
+     * via <code>CacheStore#remove(Transaction, Object)</code> method.
+     * <h2 class="header">Transactions</h2>
+     * This method is transactional and will enlist the entry into ongoing transaction
+     * if there is one.
+     *
+     * @param key Key whose mapping is to be removed from cache.
+     * @param filter Optional filter to check prior to removing value form cache. Note
+     *      that filter is checked atomically together with remove operation.
+     * @return Future for the remove operation. The future will return {@code true}
+     *      if optional filters passed validation and remove did occur, {@code false} otherwise.
+     *      Note that if filter is not specified, this method will return {@code true}.
+     * @throws NullPointerException if the key is {@code null}.
+     */
+    public IgniteInternalFuture<Boolean> removexAsync(K key, CacheEntryPredicate... filter) {
         A.notNull(key, "key");
 
         return removexAsync(key, null, filter);
     }
 
     /** {@inheritDoc} */
+    @Override public IgniteInternalFuture<Boolean> removexAsync(K key) {
+        return removexAsync(key, (CacheEntryPredicate[])null);
+    }
+
+    /** {@inheritDoc} */
     @Override public IgniteInternalFuture<Boolean> removexAsync(final K key, @Nullable final GridCacheEntryEx entry,
         @Nullable final CacheEntryPredicate... filter) {
         final boolean statsEnabled = ctx.config().isStatisticsEnabled();
@@ -4510,7 +4832,7 @@ public abstract class GridCacheAdapter<K, V> implements GridCache<K, V>,
      * @param filter Filters to evaluate.
      * @return Key set.
      */
-    @Override public Set<K> keySet(@Nullable CacheEntryPredicate... filter) {
+    public Set<K> keySet(@Nullable CacheEntryPredicate... filter) {
         return map.keySet(filter);
     }
 

http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/6ecc1164/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 5cc2aa7..9d92542 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
@@ -348,23 +348,21 @@ public class GridCacheProjectionImpl<K, V> implements GridCacheProjectionEx<K, V
     }
 
     /** {@inheritDoc} */
-    @Override public V put(K key, V val, @Nullable CacheEntryPredicate[] filter)
+    @Override public V put(K key, V val)
         throws IgniteCheckedException {
-        return putAsync(key, val, filter).get();
+        return putAsync(key, val).get();
     }
 
     /** {@inheritDoc} */
-    @Override public IgniteInternalFuture<V> putAsync(K key, V val,
-        @Nullable CacheEntryPredicate[] filter) {
+    @Override public IgniteInternalFuture<V> putAsync(K key, V val) {
         A.notNull(key, "key", val, "val");
 
-        return cache.putAsync(key, val, filter);
+        return cache.putAsync(key, val);
     }
 
     /** {@inheritDoc} */
-    @Override public boolean putx(K key, V val,
-        @Nullable CacheEntryPredicate[] filter) throws IgniteCheckedException {
-        return putxAsync(key, val, filter).get();
+    @Override public boolean putx(K key, V val) throws IgniteCheckedException {
+        return cache.putxAsync(key, val).get();
     }
 
     /** {@inheritDoc} */
@@ -420,11 +418,10 @@ public class GridCacheProjectionImpl<K, V> implements GridCacheProjectionEx<K, V
     }
 
     /** {@inheritDoc} */
-    @Override public IgniteInternalFuture<Boolean> putxAsync(K key, V val,
-        @Nullable CacheEntryPredicate[] filter) {
+    @Override public IgniteInternalFuture<Boolean> putxAsync(K key, V val) {
         A.notNull(key, "key", val, "val");
 
-        return cache.putxAsync(key, val, filter);
+        return cache.putxAsync(key, val, null);
     }
 
     /** {@inheritDoc} */
@@ -434,7 +431,7 @@ public class GridCacheProjectionImpl<K, V> implements GridCacheProjectionEx<K, V
 
     /** {@inheritDoc} */
     @Override public IgniteInternalFuture<V> putIfAbsentAsync(K key, V val) {
-        return putAsync(key, val, cctx.noValArray());
+        return cache.putAsync(key, val, cctx.noValArray());
     }
 
     /** {@inheritDoc} */
@@ -444,7 +441,7 @@ public class GridCacheProjectionImpl<K, V> implements GridCacheProjectionEx<K, V
 
     /** {@inheritDoc} */
     @Override public IgniteInternalFuture<Boolean> putxIfAbsentAsync(K key, V val) {
-        return putxAsync(key, val, cctx.noValArray());
+        return cache.putxAsync(key, val, cctx.noValArray());
     }
 
     /** {@inheritDoc} */
@@ -454,7 +451,7 @@ public class GridCacheProjectionImpl<K, V> implements GridCacheProjectionEx<K, V
 
     /** {@inheritDoc} */
     @Override public IgniteInternalFuture<V> replaceAsync(K key, V val) {
-        return putAsync(key, val, cctx.hasValArray());
+        return cache.putAsync(key, val, cctx.hasValArray());
     }
 
     /** {@inheritDoc} */
@@ -464,7 +461,7 @@ public class GridCacheProjectionImpl<K, V> implements GridCacheProjectionEx<K, V
 
     /** {@inheritDoc} */
     @Override public IgniteInternalFuture<Boolean> replacexAsync(K key, V val) {
-        return putxAsync(key, val, cctx.hasValArray());
+        return cache.putxAsync(key, val, cctx.hasValArray());
     }
 
     /** {@inheritDoc} */
@@ -480,15 +477,13 @@ public class GridCacheProjectionImpl<K, V> implements GridCacheProjectionEx<K, V
     }
 
     /** {@inheritDoc} */
-    @Override public void putAll(Map<? extends K, ? extends V> m,
-        @Nullable CacheEntryPredicate[] filter) throws IgniteCheckedException {
-        putAllAsync(m, filter).get();
+    @Override public void putAll(Map<? extends K, ? extends V> m) throws IgniteCheckedException {
+        putAllAsync(m).get();
     }
 
     /** {@inheritDoc} */
-    @Override public IgniteInternalFuture<?> putAllAsync(Map<? extends K, ? extends V> m,
-        @Nullable CacheEntryPredicate[] filter) {
-        return cache.putAllAsync(m, filter);
+    @Override public IgniteInternalFuture<?> putAllAsync(Map<? extends K, ? extends V> m) {
+        return cache.putAllAsync(m);
     }
 
     /** {@inheritDoc} */
@@ -497,11 +492,6 @@ public class GridCacheProjectionImpl<K, V> implements GridCacheProjectionEx<K, V
     }
 
     /** {@inheritDoc} */
-    @Override public Set<K> keySet(@Nullable CacheEntryPredicate... filter) {
-        return cache.keySet(filter);
-    }
-
-    /** {@inheritDoc} */
     @Override public Set<K> primaryKeySet() {
         return cache.primaryKeySet();
     }
@@ -642,9 +632,8 @@ public class GridCacheProjectionImpl<K, V> implements GridCacheProjectionEx<K, V
     }
 
     /** {@inheritDoc} */
-    @Override public V remove(K key,
-        @Nullable CacheEntryPredicate[] filter) throws IgniteCheckedException {
-        return removeAsync(key, filter).get();
+    @Override public V remove(K key) throws IgniteCheckedException {
+        return removeAsync(key).get();
     }
 
     /** {@inheritDoc} */
@@ -654,8 +643,8 @@ public class GridCacheProjectionImpl<K, V> implements GridCacheProjectionEx<K, V
     }
 
     /** {@inheritDoc} */
-    @Override public IgniteInternalFuture<V> removeAsync(K key, CacheEntryPredicate[] filter) {
-        return removeAsync(key, null, filter);
+    @Override public IgniteInternalFuture<V> removeAsync(K key) {
+        return removeAsync(key, null, null);
     }
 
     /** {@inheritDoc} */
@@ -665,9 +654,8 @@ public class GridCacheProjectionImpl<K, V> implements GridCacheProjectionEx<K, V
     }
 
     /** {@inheritDoc} */
-    @Override public boolean removex(K key,
-        @Nullable CacheEntryPredicate[] filter) throws IgniteCheckedException {
-        return removexAsync(key, filter).get();
+    @Override public boolean removex(K key) throws IgniteCheckedException {
+        return removexAsync(key).get();
     }
 
     /** {@inheritDoc} */
@@ -688,9 +676,8 @@ public class GridCacheProjectionImpl<K, V> implements GridCacheProjectionEx<K, V
     }
 
     /** {@inheritDoc} */
-    @Override public IgniteInternalFuture<Boolean> removexAsync(K key,
-        @Nullable CacheEntryPredicate[] filter) {
-        return removexAsync(key, null, filter);
+    @Override public IgniteInternalFuture<Boolean> removexAsync(K key) {
+        return cache.removexAsync(key, null, null);
     }
 
     /** {@inheritDoc} */
@@ -732,15 +719,13 @@ public class GridCacheProjectionImpl<K, V> implements GridCacheProjectionEx<K, V
     }
 
     /** {@inheritDoc} */
-    @Override public void removeAll(@Nullable Collection<? extends K> keys,
-        @Nullable CacheEntryPredicate... filter) throws IgniteCheckedException {
-        cache.removeAll(keys, filter);
+    @Override public void removeAll(@Nullable Collection<? extends K> keys) throws IgniteCheckedException {
+        cache.removeAll(keys, null);
     }
 
     /** {@inheritDoc} */
-    @Override public IgniteInternalFuture<?> removeAllAsync(@Nullable Collection<? extends K> keys,
-        @Nullable CacheEntryPredicate[] filter) {
-        return cache.removeAllAsync(keys, filter);
+    @Override public IgniteInternalFuture<?> removeAllAsync(@Nullable Collection<? extends K> keys) {
+        return cache.removeAllAsync(keys, null);
     }
 
     /** {@inheritDoc} */

http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/6ecc1164/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 13fce09..bead378 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
@@ -578,12 +578,12 @@ public class GridCacheProxyImpl<K, V> implements GridCacheProxy<K, V>, Externali
     }
 
     /** {@inheritDoc} */
-    @Nullable @Override public V put(K key, V val, @Nullable CacheEntryPredicate[] filter)
+    @Nullable @Override public V put(K key, V val)
         throws IgniteCheckedException {
         GridCacheProjectionImpl<K, V> prev = gate.enter(prj);
 
         try {
-            return delegate.put(key, val, filter);
+            return delegate.put(key, val);
         }
         finally {
             gate.leave(prev);
@@ -591,12 +591,11 @@ public class GridCacheProxyImpl<K, V> implements GridCacheProxy<K, V>, Externali
     }
 
     /** {@inheritDoc} */
-    @Override public IgniteInternalFuture<V> putAsync(K key, V val,
-        @Nullable CacheEntryPredicate[] filter) {
+    @Override public IgniteInternalFuture<V> putAsync(K key, V val) {
         GridCacheProjectionImpl<K, V> prev = gate.enter(prj);
 
         try {
-            return delegate.putAsync(key, val, filter);
+            return delegate.putAsync(key, val);
         }
         finally {
             gate.leave(prev);
@@ -604,12 +603,12 @@ public class GridCacheProxyImpl<K, V> implements GridCacheProxy<K, V>, Externali
     }
 
     /** {@inheritDoc} */
-    @Override public boolean putx(K key, V val, @Nullable CacheEntryPredicate[] filter)
+    @Override public boolean putx(K key, V val)
         throws IgniteCheckedException {
         GridCacheProjectionImpl<K, V> prev = gate.enter(prj);
 
         try {
-            return delegate.putx(key, val, filter);
+            return delegate.putx(key, val);
         }
         finally {
             gate.leave(prev);
@@ -727,12 +726,11 @@ public class GridCacheProxyImpl<K, V> implements GridCacheProxy<K, V>, Externali
     }
 
     /** {@inheritDoc} */
-    @Override public IgniteInternalFuture<Boolean> putxAsync(K key, V val,
-        @Nullable CacheEntryPredicate[] filter) {
+    @Override public IgniteInternalFuture<Boolean> putxAsync(K key, V val) {
         GridCacheProjectionImpl<K, V> prev = gate.enter(prj);
 
         try {
-            return delegate.putxAsync(key, val, filter);
+            return delegate.putxAsync(key, val);
         }
         finally {
             gate.leave(prev);
@@ -860,12 +858,11 @@ public class GridCacheProxyImpl<K, V> implements GridCacheProxy<K, V>, Externali
     }
 
     /** {@inheritDoc} */
-    @Override public void putAll(@Nullable Map<? extends K, ? extends V> m,
-        @Nullable CacheEntryPredicate[] filter) throws IgniteCheckedException {
+    @Override public void putAll(@Nullable Map<? extends K, ? extends V> m) throws IgniteCheckedException {
         GridCacheProjectionImpl<K, V> prev = gate.enter(prj);
 
         try {
-            delegate.putAll(m, filter);
+            delegate.putAll(m);
         }
         finally {
             gate.leave(prev);
@@ -873,12 +870,11 @@ public class GridCacheProxyImpl<K, V> implements GridCacheProxy<K, V>, Externali
     }
 
     /** {@inheritDoc} */
-    @Override public IgniteInternalFuture<?> putAllAsync(@Nullable Map<? extends K, ? extends V> m,
-        @Nullable CacheEntryPredicate[] filter) {
+    @Override public IgniteInternalFuture<?> putAllAsync(@Nullable Map<? extends K, ? extends V> m) {
         GridCacheProjectionImpl<K, V> prev = gate.enter(prj);
 
         try {
-            return delegate.putAllAsync(m, filter);
+            return delegate.putAllAsync(m);
         }
         finally {
             gate.leave(prev);
@@ -898,18 +894,6 @@ public class GridCacheProxyImpl<K, V> implements GridCacheProxy<K, V>, Externali
     }
 
     /** {@inheritDoc} */
-    @Override public Set<K> keySet(@Nullable CacheEntryPredicate... filter) {
-        GridCacheProjectionImpl<K, V> prev = gate.enter(prj);
-
-        try {
-            return delegate.keySet(filter);
-        }
-        finally {
-            gate.leave(prev);
-        }
-    }
-
-    /** {@inheritDoc} */
     @Override public Set<K> primaryKeySet() {
         GridCacheProjectionImpl<K, V> prev = gate.enter(prj);
 
@@ -1264,12 +1248,12 @@ public class GridCacheProxyImpl<K, V> implements GridCacheProxy<K, V>, Externali
     }
 
     /** {@inheritDoc} */
-    @Nullable @Override public V remove(K key, @Nullable CacheEntryPredicate[] filter)
+    @Nullable @Override public V remove(K key)
         throws IgniteCheckedException {
         GridCacheProjectionImpl<K, V> prev = gate.enter(prj);
 
         try {
-            return delegate.remove(key, filter);
+            return delegate.remove(key);
         }
         finally {
             gate.leave(prev);
@@ -1290,11 +1274,11 @@ public class GridCacheProxyImpl<K, V> implements GridCacheProxy<K, V>, Externali
     }
 
     /** {@inheritDoc} */
-    @Override public IgniteInternalFuture<V> removeAsync(K key, CacheEntryPredicate[] filter) {
+    @Override public IgniteInternalFuture<V> removeAsync(K key) {
         GridCacheProjectionImpl<K, V> prev = gate.enter(prj);
 
         try {
-            return delegate.removeAsync(key, filter);
+            return delegate.removeAsync(key);
         }
         finally {
             gate.leave(prev);
@@ -1315,12 +1299,12 @@ public class GridCacheProxyImpl<K, V> implements GridCacheProxy<K, V>, Externali
     }
 
     /** {@inheritDoc} */
-    @Override public boolean removex(K key, @Nullable CacheEntryPredicate[] filter)
+    @Override public boolean removex(K key)
         throws IgniteCheckedException {
         GridCacheProjectionImpl<K, V> prev = gate.enter(prj);
 
         try {
-            return delegate.removex(key, filter);
+            return delegate.removex(key);
         }
         finally {
             gate.leave(prev);
@@ -1368,12 +1352,11 @@ public class GridCacheProxyImpl<K, V> implements GridCacheProxy<K, V>, Externali
     }
 
     /** {@inheritDoc} */
-    @Override public IgniteInternalFuture<Boolean> removexAsync(K key,
-        @Nullable CacheEntryPredicate[] filter) {
+    @Override public IgniteInternalFuture<Boolean> removexAsync(K key) {
         GridCacheProjectionImpl<K, V> prev = gate.enter(prj);
 
         try {
-            return delegate.removexAsync(key, filter);
+            return delegate.removexAsync(key);
         }
         finally {
             gate.leave(prev);
@@ -1466,12 +1449,11 @@ public class GridCacheProxyImpl<K, V> implements GridCacheProxy<K, V>, Externali
     }
 
     /** {@inheritDoc} */
-    @Override public void removeAll(@Nullable Collection<? extends K> keys,
-        @Nullable CacheEntryPredicate[] filter) throws IgniteCheckedException {
+    @Override public void removeAll(@Nullable Collection<? extends K> keys) throws IgniteCheckedException {
         GridCacheProjectionImpl<K, V> prev = gate.enter(prj);
 
         try {
-            delegate.removeAll(keys, filter);
+            delegate.removeAll(keys);
         }
         finally {
             gate.leave(prev);
@@ -1479,12 +1461,11 @@ public class GridCacheProxyImpl<K, V> implements GridCacheProxy<K, V>, Externali
     }
 
     /** {@inheritDoc} */
-    @Override public IgniteInternalFuture<?> removeAllAsync(@Nullable Collection<? extends K> keys,
-        @Nullable CacheEntryPredicate[] filter) {
+    @Override public IgniteInternalFuture<?> removeAllAsync(@Nullable Collection<? extends K> keys) {
         GridCacheProjectionImpl<K, V> prev = gate.enter(prj);
 
         try {
-            return delegate.removeAllAsync(keys, filter);
+            return delegate.removeAllAsync(keys);
         }
         finally {
             gate.leave(prev);


Mime
View raw message