Merge pull request #614 from jackygurui/redisson-reference

Redisson reference

redisson/src/main/java/org/redisson/command/CommandAsyncService.java

@@ -60,13 +60,15 @@ import io.netty.util.Timeout;
 import io.netty.util.TimerTask;
 import io.netty.util.concurrent.Future;
 import io.netty.util.concurrent.FutureListener;
-import io.netty.util.concurrent.Promise;
+import java.util.HashMap;
-import org.redisson.Redisson;
+import java.util.Map;
-import org.redisson.RedissonReactive;
 import org.redisson.RedissonReference;
-import org.redisson.api.RObject;
 import org.redisson.api.RedissonClient;
 import org.redisson.api.RedissonReactiveClient;
+import org.redisson.client.protocol.ScoredEntry;
+import org.redisson.client.protocol.decoder.ListScanResult;
+import org.redisson.client.protocol.decoder.MapScanResult;
+import org.redisson.client.protocol.decoder.ScanObjectEntry;
 import org.redisson.misc.RedissonObjectFactory;
 
 /**
@@ -766,8 +768,8 @@ public class CommandAsyncService implements CommandAsyncExecutor {
                 ((RedisClientResult)res).setRedisClient(addr);
             }
             
-            if (isRedissonReferenceSupportEnabled() && res instanceof List) {
+            if (isRedissonReferenceSupportEnabled() && (res instanceof List || res instanceof ListScanResult)) {
-                List r = (List) res;
+                List r = res instanceof ListScanResult ? ((ListScanResult)res).getValues() : (List) res;
                 for (int i = 0; i < r.size(); i++) {
                     if (r.get(i) instanceof RedissonReference) {
                         try {
@@ -776,9 +778,48 @@ public class CommandAsyncService implements CommandAsyncExecutor {
                                     : RedissonObjectFactory.<R>fromReference(redissonReactive, (RedissonReference) r.get(i))));
                         } catch (Exception exception) {//skip and carry on to next one.
                         }
+                    } else if (r.get(i) instanceof ScoredEntry && ((ScoredEntry) r.get(i)).getValue() instanceof RedissonReference) {
+                        try {
+                            ScoredEntry se = ((ScoredEntry) r.get(i));
+                            r.set(i ,new ScoredEntry(se.getScore(), redisson != null
+                                    ? RedissonObjectFactory.<R>fromReference(redisson, (RedissonReference) se.getValue())
+                                    : RedissonObjectFactory.<R>fromReference(redissonReactive, (RedissonReference) se.getValue())));
+                        } catch (Exception exception) {//skip and carry on to next one.
+                        }
+                    }
+                }
+                details.getMainPromise().trySuccess(res);
+            } else if (isRedissonReferenceSupportEnabled() && (res instanceof MapScanResult)) {
+                Map<ScanObjectEntry,  ScanObjectEntry> map = ((MapScanResult)res).getMap();
+                HashMap<ScanObjectEntry,  ScanObjectEntry> toAdd = null;
+                for (Map.Entry<ScanObjectEntry,  ScanObjectEntry> e : (Set<Map.Entry<ScanObjectEntry, ScanObjectEntry>>) map.entrySet()) {
+                    if (e.getValue().getObj() instanceof RedissonReference) {
+                        try {
+                            e.setValue(new ScanObjectEntry(e.getValue().getBuf(), redisson != null
+                                    ? RedissonObjectFactory.<R>fromReference(redisson, (RedissonReference) e.getValue().getObj())
+                                    : RedissonObjectFactory.<R>fromReference(redissonReactive, (RedissonReference) e.getValue().getObj())));
+                        } catch (Exception exception) {//skip and carry on to next one.
+                        }
+                    }
+                    if (e.getKey().getObj() instanceof RedissonReference) {
+                        if (toAdd == null) {
+                            toAdd = new HashMap<ScanObjectEntry,  ScanObjectEntry>();
+                        }
+                        toAdd.put(e.getKey(), e.getValue());
+                    }
+                }
+                if (toAdd != null) {
+                    for (Map.Entry<ScanObjectEntry,  ScanObjectEntry> e : (Set<Map.Entry<ScanObjectEntry,  ScanObjectEntry>>) toAdd.entrySet()) {
+                        try {
+                            map.put(new ScanObjectEntry(e.getValue().getBuf(), (redisson != null
+                                    ? RedissonObjectFactory.<R>fromReference(redisson, (RedissonReference) e.getKey().getObj())
+                                    : RedissonObjectFactory.<R>fromReference(redissonReactive, (RedissonReference) e.getKey().getObj()))), map.remove(e.getKey()));
+                        } catch (Exception exception) {//skip and carry on to next one.
+                        }
                     }
                 }
                 details.getMainPromise().trySuccess(res);
+            } else if (isRedissonReferenceSupportEnabled() && (res instanceof MapScanResult)) {
             } else if (isRedissonReferenceSupportEnabled() && res instanceof RedissonReference) {
                 try {
                     details.getMainPromise().trySuccess(redisson != null

redisson/src/test/java/org/redisson/RedissonReferenceTest.java

@@ -1,5 +1,6 @@
 package org.redisson;
 
+import java.util.Collection;
 import java.util.List;
 import java.util.concurrent.TimeUnit;
 import static org.junit.Assert.*;
@@ -10,6 +11,10 @@ import org.redisson.api.RBucket;
 import org.redisson.api.RBucketAsync;
 import org.redisson.api.RBucketReactive;
 import org.redisson.api.RLiveObject;
+import org.redisson.api.RMap;
+import org.redisson.api.RScoredSortedSet;
+import org.redisson.api.RSet;
+import org.redisson.client.protocol.ScoredEntry;
 
 /**
  *
@@ -84,4 +89,43 @@ public class RedissonReferenceTest extends BaseTest {
         assertEquals("b1", result.get(2).getName());
     }
     
+    @Test
+    public void testWithList() {
+        RSet<RBucket<String>> b1 = redisson.getSet("set");
+        RBucket<String> b2 = redisson.getBucket("bucket");
+
+        b1.add(b2);
+        b2.set("test1");
+        assertEquals(b2.get(), b1.iterator().next().get());
+        assertEquals(2, redisson.getKeys().count());
+    }
+    
+    @Test
+    public void testWithZSet() {
+        RScoredSortedSet<RBucket<String>> b1 = redisson.getScoredSortedSet("set");
+        RBucket<String> b2 = redisson.getBucket("bucket");
+        b1.add(0.0, b2);
+        b2.set("test1");
+        assertEquals(b2.get(), b1.iterator().next().get());
+        assertEquals(2, redisson.getKeys().count());
+        Collection<ScoredEntry<RBucket<String>>> entryRange = b1.entryRange(0, 1);
+        assertEquals(b2.get(), entryRange.iterator().next().getValue().get());
+    }
+    
+    @Test
+    public void testWithMap() {
+        RMap<RBucket<RMap>, RBucket<RMap>> map = redisson.getMap("set");
+        RBucket<RMap> b1 = redisson.getBucket("bucket1");
+        RBucket<RMap> b2 = redisson.getBucket("bucket2");
+
+        map.put(b1, b2);
+        assertEquals(b2.get(), map.values().iterator().next().get());
+        assertEquals(b1.get(), map.keySet().iterator().next().get());
+        assertNotEquals(3, redisson.getKeys().count());
+        assertEquals(1, redisson.getKeys().count());
+        b1.set(map);
+        b2.set(map);
+        assertNotEquals(1, redisson.getKeys().count());
+        assertEquals(3, redisson.getKeys().count());
+    }
 }