ignite-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From sboi...@apache.org
Subject [02/16] incubator-ignite git commit: # ignite-6
Date Mon, 26 Jan 2015 14:18:52 GMT
http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/712ce142/modules/core/src/main/java/org/apache/ignite/cache/datastructures/IgniteCountDownLatch.java
----------------------------------------------------------------------
diff --git a/modules/core/src/main/java/org/apache/ignite/cache/datastructures/IgniteCountDownLatch.java b/modules/core/src/main/java/org/apache/ignite/cache/datastructures/IgniteCountDownLatch.java
new file mode 100644
index 0000000..3b4e8e5
--- /dev/null
+++ b/modules/core/src/main/java/org/apache/ignite/cache/datastructures/IgniteCountDownLatch.java
@@ -0,0 +1,226 @@
+/*
+ * 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.datastructures;
+
+import org.apache.ignite.*;
+
+import java.util.concurrent.*;
+
+/**
+ * This interface provides a rich API for working with distributed count down latch.
+ * <p>
+ * <h1 class="header">Functionality</h1>
+ * Distributed count down latch provides functionality similar to {@code java.util.CountDownLatch}.
+ * Note that you cannot remove count down latch having count greater that zero. It should be
+ * counted down to zero first.
+ * <h1 class="header">Creating Distributed Count Down Latch</h1>
+ * Instance of cache count down latch can be created by calling the following method:
+ * {@link CacheDataStructures#countDownLatch(String, int, boolean, boolean)}.
+ * @see CacheDataStructures#countDownLatch(String, int, boolean, boolean)
+ * @see CacheDataStructures#removeCountDownLatch(String)
+ */
+public interface IgniteCountDownLatch {
+    /**
+     * Gets name of the latch.
+     *
+     * @return Name of the latch.
+     */
+    public String name();
+
+    /**
+     * Gets current count value of the latch.
+     *
+     * @return Current count.
+     */
+    public int count();
+
+    /**
+     * Gets initial count value of the latch.
+     *
+     * @return Initial count.
+     */
+    public int initialCount();
+
+    /**
+     * Gets {@code autoDelete} flag. If this flag is {@code true} latch is removed
+     * from cache when it has been counted down to 0.
+     *
+     * @return Value of {@code autoDelete} flag.
+     */
+    public boolean autoDelete();
+
+    /**
+     * Causes the current thread to wait until the latch has counted down to
+     * zero, unless current thread is interrupted.
+     * <p>
+     * If the current count of the latch is zero then this method returns immediately.
+     * <p>
+     * If the current count is greater than zero then the current
+     * thread becomes disabled for thread scheduling purposes and lies
+     * dormant until one of two things happen:
+     * <ul>
+     *     <li>The count reaches zero due to invocations of the
+     *      {@link #countDown} method on any node; or
+     *      <li>Some other thread interrupts the current thread.
+     * </ul>
+     * <p>
+     * If the current thread:
+     * <ul>
+     *      <li>has its interrupted status set on entry to this method; or
+     *      <li>is interrupted while waiting,
+     * </ul>
+     * then {@link org.apache.ignite.IgniteInterruptedException} is thrown and the current thread's
+     * interrupted status is cleared.
+     *
+     * @throws IgniteCheckedException If operation failed.
+     * @throws org.apache.ignite.IgniteInterruptedException if the current thread is interrupted
+     *      while waiting
+     */
+    public void await() throws IgniteCheckedException;
+
+    /**
+     * Causes the current thread to wait until the latch has counted down to
+     * zero, unless the thread is interrupted, or the specified waiting time elapses.
+     * <p>
+     * If the current count is zero then this method returns immediately
+     * with the value {@code true}.
+     * <p>
+     * If the current count is greater than zero then the current
+     * thread becomes disabled for thread scheduling purposes and lies
+     * dormant until one of three things happen:
+     * <ul>
+     *      <li>The count reaches zero due to invocations of the
+     *      {@link #countDown} method on any node; or
+     *      <li>Some other thread interrupts the current thread; or
+     *      <li>The specified waiting time elapses.
+     * </ul>
+     * <p>
+     * If the count reaches zero then the method returns with the
+     * value {@code true}.
+     * <p>
+     * If the current thread:
+     * <ul>
+     *      <li>has its interrupted status set on entry to this method; or
+     *      <li>is interrupted while waiting,
+     * </ul>
+     * then {@link org.apache.ignite.IgniteInterruptedException} is thrown and the current thread's
+     * interrupted status is cleared.
+     * <p>
+     * If the specified waiting time elapses then the value {@code false}
+     * is returned.  If the time is less than or equal to zero, the method
+     * will not wait at all.
+     *
+     * @param timeout The maximum time to wait in milliseconds.
+     * @return {@code True} if the count reached zero and {@code false}
+     *      if the waiting time elapsed before the count reached zero.
+     * @throws org.apache.ignite.IgniteInterruptedException If the current thread is interrupted
+     *      while waiting.
+     * @throws IgniteCheckedException If operation failed.
+     */
+    public boolean await(long timeout) throws IgniteCheckedException;
+
+    /**
+     * Causes the current thread to wait until the latch has counted down to
+     * zero, unless the thread is interrupted, or the specified waiting time elapses.
+     * <p>
+     * If the current count is zero then this method returns immediately
+     * with the value {@code true}.
+     * <p>
+     * If the current count is greater than zero then the current
+     * thread becomes disabled for thread scheduling purposes and lies
+     * dormant until one of three things happen:
+     * <ul>
+     *      <li>The count reaches zero due to invocations of the
+     *      {@link #countDown} method on any node; or
+     *      <li>Some other thread interrupts the current thread; or
+     *      <li>The specified waiting time elapses.
+     * </ul>
+     * <p>
+     * If the count reaches zero then the method returns with the
+     * value {@code true}.
+     * <p>
+     * If the current thread:
+     * <ul>
+     *      <li>has its interrupted status set on entry to this method; or
+     *      <li>is interrupted while waiting,
+     * </ul>
+     * then {@link org.apache.ignite.IgniteInterruptedException} is thrown and the current thread's
+     * interrupted status is cleared.
+     * <p>
+     * If the specified waiting time elapses then the value {@code false}
+     * is returned.  If the time is less than or equal to zero, the method
+     * will not wait at all.
+     *
+     *
+     * @param timeout The maximum time to wait.
+     * @param unit The time unit of the {@code timeout} argument.
+     * @return {@code True} if the count reached zero and {@code false}
+     *      if the waiting time elapsed before the count reached zero.
+     * @throws org.apache.ignite.IgniteInterruptedException If the current thread is interrupted
+     *      while waiting.
+     * @throws IgniteCheckedException If operation failed.
+     */
+    public boolean await(long timeout, TimeUnit unit) throws IgniteCheckedException;
+
+    /**
+     * Decrements the count of the latch, releasing all waiting threads
+     * on all nodes if the count reaches zero.
+     * <p>
+     * If the current count is greater than zero then it is decremented.
+     * If the new count is zero then all waiting threads are re-enabled for
+     * thread scheduling purposes.
+     * <p>
+     * If the current count equals zero then nothing happens.
+     *
+     * @return Count after decrement.
+     * @throws IgniteCheckedException If operation failed.
+     */
+    public int countDown() throws IgniteCheckedException;
+
+    /**
+     * Decreases the count of the latch using passed in value,
+     * releasing all waiting threads on all nodes if the count reaches zero.
+     * <p>
+     * If the current count is greater than zero then it is decreased.
+     * If the new count is zero then all waiting threads are re-enabled for
+     * thread scheduling purposes.
+     * <p>
+     * If the current count equals zero then nothing happens.
+     *
+     * @param val Value to decrease counter on.
+     * @return Count after decreasing.
+     * @throws IgniteCheckedException If operation failed.
+     */
+    public int countDown(int val) throws IgniteCheckedException;
+
+    /**
+     * Counts down this latch to zero, releasing all waiting threads on all nodes.
+     * <p>
+     * If the current count equals zero then nothing happens.
+     *
+     * @throws IgniteCheckedException If operation failed.
+     */
+    public void countDownAll() throws IgniteCheckedException;
+
+    /**
+     * Gets {@code removed} status of the latch.
+     *
+     * @return {@code True} if latch was removed from cache, {@code false} otherwise.
+     */
+    public boolean removed();
+}

http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/712ce142/modules/core/src/main/java/org/apache/ignite/cache/datastructures/IgniteQueue.java
----------------------------------------------------------------------
diff --git a/modules/core/src/main/java/org/apache/ignite/cache/datastructures/IgniteQueue.java b/modules/core/src/main/java/org/apache/ignite/cache/datastructures/IgniteQueue.java
new file mode 100644
index 0000000..6c40599
--- /dev/null
+++ b/modules/core/src/main/java/org/apache/ignite/cache/datastructures/IgniteQueue.java
@@ -0,0 +1,182 @@
+/*
+ * 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.datastructures;
+
+import org.apache.ignite.*;
+import org.jetbrains.annotations.*;
+
+import java.util.*;
+import java.util.concurrent.*;
+
+/**
+ * This interface provides a rich API for working with distributed queues based on In-Memory Data Grid.
+ * <p>
+ * <h1 class="header">Overview</h1>
+ * Cache queue provides an access to cache elements using typical queue API. Cache queue also implements
+ * {@link Collection} interface and provides all methods from collections including
+ * {@link Collection#addAll(Collection)}, {@link Collection#removeAll(Collection)}, and
+ * {@link Collection#retainAll(Collection)} methods for bulk operations. Note that all
+ * {@link Collection} methods in the queue may throw {@link IgniteException} in case
+ * of failure.
+ * <p>
+ * All queue operations have synchronous and asynchronous counterparts.
+ * <h1 class="header">Bounded vs Unbounded</h1>
+ * Queues can be {@code unbounded} or {@code bounded}. {@code Bounded} queues can
+ * have maximum capacity. Queue capacity can be set at creation time and cannot be
+ * changed later. Here is an example of how to create {@code bounded} {@code LIFO} queue with
+ * capacity of {@code 1000} items.
+ * <pre name="code" class="java">
+ * IgniteQueue&lt;String&gt; queue = cache().queue("anyName", LIFO, 1000);
+ * ...
+ * queue.add("item");
+ * </pre>
+ * For {@code bounded} queues <b>blocking</b> operations, such as {@link #take()} or {@link #put(Object)}
+ * are available. These operations will block until queue capacity changes to make the operation
+ * possible.
+ * <h1 class="header">Collocated vs Non-collocated</h1>
+ * Queue items can be placed on one node or distributed throughout grid nodes
+ * (governed by {@code collocated} parameter). {@code Non-collocated} mode is provided only
+ * for partitioned caches. If {@code collocated} parameter is {@code true}, then all queue items
+ * will be collocated on one node, otherwise items will be distributed through all grid nodes.
+ * Unless explicitly specified, by default queues are {@code collocated}.
+ * <p>
+ * Here is an example of how create {@code unbounded} queue
+ * in non-collocated mode.
+ * <pre name="code" class="java">
+ * IgniteQueue&lt;String&gt; queue = cache().queue("anyName", 0 &#047;*unbounded*&#047;, false &#047;*non-collocated*&#047;);
+ * ...
+ * queue.add("item");
+ * </pre>
+ * <h1 class="header">Creating Cache Queues</h1>
+ * Instances of distributed cache queues can be created by calling the following method
+ * on {@link CacheDataStructures} API:
+ * <ul>
+ *     <li>{@link CacheDataStructures#queue(String, int, boolean, boolean)}</li>
+ * </ul>
+ * @see CacheDataStructures#queue(String, int, boolean, boolean)
+ * @see CacheDataStructures#removeQueue(String)
+ * @see CacheDataStructures#removeQueue(String, int)
+ */
+public interface IgniteQueue<T> extends BlockingQueue<T> {
+    /**
+     * Gets queue name.
+     *
+     * @return Queue name.
+     */
+    public String name();
+
+    /** {@inheritDoc} */
+    @Override public boolean add(T item) throws IgniteException;
+
+    /** {@inheritDoc} */
+    @Override public boolean offer(T item) throws IgniteException;
+
+    /** {@inheritDoc} */
+    @Override public boolean offer(T item, long timeout, TimeUnit unit) throws IgniteException;
+
+    /** {@inheritDoc} */
+    @Override public boolean addAll(Collection<? extends T> items) throws IgniteException;
+
+    /** {@inheritDoc} */
+    @Override public boolean contains(Object item) throws IgniteException;
+
+    /** {@inheritDoc} */
+    @Override public boolean containsAll(Collection<?> items) throws IgniteException;
+
+    /** {@inheritDoc} */
+    @Override public void clear() throws IgniteException;
+
+    /** {@inheritDoc} */
+    @Override public boolean remove(Object item) throws IgniteException;
+
+    /** {@inheritDoc} */
+    @Override public boolean removeAll(Collection<?> items) throws IgniteException;
+
+    /** {@inheritDoc} */
+    @Override public boolean isEmpty() throws IgniteException;
+
+    /** {@inheritDoc} */
+    @Override public Iterator<T> iterator() throws IgniteException;
+
+    /** {@inheritDoc} */
+    @Override public Object[] toArray() throws IgniteException;
+
+    /** {@inheritDoc} */
+    @Override public <T> T[] toArray(T[] a) throws IgniteException;
+
+    /** {@inheritDoc} */
+    @Override public boolean retainAll(Collection<?> items) throws IgniteException;
+
+    /** {@inheritDoc} */
+    @Override public int size() throws IgniteException;
+
+    /** {@inheritDoc} */
+    @Override @Nullable public T poll() throws IgniteException;
+
+    /** {@inheritDoc} */
+    @Override @Nullable public T peek() throws IgniteException;
+
+    /** {@inheritDoc} */
+    @Override public void put(T item) throws IgniteException;
+
+    /** {@inheritDoc} */
+    @Override @Nullable public T take() throws IgniteException;
+
+    /** {@inheritDoc} */
+    @Override @Nullable public T poll(long timeout, TimeUnit unit) throws IgniteException;
+
+    /**
+     * Removes all of the elements from this queue. Method is used in massive queues with huge numbers of elements.
+     *
+     * @param batchSize Batch size.
+     * @throws IgniteException if operation failed.
+     */
+    public void clear(int batchSize) throws IgniteException;
+
+    /**
+     * Gets maximum number of elements of the queue.
+     *
+     * @return Maximum number of elements. If queue is unbounded {@code Integer.MAX_SIZE} will return.
+     * @throws IgniteCheckedException If operation failed.
+     */
+    public int capacity() throws IgniteCheckedException;
+
+    /**
+     * Returns {@code true} if this queue is bounded.
+     *
+     * @return {@code true} if this queue is bounded.
+     * @throws IgniteCheckedException If operation failed.
+     */
+    public boolean bounded() throws IgniteCheckedException;
+
+    /**
+     * Returns {@code true} if this queue can be kept on the one node only.
+     * Returns {@code false} if this queue can be kept on the many nodes.
+     *
+     * @return {@code true} if this queue is in {@code collocated} mode {@code false} otherwise.
+     * @throws IgniteCheckedException If operation failed.
+     */
+    public boolean collocated() throws IgniteCheckedException;
+
+    /**
+     * Gets status of queue.
+     *
+     * @return {@code true} if queue was removed from cache {@code false} otherwise.
+     */
+    public boolean removed();
+}

http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/712ce142/modules/core/src/main/java/org/apache/ignite/cache/datastructures/IgniteSet.java
----------------------------------------------------------------------
diff --git a/modules/core/src/main/java/org/apache/ignite/cache/datastructures/IgniteSet.java b/modules/core/src/main/java/org/apache/ignite/cache/datastructures/IgniteSet.java
new file mode 100644
index 0000000..ddd1f5d
--- /dev/null
+++ b/modules/core/src/main/java/org/apache/ignite/cache/datastructures/IgniteSet.java
@@ -0,0 +1,61 @@
+/*
+ * 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.datastructures;
+
+import org.apache.ignite.*;
+
+import java.util.*;
+
+/**
+ * Set implementation based on on In-Memory Data Grid.
+ * <h1 class="header">Overview</h1>
+ * Cache set implements {@link Set} interface and provides all methods from collections.
+ * Note that all {@link Collection} methods in the set may throw {@link IgniteException} in case of failure
+ * or if set was removed.
+ * <h1 class="header">Collocated vs Non-collocated</h1>
+ * Set items can be placed on one node or distributed throughout grid nodes
+ * (governed by {@code collocated} parameter). {@code Non-collocated} mode is provided only
+ * for partitioned caches. If {@code collocated} parameter is {@code true}, then all set items
+ * will be collocated on one node, otherwise items will be distributed through all grid nodes.
+ * @see CacheDataStructures#set(String, boolean, boolean)
+ * @see CacheDataStructures#removeSet(String)
+ */
+public interface IgniteSet<T> extends Set<T> {
+    /**
+     * Gets set name.
+     *
+     * @return Set name.
+     */
+    public String name();
+
+    /**
+     * Returns {@code true} if this set can be kept on the one node only.
+     * Returns {@code false} if this set can be kept on the many nodes.
+     *
+     * @return {@code True} if this set is in {@code collocated} mode {@code false} otherwise.
+     * @throws IgniteCheckedException If operation failed.
+     */
+    public boolean collocated() throws IgniteCheckedException;
+
+    /**
+     * Gets status of set.
+     *
+     * @return {@code True} if set was removed from cache {@code false} otherwise.
+     */
+    public boolean removed();
+}

http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/712ce142/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/datastructures/GridAtomicCacheQueueImpl.java
----------------------------------------------------------------------
diff --git a/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/datastructures/GridAtomicCacheQueueImpl.java b/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/datastructures/GridAtomicCacheQueueImpl.java
index 7ce5632..cc43a3e 100644
--- a/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/datastructures/GridAtomicCacheQueueImpl.java
+++ b/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/datastructures/GridAtomicCacheQueueImpl.java
@@ -27,7 +27,7 @@ import javax.cache.processor.*;
 import java.util.*;
 
 /**
- * {@link org.apache.ignite.cache.datastructures.CacheQueue} implementation using atomic cache.
+ * {@link org.apache.ignite.cache.datastructures.IgniteQueue} implementation using atomic cache.
  */
 public class GridAtomicCacheQueueImpl<T> extends GridCacheQueueAdapter<T> {
     /** */

http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/712ce142/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/datastructures/GridCacheAtomicLongEx.java
----------------------------------------------------------------------
diff --git a/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/datastructures/GridCacheAtomicLongEx.java b/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/datastructures/GridCacheAtomicLongEx.java
index 3d496e3..b7e0333 100644
--- a/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/datastructures/GridCacheAtomicLongEx.java
+++ b/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/datastructures/GridCacheAtomicLongEx.java
@@ -22,7 +22,7 @@ import org.apache.ignite.cache.datastructures.*;
 /**
  * Atomic managed by cache ({@code 'Ex'} stands for external).
  */
-public interface GridCacheAtomicLongEx extends GridCacheRemovable, CacheAtomicLong {
+public interface GridCacheAtomicLongEx extends GridCacheRemovable, IgniteAtomicLong {
     /**
      * Get current atomic long key.
      *

http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/712ce142/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/datastructures/GridCacheAtomicReferenceEx.java
----------------------------------------------------------------------
diff --git a/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/datastructures/GridCacheAtomicReferenceEx.java b/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/datastructures/GridCacheAtomicReferenceEx.java
index d7fd5da..4eac0bb 100644
--- a/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/datastructures/GridCacheAtomicReferenceEx.java
+++ b/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/datastructures/GridCacheAtomicReferenceEx.java
@@ -22,7 +22,7 @@ import org.apache.ignite.cache.datastructures.*;
 /**
  * Atomic reference managed by cache ({@code 'Ex'} stands for external).
  */
-public interface GridCacheAtomicReferenceEx<T> extends GridCacheRemovable, CacheAtomicReference<T> {
+public interface GridCacheAtomicReferenceEx<T> extends GridCacheRemovable, IgniteAtomicReference<T> {
     /**
      * Get current atomic reference key.
      *

http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/712ce142/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/datastructures/GridCacheAtomicSequenceEx.java
----------------------------------------------------------------------
diff --git a/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/datastructures/GridCacheAtomicSequenceEx.java b/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/datastructures/GridCacheAtomicSequenceEx.java
index 914872b..7e96bb2 100644
--- a/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/datastructures/GridCacheAtomicSequenceEx.java
+++ b/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/datastructures/GridCacheAtomicSequenceEx.java
@@ -22,7 +22,7 @@ import org.apache.ignite.cache.datastructures.*;
 /**
  * Sequence managed by cache ({@code 'Ex'} stands for external.
  */
-public interface GridCacheAtomicSequenceEx extends GridCacheRemovable, CacheAtomicSequence {
+public interface GridCacheAtomicSequenceEx extends GridCacheRemovable, IgniteAtomicSequence {
     /**
      * Get current sequence key.
      *

http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/712ce142/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/datastructures/GridCacheAtomicStampedEx.java
----------------------------------------------------------------------
diff --git a/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/datastructures/GridCacheAtomicStampedEx.java b/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/datastructures/GridCacheAtomicStampedEx.java
index 733c13c..c236c51 100644
--- a/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/datastructures/GridCacheAtomicStampedEx.java
+++ b/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/datastructures/GridCacheAtomicStampedEx.java
@@ -22,7 +22,7 @@ import org.apache.ignite.cache.datastructures.*;
 /**
  * Atomic stamped managed by cache ({@code 'Ex'} stands for external).
  */
-public interface GridCacheAtomicStampedEx<T, S> extends GridCacheRemovable, CacheAtomicStamped<T, S> {
+public interface GridCacheAtomicStampedEx<T, S> extends GridCacheRemovable, IgniteAtomicStamped<T, S> {
     /**
      * Get current atomic stamped key.
      *

http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/712ce142/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/datastructures/GridCacheCountDownLatchEx.java
----------------------------------------------------------------------
diff --git a/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/datastructures/GridCacheCountDownLatchEx.java b/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/datastructures/GridCacheCountDownLatchEx.java
index af7c7f3..5be5d4a 100644
--- a/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/datastructures/GridCacheCountDownLatchEx.java
+++ b/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/datastructures/GridCacheCountDownLatchEx.java
@@ -22,7 +22,7 @@ import org.apache.ignite.cache.datastructures.*;
 /**
  * Grid cache count down latch ({@code 'Ex'} stands for external).
  */
-public interface GridCacheCountDownLatchEx extends CacheCountDownLatch, GridCacheRemovable {
+public interface GridCacheCountDownLatchEx extends IgniteCountDownLatch, GridCacheRemovable {
     /**
      * Get current count down latch key.
      *

http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/712ce142/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/datastructures/GridCacheDataStructuresImpl.java
----------------------------------------------------------------------
diff --git a/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/datastructures/GridCacheDataStructuresImpl.java b/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/datastructures/GridCacheDataStructuresImpl.java
index 9008aca..79710dd 100644
--- a/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/datastructures/GridCacheDataStructuresImpl.java
+++ b/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/datastructures/GridCacheDataStructuresImpl.java
@@ -37,7 +37,7 @@ public class GridCacheDataStructuresImpl<K, V> implements CacheDataStructures {
     }
 
     /** {@inheritDoc} */
-    @Override public CacheAtomicSequence atomicSequence(String name, long initVal, boolean create)
+    @Override public IgniteAtomicSequence atomicSequence(String name, long initVal, boolean create)
         throws IgniteCheckedException {
         return dsMgr.sequence(name, initVal, create);
     }
@@ -48,7 +48,7 @@ public class GridCacheDataStructuresImpl<K, V> implements CacheDataStructures {
     }
 
     /** {@inheritDoc} */
-    @Override public CacheAtomicLong atomicLong(String name, long initVal, boolean create) throws IgniteCheckedException {
+    @Override public IgniteAtomicLong atomicLong(String name, long initVal, boolean create) throws IgniteCheckedException {
         return dsMgr.atomicLong(name, initVal, create);
     }
 
@@ -58,7 +58,7 @@ public class GridCacheDataStructuresImpl<K, V> implements CacheDataStructures {
     }
 
     /** {@inheritDoc} */
-    @Override public <T> CacheAtomicReference<T> atomicReference(String name, T initVal, boolean create)
+    @Override public <T> IgniteAtomicReference<T> atomicReference(String name, T initVal, boolean create)
         throws IgniteCheckedException {
         return dsMgr.atomicReference(name, initVal, create);
     }
@@ -69,7 +69,7 @@ public class GridCacheDataStructuresImpl<K, V> implements CacheDataStructures {
     }
 
     /** {@inheritDoc} */
-    @Override public <T, S> CacheAtomicStamped<T, S> atomicStamped(String name, T initVal, S initStamp,
+    @Override public <T, S> IgniteAtomicStamped<T, S> atomicStamped(String name, T initVal, S initStamp,
         boolean create) throws IgniteCheckedException {
         return dsMgr.atomicStamped(name, initVal, initStamp, create);
     }
@@ -80,7 +80,7 @@ public class GridCacheDataStructuresImpl<K, V> implements CacheDataStructures {
     }
 
     /** {@inheritDoc} */
-    @Override public <T> CacheQueue<T> queue(String name, int cap, boolean collocated, boolean create)
+    @Override public <T> IgniteQueue<T> queue(String name, int cap, boolean collocated, boolean create)
         throws IgniteCheckedException {
         return dsMgr.queue(name, cap <= 0 ? Integer.MAX_VALUE : cap, collocated, create);
     }
@@ -96,7 +96,7 @@ public class GridCacheDataStructuresImpl<K, V> implements CacheDataStructures {
     }
 
     /** {@inheritDoc} */
-    @Nullable @Override public <T> CacheSet<T> set(String name, boolean collocated, boolean create)
+    @Nullable @Override public <T> IgniteSet<T> set(String name, boolean collocated, boolean create)
         throws IgniteCheckedException {
         return dsMgr.set(name, collocated, create);
     }
@@ -107,7 +107,7 @@ public class GridCacheDataStructuresImpl<K, V> implements CacheDataStructures {
     }
 
     /** {@inheritDoc} */
-    @Nullable @Override public CacheCountDownLatch countDownLatch(String name, int cnt, boolean autoDel,
+    @Nullable @Override public IgniteCountDownLatch countDownLatch(String name, int cnt, boolean autoDel,
         boolean create) throws IgniteCheckedException {
         return dsMgr.countDownLatch(name, cnt, autoDel, create);
     }

http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/712ce142/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/datastructures/GridCacheDataStructuresManager.java
----------------------------------------------------------------------
diff --git a/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/datastructures/GridCacheDataStructuresManager.java b/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/datastructures/GridCacheDataStructuresManager.java
index d49ea9f..b706c2c 100644
--- a/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/datastructures/GridCacheDataStructuresManager.java
+++ b/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/datastructures/GridCacheDataStructuresManager.java
@@ -181,7 +181,7 @@ public final class GridCacheDataStructuresManager<K, V> extends GridCacheManager
      * @return Sequence.
      * @throws IgniteCheckedException If loading failed.
      */
-    public final CacheAtomicSequence sequence(final String name, final long initVal,
+    public final IgniteAtomicSequence sequence(final String name, final long initVal,
         final boolean create) throws IgniteCheckedException {
         waitInitialization();
 
@@ -191,14 +191,14 @@ public final class GridCacheDataStructuresManager<K, V> extends GridCacheManager
 
         try {
             // Check type of structure received by key from local cache.
-            CacheAtomicSequence val = cast(dsMap.get(key), CacheAtomicSequence.class);
+            IgniteAtomicSequence val = cast(dsMap.get(key), IgniteAtomicSequence.class);
 
             if (val != null)
                 return val;
 
-            return CU.outTx(new Callable<CacheAtomicSequence>() {
+            return CU.outTx(new Callable<IgniteAtomicSequence>() {
                 @Override
-                public CacheAtomicSequence call() throws Exception {
+                public IgniteAtomicSequence call() throws Exception {
                     try (IgniteTx tx = CU.txStartInternal(cctx, dsView, PESSIMISTIC, REPEATABLE_READ)) {
                         GridCacheAtomicSequenceValue seqVal = cast(dsView.get(key),
                             GridCacheAtomicSequenceValue.class);
@@ -299,7 +299,7 @@ public final class GridCacheDataStructuresManager<K, V> extends GridCacheManager
      * @return Atomic long.
      * @throws IgniteCheckedException If loading failed.
      */
-    public final CacheAtomicLong atomicLong(final String name, final long initVal,
+    public final IgniteAtomicLong atomicLong(final String name, final long initVal,
         final boolean create) throws IgniteCheckedException {
         waitInitialization();
 
@@ -309,14 +309,14 @@ public final class GridCacheDataStructuresManager<K, V> extends GridCacheManager
 
         try {
             // Check type of structure received by key from local cache.
-            CacheAtomicLong atomicLong = cast(dsMap.get(key), CacheAtomicLong.class);
+            IgniteAtomicLong atomicLong = cast(dsMap.get(key), IgniteAtomicLong.class);
 
             if (atomicLong != null)
                 return atomicLong;
 
-            return CU.outTx(new Callable<CacheAtomicLong>() {
+            return CU.outTx(new Callable<IgniteAtomicLong>() {
                 @Override
-                public CacheAtomicLong call() throws Exception {
+                public IgniteAtomicLong call() throws Exception {
                     try (IgniteTx tx = CU.txStartInternal(cctx, dsView, PESSIMISTIC, REPEATABLE_READ)) {
                         GridCacheAtomicLongValue val = cast(dsView.get(key),
                             GridCacheAtomicLongValue.class);
@@ -395,7 +395,7 @@ public final class GridCacheDataStructuresManager<K, V> extends GridCacheManager
      * @throws IgniteCheckedException If loading failed.
      */
     @SuppressWarnings("unchecked")
-    public final <T> CacheAtomicReference<T> atomicReference(final String name, final T initVal,
+    public final <T> IgniteAtomicReference<T> atomicReference(final String name, final T initVal,
         final boolean create) throws IgniteCheckedException {
         waitInitialization();
 
@@ -405,14 +405,14 @@ public final class GridCacheDataStructuresManager<K, V> extends GridCacheManager
 
         try {
             // Check type of structure received by key from local cache.
-            CacheAtomicReference atomicRef = cast(dsMap.get(key), CacheAtomicReference.class);
+            IgniteAtomicReference atomicRef = cast(dsMap.get(key), IgniteAtomicReference.class);
 
             if (atomicRef != null)
                 return atomicRef;
 
-            return CU.outTx(new Callable<CacheAtomicReference<T>>() {
+            return CU.outTx(new Callable<IgniteAtomicReference<T>>() {
                 @Override
-                public CacheAtomicReference<T> call() throws Exception {
+                public IgniteAtomicReference<T> call() throws Exception {
                     try (IgniteTx tx = CU.txStartInternal(cctx, dsView, PESSIMISTIC, REPEATABLE_READ)) {
                         GridCacheAtomicReferenceValue val = cast(dsView.get(key),
                             GridCacheAtomicReferenceValue.class);
@@ -494,7 +494,7 @@ public final class GridCacheDataStructuresManager<K, V> extends GridCacheManager
      * @throws IgniteCheckedException If loading failed.
      */
     @SuppressWarnings("unchecked")
-    public final <T, S> CacheAtomicStamped<T, S> atomicStamped(final String name, final T initVal,
+    public final <T, S> IgniteAtomicStamped<T, S> atomicStamped(final String name, final T initVal,
         final S initStamp, final boolean create) throws IgniteCheckedException {
         waitInitialization();
 
@@ -504,14 +504,14 @@ public final class GridCacheDataStructuresManager<K, V> extends GridCacheManager
 
         try {
             // Check type of structure received by key from local cache.
-            CacheAtomicStamped atomicStamped = cast(dsMap.get(key), CacheAtomicStamped.class);
+            IgniteAtomicStamped atomicStamped = cast(dsMap.get(key), IgniteAtomicStamped.class);
 
             if (atomicStamped != null)
                 return atomicStamped;
 
-            return CU.outTx(new Callable<CacheAtomicStamped<T, S>>() {
+            return CU.outTx(new Callable<IgniteAtomicStamped<T, S>>() {
                 @Override
-                public CacheAtomicStamped<T, S> call() throws Exception {
+                public IgniteAtomicStamped<T, S> call() throws Exception {
                     try (IgniteTx tx = CU.txStartInternal(cctx, dsView, PESSIMISTIC, REPEATABLE_READ)) {
                         GridCacheAtomicStampedValue val = cast(dsView.get(key),
                             GridCacheAtomicStampedValue.class);
@@ -590,7 +590,7 @@ public final class GridCacheDataStructuresManager<K, V> extends GridCacheManager
      * @return Instance of queue.
      * @throws IgniteCheckedException If failed.
      */
-    public final <T> CacheQueue<T> queue(final String name, final int cap, boolean colloc,
+    public final <T> IgniteQueue<T> queue(final String name, final int cap, boolean colloc,
         final boolean create) throws IgniteCheckedException {
         waitInitialization();
 
@@ -602,8 +602,8 @@ public final class GridCacheDataStructuresManager<K, V> extends GridCacheManager
         if (cctx.atomic())
             return queue0(name, cap, collocMode, create);
 
-        return CU.outTx(new Callable<CacheQueue<T>>() {
-            @Override public CacheQueue<T> call() throws Exception {
+        return CU.outTx(new Callable<IgniteQueue<T>>() {
+            @Override public IgniteQueue<T> call() throws Exception {
                 return queue0(name, cap, collocMode, create);
             }
         }, cctx);
@@ -620,7 +620,7 @@ public final class GridCacheDataStructuresManager<K, V> extends GridCacheManager
      * @throws IgniteCheckedException If failed.
      */
     @SuppressWarnings({"unchecked", "NonPrivateFieldAccessedInSynchronizedContext"})
-    private <T> CacheQueue<T> queue0(final String name, final int cap, boolean colloc, final boolean create)
+    private <T> IgniteQueue<T> queue0(final String name, final int cap, boolean colloc, final boolean create)
         throws IgniteCheckedException {
         GridCacheQueueHeaderKey key = new GridCacheQueueHeaderKey(name);
 
@@ -773,7 +773,7 @@ public final class GridCacheDataStructuresManager<K, V> extends GridCacheManager
      *      {@code create} is false.
      * @throws IgniteCheckedException If operation failed.
      */
-    public CacheCountDownLatch countDownLatch(final String name, final int cnt, final boolean autoDel,
+    public IgniteCountDownLatch countDownLatch(final String name, final int cnt, final boolean autoDel,
         final boolean create) throws IgniteCheckedException {
         A.ensure(cnt >= 0, "count can not be negative");
 
@@ -785,13 +785,13 @@ public final class GridCacheDataStructuresManager<K, V> extends GridCacheManager
 
         try {
             // Check type of structure received by key from local cache.
-            CacheCountDownLatch latch = cast(dsMap.get(key), CacheCountDownLatch.class);
+            IgniteCountDownLatch latch = cast(dsMap.get(key), IgniteCountDownLatch.class);
 
             if (latch != null)
                 return latch;
 
-            return CU.outTx(new Callable<CacheCountDownLatch>() {
-                    @Override public CacheCountDownLatch call() throws Exception {
+            return CU.outTx(new Callable<IgniteCountDownLatch>() {
+                    @Override public IgniteCountDownLatch call() throws Exception {
                         try (IgniteTx tx = CU.txStartInternal(cctx, dsView, PESSIMISTIC, REPEATABLE_READ)) {
                             GridCacheCountDownLatchValue val = cast(dsView.get(key),
                                 GridCacheCountDownLatchValue.class);
@@ -975,7 +975,7 @@ public final class GridCacheDataStructuresManager<K, V> extends GridCacheManager
                         }
                         else if (latch != null) {
                             U.error(log, "Failed to cast object " +
-                                "[expected=" + CacheCountDownLatch.class.getSimpleName() +
+                                "[expected=" + IgniteCountDownLatch.class.getSimpleName() +
                                 ", actual=" + latch.getClass() + ", value=" + latch + ']');
                         }
                     }
@@ -1017,18 +1017,18 @@ public final class GridCacheDataStructuresManager<K, V> extends GridCacheManager
 
 
     /**
-     * @return {@code True} if {@link org.apache.ignite.cache.datastructures.CacheQueue} can be used with current cache configuration.
+     * @return {@code True} if {@link org.apache.ignite.cache.datastructures.IgniteQueue} can be used with current cache configuration.
      */
     private boolean supportsQueue() {
         return !(cctx.atomic() && !cctx.isLocal() && cctx.config().getAtomicWriteOrderMode() == CLOCK);
     }
 
     /**
-     * @throws IgniteCheckedException If {@link org.apache.ignite.cache.datastructures.CacheQueue} can not be used with current cache configuration.
+     * @throws IgniteCheckedException If {@link org.apache.ignite.cache.datastructures.IgniteQueue} can not be used with current cache configuration.
      */
     private void checkSupportsQueue() throws IgniteCheckedException {
         if (cctx.atomic() && !cctx.isLocal() && cctx.config().getAtomicWriteOrderMode() == CLOCK)
-            throw new IgniteCheckedException("CacheQueue can not be used with ATOMIC cache with CLOCK write order mode" +
+            throw new IgniteCheckedException("IgniteQueue can not be used with ATOMIC cache with CLOCK write order mode" +
                 " (change write order mode to PRIMARY in configuration)");
     }
 
@@ -1054,7 +1054,7 @@ public final class GridCacheDataStructuresManager<K, V> extends GridCacheManager
      * @return Set instance.
      * @throws IgniteCheckedException If failed.
      */
-    @Nullable public <T> CacheSet<T> set(final String name, boolean collocated, final boolean create)
+    @Nullable public <T> IgniteSet<T> set(final String name, boolean collocated, final boolean create)
         throws IgniteCheckedException {
         waitInitialization();
 
@@ -1064,8 +1064,8 @@ public final class GridCacheDataStructuresManager<K, V> extends GridCacheManager
         if (cctx.atomic())
             return set0(name, collocMode, create);
 
-        return CU.outTx(new Callable<CacheSet<T>>() {
-            @Nullable @Override public CacheSet<T> call() throws Exception {
+        return CU.outTx(new Callable<IgniteSet<T>>() {
+            @Nullable @Override public IgniteSet<T> call() throws Exception {
                 return set0(name, collocMode, create);
             }
         }, cctx);
@@ -1163,7 +1163,7 @@ public final class GridCacheDataStructuresManager<K, V> extends GridCacheManager
      * @throws IgniteCheckedException If failed.
      */
     @SuppressWarnings("unchecked")
-    @Nullable private <T> CacheSet<T> set0(String name, boolean collocated, boolean create) throws IgniteCheckedException {
+    @Nullable private <T> IgniteSet<T> set0(String name, boolean collocated, boolean create) throws IgniteCheckedException {
         GridCacheSetHeaderKey key = new GridCacheSetHeaderKey(name);
 
         GridCacheSetHeader hdr;

http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/712ce142/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/datastructures/GridCacheDataStructuresProxy.java
----------------------------------------------------------------------
diff --git a/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/datastructures/GridCacheDataStructuresProxy.java b/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/datastructures/GridCacheDataStructuresProxy.java
index 2727c52..705be29 100644
--- a/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/datastructures/GridCacheDataStructuresProxy.java
+++ b/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/datastructures/GridCacheDataStructuresProxy.java
@@ -59,7 +59,7 @@ public class GridCacheDataStructuresProxy<K, V> implements CacheDataStructures,
     }
 
     /** {@inheritDoc} */
-    @Override public CacheAtomicSequence atomicSequence(String name, long initVal, boolean create)
+    @Override public IgniteAtomicSequence atomicSequence(String name, long initVal, boolean create)
         throws IgniteCheckedException {
         GridCacheProjectionImpl<K, V> old = gate.enter(null);
 
@@ -84,7 +84,7 @@ public class GridCacheDataStructuresProxy<K, V> implements CacheDataStructures,
     }
 
     /** {@inheritDoc} */
-    @Override public CacheAtomicLong atomicLong(String name, long initVal, boolean create) throws IgniteCheckedException {
+    @Override public IgniteAtomicLong atomicLong(String name, long initVal, boolean create) throws IgniteCheckedException {
         GridCacheProjectionImpl<K, V> old = gate.enter(null);
 
         try {
@@ -108,7 +108,7 @@ public class GridCacheDataStructuresProxy<K, V> implements CacheDataStructures,
     }
 
     /** {@inheritDoc} */
-    @Override public <T> CacheAtomicReference<T> atomicReference(String name, T initVal, boolean create)
+    @Override public <T> IgniteAtomicReference<T> atomicReference(String name, T initVal, boolean create)
         throws IgniteCheckedException {
         GridCacheProjectionImpl<K, V> old = gate.enter(null);
 
@@ -133,7 +133,7 @@ public class GridCacheDataStructuresProxy<K, V> implements CacheDataStructures,
     }
 
     /** {@inheritDoc} */
-    @Override public <T, S> CacheAtomicStamped<T, S> atomicStamped(String name, T initVal, S initStamp,
+    @Override public <T, S> IgniteAtomicStamped<T, S> atomicStamped(String name, T initVal, S initStamp,
         boolean create) throws IgniteCheckedException {
         GridCacheProjectionImpl<K, V> old = gate.enter(null);
 
@@ -158,7 +158,7 @@ public class GridCacheDataStructuresProxy<K, V> implements CacheDataStructures,
     }
 
     /** {@inheritDoc} */
-    @Override public <T> CacheQueue<T> queue(String name, int cap, boolean collocated, boolean create)
+    @Override public <T> IgniteQueue<T> queue(String name, int cap, boolean collocated, boolean create)
         throws IgniteCheckedException {
         GridCacheProjectionImpl<K, V> old = gate.enter(null);
 
@@ -195,7 +195,7 @@ public class GridCacheDataStructuresProxy<K, V> implements CacheDataStructures,
     }
 
     /** {@inheritDoc} */
-    @Nullable @Override public <T> CacheSet<T> set(String name, boolean collocated, boolean create)
+    @Nullable @Override public <T> IgniteSet<T> set(String name, boolean collocated, boolean create)
         throws IgniteCheckedException {
         GridCacheProjectionImpl<K, V> old = gate.enter(null);
 
@@ -220,7 +220,7 @@ public class GridCacheDataStructuresProxy<K, V> implements CacheDataStructures,
     }
 
     /** {@inheritDoc} */
-    @Nullable @Override public CacheCountDownLatch countDownLatch(String name, int cnt, boolean autoDel,
+    @Nullable @Override public IgniteCountDownLatch countDownLatch(String name, int cnt, boolean autoDel,
         boolean create) throws IgniteCheckedException {
         GridCacheProjectionImpl<K, V> old = gate.enter(null);
 

http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/712ce142/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/datastructures/GridCacheQueueAdapter.java
----------------------------------------------------------------------
diff --git a/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/datastructures/GridCacheQueueAdapter.java b/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/datastructures/GridCacheQueueAdapter.java
index 344a9c9..92696fa 100644
--- a/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/datastructures/GridCacheQueueAdapter.java
+++ b/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/datastructures/GridCacheQueueAdapter.java
@@ -35,9 +35,9 @@ import java.util.concurrent.*;
 import static java.util.concurrent.TimeUnit.*;
 
 /**
- * Common code for {@link org.apache.ignite.cache.datastructures.CacheQueue} implementation.
+ * Common code for {@link org.apache.ignite.cache.datastructures.IgniteQueue} implementation.
  */
-public abstract class GridCacheQueueAdapter<T> extends AbstractCollection<T> implements CacheQueue<T> {
+public abstract class GridCacheQueueAdapter<T> extends AbstractCollection<T> implements IgniteQueue<T> {
     /** Value returned by closure updating queue header indicating that queue was removed. */
     protected static final long QUEUE_REMOVED_IDX = Long.MIN_VALUE;
 

http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/712ce142/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/datastructures/GridCacheQueueProxy.java
----------------------------------------------------------------------
diff --git a/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/datastructures/GridCacheQueueProxy.java b/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/datastructures/GridCacheQueueProxy.java
index 561afe8..03415a7 100644
--- a/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/datastructures/GridCacheQueueProxy.java
+++ b/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/datastructures/GridCacheQueueProxy.java
@@ -32,7 +32,7 @@ import java.util.concurrent.*;
 /**
  * Cache queue proxy.
  */
-public class GridCacheQueueProxy<T> implements CacheQueue<T>, Externalizable {
+public class GridCacheQueueProxy<T> implements IgniteQueue<T>, Externalizable {
     /** */
     private static final long serialVersionUID = 0L;
 

http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/712ce142/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/datastructures/GridCacheSetImpl.java
----------------------------------------------------------------------
diff --git a/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/datastructures/GridCacheSetImpl.java b/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/datastructures/GridCacheSetImpl.java
index 2bb679b..b3f8f19 100644
--- a/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/datastructures/GridCacheSetImpl.java
+++ b/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/datastructures/GridCacheSetImpl.java
@@ -41,7 +41,7 @@ import static org.apache.ignite.internal.processors.cache.query.GridCacheQueryTy
 /**
  * Cache set implementation.
  */
-public class GridCacheSetImpl<T> extends AbstractCollection<T> implements CacheSet<T> {
+public class GridCacheSetImpl<T> extends AbstractCollection<T> implements IgniteSet<T> {
     /** */
     private static final int BATCH_SIZE = 100;
 

http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/712ce142/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/datastructures/GridCacheSetProxy.java
----------------------------------------------------------------------
diff --git a/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/datastructures/GridCacheSetProxy.java b/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/datastructures/GridCacheSetProxy.java
index 5557a18..01d1776 100644
--- a/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/datastructures/GridCacheSetProxy.java
+++ b/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/datastructures/GridCacheSetProxy.java
@@ -33,7 +33,7 @@ import java.util.concurrent.*;
 /**
  * Cache set proxy.
  */
-public class GridCacheSetProxy<T> implements CacheSet<T>, Externalizable {
+public class GridCacheSetProxy<T> implements IgniteSet<T>, Externalizable {
     /** */
     private static final long serialVersionUID = 0L;
 

http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/712ce142/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/datastructures/GridSetQueryPredicate.java
----------------------------------------------------------------------
diff --git a/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/datastructures/GridSetQueryPredicate.java b/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/datastructures/GridSetQueryPredicate.java
index c9fad85..7307e9d 100644
--- a/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/datastructures/GridSetQueryPredicate.java
+++ b/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/datastructures/GridSetQueryPredicate.java
@@ -24,7 +24,7 @@ import org.apache.ignite.internal.util.typedef.internal.*;
 import java.io.*;
 
 /**
- * Predicate for query over {@link org.apache.ignite.cache.datastructures.CacheSet} items.
+ * Predicate for query over {@link org.apache.ignite.cache.datastructures.IgniteSet} items.
  */
 public class GridSetQueryPredicate<K, V> implements IgniteBiPredicate<K, V>, Externalizable {
     /** */

http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/712ce142/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/datastructures/GridTransactionalCacheQueueImpl.java
----------------------------------------------------------------------
diff --git a/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/datastructures/GridTransactionalCacheQueueImpl.java b/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/datastructures/GridTransactionalCacheQueueImpl.java
index 501c09a..d10aa5a 100644
--- a/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/datastructures/GridTransactionalCacheQueueImpl.java
+++ b/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/datastructures/GridTransactionalCacheQueueImpl.java
@@ -31,7 +31,7 @@ import static org.apache.ignite.transactions.IgniteTxConcurrency.*;
 import static org.apache.ignite.transactions.IgniteTxIsolation.*;
 
 /**
- * {@link org.apache.ignite.cache.datastructures.CacheQueue} implementation using transactional cache.
+ * {@link org.apache.ignite.cache.datastructures.IgniteQueue} implementation using transactional cache.
  */
 public class GridTransactionalCacheQueueImpl<T> extends GridCacheQueueAdapter<T> {
     /** */

http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/712ce142/modules/core/src/main/java/org/apache/ignite/internal/processors/rest/handlers/cache/GridCacheCommandHandler.java
----------------------------------------------------------------------
diff --git a/modules/core/src/main/java/org/apache/ignite/internal/processors/rest/handlers/cache/GridCacheCommandHandler.java b/modules/core/src/main/java/org/apache/ignite/internal/processors/rest/handlers/cache/GridCacheCommandHandler.java
index 8a69d1b..fd18982 100644
--- a/modules/core/src/main/java/org/apache/ignite/internal/processors/rest/handlers/cache/GridCacheCommandHandler.java
+++ b/modules/core/src/main/java/org/apache/ignite/internal/processors/rest/handlers/cache/GridCacheCommandHandler.java
@@ -429,7 +429,7 @@ public class GridCacheCommandHandler extends GridRestCommandHandlerAdapter {
         if (delta == null)
             throw new IgniteCheckedException(GridRestCommandHandlerAdapter.missingParameter("delta"));
 
-        final CacheAtomicLong l = cache.cache().dataStructures().atomicLong(key, init != null ? init : 0, true);
+        final IgniteAtomicLong l = cache.cache().dataStructures().atomicLong(key, init != null ? init : 0, true);
 
         final Long d = delta;
 

http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/712ce142/modules/core/src/test/java/org/apache/ignite/internal/processors/cache/GridCacheConcurrentTxMultiNodeTest.java
----------------------------------------------------------------------
diff --git a/modules/core/src/test/java/org/apache/ignite/internal/processors/cache/GridCacheConcurrentTxMultiNodeTest.java b/modules/core/src/test/java/org/apache/ignite/internal/processors/cache/GridCacheConcurrentTxMultiNodeTest.java
index 56ce912..4785639 100644
--- a/modules/core/src/test/java/org/apache/ignite/internal/processors/cache/GridCacheConcurrentTxMultiNodeTest.java
+++ b/modules/core/src/test/java/org/apache/ignite/internal/processors/cache/GridCacheConcurrentTxMultiNodeTest.java
@@ -664,7 +664,7 @@ public class GridCacheConcurrentTxMultiNodeTest extends GridCommonAbstractTest {
          * @throws IgniteCheckedException If failed.
          */
         private long getId() throws IgniteCheckedException {
-            CacheAtomicSequence seq = ignite.cache(null).dataStructures().atomicSequence("ID", 0, true);
+            IgniteAtomicSequence seq = ignite.cache(null).dataStructures().atomicSequence("ID", 0, true);
             return seq.incrementAndGet();
         }
 

http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/712ce142/modules/core/src/test/java/org/apache/ignite/internal/processors/cache/datastructures/GridCacheAbstractDataStructuresFailoverSelfTest.java
----------------------------------------------------------------------
diff --git a/modules/core/src/test/java/org/apache/ignite/internal/processors/cache/datastructures/GridCacheAbstractDataStructuresFailoverSelfTest.java b/modules/core/src/test/java/org/apache/ignite/internal/processors/cache/datastructures/GridCacheAbstractDataStructuresFailoverSelfTest.java
index ab2d4bf..4012c74 100644
--- a/modules/core/src/test/java/org/apache/ignite/internal/processors/cache/datastructures/GridCacheAbstractDataStructuresFailoverSelfTest.java
+++ b/modules/core/src/test/java/org/apache/ignite/internal/processors/cache/datastructures/GridCacheAbstractDataStructuresFailoverSelfTest.java
@@ -120,7 +120,7 @@ public abstract class GridCacheAbstractDataStructuresFailoverSelfTest extends Gr
      */
     public void testAtomicLongConstantTopologyChange() throws Exception {
         try {
-            CacheAtomicLong s = cache().dataStructures().atomicLong(STRUCTURE_NAME, 1, true);
+            IgniteAtomicLong s = cache().dataStructures().atomicLong(STRUCTURE_NAME, 1, true);
 
             IgniteFuture<?> fut = GridTestUtils.runMultiThreadedAsync(new CA() {
                 @Override public void apply() {
@@ -170,7 +170,7 @@ public abstract class GridCacheAbstractDataStructuresFailoverSelfTest extends Gr
      */
     public void testAtomicLongConstantMultipleTopologyChange() throws Exception {
         try {
-            CacheAtomicLong s = cache().dataStructures().atomicLong(STRUCTURE_NAME, 1, true);
+            IgniteAtomicLong s = cache().dataStructures().atomicLong(STRUCTURE_NAME, 1, true);
 
             IgniteFuture<?> fut = GridTestUtils.runMultiThreadedAsync(new CA() {
                 @Override public void apply() {
@@ -249,7 +249,7 @@ public abstract class GridCacheAbstractDataStructuresFailoverSelfTest extends Gr
      */
     public void testAtomicReferenceConstantTopologyChange() throws Exception {
         try {
-            CacheAtomicReference<Integer> s = cache().dataStructures().atomicReference(STRUCTURE_NAME, 1, true);
+            IgniteAtomicReference<Integer> s = cache().dataStructures().atomicReference(STRUCTURE_NAME, 1, true);
 
             IgniteFuture<?> fut = GridTestUtils.runMultiThreadedAsync(new CA() {
                 @Override public void apply() {
@@ -298,7 +298,7 @@ public abstract class GridCacheAbstractDataStructuresFailoverSelfTest extends Gr
      */
     public void testAtomicReferenceConstantMultipleTopologyChange() throws Exception {
         try {
-            CacheAtomicReference<Integer> s = cache().dataStructures().atomicReference(STRUCTURE_NAME, 1, true);
+            IgniteAtomicReference<Integer> s = cache().dataStructures().atomicReference(STRUCTURE_NAME, 1, true);
 
             IgniteFuture<?> fut = GridTestUtils.runMultiThreadedAsync(new CA() {
                 @Override public void apply() {
@@ -384,7 +384,7 @@ public abstract class GridCacheAbstractDataStructuresFailoverSelfTest extends Gr
      */
     public void testAtomicStampedConstantTopologyChange() throws Exception {
         try {
-            CacheAtomicStamped<Integer, Integer> s = cache().dataStructures().atomicStamped(STRUCTURE_NAME, 1, 1, true);
+            IgniteAtomicStamped<Integer, Integer> s = cache().dataStructures().atomicStamped(STRUCTURE_NAME, 1, 1, true);
 
             IgniteFuture<?> fut = GridTestUtils.runMultiThreadedAsync(new CA() {
                 @Override public void apply() {
@@ -447,7 +447,7 @@ public abstract class GridCacheAbstractDataStructuresFailoverSelfTest extends Gr
      */
     public void testAtomicStampedConstantMultipleTopologyChange() throws Exception {
         try {
-            CacheAtomicStamped<Integer, Integer> s = cache().dataStructures().atomicStamped(STRUCTURE_NAME, 1, 1, true);
+            IgniteAtomicStamped<Integer, Integer> s = cache().dataStructures().atomicStamped(STRUCTURE_NAME, 1, 1, true);
 
             IgniteFuture<?> fut = GridTestUtils.runMultiThreadedAsync(new CA() {
                 @Override public void apply() {
@@ -541,7 +541,7 @@ public abstract class GridCacheAbstractDataStructuresFailoverSelfTest extends Gr
      */
     public void testCountDownLatchConstantTopologyChange() throws Exception {
         try {
-            CacheCountDownLatch s = cache().dataStructures().countDownLatch(STRUCTURE_NAME, Integer.MAX_VALUE,
+            IgniteCountDownLatch s = cache().dataStructures().countDownLatch(STRUCTURE_NAME, Integer.MAX_VALUE,
                 false, true);
 
             IgniteFuture<?> fut = GridTestUtils.runMultiThreadedAsync(new CA() {
@@ -596,7 +596,7 @@ public abstract class GridCacheAbstractDataStructuresFailoverSelfTest extends Gr
      */
     public void testCountDownLatchConstantMultipleTopologyChange() throws Exception {
         try {
-            CacheCountDownLatch s = cache().dataStructures()
+            IgniteCountDownLatch s = cache().dataStructures()
                 .countDownLatch(STRUCTURE_NAME, Integer.MAX_VALUE, false, true);
 
             IgniteFuture<?> fut = GridTestUtils.runMultiThreadedAsync(new CA() {
@@ -680,7 +680,7 @@ public abstract class GridCacheAbstractDataStructuresFailoverSelfTest extends Gr
      */
     public void testFifoQueueConstantTopologyChange() throws Exception {
         try {
-            CacheQueue<Integer> s = cache().dataStructures().queue(STRUCTURE_NAME, 0, false, true);
+            IgniteQueue<Integer> s = cache().dataStructures().queue(STRUCTURE_NAME, 0, false, true);
 
             s.put(1);
 
@@ -730,7 +730,7 @@ public abstract class GridCacheAbstractDataStructuresFailoverSelfTest extends Gr
      */
     public void testFifoQueueConstantMultipleTopologyChange() throws Exception {
         try {
-            CacheQueue<Integer> s = cache().dataStructures().queue(STRUCTURE_NAME, 0, false, true);
+            IgniteQueue<Integer> s = cache().dataStructures().queue(STRUCTURE_NAME, 0, false, true);
 
             s.put(1);
 
@@ -807,7 +807,7 @@ public abstract class GridCacheAbstractDataStructuresFailoverSelfTest extends Gr
      */
     public void testAtomicSequenceConstantTopologyChange() throws Exception {
         try {
-            CacheAtomicSequence s = cache().dataStructures().atomicSequence(STRUCTURE_NAME, 1, true);
+            IgniteAtomicSequence s = cache().dataStructures().atomicSequence(STRUCTURE_NAME, 1, true);
 
             IgniteFuture<?> fut = GridTestUtils.runMultiThreadedAsync(new CA() {
                 @Override public void apply() {
@@ -888,7 +888,7 @@ public abstract class GridCacheAbstractDataStructuresFailoverSelfTest extends Gr
                     private Ignite g;
 
                     @Override public Object call() throws Exception {
-                        CacheAtomicSequence seq = g.cache(null).dataStructures().atomicSequence(STRUCTURE_NAME, 1,
+                        IgniteAtomicSequence seq = g.cache(null).dataStructures().atomicSequence(STRUCTURE_NAME, 1,
                             true);
 
                         assert seq != null;
@@ -909,7 +909,7 @@ public abstract class GridCacheAbstractDataStructuresFailoverSelfTest extends Gr
      */
     public void testAtomicSequenceConstantMultipleTopologyChange() throws Exception {
         try {
-            CacheAtomicSequence s = cache().dataStructures().atomicSequence(STRUCTURE_NAME, 1, true);
+            IgniteAtomicSequence s = cache().dataStructures().atomicSequence(STRUCTURE_NAME, 1, true);
 
             IgniteFuture<?> fut = GridTestUtils.runMultiThreadedAsync(new CA() {
                 @Override public void apply() {

http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/712ce142/modules/core/src/test/java/org/apache/ignite/internal/processors/cache/datastructures/GridCacheAbstractQueueFailoverDataConsistencySelfTest.java
----------------------------------------------------------------------
diff --git a/modules/core/src/test/java/org/apache/ignite/internal/processors/cache/datastructures/GridCacheAbstractQueueFailoverDataConsistencySelfTest.java b/modules/core/src/test/java/org/apache/ignite/internal/processors/cache/datastructures/GridCacheAbstractQueueFailoverDataConsistencySelfTest.java
index 95db99e..b64b0ca 100644
--- a/modules/core/src/test/java/org/apache/ignite/internal/processors/cache/datastructures/GridCacheAbstractQueueFailoverDataConsistencySelfTest.java
+++ b/modules/core/src/test/java/org/apache/ignite/internal/processors/cache/datastructures/GridCacheAbstractQueueFailoverDataConsistencySelfTest.java
@@ -130,7 +130,7 @@ public abstract class GridCacheAbstractQueueFailoverDataConsistencySelfTest exte
      * @throws Exception If failed.
      */
     private void testAddFailover(boolean collocated) throws Exception {
-        CacheQueue<Integer> queue = cache().dataStructures().queue(QUEUE_NAME, 0, collocated, true);
+        IgniteQueue<Integer> queue = cache().dataStructures().queue(QUEUE_NAME, 0, collocated, true);
 
         assertNotNull(queue);
         assertEquals(0, queue.size());
@@ -168,7 +168,7 @@ public abstract class GridCacheAbstractQueueFailoverDataConsistencySelfTest exte
      * @param killIdxs Indexes of nodes to kill.
      * @throws Exception If failed.
      */
-    private void testAddFailover(CacheQueue<Integer> queue, final List<Integer> killIdxs) throws Exception {
+    private void testAddFailover(IgniteQueue<Integer> queue, final List<Integer> killIdxs) throws Exception {
         assert !killIdxs.isEmpty();
 
         final AtomicBoolean stop = new AtomicBoolean();
@@ -223,7 +223,7 @@ public abstract class GridCacheAbstractQueueFailoverDataConsistencySelfTest exte
      * @throws Exception If failed.
      */
     private void testPollFailover(boolean collocated) throws Exception {
-        CacheQueue<Integer> queue = cache().dataStructures().queue(QUEUE_NAME, 0, collocated, true);
+        IgniteQueue<Integer> queue = cache().dataStructures().queue(QUEUE_NAME, 0, collocated, true);
 
         assertNotNull(queue);
         assertEquals(0, queue.size());
@@ -261,7 +261,7 @@ public abstract class GridCacheAbstractQueueFailoverDataConsistencySelfTest exte
      * @param killIdxs Indexes of nodes to kill.
      * @throws Exception If failed.
      */
-    private void testPollFailover(CacheQueue<Integer> queue, final List<Integer> killIdxs) throws Exception {
+    private void testPollFailover(IgniteQueue<Integer> queue, final List<Integer> killIdxs) throws Exception {
         assert !killIdxs.isEmpty();
 
         final int ITEMS = atomicityMode() == ATOMIC && !queue.collocated() ? 10_000 : 3000;

http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/712ce142/modules/core/src/test/java/org/apache/ignite/internal/processors/cache/datastructures/GridCacheAtomicLongApiSelfTest.java
----------------------------------------------------------------------
diff --git a/modules/core/src/test/java/org/apache/ignite/internal/processors/cache/datastructures/GridCacheAtomicLongApiSelfTest.java b/modules/core/src/test/java/org/apache/ignite/internal/processors/cache/datastructures/GridCacheAtomicLongApiSelfTest.java
index f06f209..d0ecff1 100644
--- a/modules/core/src/test/java/org/apache/ignite/internal/processors/cache/datastructures/GridCacheAtomicLongApiSelfTest.java
+++ b/modules/core/src/test/java/org/apache/ignite/internal/processors/cache/datastructures/GridCacheAtomicLongApiSelfTest.java
@@ -134,9 +134,9 @@ public class GridCacheAtomicLongApiSelfTest extends GridCommonAbstractTest {
 
         String atomicName2 = "SECOND";
 
-        CacheAtomicLong atomic1 = cache.dataStructures().atomicLong(atomicName1, 0, true);
-        CacheAtomicLong atomic2 = cache.dataStructures().atomicLong(atomicName2, 0, true);
-        CacheAtomicLong atomic3 = cache.dataStructures().atomicLong(atomicName1, 0, true);
+        IgniteAtomicLong atomic1 = cache.dataStructures().atomicLong(atomicName1, 0, true);
+        IgniteAtomicLong atomic2 = cache.dataStructures().atomicLong(atomicName2, 0, true);
+        IgniteAtomicLong atomic3 = cache.dataStructures().atomicLong(atomicName1, 0, true);
 
         assertNotNull(atomic1);
         assertNotNull(atomic2);
@@ -188,7 +188,7 @@ public class GridCacheAtomicLongApiSelfTest extends GridCommonAbstractTest {
         assertNotNull(cache);
         assertEquals(0, cache.primarySize());
 
-        CacheAtomicLong atomic = cache.dataStructures().atomicLong("atomic", 0, true);
+        IgniteAtomicLong atomic = cache.dataStructures().atomicLong("atomic", 0, true);
 
         assertEquals(0, cache.primarySize());
 
@@ -221,7 +221,7 @@ public class GridCacheAtomicLongApiSelfTest extends GridCommonAbstractTest {
         assertNotNull(cache);
         assertEquals(0, cache.primarySize());
 
-        CacheAtomicLong atomic = cache.dataStructures().atomicLong("atomic", 0, true);
+        IgniteAtomicLong atomic = cache.dataStructures().atomicLong("atomic", 0, true);
 
         assertEquals(0, cache.primarySize());
 
@@ -254,7 +254,7 @@ public class GridCacheAtomicLongApiSelfTest extends GridCommonAbstractTest {
         assertNotNull(cache);
         assertEquals(0, cache.primarySize());
 
-        CacheAtomicLong atomic = cache.dataStructures().atomicLong("atomic", 0, true);
+        IgniteAtomicLong atomic = cache.dataStructures().atomicLong("atomic", 0, true);
 
         assertEquals(0, cache.primarySize());
 
@@ -287,7 +287,7 @@ public class GridCacheAtomicLongApiSelfTest extends GridCommonAbstractTest {
         assertNotNull(cache);
         assertEquals(0, cache.primarySize());
 
-        CacheAtomicLong atomic = cache.dataStructures().atomicLong("atomic", 0, true);
+        IgniteAtomicLong atomic = cache.dataStructures().atomicLong("atomic", 0, true);
 
         assertEquals(0, cache.primarySize());
 
@@ -320,7 +320,7 @@ public class GridCacheAtomicLongApiSelfTest extends GridCommonAbstractTest {
         assertNotNull(cache);
         assertEquals(0, cache.primarySize());
 
-        CacheAtomicLong atomic = cache.dataStructures().atomicLong("atomic", 0, true);
+        IgniteAtomicLong atomic = cache.dataStructures().atomicLong("atomic", 0, true);
 
         assertEquals(0, cache.primarySize());
 
@@ -355,7 +355,7 @@ public class GridCacheAtomicLongApiSelfTest extends GridCommonAbstractTest {
         assertNotNull(cache);
         assertEquals(0, cache.primarySize());
 
-        CacheAtomicLong atomic = cache.dataStructures().atomicLong("atomic", 0, true);
+        IgniteAtomicLong atomic = cache.dataStructures().atomicLong("atomic", 0, true);
 
         assertEquals(0, cache.primarySize());
 
@@ -390,7 +390,7 @@ public class GridCacheAtomicLongApiSelfTest extends GridCommonAbstractTest {
         assertNotNull(cache);
         assertEquals(0, cache.primarySize());
 
-        CacheAtomicLong atomic = cache.dataStructures().atomicLong("atomic", 0, true);
+        IgniteAtomicLong atomic = cache.dataStructures().atomicLong("atomic", 0, true);
 
         assertEquals(0, cache.primarySize());
 
@@ -426,7 +426,7 @@ public class GridCacheAtomicLongApiSelfTest extends GridCommonAbstractTest {
         assertNotNull(cache);
         assertEquals(0, cache.primarySize());
 
-        CacheAtomicLong atomic = cache.dataStructures().atomicLong("atomic", 0, true);
+        IgniteAtomicLong atomic = cache.dataStructures().atomicLong("atomic", 0, true);
 
         assertEquals(0, cache.primarySize());
 
@@ -468,7 +468,7 @@ public class GridCacheAtomicLongApiSelfTest extends GridCommonAbstractTest {
         assertNotNull(cache);
         assertEquals(0, cache.primarySize());
 
-        CacheAtomicLong atomic = cache.dataStructures().atomicLong("atomic", 0, true);
+        IgniteAtomicLong atomic = cache.dataStructures().atomicLong("atomic", 0, true);
 
         assertEquals(0, cache.primarySize());
 

http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/712ce142/modules/core/src/test/java/org/apache/ignite/internal/processors/cache/datastructures/GridCacheAtomicReferenceApiSelfAbstractTest.java
----------------------------------------------------------------------
diff --git a/modules/core/src/test/java/org/apache/ignite/internal/processors/cache/datastructures/GridCacheAtomicReferenceApiSelfAbstractTest.java b/modules/core/src/test/java/org/apache/ignite/internal/processors/cache/datastructures/GridCacheAtomicReferenceApiSelfAbstractTest.java
index 0e9fe83..52a9b36 100644
--- a/modules/core/src/test/java/org/apache/ignite/internal/processors/cache/datastructures/GridCacheAtomicReferenceApiSelfAbstractTest.java
+++ b/modules/core/src/test/java/org/apache/ignite/internal/processors/cache/datastructures/GridCacheAtomicReferenceApiSelfAbstractTest.java
@@ -123,9 +123,9 @@ public abstract class GridCacheAtomicReferenceApiSelfAbstractTest extends GridCo
         String atomicName2 = UUID.randomUUID().toString();
 
         String initVal = "1";
-        CacheAtomicReference<String> atomic1 = grid().cache(null).dataStructures()
+        IgniteAtomicReference<String> atomic1 = grid().cache(null).dataStructures()
             .atomicReference(atomicName1, initVal, true);
-        CacheAtomicReference<String> atomic2 = grid().cache(null).dataStructures()
+        IgniteAtomicReference<String> atomic2 = grid().cache(null).dataStructures()
             .atomicReference(atomicName2, null, true);
 
         assertNotNull(atomic1);
@@ -155,7 +155,7 @@ public abstract class GridCacheAtomicReferenceApiSelfAbstractTest extends GridCo
 
         String initVal = "qwerty";
 
-        CacheAtomicReference<String> atomic = grid().cache(null).dataStructures()
+        IgniteAtomicReference<String> atomic = grid().cache(null).dataStructures()
             .atomicReference(atomicName, initVal, true);
 
         assertEquals(initVal, atomic.get());
@@ -175,7 +175,7 @@ public abstract class GridCacheAtomicReferenceApiSelfAbstractTest extends GridCo
 
         String initVal = "qwerty";
 
-        CacheAtomicReference<String> atomic = grid().cache(null).dataStructures()
+        IgniteAtomicReference<String> atomic = grid().cache(null).dataStructures()
             .atomicReference(atomicName, initVal, true);
 
         assertEquals(initVal, atomic.get());
@@ -202,7 +202,7 @@ public abstract class GridCacheAtomicReferenceApiSelfAbstractTest extends GridCo
 
         assertNotNull(cache);
 
-        CacheAtomicReference<Boolean> atomic = cache.dataStructures().atomicReference(atomicName, false, true);
+        IgniteAtomicReference<Boolean> atomic = cache.dataStructures().atomicReference(atomicName, false, true);
 
         atomic.set(true);
 

http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/712ce142/modules/core/src/test/java/org/apache/ignite/internal/processors/cache/datastructures/GridCacheAtomicReferenceMultiNodeAbstractTest.java
----------------------------------------------------------------------
diff --git a/modules/core/src/test/java/org/apache/ignite/internal/processors/cache/datastructures/GridCacheAtomicReferenceMultiNodeAbstractTest.java b/modules/core/src/test/java/org/apache/ignite/internal/processors/cache/datastructures/GridCacheAtomicReferenceMultiNodeAbstractTest.java
index 74b5b4d..9e82a55 100644
--- a/modules/core/src/test/java/org/apache/ignite/internal/processors/cache/datastructures/GridCacheAtomicReferenceMultiNodeAbstractTest.java
+++ b/modules/core/src/test/java/org/apache/ignite/internal/processors/cache/datastructures/GridCacheAtomicReferenceMultiNodeAbstractTest.java
@@ -90,14 +90,14 @@ public abstract class GridCacheAtomicReferenceMultiNodeAbstractTest extends Grid
         final String newVal = UUID.randomUUID().toString();
 
         // Initialize atomicReference in cache.
-        CacheAtomicReference<String> ref = grid(0).cache(null).dataStructures().atomicReference(refName, val, true);
+        IgniteAtomicReference<String> ref = grid(0).cache(null).dataStructures().atomicReference(refName, val, true);
 
         final Ignite ignite = grid(0);
 
         // Execute task on all grid nodes.
         ignite.compute().call(new IgniteCallable<Object>() {
             @Override public String call() throws IgniteCheckedException {
-                CacheAtomicReference<String> ref = ignite.cache(null).dataStructures().atomicReference(refName, val, true);
+                IgniteAtomicReference<String> ref = ignite.cache(null).dataStructures().atomicReference(refName, val, true);
 
                 assertEquals(val, ref.get());
 
@@ -110,7 +110,7 @@ public abstract class GridCacheAtomicReferenceMultiNodeAbstractTest extends Grid
         // Execute task on all grid nodes.
         ignite.compute().call(new IgniteCallable<String>() {
             @Override public String call() throws IgniteCheckedException {
-                CacheAtomicReference<String> ref = ignite.cache(null).dataStructures().atomicReference(refName, val, true);
+                IgniteAtomicReference<String> ref = ignite.cache(null).dataStructures().atomicReference(refName, val, true);
 
                 assertEquals(val, ref.get());
 
@@ -123,7 +123,7 @@ public abstract class GridCacheAtomicReferenceMultiNodeAbstractTest extends Grid
         // Execute task on all grid nodes.
         ignite.compute().call(new IgniteCallable<String>() {
             @Override public String call() throws IgniteCheckedException {
-                CacheAtomicReference<String> ref = ignite.cache(null).dataStructures().atomicReference(refName, val, true);
+                IgniteAtomicReference<String> ref = ignite.cache(null).dataStructures().atomicReference(refName, val, true);
 
                 assertEquals(newVal, ref.get());
 
@@ -150,7 +150,7 @@ public abstract class GridCacheAtomicReferenceMultiNodeAbstractTest extends Grid
         final String newStamp = UUID.randomUUID().toString();
 
         // Initialize atomicStamped in cache.
-        CacheAtomicStamped<String, String> stamped = grid(0).cache(null).dataStructures()
+        IgniteAtomicStamped<String, String> stamped = grid(0).cache(null).dataStructures()
             .atomicStamped(stampedName, val, stamp, true);
 
         final Ignite ignite = grid(0);
@@ -158,7 +158,7 @@ public abstract class GridCacheAtomicReferenceMultiNodeAbstractTest extends Grid
         // Execute task on all grid nodes.
         ignite.compute().call(new IgniteCallable<String>() {
             @Override public String call() throws IgniteCheckedException {
-                CacheAtomicStamped<String, String> stamped = ignite.cache(null).dataStructures()
+                IgniteAtomicStamped<String, String> stamped = ignite.cache(null).dataStructures()
                     .atomicStamped(stampedName, val, stamp, true);
 
                 assertEquals(val, stamped.value());
@@ -173,7 +173,7 @@ public abstract class GridCacheAtomicReferenceMultiNodeAbstractTest extends Grid
         // Execute task on all grid nodes.
         ignite.compute().call(new IgniteCallable<String>() {
             @Override public String call() throws IgniteCheckedException {
-                CacheAtomicStamped<String, String> stamped = ignite.cache(null).dataStructures()
+                IgniteAtomicStamped<String, String> stamped = ignite.cache(null).dataStructures()
                     .atomicStamped(stampedName, val, stamp, true);
 
                 assertEquals(val, stamped.value());
@@ -188,7 +188,7 @@ public abstract class GridCacheAtomicReferenceMultiNodeAbstractTest extends Grid
         // Execute task on all grid nodes.
         ignite.compute().call(new IgniteCallable<String>() {
             @Override public String call() throws IgniteCheckedException {
-                CacheAtomicStamped<String, String> stamped = ignite.cache(null).dataStructures()
+                IgniteAtomicStamped<String, String> stamped = ignite.cache(null).dataStructures()
                     .atomicStamped(stampedName, val, stamp, true);
 
                 assertEquals(newVal, stamped.value());

http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/712ce142/modules/core/src/test/java/org/apache/ignite/internal/processors/cache/datastructures/GridCacheAtomicStampedApiSelfAbstractTest.java
----------------------------------------------------------------------
diff --git a/modules/core/src/test/java/org/apache/ignite/internal/processors/cache/datastructures/GridCacheAtomicStampedApiSelfAbstractTest.java b/modules/core/src/test/java/org/apache/ignite/internal/processors/cache/datastructures/GridCacheAtomicStampedApiSelfAbstractTest.java
index d6051f7..b2a20ee 100644
--- a/modules/core/src/test/java/org/apache/ignite/internal/processors/cache/datastructures/GridCacheAtomicStampedApiSelfAbstractTest.java
+++ b/modules/core/src/test/java/org/apache/ignite/internal/processors/cache/datastructures/GridCacheAtomicStampedApiSelfAbstractTest.java
@@ -71,9 +71,9 @@ public abstract class GridCacheAtomicStampedApiSelfAbstractTest extends GridComm
         String initVal = "1";
         String initStamp = "2";
 
-        CacheAtomicStamped<String, String> atomic1 = grid().cache(null).dataStructures()
+        IgniteAtomicStamped<String, String> atomic1 = grid().cache(null).dataStructures()
             .atomicStamped(atomicName1, initVal, initStamp, true);
-        CacheAtomicStamped<String, String> atomic2 = grid().cache(null).dataStructures()
+        IgniteAtomicStamped<String, String> atomic2 = grid().cache(null).dataStructures()
             .atomicStamped(atomicName1, null, null, true);
 
         assertNotNull(atomic1);
@@ -107,7 +107,7 @@ public abstract class GridCacheAtomicStampedApiSelfAbstractTest extends GridComm
         String initVal = "qwerty";
         String initStamp = "asdfgh";
 
-        CacheAtomicStamped<String, String> atomic = grid().cache(null).dataStructures()
+        IgniteAtomicStamped<String, String> atomic = grid().cache(null).dataStructures()
             .atomicStamped(atomicName, initVal, initStamp, true);
 
         assertEquals(initVal, atomic.value());
@@ -132,7 +132,7 @@ public abstract class GridCacheAtomicStampedApiSelfAbstractTest extends GridComm
         String initVal = "qwerty";
         String initStamp = "asdfgh";
 
-        CacheAtomicStamped<String, String> atomic = grid().cache(null).dataStructures()
+        IgniteAtomicStamped<String, String> atomic = grid().cache(null).dataStructures()
             .atomicStamped(atomicName, initVal, initStamp, true);
 
         assertEquals(initVal, atomic.value());


Mime
View raw message