ignite-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From sboi...@apache.org
Subject [12/56] [abbrv] incubator-ignite git commit: ignite-42
Date Thu, 22 Jan 2015 15:15:36 GMT
http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/b0d8a67a/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 1d4fdb4..cc51e9b 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
@@ -17,15 +17,1705 @@
 
 package org.apache.ignite.cache;
 
+import org.apache.ignite.Ignite;
+import org.apache.ignite.cache.store.*;
+import org.apache.ignite.configuration.IgniteConfiguration;
+import org.apache.ignite.portables.PortableObject;
+import org.apache.ignite.spi.indexing.*;
+import org.gridgain.grid.cache.*;
+import org.gridgain.grid.cache.affinity.*;
+import org.gridgain.grid.cache.affinity.consistenthash.*;
+import org.gridgain.grid.cache.cloner.*;
+import org.gridgain.grid.cache.datastructures.*;
+import org.gridgain.grid.cache.eviction.*;
+import org.gridgain.grid.cache.query.*;
+import org.gridgain.grid.util.typedef.internal.*;
+import org.jetbrains.annotations.*;
+
 import javax.cache.configuration.*;
+import java.util.*;
 
 /**
- * TODO: Add class description.
- *
- * @author @java.author
- * @version @java.version
+ * This class defines grid cache configuration. This configuration is passed to
+ * grid via {@link IgniteConfiguration#getCacheConfiguration()} method. It defines all configuration
+ * parameters required to start a cache within grid instance. You can have multiple caches
+ * configured with different names within one grid.
+ * <p>
+ * Cache configuration is set on {@link
+ * IgniteConfiguration#setCacheConfiguration(CacheConfiguration...)} method. This adapter is a simple bean and
+ * can be configured from Spring XML files (or other DI frameworks). <p> Note that absolutely all configuration
+ * properties are optional, so users should only change what they need.
  */
-// TODO: remove 'abstract'
-public abstract class CacheConfiguration<K, V> implements Configuration<K, V> {
+@SuppressWarnings("RedundantFieldInitialization")
+public class CacheConfiguration extends MutableConfiguration {
+    /** Default atomic sequence reservation size. */
+    public static final int DFLT_ATOMIC_SEQUENCE_RESERVE_SIZE = 1000;
+
+    /** Default size of preload thread pool. */
+    public static final int DFLT_PRELOAD_THREAD_POOL_SIZE = 2;
+
+    /** Default preload timeout (ms).*/
+    public static final long DFLT_PRELOAD_TIMEOUT = 10000;
+
+    /** Time in milliseconds to wait between preload messages to avoid overloading CPU. */
+    public static final long DFLT_PRELOAD_THROTTLE = 0;
+
+    /**
+     * Default time to live. The value is <tt>0</tt> which means that
+     * cached objects never expire based on time.
+     */
+    public static final long DFLT_TIME_TO_LIVE = 0;
+
+    /** Default number of backups. */
+    public static final int DFLT_BACKUPS = 0;
+
+    /** Default caching mode. */
+    public static final GridCacheMode DFLT_CACHE_MODE = GridCacheMode.REPLICATED;
+
+    /** Default atomicity mode. */
+    public static final GridCacheAtomicityMode DFLT_CACHE_ATOMICITY_MODE = GridCacheAtomicityMode.ATOMIC;
+
+    /** Default value for cache distribution mode. */
+    public static final GridCacheDistributionMode DFLT_DISTRIBUTION_MODE = GridCacheDistributionMode.PARTITIONED_ONLY;
+
+    /** Default query timeout. */
+    public static final long DFLT_QUERY_TIMEOUT = 0;
+
+    /** Default lock timeout. */
+    public static final long DFLT_LOCK_TIMEOUT = 0;
+
+    /** Initial default cache size. */
+    public static final int DFLT_START_SIZE = 1500000;
+
+    /** Default cache size to use with eviction policy. */
+    public static final int DFLT_CACHE_SIZE = 100000;
+
+    /** Initial default near cache size. */
+    public static final int DFLT_NEAR_START_SIZE = DFLT_START_SIZE / 4;
+
+    /** Default value for 'invalidate' flag that indicates if this is invalidation-based cache. */
+    public static final boolean DFLT_INVALIDATE = false;
+
+    /** Default value for 'storeValueBytes' flag indicating if value bytes should be stored. */
+    public static final boolean DFLT_STORE_VALUE_BYTES = true;
+
+    /** Default preload mode for distributed cache. */
+    public static final GridCachePreloadMode DFLT_PRELOAD_MODE = GridCachePreloadMode.ASYNC;
+
+    /** Default preload batch size in bytes. */
+    public static final int DFLT_PRELOAD_BATCH_SIZE = 512 * 1024; // 512K
+
+    /** Default maximum eviction queue ratio. */
+    public static final float DFLT_MAX_EVICTION_OVERFLOW_RATIO = 10;
+
+    /** Default eviction synchronized flag. */
+    public static final boolean DFLT_EVICT_SYNCHRONIZED = false;
+
+    /** Default near nodes eviction synchronized flag. */
+    public static final boolean DFLT_EVICT_NEAR_SYNCHRONIZED = true;
+
+    /** Default eviction key buffer size for batching synchronized evicts. */
+    public static final int DFLT_EVICT_KEY_BUFFER_SIZE = 1024;
+
+    /** Default synchronous eviction timeout in milliseconds. */
+    public static final long DFLT_EVICT_SYNCHRONIZED_TIMEOUT = 10000;
+
+    /** Default synchronous eviction concurrency level. */
+    public static final int DFLT_EVICT_SYNCHRONIZED_CONCURRENCY_LEVEL = 4;
+
+    /** Default value for eager ttl flag. */
+    public static final boolean DFLT_EAGER_TTL = true;
+
+    /** Default off-heap storage size is {@code -1} which means that off-heap storage is disabled. */
+    public static final long DFLT_OFFHEAP_MEMORY = -1;
+
+    /** Default value for 'swapEnabled' flag. */
+    public static final boolean DFLT_SWAP_ENABLED = false;
+
+    /** Default value for 'maxConcurrentAsyncOps'. */
+    public static final int DFLT_MAX_CONCURRENT_ASYNC_OPS = 500;
+
+    /** Default value for 'queryIndexEnabled' flag. */
+    public static final boolean DFLT_QUERY_INDEX_ENABLED = false;
+
+    /** Default value for 'writeBehindEnabled' flag. */
+    public static final boolean DFLT_WRITE_BEHIND_ENABLED = false;
+
+    /** Default flush size for write-behind cache store. */
+    public static final int DFLT_WRITE_BEHIND_FLUSH_SIZE = 10240; // 10K
+
+    /** Default critical size used when flush size is not specified. */
+    public static final int DFLT_WRITE_BEHIND_CRITICAL_SIZE = 16384; // 16K
+
+    /** Default flush frequency for write-behind cache store in milliseconds. */
+    public static final long DFLT_WRITE_BEHIND_FLUSH_FREQUENCY = 5000;
+
+    /** Default count of flush threads for write-behind cache store. */
+    public static final int DFLT_WRITE_FROM_BEHIND_FLUSH_THREAD_CNT = 1;
+
+    /** Default batch size for write-behind cache store. */
+    public static final int DFLT_WRITE_BEHIND_BATCH_SIZE = 512;
+
+    /** Default maximum number of query iterators that can be stored. */
+    public static final int DFLT_MAX_QUERY_ITERATOR_CNT = 1024;
+
+    /** Default continuous query buffers queue size. */
+    @SuppressWarnings("UnusedDeclaration")
+    @Deprecated
+    public static final int DFLT_CONT_QUERY_QUEUE_SIZE = 1024 * 1024;
+
+    /** Default memory mode. */
+    public static final GridCacheMemoryMode DFLT_MEMORY_MODE = GridCacheMemoryMode.ONHEAP_TIERED;
+
+    /** Default continuous query max buffer size. */
+    @SuppressWarnings("UnusedDeclaration")
+    @Deprecated
+    public static final int DFLT_CONT_QUERY_MAX_BUF_SIZE = 1024;
+
+    /** Cache name. */
+    private String name;
+
+    /** Default batch size for all cache's sequences. */
+    private int seqReserveSize = DFLT_ATOMIC_SEQUENCE_RESERVE_SIZE;
+
+    /** Preload thread pool size. */
+    private int preloadPoolSize = DFLT_PRELOAD_THREAD_POOL_SIZE;
+
+    /** Preload timeout. */
+    private long preloadTimeout = DFLT_PRELOAD_TIMEOUT;
+
+    /** Default time to live for cache entries. */
+    private long ttl = DFLT_TIME_TO_LIVE;
+
+    /** Cache expiration policy. */
+    private GridCacheEvictionPolicy evictPlc;
+
+    /** Near cache eviction policy. */
+    private GridCacheEvictionPolicy nearEvictPlc;
+
+    /** Flag indicating whether eviction is synchronized. */
+    private boolean evictSync = DFLT_EVICT_SYNCHRONIZED;
+
+    /** Flag indicating whether eviction is synchronized with near nodes. */
+    private boolean evictNearSync = DFLT_EVICT_NEAR_SYNCHRONIZED;
+
+    /** Eviction key buffer size. */
+    private int evictKeyBufSize = DFLT_EVICT_KEY_BUFFER_SIZE;
+
+    /** Synchronous eviction timeout. */
+    private int evictSyncConcurrencyLvl = DFLT_EVICT_SYNCHRONIZED_CONCURRENCY_LEVEL;
+
+    /** Synchronous eviction timeout. */
+    private long evictSyncTimeout = DFLT_EVICT_SYNCHRONIZED_TIMEOUT;
+
+    /** Eviction filter. */
+    private GridCacheEvictionFilter<?, ?> evictFilter;
+
+    /** Maximum eviction overflow ratio. */
+    private float evictMaxOverflowRatio = DFLT_MAX_EVICTION_OVERFLOW_RATIO;
+
+    /** Eager ttl flag. */
+    private boolean eagerTtl = DFLT_EAGER_TTL;
+
+    /** Default lock timeout. */
+    private long dfltLockTimeout = DFLT_LOCK_TIMEOUT;
+
+    /** Default query timeout. */
+    private long dfltQryTimeout = DFLT_QUERY_TIMEOUT;
+
+    /** Default cache start size. */
+    private int startSize = DFLT_START_SIZE;
+
+    /** Default near cache start size. */
+    private int nearStartSize = DFLT_NEAR_START_SIZE;
+
+    /** Cache distribution mode. */
+    private GridCacheDistributionMode distro = DFLT_DISTRIBUTION_MODE;
+
+    /** Write synchronization mode. */
+    private GridCacheWriteSynchronizationMode writeSync;
+
+    /** */
+    private CacheStore<?, ?> store;
+
+    /** Node group resolver. */
+    private GridCacheAffinityFunction aff;
+
+    /** Cache mode. */
+    private GridCacheMode cacheMode = DFLT_CACHE_MODE;
+
+    /** Cache atomicity mode. */
+    private GridCacheAtomicityMode atomicityMode;
+
+    /** Write ordering mode. */
+    private GridCacheAtomicWriteOrderMode atomicWriteOrderMode;
+
+    /** Number of backups for cache. */
+    private int backups = DFLT_BACKUPS;
+
+    /** Flag indicating whether this is invalidation-based cache. */
+    private boolean invalidate = DFLT_INVALIDATE;
+
+    /** Flag indicating if cached values should be additionally stored in serialized form. */
+    private boolean storeValBytes = DFLT_STORE_VALUE_BYTES;
+
+    /** Name of class implementing GridCacheTmLookup. */
+    private String tmLookupClsName;
+
+    /** Distributed cache preload mode. */
+    private GridCachePreloadMode preloadMode = DFLT_PRELOAD_MODE;
+
+    /** Cache preload order. */
+    private int preloadOrder;
+
+    /** Preload batch size. */
+    private int preloadBatchSize = DFLT_PRELOAD_BATCH_SIZE;
+
+    /** Off-heap memory size. */
+    private long offHeapMaxMem = DFLT_OFFHEAP_MEMORY;
+
+    /** */
+    private boolean swapEnabled = DFLT_SWAP_ENABLED;
+
+    /** Maximum number of concurrent asynchronous operations. */
+    private int maxConcurrentAsyncOps = DFLT_MAX_CONCURRENT_ASYNC_OPS;
+
+    /** */
+    private boolean qryIdxEnabled = DFLT_QUERY_INDEX_ENABLED;
+
+    /** Write-behind feature. */
+    private boolean writeBehindEnabled = DFLT_WRITE_BEHIND_ENABLED;
+
+    /** Maximum size of write-behind cache. */
+    private int writeBehindFlushSize = DFLT_WRITE_BEHIND_FLUSH_SIZE;
+
+    /** Write-behind flush frequency in milliseconds. */
+    private long writeBehindFlushFreq = DFLT_WRITE_BEHIND_FLUSH_FREQUENCY;
+
+    /** Flush thread count for write-behind cache store. */
+    private int writeBehindFlushThreadCnt = DFLT_WRITE_FROM_BEHIND_FLUSH_THREAD_CNT;
+
+    /** Maximum batch size for write-behind cache store. */
+    private int writeBehindBatchSize = DFLT_WRITE_BEHIND_BATCH_SIZE;
+
+    /** Maximum number of query iterators that can be stored. */
+    private int maxQryIterCnt = DFLT_MAX_QUERY_ITERATOR_CNT;
+
+    /** Memory mode. */
+    private GridCacheMemoryMode memMode = DFLT_MEMORY_MODE;
+
+    /** */
+    private GridCacheCloner cloner;
+
+    /** */
+    private GridCacheAffinityKeyMapper affMapper;
+
+    /** */
+    private String indexingSpiName;
+
+    /** */
+    private long preloadDelay;
+
+    /** */
+    private long preloadThrottle = DFLT_PRELOAD_THROTTLE;
+
+    /** */
+    private GridCacheInterceptor<?, ?> interceptor;
+
+    /** */
+    private boolean portableEnabled;
+
+    /** */
+    private boolean keepPortableInStore = true;
+
+    /** Query configuration. */
+    private GridCacheQueryConfiguration qryCfg;
+
+    /** Empty constructor (all values are initialized to their defaults). */
+    public CacheConfiguration() {
+        /* No-op. */
+    }
+
+    /**
+     * Copy constructor.
+     *
+     * @param cfg Configuration to copy.
+     */
+    public CacheConfiguration(CompleteConfiguration cfg) {
+        super(cfg);
+
+        if (!(cfg instanceof CacheConfiguration))
+            return;
+
+        CacheConfiguration cc = (CacheConfiguration)cfg;
+
+        /*
+         * NOTE: MAKE SURE TO PRESERVE ALPHABETIC ORDER!
+         * ==============================================
+         */
+        aff = cc.getAffinity();
+        affMapper = cc.getAffinityMapper();
+        atomicityMode = cc.getAtomicityMode();
+        atomicWriteOrderMode = cc.getAtomicWriteOrderMode();
+        backups = cc.getBackups();
+        cacheLoaderFactory = cc.getCacheLoaderFactory();
+        cacheMode = cc.getCacheMode();
+        cacheWriterFactory = cc.getCacheWriterFactory();
+        cloner = cc.getCloner();
+        dfltLockTimeout = cc.getDefaultLockTimeout();
+        dfltQryTimeout = cc.getDefaultQueryTimeout();
+        distro = cc.getDistributionMode();
+        eagerTtl = cc.isEagerTtl();
+        evictFilter = cc.getEvictionFilter();
+        evictKeyBufSize = cc.getEvictSynchronizedKeyBufferSize();
+        evictMaxOverflowRatio = cc.getEvictMaxOverflowRatio();
+        evictNearSync = cc.isEvictNearSynchronized();
+        evictPlc = cc.getEvictionPolicy();
+        evictSync = cc.isEvictSynchronized();
+        evictSyncConcurrencyLvl = cc.getEvictSynchronizedConcurrencyLevel();
+        evictSyncTimeout = cc.getEvictSynchronizedTimeout();
+        expiryPolicyFactory = cc.getExpiryPolicyFactory();
+        indexingSpiName = cc.getIndexingSpiName();
+        interceptor = cc.getInterceptor();
+        invalidate = cc.isInvalidate();
+        isReadThrough = cc.isReadThrough();
+        isWriteThrough = cc.isWriteThrough();
+        keepPortableInStore = cc.isKeepPortableInStore();
+        offHeapMaxMem = cc.getOffHeapMaxMemory();
+        maxConcurrentAsyncOps = cc.getMaxConcurrentAsyncOperations();
+        maxQryIterCnt = cc.getMaximumQueryIteratorCount();
+        memMode = cc.getMemoryMode();
+        name = cc.getName();
+        nearStartSize = cc.getNearStartSize();
+        nearEvictPlc = cc.getNearEvictionPolicy();
+        portableEnabled = cc.isPortableEnabled();
+        preloadMode = cc.getPreloadMode();
+        preloadBatchSize = cc.getPreloadBatchSize();
+        preloadDelay = cc.getPreloadPartitionedDelay();
+        preloadOrder = cc.getPreloadOrder();
+        preloadPoolSize = cc.getPreloadThreadPoolSize();
+        preloadTimeout = cc.getPreloadTimeout();
+        preloadThrottle = cc.getPreloadThrottle();
+        qryCfg = cc.getQueryConfiguration();
+        qryIdxEnabled = cc.isQueryIndexEnabled();
+        seqReserveSize = cc.getAtomicSequenceReserveSize();
+        startSize = cc.getStartSize();
+        store = cc.getStore();
+        storeValBytes = cc.isStoreValueBytes();
+        swapEnabled = cc.isSwapEnabled();
+        tmLookupClsName = cc.getTransactionManagerLookupClassName();
+        ttl = cc.getDefaultTimeToLive();
+        writeBehindBatchSize = cc.getWriteBehindBatchSize();
+        writeBehindEnabled = cc.isWriteBehindEnabled();
+        writeBehindFlushFreq = cc.getWriteBehindFlushFrequency();
+        writeBehindFlushSize = cc.getWriteBehindFlushSize();
+        writeBehindFlushThreadCnt = cc.getWriteBehindFlushThreadCount();
+        writeSync = cc.getWriteSynchronizationMode();
+    }
+
+    /**
+     * Cache name. If not provided or {@code null}, then this will be considered a default
+     * cache which can be accessed via {@link Ignite#cache(String) Grid.cache(null)} method. Otherwise, if name
+     * is provided, the cache will be accessed via {@link Ignite#cache(String)} method.
+     *
+     * @return Cache name.
+     */
+    public String getName() {
+        return name;
+    }
+
+    /**
+     * Sets cache name.
+     *
+     * @param name Cache name. May be <tt>null</tt>, but may not be empty string.
+     */
+    public void setName(String name) {
+        A.ensure(name == null || !name.isEmpty(), "Name cannot be null or empty.");
+
+        this.name = name;
+    }
+
+    /**
+     * Gets time to live for all objects in cache. This value can be overridden for individual objects.
+     * If not set, then value is {@code 0} which means that objects never expire.
+     *
+     * @return Time to live for all objects in cache.
+     */
+    public long getDefaultTimeToLive() {
+        return ttl;
+    }
+
+    /**
+     * Sets time to live for all objects in cache. This value can be override for individual objects.
+     *
+     * @param ttl Time to live for all objects in cache.
+     */
+    public void setDefaultTimeToLive(long ttl) {
+        this.ttl = ttl;
+    }
+
+    /**
+     * Gets cache eviction policy. By default, returns {@code null}
+     * which means that evictions are disabled for cache.
+     *
+     * @return Cache eviction policy or {@code null} if evictions should be disabled.
+     */
+    @SuppressWarnings({"unchecked"})
+    @Nullable public <K, V> GridCacheEvictionPolicy<K, V> getEvictionPolicy() {
+        return evictPlc;
+    }
+
+    /**
+     * Sets cache eviction policy.
+     *
+     * @param evictPlc Cache expiration policy.
+     */
+    public void setEvictionPolicy(@Nullable GridCacheEvictionPolicy evictPlc) {
+        this.evictPlc = evictPlc;
+    }
+
+    /**
+     * Gets cache distribution mode. This parameter is taken into account only if
+     * {@link #getCacheMode()} is set to {@link GridCacheMode#PARTITIONED} or {@link GridCacheMode#REPLICATED} mode.
+     * <p>
+     * If not set, default value is {@link #DFLT_DISTRIBUTION_MODE}.
+     *
+     * @return Cache distribution mode.
+     */
+    public GridCacheDistributionMode getDistributionMode() {
+        return distro;
+    }
+
+    /**
+     * Sets cache distribution mode.
+     *
+     * @param distro Distribution mode.
+     */
+    public void setDistributionMode(GridCacheDistributionMode distro) {
+        this.distro = distro;
+    }
+
+    /**
+     * Gets write synchronization mode. This mode controls whether the main
+     * caller should wait for update on other nodes to complete or not.
+     *
+     * @return Write synchronization mode.
+     */
+    public GridCacheWriteSynchronizationMode getWriteSynchronizationMode() {
+        return writeSync;
+    }
+
+    /**
+     * Sets write synchronization mode.
+     *
+     * @param writeSync Write synchronization mode.
+     */
+    public void setWriteSynchronizationMode(GridCacheWriteSynchronizationMode writeSync) {
+        this.writeSync = writeSync;
+    }
+
+    /**
+     * Gets eviction policy for {@code near} cache which is different from the one used for
+     * {@code partitioned} cache. By default, returns {@code null}
+     * which means that evictions are disabled for near cache.
+     *
+     * @return Cache eviction policy or {@code null} if evictions should be disabled.
+     */
+    @SuppressWarnings({"unchecked"})
+    @Nullable public <K, V> GridCacheEvictionPolicy<K, V> getNearEvictionPolicy() {
+        return nearEvictPlc;
+    }
+
+    /**
+     * Sets eviction policy for near cache. This property is only used for {@link GridCacheMode#PARTITIONED} caching
+     * mode.
+     *
+     * @param nearEvictPlc Eviction policy for near cache.
+     */
+    public void setNearEvictionPolicy(@Nullable GridCacheEvictionPolicy 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 GridCacheProjection#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
+     * eviction is done independently on cache nodes.
+     * <p>
+     * Default value is defined by {@link #DFLT_EVICT_SYNCHRONIZED}.
+     * <p>
+     * Note that it's not recommended to set this value to {@code true} if cache
+     * store is configured since it will allow to significantly improve cache
+     * performance.
+     *
+     * @return {@code true} If eviction is synchronized with backup nodes (or the
+     *      rest of the nodes in case of replicated cache), {@code false} if not.
+     */
+    public boolean isEvictSynchronized() {
+        return evictSync;
+    }
+
+    /**
+     * Sets flag indicating whether eviction is synchronized with backup nodes (or the rest of the nodes for replicated
+     * cache).
+     *
+     * @param evictSync {@code true} if synchronized, {@code false} if not.
+     */
+    public void setEvictSynchronized(boolean evictSync) {
+        this.evictSync = evictSync;
+    }
+
+    /**
+     * Sets flag indicating whether eviction is synchronized with near nodes.
+     *
+     * @param evictNearSync {@code true} if synchronized, {@code false} if not.
+     */
+    public void setEvictNearSynchronized(boolean evictNearSync) {
+        this.evictNearSync = evictNearSync;
+    }
+
+    /**
+     * Gets flag indicating whether eviction on primary node is synchronized with
+     * near nodes where entry is kept. Default value is {@code true} and
+     * is defined by {@link #DFLT_EVICT_NEAR_SYNCHRONIZED}.
+     * <p>
+     * Note that in most cases this property should be set to {@code true} to keep
+     * cache consistency. But there may be the cases when user may use some
+     * special near eviction policy to have desired control over near cache
+     * entry set.
+     *
+     * @return {@code true} If eviction is synchronized with near nodes in
+     *      partitioned cache, {@code false} if not.
+     */
+    public boolean isEvictNearSynchronized() {
+        return evictNearSync;
+    }
+
+    /**
+     * Gets size of the key buffer for synchronized evictions.
+     * <p>
+     * Default value is defined by {@link #DFLT_EVICT_KEY_BUFFER_SIZE}.
+     *
+     * @return Eviction key buffer size.
+     */
+    public int getEvictSynchronizedKeyBufferSize() {
+        return evictKeyBufSize;
+    }
+
+    /**
+     * Sets eviction key buffer size.
+     *
+     * @param evictKeyBufSize Eviction key buffer size.
+     */
+    public void setEvictSynchronizedKeyBufferSize(int evictKeyBufSize) {
+        this.evictKeyBufSize = evictKeyBufSize;
+    }
+
+    /**
+     * Gets concurrency level for synchronized evictions. This flag only makes sense
+     * with {@link #isEvictNearSynchronized()} or {@link #isEvictSynchronized()} set
+     * to {@code true}. When synchronized evictions are enabled, it is possible that
+     * local eviction policy will try to evict entries faster than evictions can be
+     * synchronized with backup or near nodes. This value specifies how many concurrent
+     * synchronous eviction sessions should be allowed before the system is forced to
+     * wait and let synchronous evictions catch up with the eviction policy.
+     * <p>
+     * Note that if synchronous evictions start lagging, it is possible that you have either
+     * too big or too small eviction key buffer size or small eviction timeout. In that case
+     * you will need to adjust {@link #getEvictSynchronizedKeyBufferSize} or
+     * {@link #getEvictSynchronizedTimeout()} values as well.
+     * <p>
+     * Default value is defined by {@link #DFLT_EVICT_SYNCHRONIZED_CONCURRENCY_LEVEL}.
+     *
+     * @return Synchronous eviction concurrency level.
+     */
+    public int getEvictSynchronizedConcurrencyLevel() {
+        return evictSyncConcurrencyLvl;
+    }
+
+    /**
+     * Sets concurrency level for synchronized evictions.
+     *
+     * @param evictSyncConcurrencyLvl Concurrency level for synchronized evictions.
+     */
+    public void setEvictSynchronizedConcurrencyLevel(int evictSyncConcurrencyLvl) {
+        this.evictSyncConcurrencyLvl = evictSyncConcurrencyLvl;
+    }
+
+    /**
+     * Gets timeout for synchronized evictions.
+     * <p>
+     * Node that initiates eviction waits for responses
+     * from remote nodes within this timeout.
+     * <p>
+     * Default value is defined by {@link #DFLT_EVICT_SYNCHRONIZED_TIMEOUT}.
+     *
+     * @return Synchronous eviction timeout.
+     */
+    public long getEvictSynchronizedTimeout() {
+        return evictSyncTimeout;
+    }
+
+    /**
+     * Sets timeout for synchronized evictions.
+     *
+     * @param evictSyncTimeout Timeout for synchronized evictions.
+     */
+    public void setEvictSynchronizedTimeout(long evictSyncTimeout) {
+        this.evictSyncTimeout = evictSyncTimeout;
+    }
+
+    /**
+     * This value denotes the maximum size of eviction queue in percents of cache
+     * size in case of distributed cache (replicated and partitioned) and using
+     * synchronized eviction (that is if {@link #isEvictSynchronized()} returns
+     * {@code true}).
+     * <p>
+     * That queue is used internally as a buffer to decrease network costs for
+     * synchronized eviction. Once queue size reaches specified value all required
+     * requests for all entries in the queue are sent to remote nodes and the queue
+     * is cleared.
+     * <p>
+     * Default value is defined by {@link #DFLT_MAX_EVICTION_OVERFLOW_RATIO} and
+     * equals to {@code 10%}.
+     *
+     * @return Maximum size of eviction queue in percents of cache size.
+     */
+    public float getEvictMaxOverflowRatio() {
+        return evictMaxOverflowRatio;
+    }
+
+    /**
+     * Sets maximum eviction overflow ratio.
+     *
+     * @param evictMaxOverflowRatio Maximum eviction overflow ratio.
+     */
+    public void setEvictMaxOverflowRatio(float evictMaxOverflowRatio) {
+        this.evictMaxOverflowRatio = evictMaxOverflowRatio;
+    }
+
+    /**
+     * 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
+     * {@code false} then eviction policy will not be notified and entry will
+     * never be evicted.
+     * <p>
+     * If not provided, any entry may be evicted depending on
+     * {@link #getEvictionPolicy() eviction policy} configuration.
+     *
+     * @return Eviction filter or {@code null}.
+     */
+    @SuppressWarnings("unchecked")
+    public <K, V> GridCacheEvictionFilter<K, V> getEvictionFilter() {
+        return (GridCacheEvictionFilter<K, V>)evictFilter;
+    }
+
+    /**
+     * Sets eviction filter.
+     *
+     * @param evictFilter Eviction filter.
+     */
+    public <K, V> void setEvictionFilter(GridCacheEvictionFilter<K, V> evictFilter) {
+        this.evictFilter = evictFilter;
+    }
+
+    /**
+     * Gets flag indicating whether expired cache entries will be eagerly removed from cache. When
+     * set to {@code false}, expired entries will be removed on next entry access.
+     * <p>
+     * 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}.
+     *
+     * @return Flag indicating whether GridGain will eagerly remove expired entries.
+     */
+    public boolean isEagerTtl() {
+        return eagerTtl;
+    }
+
+    /**
+     * Sets eager ttl flag.
+     *
+     * @param eagerTtl {@code True} if GridGain should eagerly remove expired cache entries.
+     * @see #isEagerTtl()
+     */
+    public void setEagerTtl(boolean eagerTtl) {
+        this.eagerTtl = eagerTtl;
+    }
+
+    /**
+     * Gets initial cache size which will be used to pre-create internal
+     * hash table after start. Default value is defined by {@link #DFLT_START_SIZE}.
+     *
+     * @return Initial cache size.
+     */
+    public int getStartSize() {
+        return startSize;
+    }
+
+    /**
+     * Initial size for internal hash map.
+     *
+     * @param startSize Cache start size.
+     */
+    public void setStartSize(int startSize) {
+        this.startSize = startSize;
+    }
+
+    /**
+     * Gets initial cache size for near cache which will be used to pre-create internal
+     * hash table after start. Default value is defined by {@link #DFLT_NEAR_START_SIZE}.
+     *
+     * @return Initial near cache size.
+     */
+    public int getNearStartSize() {
+        return nearStartSize;
+    }
+
+    /**
+     * Start size for near cache. This property is only used for {@link GridCacheMode#PARTITIONED} caching mode.
+     *
+     * @param nearStartSize Start size for near cache.
+     */
+    public void setNearStartSize(int nearStartSize) {
+        this.nearStartSize = nearStartSize;
+    }
+
+    /**
+     * Gets underlying persistent storage for read-through and write-through operations.
+     * If not provided, cache will not exhibit read-through or write-through behavior.
+     *
+     * @return Underlying persistent storage for read-through and write-through operations.
+     */
+    @SuppressWarnings({"unchecked"})
+    public <K, V> CacheStore<K, V> getStore() {
+        return (CacheStore<K, V>)store;
+    }
+
+    /**
+     * Sets persistent storage for cache data.
+     *
+     * @param store Persistent cache store.
+     */
+    public <K, V> void setStore(CacheStore<K, V> store) {
+        this.store = store;
+    }
+
+    /**
+     * Gets key topology resolver to provide mapping from keys to nodes.
+     *
+     * @return Key topology resolver to provide mapping from keys to nodes.
+     */
+    public GridCacheAffinityFunction getAffinity() {
+        return aff;
+    }
+
+    /**
+     * Sets affinity for cache keys.
+     *
+     * @param aff Cache key affinity.
+     */
+    public void setAffinity(GridCacheAffinityFunction aff) {
+        this.aff = aff;
+    }
+
+    /**
+     * Gets caching mode to use. You can configure cache either to be local-only,
+     * fully replicated, partitioned, or near. If not provided, {@link GridCacheMode#REPLICATED}
+     * mode will be used by default (defined by {@link #DFLT_CACHE_MODE} constant).
+     *
+     * @return {@code True} if cache is local.
+     */
+    public GridCacheMode getCacheMode() {
+        return cacheMode;
+    }
+
+    /**
+     * Sets caching mode.
+     *
+     * @param cacheMode Caching mode.
+     */
+    public void setCacheMode(GridCacheMode cacheMode) {
+        this.cacheMode = cacheMode;
+    }
+
+    /**
+     * Gets cache atomicity mode.
+     * <p>
+     * Default value is defined by {@link #DFLT_CACHE_ATOMICITY_MODE}.
+     *
+     * @return Cache atomicity mode.
+     */
+    public GridCacheAtomicityMode getAtomicityMode() {
+        return atomicityMode;
+    }
+
+    /**
+     * Sets cache atomicity mode.
+     *
+     * @param atomicityMode Cache atomicity mode.
+     */
+    public void setAtomicityMode(GridCacheAtomicityMode atomicityMode) {
+        this.atomicityMode = atomicityMode;
+    }
+
+    /**
+     * Gets cache write ordering mode. This property can be enabled only for {@link GridCacheAtomicityMode#ATOMIC}
+     * cache (for other atomicity modes it will be ignored).
+     *
+     * @return Cache write ordering mode.
+     */
+    public GridCacheAtomicWriteOrderMode getAtomicWriteOrderMode() {
+        return atomicWriteOrderMode;
+    }
+
+    /**
+     * Sets cache write ordering mode. This property can be enabled only for {@link GridCacheAtomicityMode#ATOMIC}
+     * cache (for other atomicity modes it will be ignored).
+     *
+     * @param atomicWriteOrderMode Cache write ordering mode.
+     */
+    public void setAtomicWriteOrderMode(GridCacheAtomicWriteOrderMode atomicWriteOrderMode) {
+        this.atomicWriteOrderMode = atomicWriteOrderMode;
+    }
+
+    /**
+     * Gets number of nodes used to back up single partition for {@link GridCacheMode#PARTITIONED} cache.
+     * <p>
+     * If not set, default value is {@link #DFLT_BACKUPS}.
+     *
+     * @return Number of backup nodes for one partition.
+     */
+    public int getBackups() {
+        return backups;
+    }
+
+    /**
+     * Sets number of nodes used to back up single partition for {@link GridCacheMode#PARTITIONED} cache.
+     * <p>
+     * If not set, default value is {@link #DFLT_BACKUPS}.
+     *
+     * @param backups Number of backup nodes for one partition.
+     */
+    public void setBackups(int backups) {
+        this.backups = backups;
+    }
+
+    /**
+     * Gets default lock acquisition timeout. Default value is defined by {@link #DFLT_LOCK_TIMEOUT}
+     * which is {@code 0} and means that lock acquisition will never timeout.
+     *
+     * @return Default lock timeout.
+     */
+    public long getDefaultLockTimeout() {
+        return dfltLockTimeout;
+    }
+
+    /**
+     * Sets default lock timeout in milliseconds. By default this value is defined by {@link #DFLT_LOCK_TIMEOUT}.
+     *
+     * @param dfltLockTimeout Default lock timeout.
+     */
+    public void setDefaultLockTimeout(long dfltLockTimeout) {
+        this.dfltLockTimeout = dfltLockTimeout;
+    }
+
+    /**
+     * Gets default query timeout. Default value is defined by {@link #DFLT_QUERY_TIMEOUT}. {@code 0} (zero)
+     * means that the query will never timeout and will wait for completion.
+     *
+     * @return Default query timeout, {@code 0} for never.
+     */
+    public long getDefaultQueryTimeout() {
+        return dfltQryTimeout;
+    }
+
+    /**
+     * Sets default query timeout, {@code 0} for never. For more information see {@link #getDefaultQueryTimeout()}.
+     *
+     * @param dfltQryTimeout Default query timeout.
+     */
+    public void setDefaultQueryTimeout(long dfltQryTimeout) {
+        this.dfltQryTimeout = dfltQryTimeout;
+    }
+
+    /**
+     * Invalidation flag. If {@code true}, values will be invalidated (nullified) upon commit in near cache.
+     *
+     * @return Invalidation flag.
+     */
+    public boolean isInvalidate() {
+        return invalidate;
+    }
+
+    /**
+     * Sets invalidation flag for near cache entries in this transaction. Default is {@code false}.
+     *
+     * @param invalidate Flag to set this cache into invalidation-based mode. Default value is {@code false}.
+     */
+    public void setInvalidate(boolean invalidate) {
+        this.invalidate = invalidate;
+    }
+
+    /**
+     * Flag indicating if cached values should be additionally stored in serialized form. It's set to true by default.
+     *
+     * @param storeValBytes {@code true} if cached values should be additionally stored in serialized form, {@code
+     * false} otherwise.
+     */
+    public void setStoreValueBytes(boolean storeValBytes) {
+        this.storeValBytes = storeValBytes;
+    }
+
+    /**
+     * Flag indicating if cached values should be additionally stored in serialized form.
+     * It's set to {@code true} by default.
+     *
+     * @return {@code true} if cached values should be additionally stored in
+     *      serialized form, {@code false} otherwise.
+     */
+    public boolean isStoreValueBytes() {
+        return storeValBytes;
+    }
+
+    /**
+     * Gets class name of transaction manager finder for integration for JEE app servers.
+     *
+     * @return Transaction manager finder.
+     */
+    public String getTransactionManagerLookupClassName() {
+        return tmLookupClsName;
+    }
+
+    /**
+     * Sets look up mechanism for available {@code TransactionManager} implementation, if any.
+     *
+     * @param tmLookupClsName Name of class implementing GridCacheTmLookup interface that is used to
+     *      receive JTA transaction manager.
+     */
+    public void setTransactionManagerLookupClassName(String tmLookupClsName) {
+        this.tmLookupClsName = tmLookupClsName;
+    }
+
+    /**
+     * Sets cache preload mode.
+     *
+     * @param preloadMode Preload mode.
+     */
+    public void setPreloadMode(GridCachePreloadMode preloadMode) {
+        this.preloadMode = preloadMode;
+    }
+
+    /**
+     * Gets preload mode for distributed cache.
+     * <p>
+     * Default is defined by {@link #DFLT_PRELOAD_MODE}.
+     *
+     * @return Preload mode.
+     */
+    public GridCachePreloadMode 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.
+     * <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.
+     * <p/>
+     * Note that cache with order {@code 0} does not participate in ordering. This means that cache with
+     * preload order {@code 1} will never wait for any other caches. All caches with order {@code 0} will
+     * be preloaded right away concurrently with each other and ordered preload processes.
+     * <p/>
+     * If not set, cache order is 0, i.e. preloading is not ordered.
+     *
+     * @return Cache preload order.
+     */
+    public int getPreloadOrder() {
+        return preloadOrder;
+    }
+
+    /**
+     * Sets cache preload order.
+     *
+     * @param preloadOrder Cache preload order.
+     * @see #getPreloadOrder()
+     */
+    public void setPreloadOrder(int preloadOrder) {
+        this.preloadOrder = preloadOrder;
+    }
+
+    /**
+     * Gets size (in number bytes) to be loaded within a single preload message.
+     * Preloading algorithm will split total data set on every node into multiple
+     * batches prior to sending data. Default value is defined by
+     * {@link #DFLT_PRELOAD_BATCH_SIZE}.
+     *
+     * @return Size in bytes of a single preload message.
+     */
+    public int getPreloadBatchSize() {
+        return preloadBatchSize;
+    }
+
+    /**
+     * Sets preload batch size.
+     *
+     * @param preloadBatchSize Preload batch size.
+     */
+    public void setPreloadBatchSize(int preloadBatchSize) {
+        this.preloadBatchSize = preloadBatchSize;
+    }
+
+    /**
+     * Flag indicating whether GridGain should use swap storage by default. By default
+     * 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}.
+     *
+     * @return {@code True} if swap storage is enabled.
+     */
+    public boolean isSwapEnabled() {
+        return swapEnabled;
+    }
+
+    /**
+     * Flag indicating whether swap storage is enabled or not.
+     *
+     * @param swapEnabled {@code True} if swap storage is enabled.
+     */
+    public void setSwapEnabled(boolean swapEnabled) {
+        this.swapEnabled = swapEnabled;
+    }
+
+    /**
+     * Gets maximum number of allowed concurrent asynchronous operations. If 0 returned then number
+     * of concurrent asynchronous operations is unlimited.
+     * <p>
+     * If not set, default value is {@link #DFLT_MAX_CONCURRENT_ASYNC_OPS}.
+     * <p>
+     * If user threads do not wait for asynchronous operations to complete, it is possible to overload
+     * a system. This property enables back-pressure control by limiting number of scheduled asynchronous
+     * cache operations.
+     *
+     * @return Maximum number of concurrent asynchronous operations or {@code 0} if unlimited.
+     */
+    public int getMaxConcurrentAsyncOperations() {
+        return maxConcurrentAsyncOps;
+    }
+
+    /**
+     * Sets maximum number of concurrent asynchronous operations.
+     *
+     * @param maxConcurrentAsyncOps Maximum number of concurrent asynchronous operations.
+     * @see #getMaxConcurrentAsyncOperations()
+     */
+    public void setMaxConcurrentAsyncOperations(int maxConcurrentAsyncOps) {
+        this.maxConcurrentAsyncOps = maxConcurrentAsyncOps;
+    }
+
+    /**
+     * Flag indicating whether GridGain should attempt to index value and/or key instances
+     * stored in cache. If this property is {@code false}, then all indexing annotations
+     * inside of any class will be ignored. By default query indexing is disabled and
+     * defined via {@link #DFLT_QUERY_INDEX_ENABLED} constant.
+     *
+     * @return {@code True} if query indexing is enabled.
+     * @see #getMemoryMode()
+     */
+    public boolean isQueryIndexEnabled() {
+        return qryIdxEnabled;
+    }
+
+    /**
+     * Flag indicating whether query indexing is enabled or not.
+     *
+     * @param qryIdxEnabled {@code True} if query indexing is enabled.
+     */
+    public void setQueryIndexEnabled(boolean qryIdxEnabled) {
+        this.qryIdxEnabled = qryIdxEnabled;
+    }
+
+    /**
+     * Flag indicating whether GridGain should use write-behind behaviour for the cache store.
+     * By default write-behind is disabled which is defined via {@link #DFLT_WRITE_BEHIND_ENABLED}
+     * constant.
+     *
+     * @return {@code True} if write-behind is enabled.
+     */
+    public boolean isWriteBehindEnabled() {
+        return writeBehindEnabled;
+    }
+
+    /**
+     * Sets flag indicating whether write-behind is enabled.
+     *
+     * @param writeBehindEnabled {@code true} if write-behind is enabled.
+     */
+    public void setWriteBehindEnabled(boolean writeBehindEnabled) {
+        this.writeBehindEnabled = writeBehindEnabled;
+    }
+
+    /**
+     * Maximum size of the write-behind cache. If cache size exceeds this value,
+     * all cached items are flushed to the cache store and write cache is cleared.
+     * <p/>
+     * If not provided, default value is {@link #DFLT_WRITE_BEHIND_FLUSH_SIZE}.
+     * If this value is {@code 0}, then flush is performed according to the flush frequency interval.
+     * <p/>
+     * Note that you cannot set both, {@code flush} size and {@code flush frequency}, to {@code 0}.
+     *
+     * @return Maximum object count in write-behind cache.
+     */
+    public int getWriteBehindFlushSize() {
+        return writeBehindFlushSize;
+    }
+
+    /**
+     * Sets write-behind flush size.
+     *
+     * @param writeBehindFlushSize Write-behind cache flush size.
+     * @see #getWriteBehindFlushSize()
+     */
+    public void setWriteBehindFlushSize(int writeBehindFlushSize) {
+        this.writeBehindFlushSize = writeBehindFlushSize;
+    }
+
+    /**
+     * Frequency with which write-behind cache is flushed to the cache store in milliseconds.
+     * This value defines the maximum time interval between object insertion/deletion from the cache
+     * ant the moment when corresponding operation is applied to the cache store.
+     * <p>
+     * If not provided, default value is {@link #DFLT_WRITE_BEHIND_FLUSH_FREQUENCY}.
+     * If this value is {@code 0}, then flush is performed according to the flush size.
+     * <p>
+     * Note that you cannot set both, {@code flush} size and {@code flush frequency}, to {@code 0}.
+     *
+     * @return Write-behind flush frequency in milliseconds.
+     */
+    public long getWriteBehindFlushFrequency() {
+        return writeBehindFlushFreq;
+    }
+
+    /**
+     * Sets write-behind flush frequency.
+     *
+     * @param writeBehindFlushFreq Write-behind flush frequency in milliseconds.
+     * @see #getWriteBehindFlushFrequency()
+     */
+    public void setWriteBehindFlushFrequency(long writeBehindFlushFreq) {
+        this.writeBehindFlushFreq = writeBehindFlushFreq;
+    }
+
+    /**
+     * Number of threads that will perform cache flushing. Cache flushing is performed
+     * when cache size exceeds value defined by
+     * {@link #getWriteBehindFlushSize}, or flush interval defined by
+     * {@link #getWriteBehindFlushFrequency} is elapsed.
+     * <p/>
+     * If not provided, default value is {@link #DFLT_WRITE_FROM_BEHIND_FLUSH_THREAD_CNT}.
+     *
+     * @return Count of flush threads.
+     */
+    public int getWriteBehindFlushThreadCount() {
+        return writeBehindFlushThreadCnt;
+    }
+
+    /**
+     * Sets flush thread count for write-behind cache.
+     *
+     * @param writeBehindFlushThreadCnt Count of flush threads.
+     * @see #getWriteBehindFlushThreadCount()
+     */
+    public void setWriteBehindFlushThreadCount(int writeBehindFlushThreadCnt) {
+        this.writeBehindFlushThreadCnt = writeBehindFlushThreadCnt;
+    }
+
+    /**
+     * Maximum batch size for write-behind cache store operations. Store operations (get or remove)
+     * are combined in a batch of this size to be passed to
+     * {@link CacheStore#writeAll(Collection)} or
+     * {@link CacheStore#deleteAll(Collection)} methods.
+     * <p/>
+     * If not provided, default value is {@link #DFLT_WRITE_BEHIND_BATCH_SIZE}.
+     *
+     * @return Maximum batch size for store operations.
+     */
+    public int getWriteBehindBatchSize() {
+        return writeBehindBatchSize;
+    }
+
+    /**
+     * Sets maximum batch size for write-behind cache.
+     *
+     * @param writeBehindBatchSize Maximum batch size.
+     * @see #getWriteBehindBatchSize()
+     */
+    public void setWriteBehindBatchSize(int writeBehindBatchSize) {
+        this.writeBehindBatchSize = writeBehindBatchSize;
+    }
+
+    /**
+     * Cloner to be used for cloning values that are returned to user only if {@link GridCacheFlag#CLONE}
+     * is set on {@link GridCacheProjection}. 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 GridCacheBasicCloner} implementation which will clone only objects
+     * implementing {@link Cloneable} interface. You can also configure cache to use
+     * {@link GridCacheDeepCloner} 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.
+     *
+     * @return Cloner to be used if {@link GridCacheFlag#CLONE} flag is set on cache projection.
+     */
+    @SuppressWarnings({"unchecked"})
+    public GridCacheCloner getCloner() {
+        return cloner;
+    }
+
+    /**
+     * Sets cloner to be used if {@link GridCacheFlag#CLONE} flag is set on projection.
+     *
+     * @param cloner Cloner to use.
+     * @see #getCloner()
+     */
+    public void setCloner(GridCacheCloner cloner) {
+        this.cloner = cloner;
+    }
+
+    /**
+     * Gets default number of sequence values reserved for {@link GridCacheAtomicSequence} 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>
+     * Default value is {@link #DFLT_ATOMIC_SEQUENCE_RESERVE_SIZE}.
+     *
+     * @return Atomic sequence reservation size.
+     */
+    public int getAtomicSequenceReserveSize() {
+        return seqReserveSize;
+    }
+
+    /**
+     * Sets default number of sequence values reserved for {@link GridCacheAtomicSequence} 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.
+     *
+     * @param seqReserveSize Atomic sequence reservation size.
+     * @see #getAtomicSequenceReserveSize()
+     */
+    public void setAtomicSequenceReserveSize(int seqReserveSize) {
+        this.seqReserveSize = seqReserveSize;
+    }
+
+    /**
+     * Gets size of preloading thread pool. Note that size serves as a hint and implementation
+     * may create more threads for preloading than specified here (but never less threads).
+     * <p>
+     * Default value is {@link #DFLT_PRELOAD_THREAD_POOL_SIZE}.
+     *
+     * @return Size of preloading thread pool.
+     */
+    public int getPreloadThreadPoolSize() {
+        return preloadPoolSize;
+    }
+
+    /**
+     * Sets size of preloading thread pool. Note that size serves as a hint and implementation may create more threads
+     * for preloading than specified here (but never less threads).
+     *
+     * @param preloadPoolSize Size of preloading thread pool.
+     */
+    public void setPreloadThreadPoolSize(int preloadPoolSize) {
+        this.preloadPoolSize = preloadPoolSize;
+    }
+
+    /**
+     * Gets preload timeout (ms).
+     * <p>
+     * Default value is {@link #DFLT_PRELOAD_TIMEOUT}.
+     *
+     * @return Preload timeout (ms).
+     */
+    public long getPreloadTimeout() {
+        return preloadTimeout;
+    }
+
+    /**
+     * Sets preload timeout (ms).
+     *
+     * @param preloadTimeout Preload timeout (ms).
+     */
+    public void setPreloadTimeout(long preloadTimeout) {
+        this.preloadTimeout = preloadTimeout;
+    }
+
+    /**
+     * Gets delay in milliseconds upon a node joining or leaving topology (or crash) after which preloading
+     * should be started automatically. Preloading should be delayed if you plan to restart nodes
+     * after they leave topology, or if you plan to start multiple nodes at once or one after another
+     * and don't want to repartition and preload until all nodes are started.
+     * <p>
+     * Delayed preloading is applied to {@link GridCacheMode#PARTITIONED} caches only.
+     * 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 GridCacheConsistentHashAffinityFunction#setHashIdResolver(GridCacheAffinityNodeHashResolver)}
+     * 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
+     * from management console.
+     *
+     * @return Preloading delay, {@code 0} to start preloading immediately, {@code -1} to
+     *      start preloading manually, or positive value to specify delay in milliseconds
+     *      after which preloading should start automatically.
+     */
+    public long getPreloadPartitionedDelay() {
+        return preloadDelay;
+    }
+
+    /**
+     * Sets preload delay (see {@link #getPreloadPartitionedDelay()} for more information).
+     *
+     * @param preloadDelay Preload delay to set.
+     */
+    public void setPreloadPartitionedDelay(long preloadDelay) {
+        this.preloadDelay = preloadDelay;
+    }
+
+    /**
+     * Time in milliseconds to wait between preload messages to avoid overloading of CPU or network.
+     * When preloading large data sets, the CPU or network can get over-consumed with preloading messages,
+     * which consecutively may slow down the application performance. This parameter helps tune
+     * the amount of time to wait between preload messages to make sure that preloading process
+     * does not have any negative performance impact. Note that application will continue to work
+     * properly while preloading is still in progress.
+     * <p>
+     * Value of {@code 0} means that throttling is disabled. By default throttling is disabled -
+     * the default is defined by {@link #DFLT_PRELOAD_THROTTLE} constant.
+     *
+     * @return Time in milliseconds to wait between preload messages to avoid overloading of CPU,
+     *      {@code 0} to disable throttling.
+     */
+    public long getPreloadThrottle() {
+        return preloadThrottle;
+    }
+
+    /**
+     * Time in milliseconds to wait between preload messages to avoid overloading of CPU or network. When preloading
+     * large data sets, the CPU or network can get over-consumed with preloading messages, which consecutively may slow
+     * down the application performance. This parameter helps tune the amount of time to wait between preload messages
+     * to make sure that preloading process does not have any negative performance impact. Note that application will
+     * continue to work properly while preloading is still in progress. <p> Value of {@code 0} means that throttling is
+     * disabled. By default throttling is disabled - the default is defined by {@link #DFLT_PRELOAD_THROTTLE} constant.
+     *
+     * @param preloadThrottle Time in milliseconds to wait between preload messages to avoid overloading of CPU, {@code
+     * 0} to disable throttling.
+     */
+    public void setPreloadThrottle(long preloadThrottle) {
+        this.preloadThrottle = preloadThrottle;
+    }
+
+    /**
+     * Affinity key mapper used to provide custom affinity key for any given key.
+     * Affinity mapper is particularly useful when several objects need to be collocated
+     * 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.
+     *
+     * @return Mapper to use for affinity key mapping.
+     */
+    public GridCacheAffinityKeyMapper 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.
+     *
+     * @param affMapper Affinity mapper.
+     */
+    public void setAffinityMapper(GridCacheAffinityKeyMapper affMapper) {
+        this.affMapper = affMapper;
+    }
+
+    /**
+     * Gets name of the SPI to use for indexing. If not specified, the default
+     * indexing SPI will be used.
+     * <p>
+     * This property becomes useful in rare cases when more than one indexing
+     * SPI is configured. In majority of the cases default value should be used.
+     *
+     * @return Name of SPI to use for indexing.
+     * @see GridIndexingSpi
+     */
+    public String getIndexingSpiName() {
+        return indexingSpiName;
+    }
+
+    /**
+     * Sets name of the SPI to use for indexing. If not specified, the default
+     * indexing SPI will be used.
+     * <p>
+     * This property becomes useful in rare cases when more than one indexing
+     * SPI is configured. In majority of the cases default value should be used.
+     *
+     * @param indexingSpiName Name.
+     * @see GridIndexingSpi
+     */
+    public void setIndexingSpiName(String indexingSpiName) {
+        this.indexingSpiName = indexingSpiName;
+    }
+
+    /**
+     * Gets maximum amount of memory available to off-heap storage. Possible values are
+     * <ul>
+     * <li>{@code -1} - Means that off-heap storage is disabled.</li>
+     * <li>
+     *     {@code 0} - GridGain will not limit off-heap storage (it's up to user to properly
+     *     add and remove entries from cache to ensure that off-heap storage does not grow
+     *     indefinitely.
+     * </li>
+     * <li>Any positive value specifies the limit of off-heap storage in bytes.</li>
+     * </ul>
+     * Default value is {@code -1}, specified by {@link #DFLT_OFFHEAP_MEMORY} constant
+     * which means that off-heap storage is disabled by default.
+     * <p>
+     * Use off-heap storage to load gigabytes of data in memory without slowing down
+     * Garbage Collection. Essentially in this case you should allocate very small amount
+     * of memory to JVM and GridGain will cache most of the data in off-heap space
+     * without affecting JVM performance at all.
+     * <p>
+     * Note that GridGain will throw an exception if max memory is set to {@code -1} and
+     * {@code offHeapValuesOnly} flag is set to {@code true}.
+     *
+     * @return Maximum memory in bytes available to off-heap memory space.
+     */
+    public long getOffHeapMaxMemory() {
+        return offHeapMaxMem;
+    }
+
+    /**
+     * Sets maximum amount of memory available to off-heap storage. Possible values are <ul> <li>{@code -1} - Means that
+     * off-heap storage is disabled.</li> <li> {@code 0} - GridGain will not limit off-heap storage (it's up to user to
+     * properly add and remove entries from cache to ensure that off-heap storage does not grow infinitely. </li>
+     * <li>Any positive value specifies the limit of off-heap storage in bytes.</li> </ul> Default value is {@code -1},
+     * specified by {@link #DFLT_OFFHEAP_MEMORY} constant which means that off-heap storage is disabled by default. <p>
+     * Use off-heap storage to load gigabytes of data in memory without slowing down Garbage Collection. Essentially in
+     * this case you should allocate very small amount of memory to JVM and GridGain will cache most of the data in
+     * off-heap space without affecting JVM performance at all.
+     *
+     * @param offHeapMaxMem Maximum memory in bytes available to off-heap memory space.
+     */
+    public void setOffHeapMaxMemory(long offHeapMaxMem) {
+        this.offHeapMaxMem = offHeapMaxMem;
+    }
+
+    /**
+     * Gets maximum number of query iterators that can be stored. Iterators are stored to
+     * support query pagination when each page of data is sent to user's node only on demand.
+     * Increase this property if you are running and processing lots of queries in parallel.
+     * <p>
+     * Default value is {@link #DFLT_MAX_QUERY_ITERATOR_CNT}.
+     *
+     * @return Maximum number of query iterators that can be stored.
+     */
+    public int getMaximumQueryIteratorCount() {
+        return maxQryIterCnt;
+    }
+
+    /**
+     * Sets maximum number of query iterators that can be stored.
+     *
+     * @param maxQryIterCnt Maximum number of query iterators that can be stored.
+     */
+    public void setMaximumQueryIteratorCount(int maxQryIterCnt) {
+        this.maxQryIterCnt = maxQryIterCnt;
+    }
+
+    /**
+     * Gets maximum number of entries that can be accumulated before back-pressure
+     * is enabled to postpone cache updates until query listeners are notified.
+     * If your system is configured properly, then this number should never be reached.
+     * <p>
+     * Default value is {@link #DFLT_CONT_QUERY_QUEUE_SIZE}.
+     *
+     * @return Continuous query queue size.
+     * @deprecated Ignored in current version.
+     */
+    @Deprecated
+    public int getContinuousQueryQueueSize() {
+        return 0;
+    }
+
+    /**
+     * Sets continuous query queue size.
+     *
+     * @param contQryQueueSize Continuous query queue size.
+     * @deprecated Ignored in current version.
+     */
+    @Deprecated
+    public void setContinuousQueryQueueSize(int contQryQueueSize) {
+        // No-op.
+    }
+
+    /**
+     * 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.
+     * <p>
+     * Default value is {@link #DFLT_MEMORY_MODE}.
+     *
+     * @return Memory mode.
+     */
+    public GridCacheMemoryMode getMemoryMode() {
+        return memMode;
+    }
+
+    /**
+     * Sets memory mode for cache.
+     *
+     * @param memMode Memory mode.
+     */
+    public void setMemoryMode(GridCacheMemoryMode memMode) {
+        this.memMode = memMode;
+    }
+
+    /**
+     * Gets the maximum buffer size for continuous queries. When the current
+     * number of entries in buffer exceeds the maximum buffer size, the buffer
+     * is flushed to the notification queue. Greater buffer size may improve throughput,
+     * but also may increase latency.
+     * <p>
+     * Default value is either {@link #DFLT_CONT_QUERY_MAX_BUF_SIZE} or
+     * {@code GG_CONT_QUERY_MAX_BUF_SIZE} system property value (if specified).
+     *
+     * @return Maximum buffer size for continuous queries.
+     * @deprecated Ignored in current version.
+     */
+    @Deprecated
+    public int getContinuousQueryMaximumBufferSize() {
+        return 0;
+    }
+
+    /**
+     * Sets maximum buffer size for continuous queries.
+     *
+     * @param contQryMaxBufSize Maximum buffer size for continuous queries.
+     * @deprecated Ignored in current version.
+     */
+    @Deprecated
+    public void setContinuousQueryMaximumBufferSize(int contQryMaxBufSize) {
+        // No-op.
+    }
+
+    /**
+     * Gets cache interceptor.
+     *
+     * @return Cache interceptor.
+     */
+    @SuppressWarnings({"unchecked"})
+    @Nullable public <K, V> GridCacheInterceptor<K, V> getInterceptor() {
+        return (GridCacheInterceptor<K, V>)interceptor;
+    }
+
+    /**
+     * Sets cache interceptor.
+     *
+     * @param interceptor Cache interceptor.
+     */
+    public <K, V> void setInterceptor(GridCacheInterceptor<K, V> interceptor) {
+        this.interceptor = interceptor;
+    }
+
+    /**
+     * Flag indicating whether GridGain should store portable keys and values
+     * as instances of {@link PortableObject}.
+     *
+     * @return Portable enabled flag.
+     */
+    public boolean isPortableEnabled() {
+        return portableEnabled;
+    }
+
+    /**
+     * Gets portable enabled flag value.
+     *
+     * @param portableEnabled Portable enabled flag value.
+     */
+    public void setPortableEnabled(boolean portableEnabled) {
+        this.portableEnabled = portableEnabled;
+    }
+
+    /**
+     * Flag indicating that {@link CacheStore} implementation
+     * is working with portable objects instead of Java objects
+     * if portable mode for this cache is enabled ({@link #isPortableEnabled()}
+     * flag is {@code true}). Default value of this flag is {@code true},
+     * because this is recommended behavior from performance standpoint.
+     * <p>
+     * If set to {@code false}, GridGain will deserialize keys and
+     * values stored in portable format before they are passed
+     * to cache store.
+     * <p>
+     * Note that setting this flag to {@code false} can simplify
+     * store implementation in some cases, but it can cause performance
+     * degradation due to additional serializations and deserializations
+     * of portable objects. You will also need to have key and value
+     * classes on all nodes since portables will be deserialized when
+     * store is called.
+     * <p>
+     * This flag is ignored if portable mode is disabled for this
+     * cache ({@link #isPortableEnabled()} flag is {@code false}).
+     *
+     * @return Keep portables in store flag.
+     */
+    public boolean isKeepPortableInStore() {
+        return keepPortableInStore;
+    }
+
+    /**
+     * Sets keep portables in store flag.
+     *
+     * @param keepPortableInStore Keep portables in store flag.
+     */
+    public void setKeepPortableInStore(boolean keepPortableInStore) {
+        this.keepPortableInStore = keepPortableInStore;
+    }
+
+    /**
+     * Gets query configuration. Query configuration defines which fields should be indexed for objects
+     * without annotations or portable objects.
+     *
+     * @return Cache query configuration.
+     */
+    public GridCacheQueryConfiguration getQueryConfiguration() {
+        return qryCfg;
+    }
+
+    /**
+     * Sets query configuration.
+     *
+     * @param qryCfg Query configuration.
+     * @see GridCacheQueryConfiguration
+     */
+    public void setQueryConfiguration(GridCacheQueryConfiguration qryCfg) {
+        this.qryCfg = qryCfg;
+    }
 
+    /** {@inheritDoc} */
+    @Override public String toString() {
+        return S.toString(CacheConfiguration.class, this);
+    }
 }

http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/b0d8a67a/modules/core/src/main/java/org/apache/ignite/cache/CacheFlag.java
----------------------------------------------------------------------
diff --git a/modules/core/src/main/java/org/apache/ignite/cache/CacheFlag.java b/modules/core/src/main/java/org/apache/ignite/cache/CacheFlag.java
index 1e5076f..bd44880 100644
--- a/modules/core/src/main/java/org/apache/ignite/cache/CacheFlag.java
+++ b/modules/core/src/main/java/org/apache/ignite/cache/CacheFlag.java
@@ -45,7 +45,7 @@ public enum CacheFlag {
      * messages will be sent to set the values to {@code null}.
      *
      * @see IgniteTx#isInvalidate()
-     * @see org.gridgain.grid.cache.GridCacheConfiguration#isInvalidate()
+     * @see CacheConfiguration#isInvalidate()
      */
     INVALIDATE,
 

http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/b0d8a67a/modules/core/src/main/java/org/apache/ignite/cache/store/CacheStore.java
----------------------------------------------------------------------
diff --git a/modules/core/src/main/java/org/apache/ignite/cache/store/CacheStore.java b/modules/core/src/main/java/org/apache/ignite/cache/store/CacheStore.java
index 4cdfe5a..f44d79a 100644
--- a/modules/core/src/main/java/org/apache/ignite/cache/store/CacheStore.java
+++ b/modules/core/src/main/java/org/apache/ignite/cache/store/CacheStore.java
@@ -35,7 +35,7 @@ import static javax.cache.Cache.*;
 
 /**
  * API for cache persistent storage for read-through and write-through behavior.
- * Persistent store is configured via {@link GridCacheConfiguration#getStore()}
+ * Persistent store is configured via {@link org.apache.ignite.cache.CacheConfiguration#getStore()}
  * configuration property. If not provided, values will be only kept in cache memory
  * or swap storage without ever being persisted to a persistent storage.
  * <p>
@@ -70,7 +70,7 @@ import static javax.cache.Cache.*;
  * }
  * </pre>
  * <h1 class="header">Working With Portable Objects</h1>
- * When portables are enabled for cache by setting {@link GridCacheConfiguration#isPortableEnabled()} to
+ * When portables are enabled for cache by setting {@link org.apache.ignite.cache.CacheConfiguration#isPortableEnabled()} to
  * {@code true}), all portable keys and values are converted to instances of {@link PortableObject}.
  * Therefore, all cache store methods will take parameters in portable format. To avoid class
  * cast exceptions, store must have signature compatible with portables. E.g., if you use {@link Integer}
@@ -85,7 +85,7 @@ import static javax.cache.Cache.*;
  *     ...
  * }
  * </pre>
- * This behavior can be overridden by setting {@link GridCacheConfiguration#setKeepPortableInStore(boolean)}
+ * This behavior can be overridden by setting {@link org.apache.ignite.cache.CacheConfiguration#setKeepPortableInStore(boolean)}
  * flag value to {@code false}. In this case, GridGain will deserialize keys and values stored in portable
  * format before they are passed to cache store, so that you can use the following cache store signature instead:
  * <pre name="code" class="java">

http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/b0d8a67a/modules/core/src/main/java/org/apache/ignite/cache/store/CacheStoreBalancingWrapper.java
----------------------------------------------------------------------
diff --git a/modules/core/src/main/java/org/apache/ignite/cache/store/CacheStoreBalancingWrapper.java b/modules/core/src/main/java/org/apache/ignite/cache/store/CacheStoreBalancingWrapper.java
index c76d4ec..e8430aa 100644
--- a/modules/core/src/main/java/org/apache/ignite/cache/store/CacheStoreBalancingWrapper.java
+++ b/modules/core/src/main/java/org/apache/ignite/cache/store/CacheStoreBalancingWrapper.java
@@ -109,6 +109,8 @@ public class CacheStoreBalancingWrapper<K, V> implements CacheStore<K, V> {
 
     /** {@inheritDoc} */
     @Override public Map<K, V> loadAll(Iterable<? extends K> keys) throws CacheLoaderException {
+        assert false;
+
         return delegate.loadAll(keys);
     }
 
@@ -117,7 +119,7 @@ public class CacheStoreBalancingWrapper<K, V> implements CacheStore<K, V> {
      * @param c Closure for loaded values.
      */
     public void loadAll(Collection<? extends K> keys, final IgniteBiInClosure<K, V> c) {
-        assert keys.size() < loadAllThreshold;
+        assert keys.size() <= loadAllThreshold : loadAllThreshold;
 
         Collection<K> needLoad = null;
         Map<K, LoadFuture> pending = null;
@@ -161,8 +163,10 @@ public class CacheStoreBalancingWrapper<K, V> implements CacheStore<K, V> {
             try {
                 Map<K, V> loaded = delegate.loadAll(needLoad);
 
-                for (Map.Entry<K, V> e : loaded.entrySet())
-                    c.apply(e.getKey(), e.getValue());
+                if (loaded != null) {
+                    for (Map.Entry<K, V> e : loaded.entrySet())
+                        c.apply(e.getKey(), e.getValue());
+                }
 
                 span.onComplete(needLoad, loaded);
             }

http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/b0d8a67a/modules/core/src/main/java/org/apache/ignite/cache/store/CacheStoreSession.java
----------------------------------------------------------------------
diff --git a/modules/core/src/main/java/org/apache/ignite/cache/store/CacheStoreSession.java b/modules/core/src/main/java/org/apache/ignite/cache/store/CacheStoreSession.java
index 2331e02..0fb5c47 100644
--- a/modules/core/src/main/java/org/apache/ignite/cache/store/CacheStoreSession.java
+++ b/modules/core/src/main/java/org/apache/ignite/cache/store/CacheStoreSession.java
@@ -34,5 +34,5 @@ public interface CacheStoreSession {
     /**
      * @return Session properties.
      */
-    public Map<Object, Object> properties();
+    public <K, V> Map<K, V> properties();
 }

http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/b0d8a67a/modules/core/src/main/java/org/apache/ignite/cache/store/jdbc/CacheJdbcBlobStore.java
----------------------------------------------------------------------
diff --git a/modules/core/src/main/java/org/apache/ignite/cache/store/jdbc/CacheJdbcBlobStore.java b/modules/core/src/main/java/org/apache/ignite/cache/store/jdbc/CacheJdbcBlobStore.java
index 8c13db9..394a5ed 100644
--- a/modules/core/src/main/java/org/apache/ignite/cache/store/jdbc/CacheJdbcBlobStore.java
+++ b/modules/core/src/main/java/org/apache/ignite/cache/store/jdbc/CacheJdbcBlobStore.java
@@ -29,6 +29,7 @@ import org.gridgain.grid.util.typedef.internal.*;
 import org.jdk8.backport.*;
 import org.jetbrains.annotations.*;
 
+import javax.cache.*;
 import javax.cache.integration.*;
 import javax.sql.*;
 import java.sql.*;
@@ -239,11 +240,14 @@ public class CacheJdbcBlobStore<K, V> extends CacheStoreAdapter<K, V> {
     }
 
     /** {@inheritDoc} */
-    @Override public void put(K key, V val) {
+    @Override public void write(Cache.Entry<? extends K, ? extends V> entry) {
         init();
 
         IgniteTx tx = transaction();
 
+        K key = entry.getKey();
+        V val = entry.getValue();
+
         if (log.isDebugEnabled())
             log.debug("Store put [key=" + key + ", val=" + val + ", tx=" + tx + ']');
 
@@ -279,7 +283,7 @@ public class CacheJdbcBlobStore<K, V> extends CacheStoreAdapter<K, V> {
     }
 
     /** {@inheritDoc} */
-    @Override public void remove(K key) {
+    @Override public void delete(Object key) {
         init();
 
         IgniteTx tx = transaction();

http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/b0d8a67a/modules/core/src/main/java/org/apache/ignite/configuration/IgniteConfiguration.java
----------------------------------------------------------------------
diff --git a/modules/core/src/main/java/org/apache/ignite/configuration/IgniteConfiguration.java b/modules/core/src/main/java/org/apache/ignite/configuration/IgniteConfiguration.java
index 345f8d7..0c56c51 100644
--- a/modules/core/src/main/java/org/apache/ignite/configuration/IgniteConfiguration.java
+++ b/modules/core/src/main/java/org/apache/ignite/configuration/IgniteConfiguration.java
@@ -18,6 +18,7 @@
 package org.apache.ignite.configuration;
 
 import org.apache.ignite.*;
+import org.apache.ignite.cache.*;
 import org.apache.ignite.events.*;
 import org.apache.ignite.fs.*;
 import org.apache.ignite.lang.*;
@@ -30,7 +31,6 @@ import org.apache.ignite.spi.authentication.*;
 import org.apache.ignite.spi.indexing.*;
 import org.apache.ignite.streamer.*;
 import org.gridgain.client.ssl.*;
-import org.gridgain.grid.cache.*;
 import org.gridgain.grid.dotnet.*;
 import org.gridgain.grid.hadoop.*;
 import org.gridgain.grid.kernal.managers.eventstorage.*;
@@ -384,7 +384,7 @@ public class IgniteConfiguration {
     private IgniteAddressResolver addrRslvr;
 
     /** Cache configurations. */
-    private GridCacheConfiguration[] cacheCfg;
+    private CacheConfiguration[] cacheCfg;
 
     /** Transactions configuration. */
     private TransactionsConfiguration txCfg = new TransactionsConfiguration();
@@ -2241,7 +2241,7 @@ public class IgniteConfiguration {
      *
      * @return Array of fully initialized cache descriptors.
      */
-    public GridCacheConfiguration[] getCacheConfiguration() {
+    public CacheConfiguration[] getCacheConfiguration() {
         return cacheCfg;
     }
 
@@ -2251,8 +2251,8 @@ public class IgniteConfiguration {
      * @param cacheCfg Cache configurations.
      */
     @SuppressWarnings({"ZeroLengthArrayAllocation"})
-    public void setCacheConfiguration(GridCacheConfiguration... cacheCfg) {
-        this.cacheCfg = cacheCfg == null ? new GridCacheConfiguration[0] : cacheCfg;
+    public void setCacheConfiguration(CacheConfiguration... cacheCfg) {
+        this.cacheCfg = cacheCfg == null ? new CacheConfiguration[0] : cacheCfg;
     }
 
     /**

http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/b0d8a67a/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/IgniteCacheProxy.java
----------------------------------------------------------------------
diff --git a/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/IgniteCacheProxy.java b/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/IgniteCacheProxy.java
index f95cd2a..cca2946 100644
--- a/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/IgniteCacheProxy.java
+++ b/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/IgniteCacheProxy.java
@@ -99,7 +99,7 @@ public class IgniteCacheProxy<K, V> extends IgniteAsyncSupportAdapter implements
 
     /** {@inheritDoc} */
     @Override public <C extends Configuration<K, V>> C getConfiguration(Class<C> clazz) {
-        GridCacheConfiguration cfg = ctx.config();
+        CacheConfiguration cfg = ctx.config();
 
         if (!clazz.isAssignableFrom(cfg.getClass()))
             throw new IllegalArgumentException();

http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/b0d8a67a/modules/core/src/main/java/org/apache/ignite/resources/IgniteCacheNameResource.java
----------------------------------------------------------------------
diff --git a/modules/core/src/main/java/org/apache/ignite/resources/IgniteCacheNameResource.java b/modules/core/src/main/java/org/apache/ignite/resources/IgniteCacheNameResource.java
index 8b843f3..3f16f2e 100644
--- a/modules/core/src/main/java/org/apache/ignite/resources/IgniteCacheNameResource.java
+++ b/modules/core/src/main/java/org/apache/ignite/resources/IgniteCacheNameResource.java
@@ -18,13 +18,12 @@
 package org.apache.ignite.resources;
 
 import java.lang.annotation.*;
-import org.gridgain.grid.cache.*;
 
 /**
  * Annotates a field or a setter method for injection of grid cache name.
- * Grid cache name is provided to cache via {@link GridCacheConfiguration#getName()} method.
+ * Grid cache name is provided to cache via {@link org.apache.ignite.cache.CacheConfiguration#getName()} method.
  * <p>
- * Cache name can be injected into components provided in the {@link GridCacheConfiguration},
+ * Cache name can be injected into components provided in the {@link org.apache.ignite.cache.CacheConfiguration},
  * if {@link IgniteCacheNameResource} annotation is used in another classes it is no-op.
  * <p>
  * Here is how injection would typically happen:
@@ -50,7 +49,7 @@ import org.gridgain.grid.cache.*;
  * }
  * </pre>
  * <p>
- * See {@link GridCacheConfiguration#getName()} for cache configuration details.
+ * See {@link org.apache.ignite.cache.CacheConfiguration#getName()} for cache configuration details.
  */
 @Documented
 @Retention(RetentionPolicy.RUNTIME)

http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/b0d8a67a/modules/core/src/main/java/org/apache/ignite/transactions/IgniteTx.java
----------------------------------------------------------------------
diff --git a/modules/core/src/main/java/org/apache/ignite/transactions/IgniteTx.java b/modules/core/src/main/java/org/apache/ignite/transactions/IgniteTx.java
index 80409f4..263747a 100644
--- a/modules/core/src/main/java/org/apache/ignite/transactions/IgniteTx.java
+++ b/modules/core/src/main/java/org/apache/ignite/transactions/IgniteTx.java
@@ -19,7 +19,6 @@ package org.apache.ignite.transactions;
 
 import org.apache.ignite.*;
 import org.apache.ignite.lang.*;
-import org.gridgain.grid.*;
 import org.gridgain.grid.cache.*;
 
 import java.util.*;
@@ -67,7 +66,7 @@ import java.util.*;
  *  all nodes reply {@code 'OK'} (i.e. {@code Phase 1} completes successfully), a one-way' {@code 'COMMIT'}
  *  message is sent without waiting for reply. If it is necessary to know whenever remote nodes have committed
  *  as well, synchronous commit or synchronous rollback should be enabled via
- *  {@link GridCacheConfiguration#setWriteSynchronizationMode}
+ *  {@link org.apache.ignite.cache.CacheConfiguration#setWriteSynchronizationMode}
  *  or by setting proper flags on cache projection, such as {@link GridCacheFlag#SYNC_COMMIT}.
  *  <p>
  *  Note that in this mode, optimistic failures are only possible in conjunction with
@@ -114,7 +113,7 @@ import java.util.*;
  * }
  * </pre>
  */
-public interface IgniteTx extends GridMetadataAware, AutoCloseable, IgniteAsyncSupport {
+public interface IgniteTx extends AutoCloseable, IgniteAsyncSupport {
     /**
      * Gets unique identifier for this transaction.
      *

http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/b0d8a67a/modules/core/src/main/java/org/gridgain/grid/GridBasicWarmupClosure.java
----------------------------------------------------------------------
diff --git a/modules/core/src/main/java/org/gridgain/grid/GridBasicWarmupClosure.java b/modules/core/src/main/java/org/gridgain/grid/GridBasicWarmupClosure.java
index 8639b5f..40b94e8 100644
--- a/modules/core/src/main/java/org/gridgain/grid/GridBasicWarmupClosure.java
+++ b/modules/core/src/main/java/org/gridgain/grid/GridBasicWarmupClosure.java
@@ -18,6 +18,7 @@
 package org.gridgain.grid;
 
 import org.apache.ignite.*;
+import org.apache.ignite.cache.*;
 import org.apache.ignite.configuration.*;
 import org.apache.ignite.lang.*;
 import org.apache.ignite.logger.*;
@@ -341,14 +342,14 @@ public class GridBasicWarmupClosure implements IgniteInClosure<IgniteConfigurati
 
         cp.setClientConnectionConfiguration(null);
 
-        Collection<GridCacheConfiguration> reduced = new ArrayList<>();
+        Collection<CacheConfiguration> reduced = new ArrayList<>();
 
-        for (GridCacheConfiguration ccfg : gridCfg.getCacheConfiguration()) {
+        for (CacheConfiguration ccfg : gridCfg.getCacheConfiguration()) {
             if (CU.isSystemCache(ccfg.getName()))
                 continue;
 
             if (!matches(reduced, ccfg)) {
-                GridCacheConfiguration ccfgCp = new GridCacheConfiguration(ccfg);
+                CacheConfiguration ccfgCp = new CacheConfiguration(ccfg);
 
                 if (ccfgCp.getDistributionMode() == GridCacheDistributionMode.CLIENT_ONLY)
                     ccfgCp.setDistributionMode(GridCacheDistributionMode.PARTITIONED_ONLY);
@@ -365,7 +366,7 @@ public class GridBasicWarmupClosure implements IgniteInClosure<IgniteConfigurati
         if (F.isEmpty(reduced))
             return null;
 
-        GridCacheConfiguration[] res = new GridCacheConfiguration[reduced.size()];
+        CacheConfiguration[] res = new CacheConfiguration[reduced.size()];
 
         reduced.toArray(res);
 
@@ -381,8 +382,8 @@ public class GridBasicWarmupClosure implements IgniteInClosure<IgniteConfigurati
      * @param ccfg Cache configuration to match.
      * @return {@code True} if matching configuration is found, {@code false} otherwise.
      */
-    private boolean matches(Iterable<GridCacheConfiguration> reduced, GridCacheConfiguration ccfg) {
-        for (GridCacheConfiguration ccfg0 : reduced) {
+    private boolean matches(Iterable<CacheConfiguration> reduced, CacheConfiguration ccfg) {
+        for (CacheConfiguration ccfg0 : reduced) {
             if (matches(ccfg0, ccfg))
                 return true;
         }
@@ -397,7 +398,7 @@ public class GridBasicWarmupClosure implements IgniteInClosure<IgniteConfigurati
      * @param ccfg1 Second configuration.
      * @return {@code True} if configurations match.
      */
-    private boolean matches(GridCacheConfiguration ccfg0, GridCacheConfiguration ccfg1) {
+    private boolean matches(CacheConfiguration ccfg0, CacheConfiguration ccfg1) {
         return
             F.eq(ccfg0.getCacheMode(), ccfg1.getCacheMode()) &&
             F.eq(ccfg0.getBackups(), ccfg1.getBackups()) &&

http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/b0d8a67a/modules/core/src/main/java/org/gridgain/grid/cache/GridCache.java
----------------------------------------------------------------------
diff --git a/modules/core/src/main/java/org/gridgain/grid/cache/GridCache.java b/modules/core/src/main/java/org/gridgain/grid/cache/GridCache.java
index 95a002b..d003bf1 100644
--- a/modules/core/src/main/java/org/gridgain/grid/cache/GridCache.java
+++ b/modules/core/src/main/java/org/gridgain/grid/cache/GridCache.java
@@ -18,6 +18,7 @@
 package org.gridgain.grid.cache;
 
 import org.apache.ignite.*;
+import org.apache.ignite.cache.*;
 import org.apache.ignite.lang.*;
 import org.apache.ignite.transactions.*;
 import org.gridgain.grid.cache.affinity.*;
@@ -65,7 +66,7 @@ public interface GridCache<K, V> extends GridCacheProjection<K, V> {
      *
      * @return Configuration bean for this cache.
      */
-    public GridCacheConfiguration configuration();
+    public CacheConfiguration configuration();
 
     /**
      * Registers transactions synchronizations for all transactions started by this cache.
@@ -251,7 +252,7 @@ public interface GridCache<K, V> extends GridCacheProjection<K, V> {
 
     /**
      * Forces this cache node to re-balance its partitions. This method is usually used when
-     * {@link GridCacheConfiguration#getPreloadPartitionedDelay()} configuration parameter has non-zero value.
+     * {@link org.apache.ignite.cache.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.
@@ -259,12 +260,12 @@ public interface GridCache<K, V> extends GridCacheProjection<K, V> {
      * In case of{@link GridCacheMode#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 GridCacheConfiguration#getPreloadPartitionedDelay() preloadDelay} expires. To place nodes
+     * {@link org.apache.ignite.cache.CacheConfiguration#getPreloadPartitionedDelay() preloadDelay} expires. To place nodes
      * on the same place in consistent hash ring, use
      * {@link GridCacheConsistentHashAffinityFunction#setHashIdResolver(GridCacheAffinityNodeHashResolver)} to make sure that
      * a node maps to the same hash ID if re-started.
      * <p>
-     * See {@link GridCacheConfiguration#getPreloadPartitionedDelay()} for more information on how to configure
+     * See {@link org.apache.ignite.cache.CacheConfiguration#getPreloadPartitionedDelay()} for more information on how to configure
      * preload re-partition delay.
      * <p>
      * @return Future that will be completed when preloading is finished.

http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/b0d8a67a/modules/core/src/main/java/org/gridgain/grid/cache/GridCacheAtomicityMode.java
----------------------------------------------------------------------
diff --git a/modules/core/src/main/java/org/gridgain/grid/cache/GridCacheAtomicityMode.java b/modules/core/src/main/java/org/gridgain/grid/cache/GridCacheAtomicityMode.java
index 8098409..21cf540 100644
--- a/modules/core/src/main/java/org/gridgain/grid/cache/GridCacheAtomicityMode.java
+++ b/modules/core/src/main/java/org/gridgain/grid/cache/GridCacheAtomicityMode.java
@@ -26,7 +26,7 @@ import org.jetbrains.annotations.*;
  * used whenever transactions and explicit locking are not needed. Note that in {@link #ATOMIC}
  * mode cache will still maintain full data consistency across all cache nodes.
  * <p>
- * Cache atomicity may be set via {@link GridCacheConfiguration#getAtomicityMode()}
+ * Cache atomicity may be set via {@link org.apache.ignite.cache.CacheConfiguration#getAtomicityMode()}
  * configuration property.
  */
 public enum GridCacheAtomicityMode {


Mime
View raw message