lexRange, lexRangeHead and lexRangeTail methods added. #135

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

@@ -277,6 +277,42 @@ public class RedissonScoredSortedSet<V> extends RedissonExpirable implements RSc
         return commandExecutor.readAsync(getName(), RedisCommands.ZRANGE_ENTRY, getName(), startIndex, endIndex, "WITHSCORES");
     }
 
+    @Override
+    public Collection<V> lexRange(V fromElement, boolean fromInclusive, V toElement, boolean toInclusive) {
+        return get(lexRangeAsync(fromElement, fromInclusive, toElement, toInclusive));
+    }
+
+    @Override
+    public Collection<V> lexRangeHead(V toElement, boolean toInclusive) {
+        return get(lexRangeHeadAsync(toElement, toInclusive));
+    }
+
+    @Override
+    public Future<Collection<V>> lexRangeHeadAsync(V toElement, boolean toInclusive) {
+        String toValue = value(toElement, toInclusive);
+        return commandExecutor.readAsync(getName(), StringCodec.INSTANCE, RedisCommands.ZRANGEBYLEX, getName(), "-", toValue);
+    }
+
+    @Override
+    public Collection<V> lexRangeTail(V fromElement, boolean fromInclusive) {
+        return get(lexRangeTailAsync(fromElement, fromInclusive));
+    }
+
+    @Override
+    public Future<Collection<V>> lexRangeTailAsync(V fromElement, boolean fromInclusive) {
+        String fromValue = value(fromElement, fromInclusive);
+        return commandExecutor.readAsync(getName(), StringCodec.INSTANCE, RedisCommands.ZRANGEBYLEX, getName(), fromValue, "+");
+    }
+
+
+    @Override
+    public Future<Collection<V>> lexRangeAsync(V fromElement, boolean fromInclusive, V toElement, boolean toInclusive) {
+        String fromValue = value(fromElement, fromInclusive);
+        String toValue = value(toElement, toInclusive);
+
+        return commandExecutor.readAsync(getName(), StringCodec.INSTANCE, RedisCommands.ZRANGEBYLEX, getName(), fromValue, toValue);
+    }
+
     @Override
     public Integer lexCount(V fromElement, boolean fromInclusive, V toElement, boolean toInclusive) {
         return get(lexCountAsync(fromElement, fromInclusive, toElement, toInclusive));
@@ -284,21 +320,20 @@ public class RedissonScoredSortedSet<V> extends RedissonExpirable implements RSc
 
     @Override
     public Future<Integer> lexCountAsync(V fromElement, boolean fromInclusive, V toElement, boolean toInclusive) {
+        String fromValue = value(fromElement, fromInclusive);
+        String toValue = value(toElement, toInclusive);
+
+        return commandExecutor.readAsync(getName(), RedisCommands.ZLEXCOUNT, getName(), fromValue, toValue);
+    }
+
+    private String value(V fromElement, boolean fromInclusive) {
         String fromValue = fromElement.toString();
         if (fromInclusive) {
             fromValue = "[" + fromValue;
         } else {
             fromValue = "(" + fromValue;
         }
-
-        String toValue = toElement.toString();
-        if (toInclusive) {
-            toValue = "[" + toValue;
-        } else {
-            toValue = "(" + toValue;
-        }
-
-        return commandExecutor.readAsync(getName(), RedisCommands.ZLEXCOUNT, getName(), fromValue, toValue);
+        return fromValue;
     }
 
 }

src/main/java/org/redisson/client/protocol/RedisCommands.java

@@ -56,6 +56,7 @@ public interface RedisCommands {
     RedisStrictCommand<Double> ZSCORE = new RedisStrictCommand<Double>("ZSCORE", new DoubleReplayConvertor());
     RedisStrictCommand<Integer> ZRANK = new RedisStrictCommand<Integer>("ZRANK", new IntegerReplayConvertor());
     RedisCommand<List<Object>> ZRANGE = new RedisCommand<List<Object>>("ZRANGE", new ObjectListReplayDecoder<Object>());
+    RedisCommand<List<Object>> ZRANGEBYLEX = new RedisCommand<List<Object>>("ZRANGEBYLEX", new ObjectListReplayDecoder<Object>());
     RedisCommand<List<ScoredEntry<Object>>> ZRANGE_ENTRY = new RedisCommand<List<ScoredEntry<Object>>>("ZRANGE", new ScoredSortedSetReplayDecoder<Object>());
     RedisCommand<ListScanResult<Object>> ZSCAN = new RedisCommand<ListScanResult<Object>>("ZSCAN", new NestedMultiDecoder(new ObjectListReplayDecoder<Object>(), new ScoredSortedSetScanReplayDecoder()), ValueType.OBJECT);
     RedisStrictCommand<Double> ZINCRBY = new RedisStrictCommand<Double>("ZINCRBY", new DoubleReplayConvertor());

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

@@ -21,6 +21,12 @@ import org.redisson.client.protocol.ScoredEntry;
 
 public interface RScoredSortedSet<V> extends RScoredSortedSetAsync<V>, Iterable<V>, RExpirable {
 
+    Collection<V> lexRangeTail(V fromElement, boolean fromInclusive);
+
+    Collection<V> lexRangeHead(V toElement, boolean toInclusive);
+
+    Collection<V> lexRange(V fromElement, boolean fromInclusive, V toElement, boolean toInclusive);
+
     Integer lexCount(V fromElement, boolean fromInclusive, V toElement, boolean toInclusive);
 
     Integer rank(V o);

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

@@ -23,6 +23,12 @@ import io.netty.util.concurrent.Future;
 
 public interface RScoredSortedSetAsync<V> extends RExpirableAsync {
 
+    Future<Collection<V>> lexRangeTailAsync(V fromElement, boolean fromInclusive);
+
+    Future<Collection<V>> lexRangeHeadAsync(V toElement, boolean toInclusive);
+
+    Future<Collection<V>> lexRangeAsync(V fromElement, boolean fromInclusive, V toElement, boolean toInclusive);
+
     Future<Integer> lexCountAsync(V fromElement, boolean fromInclusive, V toElement, boolean toInclusive);
 
     Future<Integer> rankAsync(V o);

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

@@ -21,6 +21,52 @@ import io.netty.util.concurrent.Future;
 
 public class RedissonScoredSortedSetTest extends BaseTest {
 
+    @Test
+    public void testLexRangeTail() {
+        RScoredSortedSet<String> set = redisson.getScoredSortedSet("simple");
+        set.add(0, "a");
+        set.add(0, "b");
+        set.add(0, "c");
+        set.add(0, "d");
+        set.add(0, "e");
+        set.add(0, "f");
+        set.add(0, "g");
+
+        MatcherAssert.assertThat(set.lexRangeTail("c", false), Matchers.contains("d", "e", "f", "g"));
+        MatcherAssert.assertThat(set.lexRangeTail("c", true), Matchers.contains("c", "d", "e", "f", "g"));
+    }
+
+
+    @Test
+    public void testLexRangeHead() {
+        RScoredSortedSet<String> set = redisson.getScoredSortedSet("simple");
+        set.add(0, "a");
+        set.add(0, "b");
+        set.add(0, "c");
+        set.add(0, "d");
+        set.add(0, "e");
+        set.add(0, "f");
+        set.add(0, "g");
+
+        MatcherAssert.assertThat(set.lexRangeHead("c", false), Matchers.contains("a", "b"));
+        MatcherAssert.assertThat(set.lexRangeHead("c", true), Matchers.contains("a", "b", "c"));
+    }
+
+
+    @Test
+    public void testLexRange() {
+        RScoredSortedSet<String> set = redisson.getScoredSortedSet("simple");
+        set.add(0, "a");
+        set.add(0, "b");
+        set.add(0, "c");
+        set.add(0, "d");
+        set.add(0, "e");
+        set.add(0, "f");
+        set.add(0, "g");
+
+        MatcherAssert.assertThat(set.lexRange("aaa", true, "g", false), Matchers.contains("b", "c", "d", "e", "f"));
+    }
+
     @Test
     public void testRank() {
         RScoredSortedSet<String> set = redisson.getScoredSortedSet("simple");