addScoreAndGetRank and addScoreAndGetRevRank methods added to RScoredSortedSet object. #987

redisson/src/main/java/org/redisson/RedissonScoredSortedSet.java

@@ -400,6 +400,32 @@ public class RedissonScoredSortedSet<V> extends RedissonExpirable implements RSc
                                    getName(), new BigDecimal(value.toString()).toPlainString(), encode(object));
     }
     
+    @Override
+    public Integer addScoreAndGetRank(V object, Number value) {
+        return get(addScoreAndGetRankAsync(object, value));
+    }
+    
+    @Override
+    public RFuture<Integer> addScoreAndGetRankAsync(V object, Number value) {
+        return commandExecutor.evalWriteAsync(getName(), LongCodec.INSTANCE, RedisCommands.EVAL_INTEGER,
+                "redis.call('zincrby', KEYS[1], ARGV[1], ARGV[2]); "
+               +"return redis.call('zrank', KEYS[1], ARGV[2]); ",
+                Collections.<Object>singletonList(getName()), new BigDecimal(value.toString()).toPlainString(), encode(object));
+    }
+
+    @Override
+    public Integer addScoreAndGetRevRank(V object, Number value) {
+        return get(addScoreAndGetRevRankAsync(object, value));
+    }
+    
+    @Override
+    public RFuture<Integer> addScoreAndGetRevRankAsync(V object, Number value) {
+        return commandExecutor.evalWriteAsync(getName(), LongCodec.INSTANCE, RedisCommands.EVAL_INTEGER,
+                "redis.call('zincrby', KEYS[1], ARGV[1], ARGV[2]); "
+               +"return redis.call('zrevrank', KEYS[1], ARGV[2]); ",
+                Collections.<Object>singletonList(getName()), new BigDecimal(value.toString()).toPlainString(), encode(object));
+    }
+
     @Override
     public Collection<V> valueRange(int startIndex, int endIndex) {
         return get(valueRangeAsync(startIndex, endIndex));

redisson/src/main/java/org/redisson/api/RScoredSortedSet.java

@@ -123,6 +123,24 @@ public interface RScoredSortedSet<V> extends RScoredSortedSetAsync<V>, Iterable<
 
     Double addScore(V object, Number value);
 
+    /**
+     * Adds score to element and returns its rank
+     * 
+     * @param object - object itself
+     * @param value - object score
+     * @return rank
+     */
+    Integer addScoreAndGetRank(V object, Number value);
+
+    /**
+     * Adds score to element and returns its reverse rank
+     * 
+     * @param object - object itself
+     * @param value - object score
+     * @return reverse rank
+     */
+    Integer addScoreAndGetRevRank(V object, Number value);
+    
     Collection<V> valueRange(int startIndex, int endIndex);
     
     Collection<V> valueRangeReversed(int startIndex, int endIndex);

redisson/src/main/java/org/redisson/api/RScoredSortedSetAsync.java

@@ -88,6 +88,24 @@ public interface RScoredSortedSetAsync<V> extends RExpirableAsync, RSortableAsyn
 
     RFuture<Double> addScoreAsync(V object, Number value);
 
+    /**
+     * Adds score to element and returns its reverse rank
+     * 
+     * @param object - object itself
+     * @param value - object score
+     * @return reverse rank
+     */
+    RFuture<Integer> addScoreAndGetRevRankAsync(V object, Number value);
+    
+    /**
+     * Adds score to element and returns its rank
+     * 
+     * @param object - object itself
+     * @param value - object score
+     * @return rank
+     */
+    RFuture<Integer> addScoreAndGetRankAsync(V object, Number value);
+    
     RFuture<Collection<V>> valueRangeAsync(int startIndex, int endIndex);
     
     RFuture<Collection<V>> valueRangeReversedAsync(int startIndex, int endIndex);

redisson/src/test/java/org/redisson/RedissonScoredSortedSetTest.java

@@ -966,6 +966,46 @@ public class RedissonScoredSortedSetTest extends BaseTest {
         Assert.assertTrue(new Double(112.3).compareTo(res2) == 0);
     }
     
+    @Test
+    public void testAddScoreAndGetRank() throws InterruptedException {
+        RScoredSortedSet<String> set = redisson.getScoredSortedSet("simple");
+
+        Integer res1 = set.addScoreAndGetRank("12", 12);
+        assertThat(res1).isEqualTo(0);
+        Integer res2 = set.addScoreAndGetRank("15", 10);
+        assertThat(res2).isEqualTo(0);
+        
+        assertThat(set.rank("12")).isEqualTo(1);
+        assertThat(set.rank("15")).isEqualTo(0);
+        
+        Integer res3 = set.addScoreAndGetRank("12", 2);
+        assertThat(res3).isEqualTo(1);
+        Double score = set.getScore("12");
+        assertThat(score).isEqualTo(14);
+    }
+    
+    @Test
+    public void testAddScoreAndGetRevRank() throws InterruptedException {
+        RScoredSortedSet<String> set = redisson.getScoredSortedSet("simple");
+
+        Integer res1 = set.addScoreAndGetRevRank("12", 12);
+        assertThat(res1).isEqualTo(0);
+        Integer res2 = set.addScoreAndGetRevRank("15", 10);
+        assertThat(res2).isEqualTo(1);
+        
+        assertThat(set.revRank("12")).isEqualTo(0);
+        assertThat(set.revRank("15")).isEqualTo(1);
+        
+        Integer res3 = set.addScoreAndGetRevRank("12", 2);
+        assertThat(res3).isEqualTo(0);
+        Integer res4 = set.addScoreAndGetRevRank("15", -1);
+        assertThat(res4).isEqualTo(1);
+        Double score = set.getScore("12");
+        assertThat(score).isEqualTo(14);
+    }
+
+
+
     @Test
     public void testIntersection() {
         RScoredSortedSet<String> set1 = redisson.getScoredSortedSet("simple1");