ignite-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From sboi...@apache.org
Subject [32/56] [abbrv] incubator-ignite git commit: # ignite-63
Date Fri, 23 Jan 2015 14:42:13 GMT
http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/cafee25f/modules/core/src/main/java/org/apache/ignite/cache/datastructures/CacheAtomicReference.java
----------------------------------------------------------------------
diff --git a/modules/core/src/main/java/org/apache/ignite/cache/datastructures/CacheAtomicReference.java b/modules/core/src/main/java/org/apache/ignite/cache/datastructures/CacheAtomicReference.java
new file mode 100644
index 0000000..ec0d827
--- /dev/null
+++ b/modules/core/src/main/java/org/apache/ignite/cache/datastructures/CacheAtomicReference.java
@@ -0,0 +1,93 @@
+/*
+ * 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.*;
+
+/**
+ * This interface provides a rich API for working with distributed atomic reference.
+ * <p>
+ * <h1 class="header">Functionality</h1>
+ * Distributed atomic reference includes the following main functionality:
+ * <ul>
+ * <li>
+ * Method {@link #get()} synchronously gets current value of an atomic reference.
+ * </li>
+ * <li>
+ * Method {@link #set(Object)} synchronously and unconditionally sets the value in the an atomic reference.
+ * </li>
+ * <li>
+ * Methods {@code compareAndSet(...)} synchronously and conditionally set the value in the an atomic reference.
+ * </li>
+ * </ul>
+ * All previously described methods have asynchronous analogs.
+ * <ul>
+ * <li>
+ * Method {@link #name()} gets name of atomic reference.
+ * </li>
+ * </ul>
+ * <h1 class="header">Creating Distributed Atomic Reference</h1>
+ * Instance of distributed atomic reference can be created by calling the following method:
+ * <ul>
+ *     <li>{@link CacheDataStructures#atomicReference(String, Object, boolean)}</li>
+ * </ul>
+ * @see CacheDataStructures#atomicReference(String, Object, boolean)
+ * @see CacheDataStructures#removeAtomicReference(String)
+ */
+public interface CacheAtomicReference<T> {
+    /**
+     * Name of atomic reference.
+     *
+     * @return Name of an atomic reference.
+     */
+    public String name();
+
+    /**
+     * Gets current value of an atomic reference.
+     *
+     * @return current value of an atomic reference.
+     * @throws IgniteCheckedException If operation failed.
+     */
+    public T get() throws IgniteCheckedException;
+
+    /**
+     * Unconditionally sets the value.
+     *
+     * @param val Value.
+     * @throws IgniteCheckedException If operation failed.
+     */
+    public void set(T val) throws IgniteCheckedException;
+
+    /**
+     * Conditionally sets the new value. That will be set if {@code expVal} is equal
+     * to current value respectively.
+     *
+     * @param expVal Expected value.
+     * @param newVal New value.
+     * @return Result of operation execution. If {@code true} than value have been updated.
+     * @throws IgniteCheckedException If operation failed.
+     */
+    public boolean compareAndSet(T expVal, T newVal) throws IgniteCheckedException;
+
+    /**
+     * Gets status of atomic.
+     *
+     * @return {@code true} if an atomic reference was removed from cache, {@code false} otherwise.
+     */
+    public boolean removed();
+}

http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/cafee25f/modules/core/src/main/java/org/apache/ignite/cache/datastructures/CacheAtomicSequence.java
----------------------------------------------------------------------
diff --git a/modules/core/src/main/java/org/apache/ignite/cache/datastructures/CacheAtomicSequence.java b/modules/core/src/main/java/org/apache/ignite/cache/datastructures/CacheAtomicSequence.java
new file mode 100644
index 0000000..09ef416
--- /dev/null
+++ b/modules/core/src/main/java/org/apache/ignite/cache/datastructures/CacheAtomicSequence.java
@@ -0,0 +1,130 @@
+/*
+ * 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.*;
+
+/**
+ * This interface provides a rich API for working with distributed atomic sequence.
+ * <p>
+ * <h1 class="header">Functionality</h1>
+ * Distributed atomic sequence includes the following main functionality:
+ * <ul>
+ * <li>
+ * Method {@link #get()} synchronously gets current value from atomic sequence.
+ * </li>
+ * <li>
+ * Various {@code get..(..)} methods synchronously get current value from atomic sequence
+ * and increase atomic sequences value.
+ * </li>
+ * <li>
+ * Various {@code add..(..)} {@code increment(..)} methods synchronously increase atomic sequences value
+ * and return increased value.
+ * </li>
+ * </ul>
+ * All previously described methods have asynchronous analogs.
+ * <ul>
+ * <li>
+ * Method {@link #batchSize(int size)} sets batch size of current atomic sequence.
+ * </li>
+ * <li>
+ * Method {@link #batchSize()} gets current batch size of atomic sequence.
+ * </li>
+ * <li>
+ * Method {@link #name()} gets name of atomic sequence.
+ * </li>
+ * </ul>
+ * <h1 class="header">Creating Distributed Atomic Sequence</h1>
+ * Instance of distributed atomic sequence can be created by calling the following method:
+ * <ul>
+ *     <li>{@link CacheDataStructures#atomicSequence(String, long, boolean)}</li>
+ * </ul>
+ * @see CacheDataStructures#atomicSequence(String, long, boolean)
+ * @see CacheDataStructures#removeAtomicSequence(String)
+ */
+public interface CacheAtomicSequence {
+    /**
+     * Name of atomic sequence.
+     *
+     * @return Name of atomic sequence.
+     */
+    public String name();
+
+    /**
+     * Gets current value of atomic sequence.
+     *
+     * @return Value of atomic sequence.
+     * @throws IgniteCheckedException If operation failed.
+     */
+    public long get() throws IgniteCheckedException;
+
+    /**
+     * Increments and returns the value of atomic sequence.
+     *
+     * @return Value of atomic sequence after increment.
+     * @throws IgniteCheckedException If operation failed.
+     */
+    public long incrementAndGet() throws IgniteCheckedException;
+
+    /**
+     * Gets and increments current value of atomic sequence.
+     *
+     * @return Value of atomic sequence before increment.
+     * @throws IgniteCheckedException If operation failed.
+     */
+    public long getAndIncrement() throws IgniteCheckedException;
+
+    /**
+     * Adds {@code l} elements to atomic sequence and gets value of atomic sequence.
+     *
+     * @param l Number of added elements.
+     * @return Value of atomic sequence.
+     * @throws IgniteCheckedException If operation failed.
+     */
+    public long addAndGet(long l) throws IgniteCheckedException;
+
+    /**
+     * Gets current value of atomic sequence and adds {@code l} elements.
+     *
+     * @param l Number of added elements.
+     * @return Value of atomic sequence.
+     * @throws IgniteCheckedException If operation failed.
+     */
+    public long getAndAdd(long l) throws IgniteCheckedException;
+
+    /**
+     * Gets local batch size for this atomic sequence.
+     *
+     * @return Sequence batch size.
+     */
+    public int batchSize();
+
+    /**
+     * Sets local batch size for atomic sequence.
+     *
+     * @param size Sequence batch size. Must be more then 0.
+     */
+    public void batchSize(int size);
+
+    /**
+     * Gets status of atomic sequence.
+     *
+     * @return {@code true} if atomic sequence was removed from cache, {@code false} otherwise.
+     */
+    public boolean removed();
+}

http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/cafee25f/modules/core/src/main/java/org/apache/ignite/cache/datastructures/CacheAtomicStamped.java
----------------------------------------------------------------------
diff --git a/modules/core/src/main/java/org/apache/ignite/cache/datastructures/CacheAtomicStamped.java b/modules/core/src/main/java/org/apache/ignite/cache/datastructures/CacheAtomicStamped.java
new file mode 100644
index 0000000..ab70f24
--- /dev/null
+++ b/modules/core/src/main/java/org/apache/ignite/cache/datastructures/CacheAtomicStamped.java
@@ -0,0 +1,121 @@
+/*
+ * 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.apache.ignite.lang.*;
+
+/**
+ * This interface provides a rich API for working with distributed atomic stamped value.
+ * <p>
+ * <h1 class="header">Functionality</h1>
+ * Distributed atomic stamped includes the following main functionality:
+ * <ul>
+ * <li>
+ * Method {@link #get()} synchronously gets both value and stamp of atomic.
+ * </li>
+ * <li>
+ * Method {@link #value()} synchronously gets current value of atomic.
+ * </li>
+ * <li>
+ * Method {@link #stamp()} synchronously gets current stamp of atomic.
+ * </li>
+ * <li>
+ * Method {@link #set(Object, Object)} synchronously and unconditionally sets the value
+ * and the stamp in the atomic.
+ * </li>
+ * <li>
+ * Methods {@code compareAndSet(...)} synchronously and conditionally set the value
+ * and the stamp in the atomic.
+ * </li>
+ * </ul>
+ * All previously described methods have asynchronous analogs.
+ * <ul>
+ * <li>
+ * Method {@link #name()} gets name of atomic stamped.
+ * </li>
+ * </ul>
+ * <h1 class="header">Creating Distributed Atomic Stamped</h1>
+ * Instance of distributed atomic stamped can be created by calling the following method:
+ * <ul>
+ *     <li>{@link CacheDataStructures#atomicLong(String, long, boolean)}</li>
+ * </ul>
+ * @see CacheDataStructures#atomicStamped(String, Object, Object, boolean)
+ * @see CacheDataStructures#removeAtomicStamped(String)
+ */
+public interface CacheAtomicStamped<T, S> {
+    /**
+     * Name of atomic stamped.
+     *
+     * @return Name of atomic stamped.
+     */
+    public String name();
+
+    /**
+     * Gets both current value and current stamp of atomic stamped.
+     *
+     * @return both current value and current stamp of atomic stamped.
+     * @throws IgniteCheckedException If operation failed.
+     */
+    public IgniteBiTuple<T, S> get() throws IgniteCheckedException;
+
+    /**
+     * Unconditionally sets the value and the stamp.
+     *
+     * @param val Value.
+     * @param stamp Stamp.
+     * @throws IgniteCheckedException If operation failed.
+     */
+    public void set(T val, S stamp) throws IgniteCheckedException;
+
+    /**
+     * Conditionally sets the new value and new stamp. They will be set if {@code expVal}
+     * and {@code expStamp} are equal to current value and current stamp respectively.
+     *
+     * @param expVal Expected value.
+     * @param newVal New value.
+     * @param expStamp Expected stamp.
+     * @param newStamp New stamp.
+     * @return Result of operation execution. If {@code true} than  value and stamp will be updated.
+     * @throws IgniteCheckedException If operation failed.
+     */
+    public boolean compareAndSet(T expVal, T newVal, S expStamp, S newStamp) throws IgniteCheckedException;
+
+    /**
+     * Gets current stamp.
+     *
+     * @return Current stamp.
+     * @throws IgniteCheckedException If operation failed.
+     */
+    public S stamp() throws IgniteCheckedException;
+
+    /**
+     * Gets current value.
+     *
+     * @return Current value.
+     * @throws IgniteCheckedException If operation failed.
+     */
+    public T value() throws IgniteCheckedException;
+
+    /**
+     * Gets status of atomic.
+     *
+     * @return {@code true} if atomic stamped was removed from cache, {@code false} otherwise.
+     */
+    public boolean removed();
+}

http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/cafee25f/modules/core/src/main/java/org/apache/ignite/cache/datastructures/CacheCountDownLatch.java
----------------------------------------------------------------------
diff --git a/modules/core/src/main/java/org/apache/ignite/cache/datastructures/CacheCountDownLatch.java b/modules/core/src/main/java/org/apache/ignite/cache/datastructures/CacheCountDownLatch.java
new file mode 100644
index 0000000..0f4aae0
--- /dev/null
+++ b/modules/core/src/main/java/org/apache/ignite/cache/datastructures/CacheCountDownLatch.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 CacheCountDownLatch {
+    /**
+     * 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/cafee25f/modules/core/src/main/java/org/apache/ignite/cache/datastructures/CacheDataStructureInvalidException.java
----------------------------------------------------------------------
diff --git a/modules/core/src/main/java/org/apache/ignite/cache/datastructures/CacheDataStructureInvalidException.java b/modules/core/src/main/java/org/apache/ignite/cache/datastructures/CacheDataStructureInvalidException.java
new file mode 100644
index 0000000..f5b1e11
--- /dev/null
+++ b/modules/core/src/main/java/org/apache/ignite/cache/datastructures/CacheDataStructureInvalidException.java
@@ -0,0 +1,66 @@
+/*
+ * 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.*;
+
+/**
+ * This checked exception gets thrown if attempt to access an invalid data structure has been made.
+ * Data structure may become invalid if communication with remote nodes has been lost or
+ * any other error condition happened that prevented from insuring consistent state.
+ * <p>
+ * The best way to handle this error is to discard the invalid data structure instance and try
+ * getting the underlying data structure from cache again.
+ * <p>
+ * Note that data structures throw runtime exceptions out of methods that don't have
+ * checked exceptions in the signature.
+ */
+public class CacheDataStructureInvalidException extends IgniteCheckedException {
+    /** */
+    private static final long serialVersionUID = 0L;
+
+    /**
+     * Creates new exception with given error message.
+     *
+     * @param msg Error message.
+     */
+    public CacheDataStructureInvalidException(String msg) {
+        super(msg);
+    }
+
+    /**
+     * Creates new exception with given throwable as a nested cause and
+     * source of error message.
+     *
+     * @param cause Non-null throwable cause.
+     */
+    public CacheDataStructureInvalidException(Throwable cause) {
+        this(cause.getMessage(), cause);
+    }
+
+    /**
+     * Creates a new exception with given error message and optional nested cause exception.
+     *
+     * @param msg Error message.
+     * @param cause Optional nested exception (can be {@code null}).
+     */
+    public CacheDataStructureInvalidException(String msg, @Nullable Throwable cause) {
+        super(msg, cause);
+    }
+}

http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/cafee25f/modules/core/src/main/java/org/apache/ignite/cache/datastructures/CacheDataStructureInvalidRuntimeException.java
----------------------------------------------------------------------
diff --git a/modules/core/src/main/java/org/apache/ignite/cache/datastructures/CacheDataStructureInvalidRuntimeException.java b/modules/core/src/main/java/org/apache/ignite/cache/datastructures/CacheDataStructureInvalidRuntimeException.java
new file mode 100644
index 0000000..3fcf528
--- /dev/null
+++ b/modules/core/src/main/java/org/apache/ignite/cache/datastructures/CacheDataStructureInvalidRuntimeException.java
@@ -0,0 +1,66 @@
+/*
+ * 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.*;
+
+/**
+ * This runtime exception gets thrown if attempt to access an invalid data structure has been made.
+ * Data structure may become invalid if communication with remote nodes has been lost or
+ * any other error condition happened that prevented from insuring consistent state.
+ * <p>
+ * The best way to handle this error is to discard the invalid data structure instance and try
+ * getting the underlying data structure from cache again.
+ * <p>
+ * Note that data structures throw runtime exceptions out of methods that don't have
+ * checked exceptions in the signature.
+ */
+public class CacheDataStructureInvalidRuntimeException extends IgniteException {
+    /** */
+    private static final long serialVersionUID = 0L;
+
+    /**
+     * Creates new exception with given error message.
+     *
+     * @param msg Error message.
+     */
+    public CacheDataStructureInvalidRuntimeException(String msg) {
+        super(msg);
+    }
+
+    /**
+     * Creates new exception with given throwable as a nested cause and
+     * source of error message.
+     *
+     * @param cause Non-null throwable cause.
+     */
+    public CacheDataStructureInvalidRuntimeException(Throwable cause) {
+        this(cause.getMessage(), cause);
+    }
+
+    /**
+     * Creates a new exception with given error message and optional nested cause exception.
+     *
+     * @param msg Error message.
+     * @param cause Optional nested exception (can be {@code null}).
+     */
+    public CacheDataStructureInvalidRuntimeException(String msg, @Nullable Throwable cause) {
+        super(msg, cause);
+    }
+}

http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/cafee25f/modules/core/src/main/java/org/apache/ignite/cache/datastructures/CacheDataStructureRemovedException.java
----------------------------------------------------------------------
diff --git a/modules/core/src/main/java/org/apache/ignite/cache/datastructures/CacheDataStructureRemovedException.java b/modules/core/src/main/java/org/apache/ignite/cache/datastructures/CacheDataStructureRemovedException.java
new file mode 100644
index 0000000..5be9e13
--- /dev/null
+++ b/modules/core/src/main/java/org/apache/ignite/cache/datastructures/CacheDataStructureRemovedException.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 org.jetbrains.annotations.*;
+
+/**
+ * This checked exception gets thrown if attempt to access a removed data structure has been made.
+ * <p>
+ * Note that data structures throw runtime exceptions out of methods that don't have
+ * checked exceptions in the signature.
+ */
+public class CacheDataStructureRemovedException extends IgniteCheckedException {
+    /** */
+    private static final long serialVersionUID = 0L;
+
+    /**
+     * Creates new exception with given error message.
+     *
+     * @param msg Error message.
+     */
+    public CacheDataStructureRemovedException(String msg) {
+        super(msg);
+    }
+
+    /**
+     * Creates new exception with given throwable as a nested cause and
+     * source of error message.
+     *
+     * @param cause Non-null throwable cause.
+     */
+    public CacheDataStructureRemovedException(Throwable cause) {
+        this(cause.getMessage(), cause);
+    }
+
+    /**
+     * Creates a new exception with given error message and optional nested cause exception.
+     *
+     * @param msg Error message.
+     * @param cause Optional nested exception (can be {@code null}).
+     */
+    public CacheDataStructureRemovedException(String msg, @Nullable Throwable cause) {
+        super(msg, cause);
+    }
+}

http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/cafee25f/modules/core/src/main/java/org/apache/ignite/cache/datastructures/CacheDataStructureRemovedRuntimeException.java
----------------------------------------------------------------------
diff --git a/modules/core/src/main/java/org/apache/ignite/cache/datastructures/CacheDataStructureRemovedRuntimeException.java b/modules/core/src/main/java/org/apache/ignite/cache/datastructures/CacheDataStructureRemovedRuntimeException.java
new file mode 100644
index 0000000..dbacaf9
--- /dev/null
+++ b/modules/core/src/main/java/org/apache/ignite/cache/datastructures/CacheDataStructureRemovedRuntimeException.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 org.jetbrains.annotations.*;
+
+/**
+ * This runtime exception gets thrown if attempt to access a removed data structure has been made.
+ * <p>
+ * Note that data structures throw runtime exceptions out of methods that don't have
+ * checked exceptions in the signature.
+ */
+public class CacheDataStructureRemovedRuntimeException extends IgniteException {
+    /** */
+    private static final long serialVersionUID = 0L;
+
+    /**
+     * Creates new exception with given error message.
+     *
+     * @param msg Error message.
+     */
+    public CacheDataStructureRemovedRuntimeException(String msg) {
+        super(msg);
+    }
+
+    /**
+     * Creates new exception with given throwable as a nested cause and
+     * source of error message.
+     *
+     * @param cause Non-null throwable cause.
+     */
+    public CacheDataStructureRemovedRuntimeException(Throwable cause) {
+        this(cause.getMessage(), cause);
+    }
+
+    /**
+     * Creates a new exception with given error message and optional nested cause exception.
+     *
+     * @param msg Error message.
+     * @param cause Optional nested exception (can be {@code null}).
+     */
+    public CacheDataStructureRemovedRuntimeException(String msg, @Nullable Throwable cause) {
+        super(msg, cause);
+    }
+}

http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/cafee25f/modules/core/src/main/java/org/apache/ignite/cache/datastructures/CacheDataStructures.java
----------------------------------------------------------------------
diff --git a/modules/core/src/main/java/org/apache/ignite/cache/datastructures/CacheDataStructures.java b/modules/core/src/main/java/org/apache/ignite/cache/datastructures/CacheDataStructures.java
new file mode 100644
index 0000000..fd2df8a
--- /dev/null
+++ b/modules/core/src/main/java/org/apache/ignite/cache/datastructures/CacheDataStructures.java
@@ -0,0 +1,220 @@
+/*
+ * 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.*;
+
+/**
+ * Facade for working with distributed cache data structures. All cache data structures are similar
+ * in APIs to {@code 'java.util.concurrent'} package, but all operations on them are grid-aware.
+ * For example, if you increment {@link CacheAtomicLong} on one node, another node will
+ * know about the change. Or if you add an element to {@link CacheQueue} on one node,
+ * you can poll it on another node.
+ * <p>
+ * You can get data structures facade by calling {@link org.apache.ignite.cache.Cache#dataStructures()} method.
+ */
+public interface CacheDataStructures {
+    /**
+     * Will get an atomic sequence from cache and create one if it has not been created yet and {@code create} flag
+     * is {@code true}.
+     *
+     * @param name Sequence name.
+     * @param initVal Initial value for sequence. If sequence already cached, {@code initVal} will be ignored.
+     * @param create Boolean flag indicating whether data structure should be created if does not exist.
+     * @return Sequence for the given name.
+     * @throws IgniteCheckedException If sequence could not be fetched or created.
+     */
+    @Nullable public CacheAtomicSequence atomicSequence(String name, long initVal, boolean create)
+        throws IgniteCheckedException;
+
+    /**
+     * Remove sequence from cache.
+     *
+     * @param name Sequence name.
+     * @return {@code True} if sequence has been removed, {@code false} otherwise.
+     * @throws IgniteCheckedException If remove failed.
+     */
+    public boolean removeAtomicSequence(String name) throws IgniteCheckedException;
+
+    /**
+     * Will get a atomic long from cache and create one if it has not been created yet and {@code create} flag
+     * is {@code true}.
+     *
+     * @param name Name of atomic long.
+     * @param initVal Initial value for atomic long. If atomic long already cached, {@code initVal}
+     *        will be ignored.
+     * @param create Boolean flag indicating whether data structure should be created if does not exist.
+     * @return Atomic long.
+     * @throws IgniteCheckedException If atomic long could not be fetched or created.
+     */
+    @Nullable public CacheAtomicLong atomicLong(String name, long initVal, boolean create) throws IgniteCheckedException;
+
+    /**
+     * Remove atomic long from cache.
+     *
+     * @param name Name of atomic long.
+     * @return {@code True} if atomic long has been removed, {@code false} otherwise.
+     * @throws IgniteCheckedException If removing failed.
+     */
+    public boolean removeAtomicLong(String name) throws IgniteCheckedException;
+
+    /**
+     * Will get a named queue from cache and create one if it has not been created yet and {@code create} flag
+     * is {@code true}.
+     * If queue is present in cache already, queue properties will not be changed. Use
+     * collocation for {@link org.apache.ignite.cache.CacheMode#PARTITIONED} caches if you have lots of relatively
+     * small queues as it will make fetching, querying, and iteration a lot faster. If you have
+     * few very large queues, then you should consider turning off collocation as they simply
+     * may not fit in a single node's memory. However note that in this case
+     * to get a single element off the queue all nodes may have to be queried.
+     *
+     * @param name Name of queue.
+     * @param cap Capacity of queue, {@code 0} for unbounded queue.
+     * @param collocated If {@code true} then all items within the same queue will be collocated on the same node.
+     *      Otherwise elements of the same queue maybe be cached on different nodes. If you have lots of relatively
+     *      small queues, then you should use collocation. If you have few large queues, then you should turn off
+     *      collocation. This parameter works only for {@link org.apache.ignite.cache.CacheMode#PARTITIONED} cache.
+     * @param create Boolean flag indicating whether data structure should be created if does not exist.
+     * @return Queue with given properties.
+     * @throws IgniteCheckedException If remove failed.
+     */
+    @Nullable public <T> CacheQueue<T> queue(String name, int cap, boolean collocated,
+        boolean create) throws IgniteCheckedException;
+
+    /**
+     * Remove queue from cache. Internally one transaction will be created for all elements
+     * in the queue. If you anticipate that queue may be large, then it's better to use
+     * {@link #removeQueue(String, int)} which allows to specify batch size. In that case
+     * transaction will be split into multiple transactions which will have upto {@code batchSize}
+     * elements in it.
+     *
+     * @param name Name queue.
+     * @return {@code True} if queue has been removed and false if it's not cached.
+     * @throws IgniteCheckedException If remove failed.
+     */
+    public boolean removeQueue(String name) throws IgniteCheckedException;
+
+    /**
+     * Remove queue from cache. Internally multiple transactions will be created
+     * with no more than {@code batchSize} elements in them. For larger queues, this
+     * method is preferrable over {@link #removeQueue(String)} which will create only
+     * one transaction for the whole operation.
+     *
+     * @param name Name queue.
+     * @param batchSize Batch size.
+     * @return {@code True} if queue has been removed and false if it's not cached.
+     * @throws IgniteCheckedException If remove failed.
+     */
+    public boolean removeQueue(String name, int batchSize) throws IgniteCheckedException;
+
+    /**
+     * Will get a named set from cache and create one if it has not been created yet and {@code create} flag
+     * is {@code true}.
+     *
+     * @param name Set name.
+     * @param collocated If {@code true} then all items within the same set will be collocated on the same node.
+     *      Otherwise elements of the same set maybe be cached on different nodes. This parameter works only
+     *      for {@link org.apache.ignite.cache.CacheMode#PARTITIONED} cache.
+     * @param create Flag indicating whether set should be created if does not exist.
+     * @return Set with given properties.
+     * @throws IgniteCheckedException If failed.
+     */
+    @Nullable public <T> CacheSet<T> set(String name, boolean collocated, boolean create) throws IgniteCheckedException;
+
+    /**
+     * Removes set from cache.
+     *
+     * @param name Set name.
+     * @return {@code True} if set has been removed and false if it's not cached.
+     * @throws IgniteCheckedException If failed.
+     */
+    public boolean removeSet(String name) throws IgniteCheckedException;
+
+    /**
+     * Will get a atomic reference from cache and create one if it has not been created yet and {@code create} flag
+     * is {@code true}.
+     *
+     * @param name Atomic reference name.
+     * @param initVal Initial value for atomic reference. If atomic reference already cached,
+     *      {@code initVal} will be ignored.
+     * @param create Boolean flag indicating whether data structure should be created if does not exist.
+     * @return Atomic reference for the given name.
+     * @throws IgniteCheckedException If atomic reference could not be fetched or created.
+     */
+    @Nullable public <T> CacheAtomicReference<T> atomicReference(String name, @Nullable T initVal, boolean create)
+        throws IgniteCheckedException;
+
+    /**
+     * Remove atomic reference from cache.
+     *
+     * @param name Atomic reference name.
+     * @return {@code True} if atomic reference has been removed, {@code false} otherwise.
+     * @throws IgniteCheckedException If remove failed.
+     */
+    public boolean removeAtomicReference(String name) throws IgniteCheckedException;
+
+    /**
+     * Will get a atomic stamped from cache and create one if it has not been created yet and {@code create} flag
+     * is {@code true}.
+     *
+     * @param name Atomic stamped name.
+     * @param initVal Initial value for atomic stamped. If atomic stamped already cached,
+     *      {@code initVal} will be ignored.
+     * @param initStamp Initial stamp for atomic stamped. If atomic stamped already cached,
+     *      {@code initStamp} will be ignored.
+     * @param create Boolean flag indicating whether data structure should be created if does not exist.
+     * @return Atomic stamped for the given name.
+     * @throws IgniteCheckedException If atomic stamped could not be fetched or created.
+     */
+    @Nullable public <T, S> CacheAtomicStamped<T, S> atomicStamped(String name, @Nullable T initVal,
+        @Nullable S initStamp, boolean create) throws IgniteCheckedException;
+
+    /**
+     * Remove atomic stamped from cache.
+     *
+     * @param name Atomic stamped name.
+     * @return {@code True} if atomic stamped has been removed, {@code false} otherwise.
+     * @throws IgniteCheckedException If remove failed.
+     */
+    public boolean removeAtomicStamped(String name) throws IgniteCheckedException;
+
+    /**
+     * Gets or creates count down latch. If count down latch is not found in cache and {@code create} flag
+     * is {@code true}, it is created using provided name and count parameter.
+     *
+     * @param name Name of the latch.
+     * @param cnt Count for new latch creation.
+     * @param autoDel {@code True} to automatically delete latch from cache
+     *      when its count reaches zero.
+     * @param create Boolean flag indicating whether data structure should be created if does not exist.
+     * @return Count down latch for the given name.
+     * @throws IgniteCheckedException If operation failed.
+     */
+    @Nullable public CacheCountDownLatch countDownLatch(String name, int cnt, boolean autoDel, boolean create)
+        throws IgniteCheckedException;
+
+    /**
+     * Removes count down latch from cache.
+     *
+     * @param name Name of the latch.
+     * @return Count down latch for the given name.
+     * @throws IgniteCheckedException If operation failed.
+     */
+    public boolean removeCountDownLatch(String name) throws IgniteCheckedException;
+}

http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/cafee25f/modules/core/src/main/java/org/apache/ignite/cache/datastructures/CacheQueue.java
----------------------------------------------------------------------
diff --git a/modules/core/src/main/java/org/apache/ignite/cache/datastructures/CacheQueue.java b/modules/core/src/main/java/org/apache/ignite/cache/datastructures/CacheQueue.java
new file mode 100644
index 0000000..c47b185
--- /dev/null
+++ b/modules/core/src/main/java/org/apache/ignite/cache/datastructures/CacheQueue.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">
+ * CacheQueue&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">
+ * CacheQueue&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 CacheQueue<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/cafee25f/modules/core/src/main/java/org/apache/ignite/cache/datastructures/CacheSet.java
----------------------------------------------------------------------
diff --git a/modules/core/src/main/java/org/apache/ignite/cache/datastructures/CacheSet.java b/modules/core/src/main/java/org/apache/ignite/cache/datastructures/CacheSet.java
new file mode 100644
index 0000000..b049922
--- /dev/null
+++ b/modules/core/src/main/java/org/apache/ignite/cache/datastructures/CacheSet.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 CacheSet<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/cafee25f/modules/core/src/main/java/org/apache/ignite/cache/datastructures/GridCacheAtomicLong.java
----------------------------------------------------------------------
diff --git a/modules/core/src/main/java/org/apache/ignite/cache/datastructures/GridCacheAtomicLong.java b/modules/core/src/main/java/org/apache/ignite/cache/datastructures/GridCacheAtomicLong.java
deleted file mode 100644
index ac49a54..0000000
--- a/modules/core/src/main/java/org/apache/ignite/cache/datastructures/GridCacheAtomicLong.java
+++ /dev/null
@@ -1,157 +0,0 @@
-/*
- * 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.*;
-
-/**
- * This interface provides a rich API for working with distributedly cached atomic long value.
- * <p>
- * <h1 class="header">Functionality</h1>
- * Distributed atomic long includes the following main functionality:
- * <ul>
- * <li>
- * Method {@link #get()} synchronously gets current value of atomic long.
- * </li>
- * <li>
- * Various {@code get..(..)} methods synchronously get current value of atomic long
- * and increase or decrease value of atomic long.
- * </li>
- * <li>
- * Method {@link #addAndGet(long l)} synchronously sums {@code l} with current value of atomic long
- * and returns result.
- * </li>
- * <li>
- * Method {@link #incrementAndGet()} synchronously increases value of atomic long and returns result.
- * </li>
- * <li>
- * Method {@link #decrementAndGet()} synchronously decreases value of atomic long and returns result.
- * </li>
- * <li>
- * Method {@link #getAndSet(long l)} synchronously gets current value of atomic long and sets {@code l}
- * as value of atomic long.
- * </li>
- * </ul>
- * All previously described methods have asynchronous analogs.
- * <ul>
- * <li>
- * Method {@link #name()} gets name of atomic long.
- * </li>
- * </ul>
- * <p>
- * <h1 class="header">Creating Distributed Atomic Long</h1>
- * Instance of distributed atomic long can be created by calling the following method:
- * <ul>
- *     <li>{@link GridCacheDataStructures#atomicLong(String, long, boolean)}</li>
- * </ul>
- * @see GridCacheDataStructures#atomicLong(String, long, boolean)
- * @see GridCacheDataStructures#removeAtomicLong(String)
- */
-public interface GridCacheAtomicLong {
-    /**
-     * Name of atomic long.
-     *
-     * @return Name of atomic long.
-     */
-    public String name();
-
-    /**
-     * Gets current value of atomic long.
-     *
-     * @return Current value of atomic long.
-     * @throws IgniteCheckedException If operation failed.
-     */
-    public long get() throws IgniteCheckedException;
-
-    /**
-     * Increments and gets current value of atomic long.
-     *
-     * @return Value.
-     * @throws IgniteCheckedException If operation failed.
-     */
-    public long incrementAndGet() throws IgniteCheckedException;
-
-    /**
-     * Gets and increments current value of atomic long.
-     *
-     * @return Value.
-     * @throws IgniteCheckedException If operation failed.
-     */
-    public long getAndIncrement() throws IgniteCheckedException;
-
-    /**
-     * Adds {@code l} and gets current value of atomic long.
-     *
-     * @param l Number which will be added.
-     * @return Value.
-     * @throws IgniteCheckedException If operation failed.
-     */
-    public long addAndGet(long l) throws IgniteCheckedException;
-
-    /**
-     * Gets current value of atomic long and adds {@code l}.
-     *
-     * @param l Number which will be added.
-     * @return Value.
-     * @throws IgniteCheckedException If operation failed.
-     */
-    public long getAndAdd(long l) throws IgniteCheckedException;
-
-    /**
-     * Decrements and gets current value of atomic long.
-     *
-     * @return Value.
-     * @throws IgniteCheckedException If operation failed.
-     */
-    public long decrementAndGet() throws IgniteCheckedException;
-
-    /**
-     * Gets and decrements current value of atomic long.
-     *
-     * @return Value.
-     * @throws IgniteCheckedException If operation failed.
-     */
-    public long getAndDecrement() throws IgniteCheckedException;
-
-    /**
-     * Gets current value of atomic long and sets new value {@code l} of atomic long.
-     *
-     * @param l New value of atomic long.
-     * @return Value.
-     * @throws IgniteCheckedException If operation failed.
-     */
-    public long getAndSet(long l) throws IgniteCheckedException;
-
-    /**
-     * Atomically compares current value to the expected value, and if they are equal, sets current value
-     * to new value.
-     *
-     * @param expVal Expected atomic long's value.
-     * @param newVal New atomic long's value to set if current value equal to expected value.
-     * @return {@code True} if comparison succeeded, {@code false} otherwise.
-     * @throws IgniteCheckedException If failed.
-     */
-    public boolean compareAndSet(long expVal, long newVal) throws IgniteCheckedException;
-
-    /**
-     * Gets status of atomic.
-     *
-     * @return {@code true} if atomic was removed from cache, {@code false} in other case.
-     */
-    public boolean removed();
-}

http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/cafee25f/modules/core/src/main/java/org/apache/ignite/cache/datastructures/GridCacheAtomicReference.java
----------------------------------------------------------------------
diff --git a/modules/core/src/main/java/org/apache/ignite/cache/datastructures/GridCacheAtomicReference.java b/modules/core/src/main/java/org/apache/ignite/cache/datastructures/GridCacheAtomicReference.java
deleted file mode 100644
index 9d3d69a..0000000
--- a/modules/core/src/main/java/org/apache/ignite/cache/datastructures/GridCacheAtomicReference.java
+++ /dev/null
@@ -1,93 +0,0 @@
-/*
- * 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.*;
-
-/**
- * This interface provides a rich API for working with distributed atomic reference.
- * <p>
- * <h1 class="header">Functionality</h1>
- * Distributed atomic reference includes the following main functionality:
- * <ul>
- * <li>
- * Method {@link #get()} synchronously gets current value of an atomic reference.
- * </li>
- * <li>
- * Method {@link #set(Object)} synchronously and unconditionally sets the value in the an atomic reference.
- * </li>
- * <li>
- * Methods {@code compareAndSet(...)} synchronously and conditionally set the value in the an atomic reference.
- * </li>
- * </ul>
- * All previously described methods have asynchronous analogs.
- * <ul>
- * <li>
- * Method {@link #name()} gets name of atomic reference.
- * </li>
- * </ul>
- * <h1 class="header">Creating Distributed Atomic Reference</h1>
- * Instance of distributed atomic reference can be created by calling the following method:
- * <ul>
- *     <li>{@link GridCacheDataStructures#atomicReference(String, Object, boolean)}</li>
- * </ul>
- * @see GridCacheDataStructures#atomicReference(String, Object, boolean)
- * @see GridCacheDataStructures#removeAtomicReference(String)
- */
-public interface GridCacheAtomicReference<T> {
-    /**
-     * Name of atomic reference.
-     *
-     * @return Name of an atomic reference.
-     */
-    public String name();
-
-    /**
-     * Gets current value of an atomic reference.
-     *
-     * @return current value of an atomic reference.
-     * @throws IgniteCheckedException If operation failed.
-     */
-    public T get() throws IgniteCheckedException;
-
-    /**
-     * Unconditionally sets the value.
-     *
-     * @param val Value.
-     * @throws IgniteCheckedException If operation failed.
-     */
-    public void set(T val) throws IgniteCheckedException;
-
-    /**
-     * Conditionally sets the new value. That will be set if {@code expVal} is equal
-     * to current value respectively.
-     *
-     * @param expVal Expected value.
-     * @param newVal New value.
-     * @return Result of operation execution. If {@code true} than value have been updated.
-     * @throws IgniteCheckedException If operation failed.
-     */
-    public boolean compareAndSet(T expVal, T newVal) throws IgniteCheckedException;
-
-    /**
-     * Gets status of atomic.
-     *
-     * @return {@code true} if an atomic reference was removed from cache, {@code false} otherwise.
-     */
-    public boolean removed();
-}

http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/cafee25f/modules/core/src/main/java/org/apache/ignite/cache/datastructures/GridCacheAtomicSequence.java
----------------------------------------------------------------------
diff --git a/modules/core/src/main/java/org/apache/ignite/cache/datastructures/GridCacheAtomicSequence.java b/modules/core/src/main/java/org/apache/ignite/cache/datastructures/GridCacheAtomicSequence.java
deleted file mode 100644
index 051d2e3..0000000
--- a/modules/core/src/main/java/org/apache/ignite/cache/datastructures/GridCacheAtomicSequence.java
+++ /dev/null
@@ -1,130 +0,0 @@
-/*
- * 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.*;
-
-/**
- * This interface provides a rich API for working with distributed atomic sequence.
- * <p>
- * <h1 class="header">Functionality</h1>
- * Distributed atomic sequence includes the following main functionality:
- * <ul>
- * <li>
- * Method {@link #get()} synchronously gets current value from atomic sequence.
- * </li>
- * <li>
- * Various {@code get..(..)} methods synchronously get current value from atomic sequence
- * and increase atomic sequences value.
- * </li>
- * <li>
- * Various {@code add..(..)} {@code increment(..)} methods synchronously increase atomic sequences value
- * and return increased value.
- * </li>
- * </ul>
- * All previously described methods have asynchronous analogs.
- * <ul>
- * <li>
- * Method {@link #batchSize(int size)} sets batch size of current atomic sequence.
- * </li>
- * <li>
- * Method {@link #batchSize()} gets current batch size of atomic sequence.
- * </li>
- * <li>
- * Method {@link #name()} gets name of atomic sequence.
- * </li>
- * </ul>
- * <h1 class="header">Creating Distributed Atomic Sequence</h1>
- * Instance of distributed atomic sequence can be created by calling the following method:
- * <ul>
- *     <li>{@link GridCacheDataStructures#atomicSequence(String, long, boolean)}</li>
- * </ul>
- * @see GridCacheDataStructures#atomicSequence(String, long, boolean)
- * @see GridCacheDataStructures#removeAtomicSequence(String)
- */
-public interface GridCacheAtomicSequence {
-    /**
-     * Name of atomic sequence.
-     *
-     * @return Name of atomic sequence.
-     */
-    public String name();
-
-    /**
-     * Gets current value of atomic sequence.
-     *
-     * @return Value of atomic sequence.
-     * @throws IgniteCheckedException If operation failed.
-     */
-    public long get() throws IgniteCheckedException;
-
-    /**
-     * Increments and returns the value of atomic sequence.
-     *
-     * @return Value of atomic sequence after increment.
-     * @throws IgniteCheckedException If operation failed.
-     */
-    public long incrementAndGet() throws IgniteCheckedException;
-
-    /**
-     * Gets and increments current value of atomic sequence.
-     *
-     * @return Value of atomic sequence before increment.
-     * @throws IgniteCheckedException If operation failed.
-     */
-    public long getAndIncrement() throws IgniteCheckedException;
-
-    /**
-     * Adds {@code l} elements to atomic sequence and gets value of atomic sequence.
-     *
-     * @param l Number of added elements.
-     * @return Value of atomic sequence.
-     * @throws IgniteCheckedException If operation failed.
-     */
-    public long addAndGet(long l) throws IgniteCheckedException;
-
-    /**
-     * Gets current value of atomic sequence and adds {@code l} elements.
-     *
-     * @param l Number of added elements.
-     * @return Value of atomic sequence.
-     * @throws IgniteCheckedException If operation failed.
-     */
-    public long getAndAdd(long l) throws IgniteCheckedException;
-
-    /**
-     * Gets local batch size for this atomic sequence.
-     *
-     * @return Sequence batch size.
-     */
-    public int batchSize();
-
-    /**
-     * Sets local batch size for atomic sequence.
-     *
-     * @param size Sequence batch size. Must be more then 0.
-     */
-    public void batchSize(int size);
-
-    /**
-     * Gets status of atomic sequence.
-     *
-     * @return {@code true} if atomic sequence was removed from cache, {@code false} otherwise.
-     */
-    public boolean removed();
-}

http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/cafee25f/modules/core/src/main/java/org/apache/ignite/cache/datastructures/GridCacheAtomicStamped.java
----------------------------------------------------------------------
diff --git a/modules/core/src/main/java/org/apache/ignite/cache/datastructures/GridCacheAtomicStamped.java b/modules/core/src/main/java/org/apache/ignite/cache/datastructures/GridCacheAtomicStamped.java
deleted file mode 100644
index 8480708..0000000
--- a/modules/core/src/main/java/org/apache/ignite/cache/datastructures/GridCacheAtomicStamped.java
+++ /dev/null
@@ -1,121 +0,0 @@
-/*
- * 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.apache.ignite.lang.*;
-
-/**
- * This interface provides a rich API for working with distributed atomic stamped value.
- * <p>
- * <h1 class="header">Functionality</h1>
- * Distributed atomic stamped includes the following main functionality:
- * <ul>
- * <li>
- * Method {@link #get()} synchronously gets both value and stamp of atomic.
- * </li>
- * <li>
- * Method {@link #value()} synchronously gets current value of atomic.
- * </li>
- * <li>
- * Method {@link #stamp()} synchronously gets current stamp of atomic.
- * </li>
- * <li>
- * Method {@link #set(Object, Object)} synchronously and unconditionally sets the value
- * and the stamp in the atomic.
- * </li>
- * <li>
- * Methods {@code compareAndSet(...)} synchronously and conditionally set the value
- * and the stamp in the atomic.
- * </li>
- * </ul>
- * All previously described methods have asynchronous analogs.
- * <ul>
- * <li>
- * Method {@link #name()} gets name of atomic stamped.
- * </li>
- * </ul>
- * <h1 class="header">Creating Distributed Atomic Stamped</h1>
- * Instance of distributed atomic stamped can be created by calling the following method:
- * <ul>
- *     <li>{@link GridCacheDataStructures#atomicLong(String, long, boolean)}</li>
- * </ul>
- * @see GridCacheDataStructures#atomicStamped(String, Object, Object, boolean)
- * @see GridCacheDataStructures#removeAtomicStamped(String)
- */
-public interface GridCacheAtomicStamped<T, S> {
-    /**
-     * Name of atomic stamped.
-     *
-     * @return Name of atomic stamped.
-     */
-    public String name();
-
-    /**
-     * Gets both current value and current stamp of atomic stamped.
-     *
-     * @return both current value and current stamp of atomic stamped.
-     * @throws IgniteCheckedException If operation failed.
-     */
-    public IgniteBiTuple<T, S> get() throws IgniteCheckedException;
-
-    /**
-     * Unconditionally sets the value and the stamp.
-     *
-     * @param val Value.
-     * @param stamp Stamp.
-     * @throws IgniteCheckedException If operation failed.
-     */
-    public void set(T val, S stamp) throws IgniteCheckedException;
-
-    /**
-     * Conditionally sets the new value and new stamp. They will be set if {@code expVal}
-     * and {@code expStamp} are equal to current value and current stamp respectively.
-     *
-     * @param expVal Expected value.
-     * @param newVal New value.
-     * @param expStamp Expected stamp.
-     * @param newStamp New stamp.
-     * @return Result of operation execution. If {@code true} than  value and stamp will be updated.
-     * @throws IgniteCheckedException If operation failed.
-     */
-    public boolean compareAndSet(T expVal, T newVal, S expStamp, S newStamp) throws IgniteCheckedException;
-
-    /**
-     * Gets current stamp.
-     *
-     * @return Current stamp.
-     * @throws IgniteCheckedException If operation failed.
-     */
-    public S stamp() throws IgniteCheckedException;
-
-    /**
-     * Gets current value.
-     *
-     * @return Current value.
-     * @throws IgniteCheckedException If operation failed.
-     */
-    public T value() throws IgniteCheckedException;
-
-    /**
-     * Gets status of atomic.
-     *
-     * @return {@code true} if atomic stamped was removed from cache, {@code false} otherwise.
-     */
-    public boolean removed();
-}

http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/cafee25f/modules/core/src/main/java/org/apache/ignite/cache/datastructures/GridCacheCountDownLatch.java
----------------------------------------------------------------------
diff --git a/modules/core/src/main/java/org/apache/ignite/cache/datastructures/GridCacheCountDownLatch.java b/modules/core/src/main/java/org/apache/ignite/cache/datastructures/GridCacheCountDownLatch.java
deleted file mode 100644
index e2c621c..0000000
--- a/modules/core/src/main/java/org/apache/ignite/cache/datastructures/GridCacheCountDownLatch.java
+++ /dev/null
@@ -1,226 +0,0 @@
-/*
- * 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 GridCacheDataStructures#countDownLatch(String, int, boolean, boolean)}.
- * @see GridCacheDataStructures#countDownLatch(String, int, boolean, boolean)
- * @see GridCacheDataStructures#removeCountDownLatch(String)
- */
-public interface GridCacheCountDownLatch {
-    /**
-     * 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();
-}


Mime
View raw message