RList.addAsync & addAllAsync methods added

src/main/java/org/redisson/RedissonList.java

@@ -16,6 +16,7 @@
 package org.redisson;
 
 import io.netty.util.concurrent.Future;
+import io.netty.util.concurrent.Promise;
 
 import java.util.ArrayList;
 import java.util.Collection;
@@ -25,6 +26,7 @@ import java.util.List;
 import java.util.ListIterator;
 import java.util.NoSuchElementException;
 
+import org.redisson.async.AsyncOperation;
 import org.redisson.async.ResultOperation;
 import org.redisson.async.SyncOperation;
 import org.redisson.connection.ConnectionManager;
@@ -100,6 +102,11 @@ public class RedissonList<V> extends RedissonExpirable implements RList<V> {
         return addAll(Collections.singleton(e));
     }
     
+    @Override
+    public Future<Boolean> addAsync(V e) {
+        return addAllAsync(Collections.singleton(e));
+    }
+
     @Override
     public boolean remove(Object o) {
         return remove(o, 1);
@@ -143,17 +150,22 @@ public class RedissonList<V> extends RedissonExpirable implements RList<V> {
     }
 
     @Override
-    public boolean addAll(final Collection<? extends V> c) {
+    public boolean addAll(Collection<? extends V> c) {
         if (c.isEmpty()) {
             return false;
         }
-        connectionManager.write(getName(), new ResultOperation<Long, Object>() {
+        return connectionManager.get(addAllAsync(c));
+    }
+    
+    @Override
+    public Future<Boolean> addAllAsync(final Collection<? extends V> c) {
+        return connectionManager.writeAsync(getName(), new AsyncOperation<Object, Boolean>() {
             @Override
-            protected Future<Long> execute(RedisAsyncConnection<Object, Object> async) {
-                return async.rpush(getName(), c.toArray());
+            public void execute(Promise<Boolean> promise, RedisAsyncConnection<Object, Object> async) {
+                async.rpush((Object)getName(), c.toArray());
+                promise.setSuccess(true);
             }
         });
-        return true;
     }
 
     @Override

src/main/java/org/redisson/core/RList.java

@@ -15,6 +15,9 @@
  */
 package org.redisson.core;
 
+import io.netty.util.concurrent.Future;
+
+import java.util.Collection;
 import java.util.List;
 
 /**
@@ -26,4 +29,8 @@ import java.util.List;
  */
 public interface RList<V> extends List<V>, RExpirable {
 
+    Future<Boolean> addAsync(V e);
+    
+    Future<Boolean> addAllAsync(Collection<? extends V> c);
+    
 }

src/test/java/org/redisson/RedissonListTest.java

@@ -1,5 +1,8 @@
 package org.redisson;
 
+import io.netty.util.concurrent.Future;
+import io.netty.util.concurrent.FutureListener;
+
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.Iterator;
@@ -10,9 +13,36 @@ import java.util.ListIterator;
 import org.hamcrest.Matchers;
 import org.junit.Assert;
 import org.junit.Test;
+import org.redisson.core.RList;
 
 public class RedissonListTest extends BaseTest {
 
+    @Test
+    public void testAddAllAsync() {
+        final RList<Long> list = redisson.getList("list");
+        list.addAllAsync(Arrays.asList(1L, 2L, 3L)).addListener(new FutureListener<Boolean>() {
+            @Override
+            public void operationComplete(Future<Boolean> future) throws Exception {
+                list.addAllAsync(Arrays.asList(1L, 24L, 3L));
+            }
+        });
+
+        Assert.assertThat(list, Matchers.contains(1L, 2L, 3L, 1L, 24L, 3L));
+    }
+    
+    @Test
+    public void testAddAsync() {
+        final RList<Long> list = redisson.getList("list");
+        list.addAsync(1L).addListener(new FutureListener<Boolean>() {
+            @Override
+            public void operationComplete(Future<Boolean> future) throws Exception {
+                list.addAsync(2L);
+            }
+        });
+
+        Assert.assertThat(list, Matchers.contains(1L, 2L));
+    }
+    
     @Test
     public void testLong() {
         List<Long> list = redisson.getList("list");