ignite-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From sboi...@apache.org
Subject [40/55] [abbrv] incubator-ignite git commit: # ignite-63
Date Fri, 23 Jan 2015 15:07:55 GMT
http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/cafee25f/modules/core/src/main/java/org/apache/ignite/IgniteCache.java
----------------------------------------------------------------------
diff --git a/modules/core/src/main/java/org/apache/ignite/IgniteCache.java b/modules/core/src/main/java/org/apache/ignite/IgniteCache.java
index 705a569..893d52a 100644
--- a/modules/core/src/main/java/org/apache/ignite/IgniteCache.java
+++ b/modules/core/src/main/java/org/apache/ignite/IgniteCache.java
@@ -34,8 +34,8 @@ import java.util.concurrent.*;
  * Main entry point for all <b>Data Grid APIs.</b> You can get a named cache by calling {@link Ignite#cache(String)}
  * method.
  * <h1 class="header">Functionality</h1>
- * This API extends {@link org.apache.ignite.cache.GridCacheProjection} API which contains vast majority of cache functionality
- * and documentation. In addition to {@link org.apache.ignite.cache.GridCacheProjection} functionality this API provides:
+ * This API extends {@link org.apache.ignite.cache.CacheProjection} API which contains vast majority of cache functionality
+ * and documentation. In addition to {@link org.apache.ignite.cache.CacheProjection} functionality this API provides:
  * <ul>
  * <li>
  *  Various {@code 'loadCache(..)'} methods to load cache either synchronously or asynchronously.
@@ -43,13 +43,13 @@ import java.util.concurrent.*;
  *  data based on the optionally passed in arguments.
  * </li>
  * <li>
- *     Method {@link #affinity()} provides {@link org.apache.ignite.cache.affinity.GridCacheAffinityFunction} service for information on
+ *     Method {@link #affinity()} provides {@link org.apache.ignite.cache.affinity.CacheAffinityFunction} service for information on
  *     data partitioning and mapping keys to grid nodes responsible for caching those keys.
  * </li>
  * <li>
- *     Method {@link #dataStructures()} provides {@link org.apache.ignite.cache.datastructures.GridCacheDataStructures} service for
+ *     Method {@link #dataStructures()} provides {@link org.apache.ignite.cache.datastructures.CacheDataStructures} service for
  *     creating and working with distributed concurrent data structures, such as
- *     {@link IgniteAtomicLong}, {@link IgniteAtomicReference}, {@link org.apache.ignite.cache.datastructures.GridCacheQueue}, etc.
+ *     {@link IgniteAtomicLong}, {@link IgniteAtomicReference}, {@link org.apache.ignite.cache.datastructures.CacheQueue}, etc.
  * </li>
  * <li>
  *  Methods like {@code 'tx{Un}Synchronize(..)'} witch allow to get notifications for transaction state changes.
@@ -77,7 +77,7 @@ public interface IgniteCache<K, V> extends javax.cache.Cache<K, V>, IgniteAsyncS
      * which is true for near fully populated caches, this method will generally perform significantly
      * faster with complexity of O(S) where {@code S = 5}.
      * <p>
-     * Note that this method is not available on {@link org.apache.ignite.cache.GridCacheProjection} API since it is
+     * Note that this method is not available on {@link org.apache.ignite.cache.CacheProjection} API since it is
      * impossible (or very hard) to deterministically return a number value when pre-filtering
      * and post-filtering is involved (e.g. projection level predicate filters).
      *
@@ -146,14 +146,14 @@ public interface IgniteCache<K, V> extends javax.cache.Cache<K, V>, IgniteAsyncS
      * if there is one.
      * <h2 class="header">Cache Flags</h2>
      * This method is not available if any of the following flags are set on projection:
-     * {@link org.apache.ignite.cache.GridCacheFlag#LOCAL}, {@link org.apache.ignite.cache.GridCacheFlag#READ}.
+     * {@link org.apache.ignite.cache.CacheFlag#LOCAL}, {@link org.apache.ignite.cache.CacheFlag#READ}.
      *
      * @param key Key to store in cache.
      * @param val Value to be associated with the given key.
      * @return Previously contained value regardless of whether put happened or not.
      * @throws NullPointerException If either key or value are {@code null}.
      * @throws CacheException If put operation failed.
-     * @throws org.apache.ignite.cache.GridCacheFlagException If projection flags validation failed.
+     * @throws org.apache.ignite.cache.CacheFlagException If projection flags validation failed.
      */
     @Nullable public V getAndPutIfAbsent(K key, V val) throws CacheException;
 
@@ -223,11 +223,11 @@ public interface IgniteCache<K, V> extends javax.cache.Cache<K, V>, IgniteAsyncS
      * participating in any locks or transactions).
      * <p>
      * If {@link CacheConfiguration#isSwapEnabled()} is set to {@code true} and
-     * {@link org.apache.ignite.cache.GridCacheFlag#SKIP_SWAP} is not enabled, the evicted entry will
+     * {@link org.apache.ignite.cache.CacheFlag#SKIP_SWAP} is not enabled, the evicted entry will
      * be swapped to offheap, and then to disk.
      * <h2 class="header">Cache Flags</h2>
      * This method is not available if any of the following flags are set on projection:
-     * {@link org.apache.ignite.cache.GridCacheFlag#READ}.
+     * {@link org.apache.ignite.cache.CacheFlag#READ}.
      *
      * @param keys Keys to evict.
      */
@@ -242,7 +242,7 @@ public interface IgniteCache<K, V> extends javax.cache.Cache<K, V>, IgniteAsyncS
      * This method does not participate in any transactions, however, it will
      * peek at transactional value according to the {@link org.apache.ignite.cache.GridCachePeekMode#SMART} mode
      * semantics. If you need to look at global cached value even from within transaction,
-     * you can use {@link org.apache.ignite.cache.GridCache#peek(Object, Collection)} method.
+     * you can use {@link org.apache.ignite.cache.Cache#peek(Object, Collection)} method.
      *
      * @param key Entry key.
      * @return Peeked value.
@@ -257,11 +257,11 @@ public interface IgniteCache<K, V> extends javax.cache.Cache<K, V>, IgniteAsyncS
      * This method is not transactional.
      * <h2 class="header">Cache Flags</h2>
      * This method is not available if any of the following flags are set on projection:
-     * {@link org.apache.ignite.cache.GridCacheFlag#SKIP_SWAP}, {@link org.apache.ignite.cache.GridCacheFlag#READ}.
+     * {@link org.apache.ignite.cache.CacheFlag#SKIP_SWAP}, {@link org.apache.ignite.cache.CacheFlag#READ}.
      *
      * @param keys Keys to promote entries for.
      * @throws CacheException If promote failed.
-     * @throws org.apache.ignite.cache.GridCacheFlagException If flags validation failed.
+     * @throws org.apache.ignite.cache.CacheFlagException If flags validation failed.
      */
     public void localPromote(Set<? extends K> keys) throws CacheException;
 
@@ -270,7 +270,7 @@ public interface IgniteCache<K, V> extends javax.cache.Cache<K, V>, IgniteAsyncS
      * is not currently locked, and is not participating in a transaction.
      * <p>
      * If {@link CacheConfiguration#isSwapEnabled()} is set to {@code true} and
-     * {@link org.apache.ignite.cache.GridCacheFlag#SKIP_SWAP} is not enabled, the evicted entries will
+     * {@link org.apache.ignite.cache.CacheFlag#SKIP_SWAP} is not enabled, the evicted entries will
      * also be cleared from swap.
      * <p>
      * Note that this operation is local as it merely clears
@@ -278,7 +278,7 @@ public interface IgniteCache<K, V> extends javax.cache.Cache<K, V>, IgniteAsyncS
      * remote caches or from underlying persistent storage.
      * <h2 class="header">Cache Flags</h2>
      * This method is not available if any of the following flags are set on projection:
-     * {@link org.apache.ignite.cache.GridCacheFlag#READ}.
+     * {@link org.apache.ignite.cache.CacheFlag#READ}.
      *
      * @param keys Keys to clear.
      * @return {@code True} if entry was successfully cleared from cache, {@code false}
@@ -340,7 +340,7 @@ public interface IgniteCache<K, V> extends javax.cache.Cache<K, V>, IgniteAsyncS
      * (which will be stored in portable format), you should acquire following projection
      * to avoid deserialization:
      * <pre>
-     * GridCacheProjection<Integer, GridPortableObject> prj = cache.keepPortable();
+     * CacheProjection<Integer, GridPortableObject> prj = cache.keepPortable();
      *
      * // Value is not deserialized and returned in portable format.
      * GridPortableObject po = prj.get(1);

http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/cafee25f/modules/core/src/main/java/org/apache/ignite/IgniteCluster.java
----------------------------------------------------------------------
diff --git a/modules/core/src/main/java/org/apache/ignite/IgniteCluster.java b/modules/core/src/main/java/org/apache/ignite/IgniteCluster.java
index afe960e..5d17bca 100644
--- a/modules/core/src/main/java/org/apache/ignite/IgniteCluster.java
+++ b/modules/core/src/main/java/org/apache/ignite/IgniteCluster.java
@@ -108,7 +108,7 @@ public interface IgniteCluster extends ClusterGroup, IgniteAsyncSupport {
      * <ul>
      * <li>For local caches it returns only local node mapped to all keys.</li>
      * <li>
-     *      For fully replicated caches, {@link org.apache.ignite.cache.affinity.GridCacheAffinityFunction} is
+     *      For fully replicated caches, {@link org.apache.ignite.cache.affinity.CacheAffinityFunction} is
      *      used to determine which keys are mapped to which groups of nodes.
      * </li>
      * <li>For partitioned caches, the returned map represents node-to-key affinity.</li>
@@ -131,7 +131,7 @@ public interface IgniteCluster extends ClusterGroup, IgniteAsyncSupport {
      * <ul>
      * <li>For local caches it returns only local node ID.</li>
      * <li>
-     *      For fully replicated caches first node ID returned by {@link org.apache.ignite.cache.affinity.GridCacheAffinityFunction}
+     *      For fully replicated caches first node ID returned by {@link org.apache.ignite.cache.affinity.CacheAffinityFunction}
      *      is returned.
      * </li>
      * <li>For partitioned caches, the returned node ID is the primary node for the key.</li>

http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/cafee25f/modules/core/src/main/java/org/apache/ignite/IgniteDataLoader.java
----------------------------------------------------------------------
diff --git a/modules/core/src/main/java/org/apache/ignite/IgniteDataLoader.java b/modules/core/src/main/java/org/apache/ignite/IgniteDataLoader.java
index a4b41dd..c55310b 100644
--- a/modules/core/src/main/java/org/apache/ignite/IgniteDataLoader.java
+++ b/modules/core/src/main/java/org/apache/ignite/IgniteDataLoader.java
@@ -34,7 +34,7 @@ import java.util.*;
  * the loader.
  * <p>
  * Also note that {@code GridDataLoader} is not the only way to load data into cache.
- * Alternatively you can use {@link org.apache.ignite.cache.GridCache#loadCache(org.apache.ignite.lang.IgniteBiPredicate, long, Object...)}
+ * Alternatively you can use {@link org.apache.ignite.cache.Cache#loadCache(org.apache.ignite.lang.IgniteBiPredicate, long, Object...)}
  * method to load data from underlying data store. You can also use standard
  * cache {@code put(...)} and {@code putAll(...)} operations as well, but they most
  * likely will not perform as well as this class for loading data. And finally,

http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/cafee25f/modules/core/src/main/java/org/apache/ignite/IgnitePortables.java
----------------------------------------------------------------------
diff --git a/modules/core/src/main/java/org/apache/ignite/IgnitePortables.java b/modules/core/src/main/java/org/apache/ignite/IgnitePortables.java
index 9f8542a..4da163e 100644
--- a/modules/core/src/main/java/org/apache/ignite/IgnitePortables.java
+++ b/modules/core/src/main/java/org/apache/ignite/IgnitePortables.java
@@ -48,9 +48,9 @@ import java.util.Date;
  * (assuming that class definitions are present in the classpath).
  * <p>
  * To work with the portable format directly, user should create a special cache projection
- * using {@link org.apache.ignite.cache.GridCacheProjection#keepPortable()} method and then retrieve individual fields as needed:
+ * using {@link org.apache.ignite.cache.CacheProjection#keepPortable()} method and then retrieve individual fields as needed:
  * <pre name=code class=java>
- * GridCacheProjection&lt;GridPortableObject.class, GridPortableObject.class&gt; prj = cache.keepPortable();
+ * CacheProjection&lt;GridPortableObject.class, GridPortableObject.class&gt; prj = cache.keepPortable();
  *
  * // Convert instance of MyKey to portable format.
  * // We could also use GridPortableBuilder to create
@@ -66,7 +66,7 @@ import java.util.Date;
  * GridGain will only deserialize on the first access and will cache the deserialized object,
  * so it does not have to be deserialized again:
  * <pre name=code class=java>
- * GridCacheProjection&lt;MyKey.class, MyValue.class&gt; prj =
+ * CacheProjection&lt;MyKey.class, MyValue.class&gt; prj =
  *     cache.projection(MyKey.class, MyValue.class);
  *
  * MyValue val = prj.get(new MyKey());
@@ -78,7 +78,7 @@ import java.util.Date;
  * and still wanted to work with binary portable format for values, then we would declare cache projection
  * as follows:
  * <pre name=code class=java>
- * GridCacheProjection&lt;Integer.class, GridPortableObject.class&gt; prj = cache.keepPortable();
+ * CacheProjection&lt;Integer.class, GridPortableObject.class&gt; prj = cache.keepPortable();
  * </pre>
  * <h1 class="header">Automatic Portable Types</h1>
  * Note that only portable classes are converted to {@link org.apache.ignite.portables.PortableObject} format. Following
@@ -254,17 +254,17 @@ import java.util.Date;
  * or for a specific type via {@link org.apache.ignite.portables.PortableTypeConfiguration} instance.
  * <h1 class="header">Query Indexing</h1>
  * Portable objects can be indexed for querying by specifying index fields in
- * {@link org.apache.ignite.cache.query.GridCacheQueryTypeMetadata} inside of specific {@link CacheConfiguration} instance,
+ * {@link org.apache.ignite.cache.query.CacheQueryTypeMetadata} inside of specific {@link CacheConfiguration} instance,
  * like so:
  * <pre name=code class=xml>
  * ...
  * &lt;bean class="org.gridgain.grid.cache.GridCacheConfiguration"&gt;
  *     ...
  *     &lt;property name="queryConfiguration"&gt;
- *         &lt;bean class="GridCacheQueryConfiguration"&gt;
+ *         &lt;bean class="CacheQueryConfiguration"&gt;
  *             &lt;property name="typeMetadata"&gt;
  *                 &lt;list&gt;
- *                     &lt;bean class="GridCacheQueryTypeMetadata"&gt;
+ *                     &lt;bean class="CacheQueryTypeMetadata"&gt;
  *                         &lt;property name="type" value="Employee"/&gt;
  *
  *                         &lt;!-- Fields to index in ascending order. --&gt;

http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/cafee25f/modules/core/src/main/java/org/apache/ignite/cache/Cache.java
----------------------------------------------------------------------
diff --git a/modules/core/src/main/java/org/apache/ignite/cache/Cache.java b/modules/core/src/main/java/org/apache/ignite/cache/Cache.java
new file mode 100644
index 0000000..2a8fbcc
--- /dev/null
+++ b/modules/core/src/main/java/org/apache/ignite/cache/Cache.java
@@ -0,0 +1,278 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.ignite.cache;
+
+import org.apache.ignite.*;
+import org.apache.ignite.cache.affinity.*;
+import org.apache.ignite.cache.datastructures.*;
+import org.apache.ignite.cache.store.CacheStore;
+import org.apache.ignite.lang.*;
+import org.apache.ignite.transactions.*;
+import org.jetbrains.annotations.*;
+
+import java.util.*;
+
+/**
+ * Main entry point for all <b>Data Grid APIs.</b> You can get a named cache by calling {@link org.apache.ignite.Ignite#cache(String)}
+ * method.
+ * <h1 class="header">Functionality</h1>
+ * This API extends {@link CacheProjection} API which contains vast majority of cache functionality
+ * and documentation. In addition to {@link CacheProjection} functionality this API provides:
+ * <ul>
+ * <li>
+ *  Various {@code 'loadCache(..)'} methods to load cache either synchronously or asynchronously.
+ *  These methods don't specify any keys to load, and leave it to the underlying storage to load cache
+ *  data based on the optionally passed in arguments.
+ * </li>
+ * <li>
+ *     Method {@link #affinity()} provides {@link org.apache.ignite.cache.affinity.CacheAffinityFunction} service for information on
+ *     data partitioning and mapping keys to grid nodes responsible for caching those keys.
+ * </li>
+ * <li>
+ *     Method {@link #dataStructures()} provides {@link org.apache.ignite.cache.datastructures.CacheDataStructures} service for
+ *     creating and working with distributed concurrent data structures, such as
+ *     {@link org.apache.ignite.cache.datastructures.CacheAtomicLong}, {@link org.apache.ignite.cache.datastructures.CacheAtomicReference}, {@link org.apache.ignite.cache.datastructures.CacheQueue}, etc.
+ * </li>
+ * <li>
+ *  Methods like {@code 'tx{Un}Synchronize(..)'} witch allow to get notifications for transaction state changes.
+ *  This feature is very useful when integrating cache transactions with some other in-house transactions.
+ * </li>
+ * <li>Method {@link #metrics()} to provide metrics for the whole cache.</li>
+ * <li>Method {@link #configuration()} to provide cache configuration bean.</li>
+ * </ul>
+ *
+ * @param <K> Cache key type.
+ * @param <V> Cache value type.
+ */
+public interface Cache<K, V> extends CacheProjection<K, V> {
+    /**
+     * Gets configuration bean for this cache.
+     *
+     * @return Configuration bean for this cache.
+     */
+    public CacheConfiguration configuration();
+
+    /**
+     * Registers transactions synchronizations for all transactions started by this cache.
+     * Use it whenever you need to get notifications on transaction lifecycle and possibly change
+     * its course. It is also particularly useful when integrating cache transactions
+     * with some other in-house transactions.
+     *
+     * @param syncs Transaction synchronizations to register.
+     */
+    public void txSynchronize(@Nullable IgniteTxSynchronization syncs);
+
+    /**
+     * Removes transaction synchronizations.
+     *
+     * @param syncs Transactions synchronizations to remove.
+     * @see #txSynchronize(IgniteTxSynchronization)
+     */
+    public void txUnsynchronize(@Nullable IgniteTxSynchronization syncs);
+
+    /**
+     * Gets registered transaction synchronizations.
+     *
+     * @return Registered transaction synchronizations.
+     * @see #txSynchronize(IgniteTxSynchronization)
+     */
+    public Collection<IgniteTxSynchronization> txSynchronizations();
+
+    /**
+     * Gets affinity service to provide information about data partitioning
+     * and distribution.
+     *
+     * @return Cache data affinity service.
+     */
+    public CacheAffinity<K> affinity();
+
+    /**
+     * Gets data structures service to provide a gateway for creating various
+     * distributed data structures similar in APIs to {@code java.util.concurrent} package.
+     *
+     * @return Cache data structures service.
+     */
+    public CacheDataStructures dataStructures();
+
+    /**
+     * Gets metrics (statistics) for this cache.
+     *
+     * @return Cache metrics.
+     */
+    public CacheMetrics metrics();
+
+    /**
+     * Gets size (in bytes) of all entries swapped to disk.
+     *
+     * @return Size (in bytes) of all entries swapped to disk.
+     * @throws IgniteCheckedException In case of error.
+     */
+    public long overflowSize() throws IgniteCheckedException;
+
+    /**
+     * Gets number of cache entries stored in off-heap memory.
+     *
+     * @return Number of cache entries stored in off-heap memory.
+     */
+    public long offHeapEntriesCount();
+
+    /**
+     * Gets memory size allocated in off-heap.
+     *
+     * @return Allocated memory size.
+     */
+    public long offHeapAllocatedSize();
+
+    /**
+     * Gets size in bytes for swap space.
+     *
+     * @return Size in bytes.
+     * @throws IgniteCheckedException If failed.
+     */
+    public long swapSize() throws IgniteCheckedException;
+
+    /**
+     * Gets number of swap entries (keys).
+     *
+     * @return Number of entries stored in swap.
+     * @throws IgniteCheckedException If failed.
+     */
+    public long swapKeys() throws IgniteCheckedException;
+
+    /**
+     * Gets iterator over keys and values belonging to this cache swap space on local node. This
+     * iterator is thread-safe, which means that cache (and therefore its swap space)
+     * may be modified concurrently with iteration over swap.
+     * <p>
+     * Returned iterator supports {@code remove} operation which delegates to
+     * {@link #removex(Object, org.apache.ignite.lang.IgnitePredicate[])} method.
+     * <h2 class="header">Cache Flags</h2>
+     * This method is not available if any of the following flags are set on projection:
+     * {@link CacheFlag#SKIP_SWAP}.
+     *
+     * @return Iterator over keys.
+     * @throws IgniteCheckedException If failed.
+     * @see #promote(Object)
+     */
+    public Iterator<Map.Entry<K, V>> swapIterator() throws IgniteCheckedException;
+
+    /**
+     * Gets iterator over keys and values belonging to this cache off-heap memory on local node. This
+     * iterator is thread-safe, which means that cache (and therefore its off-heap memory)
+     * may be modified concurrently with iteration over off-heap. To achieve better performance
+     * the keys and values deserialized on demand, whenever accessed.
+     * <p>
+     * Returned iterator supports {@code remove} operation which delegates to
+     * {@link #removex(Object, org.apache.ignite.lang.IgnitePredicate[])} method.
+     *
+     * @return Iterator over keys.
+     * @throws IgniteCheckedException If failed.
+     */
+    public Iterator<Map.Entry<K, V>> offHeapIterator() throws IgniteCheckedException;
+
+    /**
+     * Delegates to {@link CacheStore#loadCache(org.apache.ignite.lang.IgniteBiInClosure,Object...)} method
+     * to load state from the underlying persistent storage. The loaded values
+     * will then be given to the optionally passed in predicate, and, if the predicate returns
+     * {@code true}, will be stored in cache. If predicate is {@code null}, then
+     * all loaded values will be stored in cache.
+     * <p>
+     * Note that this method does not receive keys as a parameter, so it is up to
+     * {@link CacheStore} implementation to provide all the data to be loaded.
+     * <p>
+     * This method is not transactional and may end up loading a stale value into
+     * cache if another thread has updated the value immediately after it has been
+     * loaded. It is mostly useful when pre-loading the cache from underlying
+     * data store before start, or for read-only caches.
+     *
+     * @param p Optional predicate (may be {@code null}). If provided, will be used to
+     *      filter values to be put into cache.
+     * @param ttl Time to live for loaded entries ({@code 0} for infinity).
+     * @param args Optional user arguments to be passed into
+     *      {@link CacheStore#loadCache(org.apache.ignite.lang.IgniteBiInClosure, Object...)} method.
+     * @throws IgniteCheckedException If loading failed.
+     */
+    public void loadCache(@Nullable IgniteBiPredicate<K, V> p, long ttl, @Nullable Object... args) throws IgniteCheckedException;
+
+    /**
+     * Asynchronously delegates to {@link CacheStore#loadCache(org.apache.ignite.lang.IgniteBiInClosure, Object...)} method
+     * to reload state from the underlying persistent storage. The reloaded values
+     * will then be given to the optionally passed in predicate, and if the predicate returns
+     * {@code true}, will be stored in cache. If predicate is {@code null}, then
+     * all reloaded values will be stored in cache.
+     * <p>
+     * Note that this method does not receive keys as a parameter, so it is up to
+     * {@link CacheStore} implementation to provide all the data to be loaded.
+     * <p>
+     * This method is not transactional and may end up loading a stale value into
+     * cache if another thread has updated the value immediately after it has been
+     * loaded. It is mostly useful when pre-loading the cache from underlying
+     * data store before start, or for read-only caches.
+     *
+     * @param p Optional predicate (may be {@code null}). If provided, will be used to
+     *      filter values to be put into cache.
+     * @param ttl Time to live for loaded entries ({@code 0} for infinity).
+     * @param args Optional user arguments to be passed into
+     *      {@link CacheStore#loadCache(org.apache.ignite.lang.IgniteBiInClosure,Object...)} method.
+     * @return Future to be completed whenever loading completes.
+     */
+    public IgniteFuture<?> loadCacheAsync(@Nullable IgniteBiPredicate<K, V> p, long ttl, @Nullable Object... args);
+
+    /**
+     * Gets a random entry out of cache. In the worst cache scenario this method
+     * has complexity of <pre>O(S * N/64)</pre> where {@code N} is the size of internal hash
+     * table and {@code S} is the number of hash table buckets to sample, which is {@code 5}
+     * by default. However, if the table is pretty dense, with density factor of {@code N/64},
+     * which is true for near fully populated caches, this method will generally perform significantly
+     * faster with complexity of O(S) where {@code S = 5}.
+     * <p>
+     * Note that this method is not available on {@link CacheProjection} API since it is
+     * impossible (or very hard) to deterministically return a number value when pre-filtering
+     * and post-filtering is involved (e.g. projection level predicate filters).
+     *
+     * @return Random entry, or {@code null} if cache is empty.
+     */
+    @Nullable public CacheEntry<K, V> randomEntry();
+
+    /**
+     * Forces this cache node to re-balance its partitions. This method is usually used when
+     * {@link CacheConfiguration#getPreloadPartitionedDelay()} configuration parameter has non-zero value.
+     * When many nodes are started or stopped almost concurrently, it is more efficient to delay
+     * preloading until the node topology is stable to make sure that no redundant re-partitioning
+     * happens.
+     * <p>
+     * In case of{@link CacheMode#PARTITIONED} caches, for better efficiency user should
+     * usually make sure that new nodes get placed on the same place of consistent hash ring as
+     * the left nodes, and that nodes are restarted before
+     * {@link CacheConfiguration#getPreloadPartitionedDelay() preloadDelay} expires. To place nodes
+     * on the same place in consistent hash ring, use
+     * {@link org.apache.ignite.cache.affinity.consistenthash.CacheConsistentHashAffinityFunction#setHashIdResolver(org.apache.ignite.cache.affinity.CacheAffinityNodeHashResolver)} to make sure that
+     * a node maps to the same hash ID if re-started.
+     * <p>
+     * See {@link CacheConfiguration#getPreloadPartitionedDelay()} for more information on how to configure
+     * preload re-partition delay.
+     * <p>
+     * @return Future that will be completed when preloading is finished.
+     */
+    public IgniteFuture<?> forceRepartition();
+
+    /**
+     * Resets metrics for current cache.
+     */
+    public void resetMetrics();
+}

http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/cafee25f/modules/core/src/main/java/org/apache/ignite/cache/CacheAtomicWriteOrderMode.java
----------------------------------------------------------------------
diff --git a/modules/core/src/main/java/org/apache/ignite/cache/CacheAtomicWriteOrderMode.java b/modules/core/src/main/java/org/apache/ignite/cache/CacheAtomicWriteOrderMode.java
index 746060c..0771ae9 100644
--- a/modules/core/src/main/java/org/apache/ignite/cache/CacheAtomicWriteOrderMode.java
+++ b/modules/core/src/main/java/org/apache/ignite/cache/CacheAtomicWriteOrderMode.java
@@ -24,21 +24,21 @@ import org.jetbrains.annotations.*;
  * atomicity mode. Write ordering mode determines which node assigns the write version, sender or the primary node.
  * <p>
  * For example, {@link #CLOCK} mode assigns write versions on a sender node which generally leads to better
- * performance in {@link GridCacheWriteSynchronizationMode#FULL_SYNC} synchronization mode, since in this case
+ * performance in {@link CacheWriteSynchronizationMode#FULL_SYNC} synchronization mode, since in this case
  * sender can send write requests to primary and backups at the same time. Otherwise, if ordering mode is
  * {@link #PRIMARY}, it would only send request to primary node, which in turn will assign write version
  * and forward it to backups.
  * <p>
- * {@link #CLOCK} mode will be automatically configured only with {@link GridCacheWriteSynchronizationMode#FULL_SYNC}
+ * {@link #CLOCK} mode will be automatically configured only with {@link CacheWriteSynchronizationMode#FULL_SYNC}
  * write synchronization mode, as for other synchronization modes it does not render better performance.
  */
 public enum CacheAtomicWriteOrderMode {
     /**
      * In this mode, write versions are assigned on a sender node which generally leads to better
-     * performance in {@link GridCacheWriteSynchronizationMode#FULL_SYNC} synchronization mode, since in this case
+     * performance in {@link CacheWriteSynchronizationMode#FULL_SYNC} synchronization mode, since in this case
      * sender can send write requests to primary and backups at the same time.
      * <p>
-     * This mode will be automatically configured only with {@link GridCacheWriteSynchronizationMode#FULL_SYNC}
+     * This mode will be automatically configured only with {@link CacheWriteSynchronizationMode#FULL_SYNC}
      * write synchronization mode, as for other synchronization modes it does not render better performance.
      */
     CLOCK,

http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/cafee25f/modules/core/src/main/java/org/apache/ignite/cache/CacheConfiguration.java
----------------------------------------------------------------------
diff --git a/modules/core/src/main/java/org/apache/ignite/cache/CacheConfiguration.java b/modules/core/src/main/java/org/apache/ignite/cache/CacheConfiguration.java
index 83b972e..d550531 100644
--- a/modules/core/src/main/java/org/apache/ignite/cache/CacheConfiguration.java
+++ b/modules/core/src/main/java/org/apache/ignite/cache/CacheConfiguration.java
@@ -74,7 +74,7 @@ public class CacheConfiguration extends MutableConfiguration {
     public static final CacheAtomicityMode DFLT_CACHE_ATOMICITY_MODE = CacheAtomicityMode.ATOMIC;
 
     /** Default value for cache distribution mode. */
-    public static final GridCacheDistributionMode DFLT_DISTRIBUTION_MODE = GridCacheDistributionMode.PARTITIONED_ONLY;
+    public static final CacheDistributionMode DFLT_DISTRIBUTION_MODE = CacheDistributionMode.PARTITIONED_ONLY;
 
     /** Default query timeout. */
     public static final long DFLT_QUERY_TIMEOUT = 0;
@@ -98,7 +98,7 @@ public class CacheConfiguration extends MutableConfiguration {
     public static final boolean DFLT_STORE_VALUE_BYTES = true;
 
     /** Default preload mode for distributed cache. */
-    public static final GridCachePreloadMode DFLT_PRELOAD_MODE = GridCachePreloadMode.ASYNC;
+    public static final CachePreloadMode DFLT_PRELOAD_MODE = CachePreloadMode.ASYNC;
 
     /** Default preload batch size in bytes. */
     public static final int DFLT_PRELOAD_BATCH_SIZE = 512 * 1024; // 512K
@@ -166,7 +166,7 @@ public class CacheConfiguration extends MutableConfiguration {
     public static final int DFLT_CONT_QUERY_QUEUE_SIZE = 1024 * 1024;
 
     /** Default memory mode. */
-    public static final GridCacheMemoryMode DFLT_MEMORY_MODE = GridCacheMemoryMode.ONHEAP_TIERED;
+    public static final CacheMemoryMode DFLT_MEMORY_MODE = CacheMemoryMode.ONHEAP_TIERED;
 
     /** Default continuous query max buffer size. */
     @SuppressWarnings("UnusedDeclaration")
@@ -192,10 +192,10 @@ public class CacheConfiguration extends MutableConfiguration {
     private long ttl = DFLT_TIME_TO_LIVE;
 
     /** Cache expiration policy. */
-    private GridCacheEvictionPolicy evictPlc;
+    private CacheEvictionPolicy evictPlc;
 
     /** Near cache eviction policy. */
-    private GridCacheEvictionPolicy nearEvictPlc;
+    private CacheEvictionPolicy nearEvictPlc;
 
     /** Flag indicating whether eviction is synchronized. */
     private boolean evictSync = DFLT_EVICT_SYNCHRONIZED;
@@ -213,7 +213,7 @@ public class CacheConfiguration extends MutableConfiguration {
     private long evictSyncTimeout = DFLT_EVICT_SYNCHRONIZED_TIMEOUT;
 
     /** Eviction filter. */
-    private GridCacheEvictionFilter<?, ?> evictFilter;
+    private CacheEvictionFilter<?, ?> evictFilter;
 
     /** Maximum eviction overflow ratio. */
     private float evictMaxOverflowRatio = DFLT_MAX_EVICTION_OVERFLOW_RATIO;
@@ -234,10 +234,10 @@ public class CacheConfiguration extends MutableConfiguration {
     private int nearStartSize = DFLT_NEAR_START_SIZE;
 
     /** Cache distribution mode. */
-    private GridCacheDistributionMode distro = DFLT_DISTRIBUTION_MODE;
+    private CacheDistributionMode distro = DFLT_DISTRIBUTION_MODE;
 
     /** Write synchronization mode. */
-    private GridCacheWriteSynchronizationMode writeSync;
+    private CacheWriteSynchronizationMode writeSync;
 
     /** */
     private Factory storeFactory;
@@ -246,7 +246,7 @@ public class CacheConfiguration extends MutableConfiguration {
     private boolean loadPrevVal = DFLT_LOAD_PREV_VAL;
 
     /** Node group resolver. */
-    private GridCacheAffinityFunction aff;
+    private CacheAffinityFunction aff;
 
     /** Cache mode. */
     private CacheMode cacheMode = DFLT_CACHE_MODE;
@@ -270,7 +270,7 @@ public class CacheConfiguration extends MutableConfiguration {
     private String tmLookupClsName;
 
     /** Distributed cache preload mode. */
-    private GridCachePreloadMode preloadMode = DFLT_PRELOAD_MODE;
+    private CachePreloadMode preloadMode = DFLT_PRELOAD_MODE;
 
     /** Cache preload order. */
     private int preloadOrder;
@@ -309,13 +309,13 @@ public class CacheConfiguration extends MutableConfiguration {
     private int maxQryIterCnt = DFLT_MAX_QUERY_ITERATOR_CNT;
 
     /** Memory mode. */
-    private GridCacheMemoryMode memMode = DFLT_MEMORY_MODE;
+    private CacheMemoryMode memMode = DFLT_MEMORY_MODE;
 
     /** */
-    private GridCacheCloner cloner;
+    private CacheCloner cloner;
 
     /** */
-    private GridCacheAffinityKeyMapper affMapper;
+    private CacheAffinityKeyMapper affMapper;
 
     /** */
     private String indexingSpiName;
@@ -327,7 +327,7 @@ public class CacheConfiguration extends MutableConfiguration {
     private long preloadThrottle = DFLT_PRELOAD_THROTTLE;
 
     /** */
-    private GridCacheInterceptor<?, ?> interceptor;
+    private CacheInterceptor<?, ?> interceptor;
 
     /** */
     private boolean portableEnabled;
@@ -336,7 +336,7 @@ public class CacheConfiguration extends MutableConfiguration {
     private boolean keepPortableInStore = true;
 
     /** Query configuration. */
-    private GridCacheQueryConfiguration qryCfg;
+    private CacheQueryConfiguration qryCfg;
 
     /**
      * Flag indicating whether data can be read from backup.
@@ -477,7 +477,7 @@ public class CacheConfiguration extends MutableConfiguration {
      * @return Cache eviction policy or {@code null} if evictions should be disabled.
      */
     @SuppressWarnings({"unchecked"})
-    @Nullable public <K, V> GridCacheEvictionPolicy<K, V> getEvictionPolicy() {
+    @Nullable public <K, V> CacheEvictionPolicy<K, V> getEvictionPolicy() {
         return evictPlc;
     }
 
@@ -486,7 +486,7 @@ public class CacheConfiguration extends MutableConfiguration {
      *
      * @param evictPlc Cache expiration policy.
      */
-    public void setEvictionPolicy(@Nullable GridCacheEvictionPolicy evictPlc) {
+    public void setEvictionPolicy(@Nullable CacheEvictionPolicy evictPlc) {
         this.evictPlc = evictPlc;
     }
 
@@ -498,7 +498,7 @@ public class CacheConfiguration extends MutableConfiguration {
      *
      * @return Cache distribution mode.
      */
-    public GridCacheDistributionMode getDistributionMode() {
+    public CacheDistributionMode getDistributionMode() {
         return distro;
     }
 
@@ -507,7 +507,7 @@ public class CacheConfiguration extends MutableConfiguration {
      *
      * @param distro Distribution mode.
      */
-    public void setDistributionMode(GridCacheDistributionMode distro) {
+    public void setDistributionMode(CacheDistributionMode distro) {
         this.distro = distro;
     }
 
@@ -517,7 +517,7 @@ public class CacheConfiguration extends MutableConfiguration {
      *
      * @return Write synchronization mode.
      */
-    public GridCacheWriteSynchronizationMode getWriteSynchronizationMode() {
+    public CacheWriteSynchronizationMode getWriteSynchronizationMode() {
         return writeSync;
     }
 
@@ -526,7 +526,7 @@ public class CacheConfiguration extends MutableConfiguration {
      *
      * @param writeSync Write synchronization mode.
      */
-    public void setWriteSynchronizationMode(GridCacheWriteSynchronizationMode writeSync) {
+    public void setWriteSynchronizationMode(CacheWriteSynchronizationMode writeSync) {
         this.writeSync = writeSync;
     }
 
@@ -538,7 +538,7 @@ public class CacheConfiguration extends MutableConfiguration {
      * @return Cache eviction policy or {@code null} if evictions should be disabled.
      */
     @SuppressWarnings({"unchecked"})
-    @Nullable public <K, V> GridCacheEvictionPolicy<K, V> getNearEvictionPolicy() {
+    @Nullable public <K, V> CacheEvictionPolicy<K, V> getNearEvictionPolicy() {
         return nearEvictPlc;
     }
 
@@ -548,14 +548,14 @@ public class CacheConfiguration extends MutableConfiguration {
      *
      * @param nearEvictPlc Eviction policy for near cache.
      */
-    public void setNearEvictionPolicy(@Nullable GridCacheEvictionPolicy nearEvictPlc) {
+    public void setNearEvictionPolicy(@Nullable CacheEvictionPolicy nearEvictPlc) {
         this.nearEvictPlc = nearEvictPlc;
     }
 
     /**
      * Gets flag indicating whether eviction is synchronized between primary and
      * backup nodes on partitioned cache. If this parameter is {@code true} and
-     * swap is disabled then {@link org.apache.ignite.cache.GridCacheProjection#evict(Object)}
+     * swap is disabled then {@link CacheProjection#evict(Object)}
      * and all its variations will involve all nodes where an entry is kept -
      * this is a group of nodes responsible for partition to which
      * corresponding key belongs. If this property is set to {@code false} then
@@ -715,8 +715,8 @@ public class CacheConfiguration extends MutableConfiguration {
 
     /**
      * Gets eviction filter to specify which entries should not be evicted
-     * (except explicit evict by calling {@link GridCacheEntry#evict()}).
-     * If {@link GridCacheEvictionFilter#evictAllowed(GridCacheEntry)} method returns
+     * (except explicit evict by calling {@link CacheEntry#evict()}).
+     * If {@link org.apache.ignite.cache.eviction.CacheEvictionFilter#evictAllowed(CacheEntry)} method returns
      * {@code false} then eviction policy will not be notified and entry will
      * never be evicted.
      * <p>
@@ -726,8 +726,8 @@ public class CacheConfiguration extends MutableConfiguration {
      * @return Eviction filter or {@code null}.
      */
     @SuppressWarnings("unchecked")
-    public <K, V> GridCacheEvictionFilter<K, V> getEvictionFilter() {
-        return (GridCacheEvictionFilter<K, V>)evictFilter;
+    public <K, V> CacheEvictionFilter<K, V> getEvictionFilter() {
+        return (CacheEvictionFilter<K, V>)evictFilter;
     }
 
     /**
@@ -735,7 +735,7 @@ public class CacheConfiguration extends MutableConfiguration {
      *
      * @param evictFilter Eviction filter.
      */
-    public <K, V> void setEvictionFilter(GridCacheEvictionFilter<K, V> evictFilter) {
+    public <K, V> void setEvictionFilter(CacheEvictionFilter<K, V> evictFilter) {
         this.evictFilter = evictFilter;
     }
 
@@ -746,8 +746,8 @@ public class CacheConfiguration extends MutableConfiguration {
      * When not set, default value is {@link #DFLT_EAGER_TTL}.
      * <p>
      * <b>Note</b> that this flag only matters for entries expiring based on
-     * {@link GridCacheEntry#timeToLive()} value and should not be confused with entry
-     * evictions based on configured {@link GridCacheEvictionPolicy}.
+     * {@link CacheEntry#timeToLive()} value and should not be confused with entry
+     * evictions based on configured {@link org.apache.ignite.cache.eviction.CacheEvictionPolicy}.
      *
      * @return Flag indicating whether GridGain will eagerly remove expired entries.
      */
@@ -869,7 +869,7 @@ public class CacheConfiguration extends MutableConfiguration {
      *
      * @return Key topology resolver to provide mapping from keys to nodes.
      */
-    public GridCacheAffinityFunction getAffinity() {
+    public CacheAffinityFunction getAffinity() {
         return aff;
     }
 
@@ -878,7 +878,7 @@ public class CacheConfiguration extends MutableConfiguration {
      *
      * @param aff Cache key affinity.
      */
-    public void setAffinity(GridCacheAffinityFunction aff) {
+    public void setAffinity(CacheAffinityFunction aff) {
         this.aff = aff;
     }
 
@@ -1065,7 +1065,7 @@ public class CacheConfiguration extends MutableConfiguration {
      *
      * @param preloadMode Preload mode.
      */
-    public void setPreloadMode(GridCachePreloadMode preloadMode) {
+    public void setPreloadMode(CachePreloadMode preloadMode) {
         this.preloadMode = preloadMode;
     }
 
@@ -1076,13 +1076,13 @@ public class CacheConfiguration extends MutableConfiguration {
      *
      * @return Preload mode.
      */
-    public GridCachePreloadMode getPreloadMode() {
+    public CachePreloadMode getPreloadMode() {
         return preloadMode;
     }
 
     /**
      * Gets cache preload order. Preload order can be set to non-zero value for caches with
-     * {@link GridCachePreloadMode#SYNC SYNC} or {@link GridCachePreloadMode#ASYNC ASYNC} preload modes only.
+     * {@link CachePreloadMode#SYNC SYNC} or {@link CachePreloadMode#ASYNC ASYNC} preload modes only.
      * <p/>
      * If cache preload order is positive, preloading for this cache will be started only when preloading for
      * all caches with smaller preload order (except caches with preload order {@code 0}) will be completed.
@@ -1135,7 +1135,7 @@ public class CacheConfiguration extends MutableConfiguration {
      * swap is disabled which is defined via {@link #DFLT_SWAP_ENABLED} constant.
      * <p>
      * Note that this flag may be overridden for cache projection created with flag
-     * {@link GridCacheFlag#SKIP_SWAP}.
+     * {@link CacheFlag#SKIP_SWAP}.
      *
      * @return {@code True} if swap storage is enabled.
      */
@@ -1320,36 +1320,36 @@ public class CacheConfiguration extends MutableConfiguration {
     }
 
     /**
-     * Cloner to be used for cloning values that are returned to user only if {@link GridCacheFlag#CLONE}
-     * is set on {@link org.apache.ignite.cache.GridCacheProjection}. Cloning values is useful when it is needed to get value from
+     * Cloner to be used for cloning values that are returned to user only if {@link CacheFlag#CLONE}
+     * is set on {@link CacheProjection}. Cloning values is useful when it is needed to get value from
      * cache, change it and put it back (if the value was not cloned, then user would be updating the
      * cached reference which would violate cache integrity).
      * <p>
-     * <b>NOTE:</b> by default, cache uses {@link org.apache.ignite.cache.cloner.GridCacheBasicCloner} implementation which will clone only objects
+     * <b>NOTE:</b> by default, cache uses {@link org.apache.ignite.cache.cloner.CacheBasicCloner} implementation which will clone only objects
      * implementing {@link Cloneable} interface. You can also configure cache to use
-     * {@link org.apache.ignite.cache.cloner.GridCacheDeepCloner} which will perform deep-cloning of all objects returned from cache,
+     * {@link org.apache.ignite.cache.cloner.CacheDeepCloner} which will perform deep-cloning of all objects returned from cache,
      * regardless of the {@link Cloneable} interface. If none of the above cloners fit your
-     * logic, you can also provide your own implementation of {@link GridCacheCloner} interface.
+     * logic, you can also provide your own implementation of {@link org.apache.ignite.cache.cloner.CacheCloner} interface.
      *
-     * @return Cloner to be used if {@link GridCacheFlag#CLONE} flag is set on cache projection.
+     * @return Cloner to be used if {@link CacheFlag#CLONE} flag is set on cache projection.
      */
     @SuppressWarnings({"unchecked"})
-    public GridCacheCloner getCloner() {
+    public CacheCloner getCloner() {
         return cloner;
     }
 
     /**
-     * Sets cloner to be used if {@link GridCacheFlag#CLONE} flag is set on projection.
+     * Sets cloner to be used if {@link CacheFlag#CLONE} flag is set on projection.
      *
      * @param cloner Cloner to use.
      * @see #getCloner()
      */
-    public void setCloner(GridCacheCloner cloner) {
+    public void setCloner(CacheCloner cloner) {
         this.cloner = cloner;
     }
 
     /**
-     * Gets default number of sequence values reserved for {@link org.apache.ignite.cache.datastructures.GridCacheAtomicSequence} instances. After
+     * Gets default number of sequence values reserved for {@link org.apache.ignite.cache.datastructures.CacheAtomicSequence} instances. After
      * a certain number has been reserved, consequent increments of sequence will happen locally,
      * without communication with other nodes, until the next reservation has to be made.
      * <p>
@@ -1362,7 +1362,7 @@ public class CacheConfiguration extends MutableConfiguration {
     }
 
     /**
-     * Sets default number of sequence values reserved for {@link org.apache.ignite.cache.datastructures.GridCacheAtomicSequence} instances. After a certain
+     * Sets default number of sequence values reserved for {@link org.apache.ignite.cache.datastructures.CacheAtomicSequence} instances. After a certain
      * number has been reserved, consequent increments of sequence will happen locally, without communication with other
      * nodes, until the next reservation has to be made.
      *
@@ -1425,13 +1425,13 @@ public class CacheConfiguration extends MutableConfiguration {
      * For better efficiency user should usually make sure that new nodes get placed on
      * the same place of consistent hash ring as the left nodes, and that nodes are
      * restarted before this delay expires. To place nodes on the same place in consistent hash ring,
-     * use {@link org.apache.ignite.cache.affinity.consistenthash.GridCacheConsistentHashAffinityFunction#setHashIdResolver(GridCacheAffinityNodeHashResolver)}
+     * use {@link org.apache.ignite.cache.affinity.consistenthash.CacheConsistentHashAffinityFunction#setHashIdResolver(org.apache.ignite.cache.affinity.CacheAffinityNodeHashResolver)}
      * to make sure that a node maps to the same hash ID event if restarted. As an example,
      * node IP address and port combination may be used in this case.
      * <p>
      * Default value is {@code 0} which means that repartitioning and preloading will start
      * immediately upon node leaving topology. If {@code -1} is returned, then preloading
-     * will only be started manually by calling {@link GridCache#forceRepartition()} method or
+     * will only be started manually by calling {@link Cache#forceRepartition()} method or
      * from management console.
      *
      * @return Preloading delay, {@code 0} to start preloading immediately, {@code -1} to
@@ -1490,21 +1490,21 @@ public class CacheConfiguration extends MutableConfiguration {
      * on the same node (they will also be backed up on the same nodes as well).
      * <p>
      * If not provided, then default implementation will be used. The default behavior
-     * is described in {@link GridCacheAffinityKeyMapper} documentation.
+     * is described in {@link org.apache.ignite.cache.affinity.CacheAffinityKeyMapper} documentation.
      *
      * @return Mapper to use for affinity key mapping.
      */
-    public GridCacheAffinityKeyMapper getAffinityMapper() {
+    public CacheAffinityKeyMapper getAffinityMapper() {
         return affMapper;
     }
 
     /**
      * Sets custom affinity mapper. If not provided, then default implementation will be used. The default behavior is
-     * described in {@link GridCacheAffinityKeyMapper} documentation.
+     * described in {@link org.apache.ignite.cache.affinity.CacheAffinityKeyMapper} documentation.
      *
      * @param affMapper Affinity mapper.
      */
-    public void setAffinityMapper(GridCacheAffinityKeyMapper affMapper) {
+    public void setAffinityMapper(CacheAffinityKeyMapper affMapper) {
         this.affMapper = affMapper;
     }
 
@@ -1630,13 +1630,13 @@ public class CacheConfiguration extends MutableConfiguration {
 
     /**
      * Gets memory mode for cache. Memory mode helps control whether value is stored in on-heap memory,
-     * off-heap memory, or swap space. Refer to {@link GridCacheMemoryMode} for more info.
+     * off-heap memory, or swap space. Refer to {@link CacheMemoryMode} for more info.
      * <p>
      * Default value is {@link #DFLT_MEMORY_MODE}.
      *
      * @return Memory mode.
      */
-    public GridCacheMemoryMode getMemoryMode() {
+    public CacheMemoryMode getMemoryMode() {
         return memMode;
     }
 
@@ -1645,7 +1645,7 @@ public class CacheConfiguration extends MutableConfiguration {
      *
      * @param memMode Memory mode.
      */
-    public void setMemoryMode(GridCacheMemoryMode memMode) {
+    public void setMemoryMode(CacheMemoryMode memMode) {
         this.memMode = memMode;
     }
 
@@ -1683,8 +1683,8 @@ public class CacheConfiguration extends MutableConfiguration {
      * @return Cache interceptor.
      */
     @SuppressWarnings({"unchecked"})
-    @Nullable public <K, V> GridCacheInterceptor<K, V> getInterceptor() {
-        return (GridCacheInterceptor<K, V>)interceptor;
+    @Nullable public <K, V> CacheInterceptor<K, V> getInterceptor() {
+        return (CacheInterceptor<K, V>)interceptor;
     }
 
     /**
@@ -1692,7 +1692,7 @@ public class CacheConfiguration extends MutableConfiguration {
      *
      * @param interceptor Cache interceptor.
      */
-    public <K, V> void setInterceptor(GridCacheInterceptor<K, V> interceptor) {
+    public <K, V> void setInterceptor(CacheInterceptor<K, V> interceptor) {
         this.interceptor = interceptor;
     }
 
@@ -1757,7 +1757,7 @@ public class CacheConfiguration extends MutableConfiguration {
      *
      * @return Cache query configuration.
      */
-    public GridCacheQueryConfiguration getQueryConfiguration() {
+    public CacheQueryConfiguration getQueryConfiguration() {
         return qryCfg;
     }
 
@@ -1765,9 +1765,9 @@ public class CacheConfiguration extends MutableConfiguration {
      * Sets query configuration.
      *
      * @param qryCfg Query configuration.
-     * @see GridCacheQueryConfiguration
+     * @see org.apache.ignite.cache.query.CacheQueryConfiguration
      */
-    public void setQueryConfiguration(GridCacheQueryConfiguration qryCfg) {
+    public void setQueryConfiguration(CacheQueryConfiguration qryCfg) {
         this.qryCfg = qryCfg;
     }
 

http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/cafee25f/modules/core/src/main/java/org/apache/ignite/cache/CacheDistributionMode.java
----------------------------------------------------------------------
diff --git a/modules/core/src/main/java/org/apache/ignite/cache/CacheDistributionMode.java b/modules/core/src/main/java/org/apache/ignite/cache/CacheDistributionMode.java
new file mode 100644
index 0000000..3243845
--- /dev/null
+++ b/modules/core/src/main/java/org/apache/ignite/cache/CacheDistributionMode.java
@@ -0,0 +1,69 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.ignite.cache;
+
+import org.jetbrains.annotations.*;
+
+/**
+ * This enum defines mode in which partitioned cache operates.
+ * <p>
+ * Partitioned distribution mode can be configured via {@link CacheConfiguration#getDistributionMode()}
+ * configuration property.
+ */
+public enum CacheDistributionMode {
+    /**
+     * Mode in which local node does not cache any data and communicates with other cache nodes
+     * via remote calls.
+     */
+    CLIENT_ONLY,
+
+    /**
+     * Mode in which local node will not be either primary or backup node for any keys, but will cache
+     * recently accessed keys in a smaller near cache. Amount of recently accessed keys to cache is
+     * controlled by near eviction policy.
+     *
+     * @see CacheConfiguration#getNearEvictionPolicy()
+     */
+    NEAR_ONLY,
+
+    /**
+     * Mode in which local node may store primary and/or backup keys, and also will cache recently accessed keys.
+     * Amount of recently accessed keys to cache is controlled by near eviction policy.
+     * @see CacheConfiguration#getNearEvictionPolicy()
+     */
+    NEAR_PARTITIONED,
+
+    /**
+     * Mode in which local node may store primary or backup keys, but does not cache recently accessed keys
+     * in near cache.
+     */
+    PARTITIONED_ONLY;
+
+    /** Enumerated values. */
+    private static final CacheDistributionMode[] VALS = values();
+
+    /**
+     * Efficiently gets enumerated value from its ordinal.
+     *
+     * @param ord Ordinal value.
+     * @return Enumerated value or {@code null} if ordinal out of range.
+     */
+    @Nullable public static CacheDistributionMode fromOrdinal(int ord) {
+        return ord >= 0 && ord < VALS.length ? VALS[ord] : null;
+    }
+}

http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/cafee25f/modules/core/src/main/java/org/apache/ignite/cache/CacheEntry.java
----------------------------------------------------------------------
diff --git a/modules/core/src/main/java/org/apache/ignite/cache/CacheEntry.java b/modules/core/src/main/java/org/apache/ignite/cache/CacheEntry.java
new file mode 100644
index 0000000..08789f6
--- /dev/null
+++ b/modules/core/src/main/java/org/apache/ignite/cache/CacheEntry.java
@@ -0,0 +1,621 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.ignite.cache;
+
+import org.apache.ignite.*;
+import org.apache.ignite.lang.*;
+import org.apache.ignite.transactions.*;
+import org.jetbrains.annotations.*;
+
+import java.util.*;
+import java.util.Map.*;
+import java.util.concurrent.*;
+
+/**
+ * This interface provides a rich API for working with individual cache entries. It
+ * includes the following main functionality:
+ * <ul>
+ * <li>
+ *  Various {@code 'get(..)'} methods to synchronously or asynchronously get values from cache.
+ *  All {@code 'get(..)'} methods are transactional and will participate in an ongoing transaction
+ *  if there is one.
+ * </li>
+ * <li>
+ *  Various {@code 'set(..)'}, {@code 'setIfAbsent(..)'}, and {@code 'replace(..)'} methods to
+ *  synchronously or asynchronously put single or multiple entries into cache.
+ *  All these methods are transactional and will participate in an ongoing transaction
+ *  if there is one.
+ * </li>
+ * <li>
+ *  Various {@code 'remove(..)'} methods to synchronously or asynchronously remove single or multiple keys
+ *  from cache. All {@code 'remove(..)'} methods are transactional and will participate in an ongoing transaction
+ *  if there is one.
+ * </li>
+ * <li>
+ *  Various {@code 'invalidate(..)'} methods to set cached values to {@code null}.
+ * <li>
+ * <li>
+ *  Various {@code 'isLocked(..)'} methods to check on distributed locks on a single or multiple keys
+ *  in cache. All locking methods are not transactional and will not enlist keys into ongoing transaction,
+ *  if any.
+ * </li>
+ * <li>
+ *  Various {@code 'peek(..)'} methods to peek at values in global or transactional memory, swap
+ *  storage, or persistent storage.
+ * </li>
+ * <li>
+ *  Various {@code 'reload(..)'} methods to reload latest values from persistent storage.
+ * </li>
+ * <li>
+ *  Method {@link #evict()} to evict elements from cache, and optionally store
+ *  them in underlying swap storage for later access. All {@code 'evict(..)'} methods are not
+ *  transactional and will not enlist evicted keys into ongoing transaction, if any.
+ * </li>
+ * <li>
+ *  Methods for {@link #timeToLive(long)} to change or lookup entry's time to live.
+ * </ul>
+ * <h1 class="header">Extended Put And Remove Methods</h1>
+ * All methods that end with {@code 'x'} provide the same functionality as their sibling
+ * methods that don't end with {@code 'x'}, however instead of returning a previous value they
+ * return a {@code boolean} flag indicating whether operation succeeded or not. Returning
+ * a previous value may involve a network trip or a persistent store lookup and should be
+ * avoided whenever not needed.
+ * <h1 class="header">Predicate Filters</h1>
+ * All filters passed into methods on this API are checked <b>atomically</b>. In other words the value
+ * of cache entry is guaranteed not to change throughout the cache operation.
+ * <h1 class="header">Transactions</h1>
+ * Cache API supports distributed transactions. All {@code 'get(..)'}, {@code 'put(..)'}, {@code 'replace(..)'},
+ * and {@code 'remove(..)'} operations are transactional and will participate in an ongoing transaction.
+ * Other methods like {@code 'peek(..)'} may be transaction-aware, i.e. check in-transaction entries first, but
+ * will not affect the current state of transaction. See {@link IgniteTx} documentation for more information
+ * about transactions.
+ * @param <K> Key type.
+ * @param <V> Value type.
+ */
+public interface CacheEntry<K, V> extends Map.Entry<K, V>, Cache.Entry<K, V> {
+    /**
+     * Cache projection to which this entry belongs. Note that entry and its
+     * parent projections have same flags and filters.
+     *
+     * @return Cache projection for the cache to which this entry belongs.
+     */
+    public CacheProjection<K, V> projection();
+
+    /**
+     * This method has the same semantic as {@link CacheProjection#peek(Object)} method.
+     *
+     * @return See {@link CacheProjection#peek(Object)}.
+     */
+    @Nullable public V peek();
+
+    /**
+     * This method has the same semantic as
+     * {@link CacheProjection#peek(Object, Collection)} method.
+     *
+     * @param modes See {@link CacheProjection#peek(Object, Collection)}.
+     * @return See {@link CacheProjection#peek(Object, Collection)}.
+     * @throws IgniteCheckedException See {@link CacheProjection#peek(Object, Collection)}.
+     */
+    @Nullable public V peek(@Nullable Collection<GridCachePeekMode> modes) throws IgniteCheckedException;
+
+    /**
+     * This method has the same semantic as
+     * {@link CacheProjection#reload(Object)} method.
+     *
+     * @return See {@link CacheProjection#reload(Object)}.
+     * @throws IgniteCheckedException See {@link CacheProjection#reload(Object)}.
+     */
+    @Nullable public V reload() throws IgniteCheckedException;
+
+    /**
+     * This method has the same semantic as
+     * {@link CacheProjection#reloadAsync(Object)} method.
+     *
+     * @return See {@link CacheProjection#reloadAsync(Object)}.
+     */
+    public IgniteFuture<V> reloadAsync();
+
+    /**
+     * This method has the same semantic as
+     * {@link CacheProjection#isLocked(Object)} method.
+     *
+     * @return See {@link CacheProjection#isLocked(Object)}.
+     */
+    public boolean isLocked();
+
+    /**
+     * This method has the same semantic as
+     * {@link CacheProjection#isLockedByThread(Object)} method.
+     *
+     * @return See {@link CacheProjection#isLockedByThread(Object)}.
+     */
+    public boolean isLockedByThread();
+
+    /**
+     * Gets current version of this cache entry.
+     *
+     * @return Version of this cache entry.
+     */
+    public Object version();
+
+    /**
+     * Gets expiration time for this entry.
+     *
+     * @return Absolute time when this value expires.
+     */
+    public long expirationTime();
+
+    /**
+     * Gets time to live, i.e. maximum life time, of this entry in milliseconds.
+     *
+     * @return Time to live value for this entry.
+     */
+    public long timeToLive();
+
+    /**
+     * Sets time to live, i.e. maximum life time, of this entry in milliseconds.
+     * Note that this method is transactional - if entry is enlisted into a transaction,
+     * then time-to-live will not be set until transaction commit.
+     * <p>
+     * When called outside the transaction, this method will have no effect until the
+     * next update operation.
+     *
+     * @param ttl Time to live value for this entry.
+     */
+    public void timeToLive(long ttl);
+
+    /**
+     * Gets the flag indicating current node's primary ownership for this entry.
+     * <p>
+     * Note, that this value is dynamic and may change with grid topology changes.
+     *
+     * @return {@code True} if current grid node is the primary owner for this entry.
+     */
+    public boolean primary();
+
+    /**
+     * Gets the flag indicating if current node is backup for this entry.
+     * <p>
+     * Note, that this value is dynamic and may change with grid topology changes.
+     *
+     * @return {@code True} if current grid node is the backup for this entry.
+     */
+    public boolean backup();
+
+    /**
+     * Gets affinity partition id for this entry.
+     *
+     * @return Partition id.
+     */
+    public int partition();
+
+    /**
+     * This method has the same semantic as {@link #get()} method, however it
+     * wraps {@link IgniteCheckedException} into {@link IgniteException} if failed in order to
+     * comply with {@link Entry} interface.
+     *
+     * @return See {@link #get()}
+     */
+    @Nullable @Override public V getValue();
+
+    /**
+     * This method has the same semantic as
+     * {@link CacheProjection#get(Object)} method.
+     *
+     * @return See {@link CacheProjection#get(Object)}.
+     * @throws IgniteCheckedException See {@link CacheProjection#get(Object)}.
+     */
+    @Nullable public V get() throws IgniteCheckedException;
+
+    /**
+     * This method has the same semantic as
+     * {@link CacheProjection#getAsync(Object)} method.
+     *
+     * @return See {@link CacheProjection#getAsync(Object)}.
+     */
+    public IgniteFuture<V> getAsync();
+
+    /**
+     * This method has the same semantic as {@link #set(Object, org.apache.ignite.lang.IgnitePredicate[])} method, however it
+     * wraps {@link IgniteCheckedException} into {@link IgniteException} if failed in order to
+     * comply with {@link Entry} interface.
+     *
+     * @return See {@link #set(Object, org.apache.ignite.lang.IgnitePredicate[])}
+     */
+    @Nullable @Override public V setValue(V val);
+
+    /**
+     * This method has the same semantic as
+     * {@link CacheProjection#put(Object, Object, org.apache.ignite.lang.IgnitePredicate[])} method.
+     *
+     * @param val See {@link CacheProjection#put(Object, Object, org.apache.ignite.lang.IgnitePredicate[])}
+     * @param filter See {@link CacheProjection#put(Object, Object, org.apache.ignite.lang.IgnitePredicate[])}.
+     * @return See {@link CacheProjection#put(Object, Object, org.apache.ignite.lang.IgnitePredicate[])}.
+     * @throws IgniteCheckedException See {@link CacheProjection#put(Object, Object, org.apache.ignite.lang.IgnitePredicate[])}.
+     */
+    @Nullable public V set(V val, @Nullable IgnitePredicate<CacheEntry<K, V>>... filter) throws IgniteCheckedException;
+
+    /**
+     * This method has the same semantic as
+     * {@link CacheProjection#putAsync(Object, Object, org.apache.ignite.lang.IgnitePredicate[])} method.
+     *
+     * @param val See {@link CacheProjection#putAsync(Object, Object, org.apache.ignite.lang.IgnitePredicate[])}
+     * @param filter See {@link CacheProjection#putAsync(Object, Object, org.apache.ignite.lang.IgnitePredicate[])}.
+     * @return See {@link CacheProjection#putAsync(Object, Object, org.apache.ignite.lang.IgnitePredicate[])}.
+     */
+    public IgniteFuture<V> setAsync(V val, @Nullable IgnitePredicate<CacheEntry<K, V>>... filter);
+
+    /**
+     * This method has the same semantic as
+     * {@link CacheProjection#putIfAbsent(Object, Object)} method.
+     *
+     * @param val See {@link CacheProjection#putIfAbsent(Object, Object)}
+     * @return See {@link CacheProjection#putIfAbsent(Object, Object)}.
+     * @throws IgniteCheckedException See {@link CacheProjection#putIfAbsent(Object, Object)}.
+     */
+    @Nullable public V setIfAbsent(V val) throws IgniteCheckedException;
+
+    /**
+     * This method has the same semantic as
+     * {@link CacheProjection#putIfAbsentAsync(Object, Object)} method.
+     *
+     * @param val See {@link CacheProjection#putIfAbsentAsync(Object, Object)}
+     * @return See {@link CacheProjection#putIfAbsentAsync(Object, Object)}.
+     */
+    public IgniteFuture<V> setIfAbsentAsync(V val);
+
+    /**
+     * This method has the same semantic as
+     * {@link CacheProjection#putx(Object, Object, org.apache.ignite.lang.IgnitePredicate[])} method.
+     *
+     * @param val See {@link CacheProjection#putx(Object, Object, org.apache.ignite.lang.IgnitePredicate[])}
+     * @param filter See {@link CacheProjection#putx(Object, Object, org.apache.ignite.lang.IgnitePredicate[])}.
+     * @return See {@link CacheProjection#putx(Object, Object, org.apache.ignite.lang.IgnitePredicate[])}.
+     * @throws IgniteCheckedException See {@link CacheProjection#putx(Object, Object, org.apache.ignite.lang.IgnitePredicate[])}.
+     */
+    public boolean setx(V val, @Nullable IgnitePredicate<CacheEntry<K, V>>... filter)
+        throws IgniteCheckedException;
+
+    /**
+     * This method has the same semantic as
+     * {@link CacheProjection#putxAsync(Object, Object, org.apache.ignite.lang.IgnitePredicate[])} method.
+     *
+     * @param val See {@link CacheProjection#putxAsync(Object, Object, org.apache.ignite.lang.IgnitePredicate[])}
+     * @param filter See {@link CacheProjection#putxAsync(Object, Object, org.apache.ignite.lang.IgnitePredicate[])}.
+     * @return See {@link CacheProjection#putxAsync(Object, Object, org.apache.ignite.lang.IgnitePredicate[])}.
+     */
+    public IgniteFuture<Boolean> setxAsync(V val,
+        @Nullable IgnitePredicate<CacheEntry<K, V>>... filter);
+
+    /**
+     * This method has the same semantic as
+     * {@link CacheProjection#putxIfAbsent(Object, Object)} method.
+     *
+     * @param val See {@link CacheProjection#putxIfAbsent(Object, Object)}
+     * @return See {@link CacheProjection#putxIfAbsent(Object, Object)}.
+     * @throws IgniteCheckedException See {@link CacheProjection#putxIfAbsent(Object, Object)}.
+     */
+    public boolean setxIfAbsent(@Nullable V val) throws IgniteCheckedException;
+
+    /**
+     * This method has the same semantic as
+     * {@link CacheProjection#putxIfAbsentAsync(Object, Object)} method.
+     *
+     * @param val See {@link CacheProjection#putxIfAbsentAsync(Object, Object)}
+     * @return See {@link CacheProjection#putxIfAbsentAsync(Object, Object)}.
+     */
+    public IgniteFuture<Boolean> setxIfAbsentAsync(V val);
+
+    /**
+     * This method has the same semantic as
+     * {@link CacheProjection#replace(Object, Object)} method.
+     *
+     * @param val See {@link CacheProjection#replace(Object, Object)}
+     * @return See {@link CacheProjection#replace(Object, Object)}.
+     * @throws IgniteCheckedException See {@link CacheProjection#replace(Object, Object)}.
+     */
+    @Nullable public V replace(V val) throws IgniteCheckedException;
+
+    /**
+     * This method has the same semantic as
+     * {@link CacheProjection#replaceAsync(Object, Object)} method.
+     *
+     * @param val See {@link CacheProjection#replaceAsync(Object, Object)}
+     * @return See {@link CacheProjection#replaceAsync(Object, Object)}.
+     */
+    public IgniteFuture<V> replaceAsync(V val);
+
+    /**
+     * This method has the same semantic as
+     * {@link CacheProjection#replacex(Object, Object)} method.
+     *
+     * @param val See {@link CacheProjection#replacex(Object, Object)}
+     * @return See {@link CacheProjection#replacex(Object, Object)}.
+     * @throws IgniteCheckedException See {@link CacheProjection#replacex(Object, Object)}.
+     */
+    public boolean replacex(V val) throws IgniteCheckedException;
+
+    /**
+     * This method has the same semantic as
+     * {@link CacheProjection#replacexAsync(Object, Object)} method.
+     *
+     * @param val See {@link CacheProjection#replacexAsync(Object, Object)}
+     * @return See {@link CacheProjection#replacexAsync(Object, Object)}.
+     */
+    public IgniteFuture<Boolean> replacexAsync(V val);
+
+    /**
+     * This method has the same semantic as
+     * {@link CacheProjection#replace(Object, Object, Object)} method.
+     *
+     * @param oldVal See {@link CacheProjection#replace(Object, Object, Object)}
+     * @param newVal See {@link CacheProjection#replace(Object, Object, Object)}
+     * @return See {@link CacheProjection#replace(Object, Object)}.
+     * @throws IgniteCheckedException See {@link CacheProjection#replace(Object, Object)}.
+     */
+    public boolean replace(V oldVal, V newVal) throws IgniteCheckedException;
+
+    /**
+     * This method has the same semantic as
+     * {@link CacheProjection#replaceAsync(Object, Object, Object)} method.
+     *
+     * @param oldVal See {@link CacheProjection#replaceAsync(Object, Object, Object)}
+     * @param newVal See {@link CacheProjection#replaceAsync(Object, Object, Object)}
+     * @return See {@link CacheProjection#replaceAsync(Object, Object)}.
+     */
+    public IgniteFuture<Boolean> replaceAsync(V oldVal, V newVal);
+
+    /**
+     * This method has the same semantic as
+     * {@link CacheProjection#remove(Object, org.apache.ignite.lang.IgnitePredicate[])} method.
+     *
+     * @param filter See {@link CacheProjection#remove(Object, org.apache.ignite.lang.IgnitePredicate[])}.
+     * @return See {@link CacheProjection#remove(Object, org.apache.ignite.lang.IgnitePredicate[])}.
+     * @throws IgniteCheckedException See {@link CacheProjection#remove(Object, org.apache.ignite.lang.IgnitePredicate[])}.
+     */
+    @Nullable public V remove(@Nullable IgnitePredicate<CacheEntry<K, V>>... filter) throws IgniteCheckedException;
+
+    /**
+     * This method has the same semantic as
+     * {@link CacheProjection#removeAsync(Object, org.apache.ignite.lang.IgnitePredicate[])} method.
+     *
+     * @param filter See {@link CacheProjection#removeAsync(Object, org.apache.ignite.lang.IgnitePredicate[])}.
+     * @return See {@link CacheProjection#removeAsync(Object, org.apache.ignite.lang.IgnitePredicate[])}.
+     */
+    public IgniteFuture<V> removeAsync(@Nullable IgnitePredicate<CacheEntry<K, V>>... filter);
+
+    /**
+     * This method has the same semantic as
+     * {@link CacheProjection#removex(Object, org.apache.ignite.lang.IgnitePredicate[])} method.
+     *
+     * @param filter See {@link CacheProjection#removex(Object, org.apache.ignite.lang.IgnitePredicate[])}.
+     * @return See {@link CacheProjection#removex(Object, org.apache.ignite.lang.IgnitePredicate[])}.
+     * @throws IgniteCheckedException See {@link CacheProjection#removex(Object, org.apache.ignite.lang.IgnitePredicate[])}.
+     */
+    public boolean removex(@Nullable IgnitePredicate<CacheEntry<K, V>>... filter) throws IgniteCheckedException;
+
+    /**
+     * This method has the same semantic as
+     * {@link CacheProjection#removexAsync(Object, org.apache.ignite.lang.IgnitePredicate[])} method.
+     *
+     * @param filter See {@link CacheProjection#removexAsync(Object, org.apache.ignite.lang.IgnitePredicate[])}.
+     * @return See {@link CacheProjection#removexAsync(Object, org.apache.ignite.lang.IgnitePredicate[])}.
+     */
+    public IgniteFuture<Boolean> removexAsync(@Nullable IgnitePredicate<CacheEntry<K, V>>... filter);
+
+    /**
+     * This method has the same semantic as
+     * {@link CacheProjection#remove(Object, Object)} method.
+     *
+     * @param val See {@link CacheProjection#remove(Object, Object)}.
+     * @return See {@link CacheProjection#remove(Object, Object)}.
+     * @throws IgniteCheckedException See {@link CacheProjection#remove(Object, Object)}.
+     */
+    public boolean remove(V val) throws IgniteCheckedException;
+
+    /**
+     * This method has the same semantic as
+     * {@link CacheProjection#removeAsync(Object, Object)} method.
+     *
+     * @param val See {@link CacheProjection#removeAsync(Object, Object)}.
+     * @return See {@link CacheProjection#removeAsync(Object, Object)}.
+     */
+    public IgniteFuture<Boolean> removeAsync(V val);
+
+    /**
+     * This method has the same semantic as
+     * {@link CacheProjection#evict(Object)} method.
+     *
+     * @return See {@link CacheProjection#evict(Object)}.
+     */
+    public boolean evict();
+
+    /**
+     * This method has the same semantic as
+     * {@link CacheProjection#clear(Object)} method.
+     *
+     * @return See {@link CacheProjection#clear(Object)}.
+     */
+    public boolean clear();
+
+    /**
+     * Optimizes the size of this entry. If entry is expired at the time
+     * of the call then entry is removed locally.
+     *
+     * @throws IgniteCheckedException If failed to compact.
+     * @return {@code true} if entry was cleared from cache (if value was {@code null}).
+     */
+    public boolean compact() throws IgniteCheckedException;
+
+    /**
+     * Synchronously acquires lock on a cached object associated with this entry
+     * only if the passed in filter (if any) passes. This method together with
+     * filter check will be executed as one atomic operation.
+     * <h2 class="header">Transactions</h2>
+     * Locks are not transactional and should not be used from within transactions.
+     * If you do need explicit locking within transaction, then you should use
+     * {@link IgniteTxConcurrency#PESSIMISTIC} concurrency control for transaction
+     * which will acquire explicit locks for relevant cache operations.
+     * <h2 class="header">Cache Flags</h2>
+     * This method is not available if any of the following flags are set on projection:
+     * {@link CacheFlag#LOCAL}, {@link CacheFlag#READ}.
+     *
+     * @param timeout Timeout in milliseconds to wait for lock to be acquired
+     *      ({@code '0'} for no expiration).
+     * @param filter Optional filter to validate prior to acquiring the lock.
+     * @return {@code True} if all filters passed and lock was acquired,
+     *      {@code false} otherwise.
+     * @throws IgniteCheckedException If lock acquisition resulted in error.
+     * @throws CacheFlagException If flags validation failed.
+     */
+    public boolean lock(long timeout, @Nullable IgnitePredicate<CacheEntry<K, V>>... filter)
+        throws IgniteCheckedException;
+
+    /**
+     * Asynchronously acquires lock on a cached object associated with this entry
+     * only if the passed in filter (if any) passes. This method together with
+     * filter check will be executed as one atomic operation.
+     * <h2 class="header">Transactions</h2>
+     * Locks are not transactional and should not be used from within transactions. If you do
+     * need explicit locking within transaction, then you should use
+     * {@link IgniteTxConcurrency#PESSIMISTIC} concurrency control for transaction
+     * which will acquire explicit locks for relevant cache operations.
+     * <h2 class="header">Cache Flags</h2>
+     * This method is not available if any of the following flags are set on projection:
+     * {@link CacheFlag#LOCAL}, {@link CacheFlag#READ}.
+     *
+     * @param timeout Timeout in milliseconds to wait for lock to be acquired
+     *      ({@code '0'} for no expiration).
+     * @param filter Optional filter to validate prior to acquiring the lock.
+     * @return Future for the lock operation. The future will return {@code true}
+     *      whenever all filters pass and locks are acquired before timeout is expired,
+     *      {@code false} otherwise.
+     * @throws CacheFlagException If flags validation failed.
+     */
+    public IgniteFuture<Boolean> lockAsync(long timeout,
+        @Nullable IgnitePredicate<CacheEntry<K, V>>... filter);
+
+    /**
+     * Unlocks this entry only if current thread owns the lock. If optional filter
+     * will not pass, then unlock will not happen. If this entry was never locked by
+     * current thread, then this method will do nothing.
+     * <h2 class="header">Transactions</h2>
+     * Locks are not transactional and should not be used from within transactions. If you do
+     * need explicit locking within transaction, then you should use
+     * {@link IgniteTxConcurrency#PESSIMISTIC} concurrency control for transaction
+     * which will acquire explicit locks for relevant cache operations.
+     * <h2 class="header">Cache Flags</h2>
+     * This method is not available if any of the following flags are set on projection:
+     * {@link CacheFlag#LOCAL}, {@link CacheFlag#READ}.
+     *
+     * @param filter Optional filter that needs to pass prior to unlock taking effect.
+     * @throws IgniteCheckedException If unlock execution resulted in error.
+     * @throws CacheFlagException If flags validation failed.
+     */
+    public void unlock(IgnitePredicate<CacheEntry<K, V>>... filter) throws IgniteCheckedException;
+
+    /**
+     * Checks whether entry is currently present in cache or not. If entry is not in
+     * cache (e.g. has been removed) {@code false} is returned. In this case all
+     * operations on this entry will cause creation of a new entry in cache.
+     *
+     * @return {@code True} if entry is in cache, {@code false} otherwise.
+     */
+    public boolean isCached();
+
+    /**
+     * Gets size of serialized key and value in addition to any overhead added by {@code GridGain} itself.
+     *
+     * @return size in bytes.
+     * @throws IgniteCheckedException If failed to evaluate entry size.
+     */
+    public int memorySize() throws IgniteCheckedException;
+
+    /**
+     * Removes metadata by name.
+     *
+     * @param name Name of the metadata to remove.
+     * @param <V> Type of the value.
+     * @return Value of removed metadata or {@code null}.
+     */
+    public <V> V removeMeta(String name);
+
+    /**
+     * Removes metadata only if its current value is equal to {@code val} passed in.
+     *
+     * @param name Name of metadata attribute.
+     * @param val Value to compare.
+     * @param <V> Value type.
+     * @return {@code True} if value was removed, {@code false} otherwise.
+     */
+    public <V> boolean removeMeta(String name, V val);
+
+    /**
+     * Gets metadata by name.
+     *
+     * @param name Metadata name.
+     * @param <V> Type of the value.
+     * @return Metadata value or {@code null}.
+     */
+    public <V> V meta(String name);
+
+    /**
+     * Adds given metadata value only if it was absent.
+     *
+     * @param name Metadata name.
+     * @param c Factory closure to produce value to add if it's not attached already.
+     *      Not that unlike {@link #addMeta(String, Object)} method the factory closure will
+     *      not be called unless the value is required and therefore value will only be created
+     *      when it is actually needed.
+     * @param <V> Type of the value.
+     * @return {@code null} if new value was put, or current value if put didn't happen.
+     */
+    @Nullable public <V> V putMetaIfAbsent(String name, Callable<V> c);
+
+    /**
+     * Adds given metadata value only if it was absent.
+     *
+     * @param name Metadata name.
+     * @param val Value to add if it's not attached already.
+     * @param <V> Type of the value.
+     * @return {@code null} if new value was put, or current value if put didn't happen.
+     */
+    @Nullable public <V> V putMetaIfAbsent(String name, V val);
+
+    /**
+     * Adds a new metadata.
+     *
+     * @param name Metadata name.
+     * @param val Metadata value.
+     * @param <V> Type of the value.
+     * @return Metadata previously associated with given name, or
+     *      {@code null} if there was none.
+     */
+    @Nullable public <V> V addMeta(String name, V val);
+
+    /**
+     * Replaces given metadata with new {@code newVal} value only if its current value
+     * is equal to {@code curVal}. Otherwise, it is no-op.
+     *
+     * @param name Name of the metadata.
+     * @param curVal Current value to check.
+     * @param newVal New value.
+     * @return {@code true} if replacement occurred, {@code false} otherwise.
+     */
+    public <V> boolean replaceMeta(String name, V curVal, V newVal);
+}

http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/cafee25f/modules/core/src/main/java/org/apache/ignite/cache/CacheEntryEvent.java
----------------------------------------------------------------------
diff --git a/modules/core/src/main/java/org/apache/ignite/cache/CacheEntryEvent.java b/modules/core/src/main/java/org/apache/ignite/cache/CacheEntryEvent.java
index b2ca482..1db81af 100644
--- a/modules/core/src/main/java/org/apache/ignite/cache/CacheEntryEvent.java
+++ b/modules/core/src/main/java/org/apache/ignite/cache/CacheEntryEvent.java
@@ -27,14 +27,14 @@ import javax.cache.event.*;
  */
 public class CacheEntryEvent<K, V> extends javax.cache.event.CacheEntryEvent<K, V> {
     /** */
-    private final GridCacheContinuousQueryEntry<K, V> e;
+    private final CacheContinuousQueryEntry<K, V> e;
 
     /**
      * @param src Cache.
      * @param type Event type.
      * @param e Ignite event.
      */
-    public CacheEntryEvent(IgniteCache src, EventType type, GridCacheContinuousQueryEntry<K, V> e) {
+    public CacheEntryEvent(IgniteCache src, EventType type, CacheContinuousQueryEntry<K, V> e) {
         super(src, type);
 
         this.e = e;


Mime
View raw message