Extract string and binary common interfaces for Pipline and ShardedJedisPipeline. While I'm here add missing binary methods for some bit operations and fix return types for some sharded operations (e.g. getType)

src/main/java/redis/clients/jedis/BinaryRedisPipeline.java

@@ -0,0 +1,205 @@
+package redis.clients.jedis;
+
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+
+/**
+ * @author guy
+ */
+public interface BinaryRedisPipeline {
+    Response<Long> append(byte[] key, byte[] value);
+
+    Response<Long> decr(byte[] key);
+
+    Response<Long> decrBy(byte[] key, long integer);
+
+    Response<Boolean> exists(byte[] key);
+
+    Response<Long> expire(byte[] key, int seconds);
+
+    Response<Long> expireAt(byte[] key, long unixTime);
+
+    Response<byte[]> get(byte[] key);
+
+    Response<Boolean> getbit(byte[] key, long offset);
+
+    Response<byte[]> getSet(byte[] key, byte[] value);
+
+    Response<Long> getrange(byte[] key, long startOffset, long endOffset);
+
+    Response<Long> hdel(byte[] key, byte[] field);
+
+    Response<Boolean> hexists(byte[] key, byte[] field);
+
+    Response<String> hget(byte[] key, byte[] field);
+
+    Response<Map<String, String>> hgetAll(byte[] key);
+
+    Response<Long> hincrBy(byte[] key, byte[] field, long value);
+
+    Response<Set<String>> hkeys(byte[] key);
+
+    Response<Long> hlen(byte[] key);
+
+    Response<List<String>> hmget(byte[] key, byte[]... fields);
+
+    Response<String> hmset(byte[] key, Map<byte[], byte[]> hash);
+
+    Response<Long> hset(byte[] key, byte[] field, byte[] value);
+
+    Response<Long> hsetnx(byte[] key, byte[] field, byte[] value);
+
+    Response<List<String>> hvals(byte[] key);
+
+    Response<Long> incr(byte[] key);
+
+    Response<Long> incrBy(byte[] key, long integer);
+
+    Response<String> lindex(byte[] key, int index);
+
+    Response<Long> linsert(byte[] key, BinaryClient.LIST_POSITION where,
+                           byte[] pivot, byte[] value);
+
+    Response<Long> llen(byte[] key);
+
+    Response<String> lpop(byte[] key);
+
+    Response<Long> lpush(byte[] key, byte[] string);
+
+    Response<Long> lpushx(byte[] key, byte[] bytes);
+
+    Response<List<String>> lrange(byte[] key, long start, long end);
+
+    Response<Long> lrem(byte[] key, long count, byte[] value);
+
+    Response<String> lset(byte[] key, long index, byte[] value);
+
+    Response<String> ltrim(byte[] key, long start, long end);
+
+    Response<Long> persist(byte[] key);
+
+    Response<String> rpop(byte[] key);
+
+    Response<Long> rpush(byte[] key, byte[] string);
+
+    Response<Long> rpushx(byte[] key, byte[] string);
+
+    Response<Long> sadd(byte[] key, byte[] member);
+
+    Response<Long> scard(byte[] key);
+
+    Response<String> set(byte[] key, byte[] value);
+
+    Response<Boolean> setbit(byte[] key, long offset, byte[] value);
+
+    Response<Long> setrange(byte[] key, long offset, byte[] value);
+
+    Response<String> setex(byte[] key, int seconds, byte[] value);
+
+    Response<Long> setnx(byte[] key, byte[] value);
+
+    Response<Long> setrange(String key, long offset, String value);
+
+    Response<Set<String>> smembers(byte[] key);
+
+    Response<Boolean> sismember(byte[] key, byte[] member);
+
+    Response<Long> sort(byte[] key);
+
+    Response<List<String>> sort(byte[] key,
+                                SortingParams sortingParameters);
+
+    Response<String> spop(byte[] key);
+
+    Response<String> srandmember(byte[] key);
+
+    Response<Long> srem(byte[] key, byte[] member);
+
+    Response<Long> strlen(byte[] key);
+
+    Response<String> substr(byte[] key, int start, int end);
+
+    Response<Long> ttl(byte[] key);
+
+    Response<String> type(byte[] key);
+
+    Response<Long> zadd(byte[] key, double score, byte[] member);
+
+    Response<Long> zcard(byte[] key);
+
+    Response<Long> zcount(byte[] key, double min, double max);
+
+    Response<Double> zincrby(byte[] key, double score, byte[] member);
+
+    Response<Set<String>> zrange(byte[] key, int start, int end);
+
+    Response<Set<String>> zrangeByScore(byte[] key, double min,
+                                        double max);
+
+    Response<Set<String>> zrangeByScore(byte[] key, byte[] min,
+                                        byte[] max);
+
+    Response<Set<String>> zrangeByScore(byte[] key, double min,
+                                        double max, int offset, int count);
+
+    Response<Set<String>> zrangeByScore(byte[] key, byte[] min,
+                                        byte[] max, int offset, int count);
+
+    Response<Set<Tuple>> zrangeByScoreWithScores(byte[] key, double min,
+                                                 double max);
+
+    Response<Set<Tuple>> zrangeByScoreWithScores(byte[] key, byte[] min,
+                                                 byte[] max);
+
+    Response<Set<Tuple>> zrangeByScoreWithScores(byte[] key, double min,
+                                                 double max, int offset, int count);
+
+    Response<Set<Tuple>> zrangeByScoreWithScores(byte[] key, byte[] min,
+                                                 byte[] max, int offset, int count);
+
+    Response<Set<String>> zrevrangeByScore(byte[] key, double max,
+                                           double min);
+
+    Response<Set<String>> zrevrangeByScore(byte[] key, byte[] max,
+                                           byte[] min);
+
+    Response<Set<String>> zrevrangeByScore(byte[] key, double max,
+                                           double min, int offset, int count);
+
+    Response<Set<String>> zrevrangeByScore(byte[] key, byte[] max,
+                                           byte[] min, int offset, int count);
+
+    Response<Set<Tuple>> zrevrangeByScoreWithScores(byte[] key,
+                                                    double max, double min);
+
+    Response<Set<Tuple>> zrevrangeByScoreWithScores(byte[] key,
+                                                    byte[] max, byte[] min);
+
+    Response<Set<Tuple>> zrevrangeByScoreWithScores(byte[] key,
+                                                    double max, double min, int offset, int count);
+
+    Response<Set<Tuple>> zrevrangeByScoreWithScores(byte[] key,
+                                                    byte[] max, byte[] min, int offset, int count);
+
+    Response<Set<Tuple>> zrangeWithScores(byte[] key, int start, int end);
+
+    Response<Long> zrank(byte[] key, byte[] member);
+
+    Response<Long> zrem(byte[] key, byte[] member);
+
+    Response<Long> zremrangeByRank(byte[] key, int start, int end);
+
+    Response<Long> zremrangeByScore(byte[] key, double start, double end);
+
+    Response<Long> zremrangeByScore(byte[] key, byte[] start, byte[] end);
+
+    Response<Set<String>> zrevrange(byte[] key, int start, int end);
+
+    Response<Set<Tuple>> zrevrangeWithScores(byte[] key, int start,
+                                             int end);
+
+    Response<Long> zrevrank(byte[] key, byte[] member);
+
+    Response<Double> zscore(byte[] key, byte[] member);
+}

src/main/java/redis/clients/jedis/Pipeline.java

@@ -9,7 +9,7 @@ import java.util.Set;
 import redis.clients.jedis.BinaryClient.LIST_POSITION;
 import redis.clients.jedis.exceptions.JedisDataException;
 
-public class Pipeline extends Queable {
+public class Pipeline extends Queable implements BinaryRedisPipeline, RedisPipeline {
 	
     private MultiResponseBuilder currentMulti;
     
@@ -209,8 +209,13 @@ public class Pipeline extends Queable {
         return getResponse(BuilderFactory.BOOLEAN);
     }
 
+    public Response<Boolean> getbit(byte[] key, long offset) {
+        client.getbit(key, offset);
+        return getResponse(BuilderFactory.BOOLEAN);
+    }
+
     public Response<String> getrange(String key, long startOffset,
-            long endOffset) {
+                                     long endOffset) {
         client.getrange(key, startOffset, endOffset);
         return getResponse(BuilderFactory.STRING);
     }
@@ -225,6 +230,11 @@ public class Pipeline extends Queable {
         return getResponse(BuilderFactory.BYTE_ARRAY);
     }
 
+    public Response<Long> getrange(byte[] key, long startOffset, long endOffset) {
+        client.getrange(key, startOffset, endOffset);
+        return getResponse(BuilderFactory.LONG);
+    }
+
     public Response<Long> hdel(String key, String field) {
         client.hdel(key, field);
         return getResponse(BuilderFactory.LONG);
@@ -386,13 +396,13 @@ public class Pipeline extends Queable {
     }
 
     public Response<Long> linsert(String key, LIST_POSITION where,
-            String pivot, String value) {
+                                  String pivot, String value) {
         client.linsert(key, where, pivot, value);
         return getResponse(BuilderFactory.LONG);
     }
 
     public Response<Long> linsert(byte[] key, LIST_POSITION where,
-            byte[] pivot, byte[] value) {
+                                  byte[] pivot, byte[] value) {
         client.linsert(key, where, pivot, value);
         return getResponse(BuilderFactory.LONG);
     }
@@ -642,6 +652,11 @@ public class Pipeline extends Queable {
         return getResponse(BuilderFactory.BOOLEAN);
     }
 
+    public Response<Boolean> setbit(byte[] key, long offset, byte[] value) {
+        client.setbit(key, offset, value);
+        return getResponse(BuilderFactory.BOOLEAN);
+    }
+
     public Response<String> setex(String key, int seconds, String value) {
         client.setex(key, seconds, value);
         return getResponse(BuilderFactory.STRING);
@@ -667,6 +682,11 @@ public class Pipeline extends Queable {
         return getResponse(BuilderFactory.LONG);
     }
 
+    public Response<Long> setrange(byte[] key, long offset, byte[] value) {
+        client.setrange(key, offset, value);
+        return getResponse(BuilderFactory.LONG);
+    }
+
     public Response<Set<String>> sinter(String... keys) {
         client.sinter(keys);
         return getResponse(BuilderFactory.STRING_SET);
@@ -728,25 +748,25 @@ public class Pipeline extends Queable {
     }
 
     public Response<List<String>> sort(String key,
-            SortingParams sortingParameters) {
+                                       SortingParams sortingParameters) {
         client.sort(key, sortingParameters);
         return getResponse(BuilderFactory.STRING_LIST);
     }
 
     public Response<List<String>> sort(byte[] key,
-            SortingParams sortingParameters) {
+                                       SortingParams sortingParameters) {
         client.sort(key, sortingParameters);
         return getResponse(BuilderFactory.STRING_LIST);
     }
 
     public Response<List<String>> sort(String key,
-            SortingParams sortingParameters, String dstkey) {
+                                       SortingParams sortingParameters, String dstkey) {
         client.sort(key, sortingParameters, dstkey);
         return getResponse(BuilderFactory.STRING_LIST);
     }
 
     public Response<List<String>> sort(byte[] key,
-            SortingParams sortingParameters, byte[] dstkey) {
+                                       SortingParams sortingParameters, byte[] dstkey) {
         client.sort(key, sortingParameters, dstkey);
         return getResponse(BuilderFactory.STRING_LIST);
     }
@@ -934,154 +954,154 @@ public class Pipeline extends Queable {
     }
 
     public Response<Set<String>> zrangeByScore(String key, double min,
-            double max) {
+                                               double max) {
         client.zrangeByScore(key, min, max);
         return getResponse(BuilderFactory.STRING_ZSET);
     }
 
     public Response<Set<String>> zrangeByScore(byte[] key, double min,
-            double max) {
+                                               double max) {
         return zrangeByScore(key, toByteArray(min), toByteArray(max));
     }
     
     public Response<Set<String>> zrangeByScore(String key, String min,
-            String max) {
+                                               String max) {
         client.zrangeByScore(key, min, max);
         return getResponse(BuilderFactory.STRING_ZSET);
     }
 
     public Response<Set<String>> zrangeByScore(byte[] key, byte[] min,
-            byte[] max) {
+                                               byte[] max) {
         client.zrangeByScore(key, min, max);
         return getResponse(BuilderFactory.STRING_ZSET);
     }
 
     public Response<Set<String>> zrangeByScore(String key, double min,
-            double max, int offset, int count) {
+                                               double max, int offset, int count) {
         client.zrangeByScore(key, min, max, offset, count);
         return getResponse(BuilderFactory.STRING_ZSET);
     }
 
     public Response<Set<String>> zrangeByScore(byte[] key, double min,
-            double max, int offset, int count) {
+                                               double max, int offset, int count) {
         return zrangeByScore(key, toByteArray(min), toByteArray(max), offset, count);
     }
     
     public Response<Set<String>> zrangeByScore(byte[] key, byte[] min,
-    		byte[] max, int offset, int count) {
+                                               byte[] max, int offset, int count) {
         client.zrangeByScore(key, min, max, offset, count);
         return getResponse(BuilderFactory.STRING_ZSET);
     }
 
     public Response<Set<Tuple>> zrangeByScoreWithScores(String key, double min,
-            double max) {
+                                                        double max) {
         client.zrangeByScoreWithScores(key, min, max);
         return getResponse(BuilderFactory.TUPLE_ZSET);
     }
 
     public Response<Set<Tuple>> zrangeByScoreWithScores(byte[] key, double min,
-            double max) {
+                                                        double max) {
         return zrangeByScoreWithScores(key, toByteArray(min), toByteArray(max));
     }
     
     public Response<Set<Tuple>> zrangeByScoreWithScores(byte[] key, byte[] min,
-    		byte[] max) {
+                                                        byte[] max) {
         client.zrangeByScoreWithScores(key, min, max);
         return getResponse(BuilderFactory.TUPLE_ZSET);
     }
 
     public Response<Set<Tuple>> zrangeByScoreWithScores(String key, double min,
-            double max, int offset, int count) {
+                                                        double max, int offset, int count) {
         client.zrangeByScoreWithScores(key, min, max, offset, count);
         return getResponse(BuilderFactory.TUPLE_ZSET);
     }
 
     public Response<Set<Tuple>> zrangeByScoreWithScores(byte[] key, double min,
-            double max, int offset, int count) {
+                                                        double max, int offset, int count) {
         client.zrangeByScoreWithScores(key, toByteArray(min), toByteArray(max), offset, count);
         return getResponse(BuilderFactory.TUPLE_ZSET);
     }
     
     public Response<Set<Tuple>> zrangeByScoreWithScores(byte[] key, byte[] min,
-    		byte[] max, int offset, int count) {
+                                                        byte[] max, int offset, int count) {
         client.zrangeByScoreWithScores(key, min, max, offset, count);
         return getResponse(BuilderFactory.TUPLE_ZSET);
     }
 
     public Response<Set<String>> zrevrangeByScore(String key, double max,
-            double min) {
+                                                  double min) {
         client.zrevrangeByScore(key, max, min);
         return getResponse(BuilderFactory.STRING_ZSET);
     }
 
     public Response<Set<String>> zrevrangeByScore(byte[] key, double max,
-            double min) {
+                                                  double min) {
         client.zrevrangeByScore(key, toByteArray(max), toByteArray(min));
         return getResponse(BuilderFactory.STRING_ZSET);
     }
 
     public Response<Set<String>> zrevrangeByScore(String key, String max,
-            String min) {
+                                                  String min) {
         client.zrevrangeByScore(key, max, min);
         return getResponse(BuilderFactory.STRING_ZSET);
     }
 
     public Response<Set<String>> zrevrangeByScore(byte[] key, byte[] max,
-            byte[] min) {
+                                                  byte[] min) {
         client.zrevrangeByScore(key, max, min);
         return getResponse(BuilderFactory.STRING_ZSET);
     }
 
     public Response<Set<String>> zrevrangeByScore(String key, double max,
-            double min, int offset, int count) {
+                                                  double min, int offset, int count) {
         client.zrevrangeByScore(key, max, min, offset, count);
         return getResponse(BuilderFactory.STRING_ZSET);
     }
 
     public Response<Set<String>> zrevrangeByScore(byte[] key, double max,
-            double min, int offset, int count) {
+                                                  double min, int offset, int count) {
         client.zrevrangeByScore(key, toByteArray(max), toByteArray(min), offset, count);
         return getResponse(BuilderFactory.STRING_ZSET);
     }
     
     public Response<Set<String>> zrevrangeByScore(byte[] key, byte[] max,
-    		byte[] min, int offset, int count) {
+                                                  byte[] min, int offset, int count) {
         client.zrevrangeByScore(key, max, min, offset, count);
         return getResponse(BuilderFactory.STRING_ZSET);
     }
 
     public Response<Set<Tuple>> zrevrangeByScoreWithScores(String key,
-            double max, double min) {
+                                                           double max, double min) {
         client.zrevrangeByScoreWithScores(key, max, min);
         return getResponse(BuilderFactory.TUPLE_ZSET);
     }
 
     public Response<Set<Tuple>> zrevrangeByScoreWithScores(byte[] key,
-            double max, double min) {
+                                                           double max, double min) {
         client.zrevrangeByScoreWithScores(key, toByteArray(max), toByteArray(min));
         return getResponse(BuilderFactory.TUPLE_ZSET);
     }
     
     public Response<Set<Tuple>> zrevrangeByScoreWithScores(byte[] key,
-    		byte[] max, byte[] min) {
+                                                           byte[] max, byte[] min) {
         client.zrevrangeByScoreWithScores(key, max, min);
         return getResponse(BuilderFactory.TUPLE_ZSET);
     }
 
     public Response<Set<Tuple>> zrevrangeByScoreWithScores(String key,
-            double max, double min, int offset, int count) {
+                                                           double max, double min, int offset, int count) {
         client.zrevrangeByScoreWithScores(key, max, min, offset, count);
         return getResponse(BuilderFactory.TUPLE_ZSET);
     }
 
     public Response<Set<Tuple>> zrevrangeByScoreWithScores(byte[] key,
-            double max, double min, int offset, int count) {
+                                                           double max, double min, int offset, int count) {
         client.zrevrangeByScoreWithScores(key, toByteArray(max), toByteArray(min), offset, count);
         return getResponse(BuilderFactory.TUPLE_ZSET);
     }
     
     public Response<Set<Tuple>> zrevrangeByScoreWithScores(byte[] key,
-    		byte[] max, byte[] min, int offset, int count) {
+                                                           byte[] max, byte[] min, int offset, int count) {
         client.zrevrangeByScoreWithScores(key, max, min, offset, count);
         return getResponse(BuilderFactory.TUPLE_ZSET);
     }
@@ -1152,13 +1172,13 @@ public class Pipeline extends Queable {
     }
 
     public Response<Set<Tuple>> zrevrangeWithScores(String key, int start,
-            int end) {
+                                                    int end) {
         client.zrevrangeWithScores(key, start, end);
         return getResponse(BuilderFactory.TUPLE_ZSET);
     }
 
     public Response<Set<Tuple>> zrevrangeWithScores(byte[] key, int start,
-            int end) {
+                                                    int end) {
         client.zrevrangeWithScores(key, start, end);
         return getResponse(BuilderFactory.TUPLE_ZSET);
     }

src/main/java/redis/clients/jedis/RedisPipeline.java

@@ -0,0 +1,184 @@
+package redis.clients.jedis;
+
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+
+/**
+ * @author guy
+ */
+public interface RedisPipeline {
+    Response<Long> append(String key, String value);
+
+    Response<Long> decr(String key);
+
+    Response<Long> decrBy(String key, long integer);
+
+    Response<Boolean> exists(String key);
+
+    Response<Long> expire(String key, int seconds);
+
+    Response<Long> expireAt(String key, long unixTime);
+
+    Response<String> get(String key);
+
+    Response<Boolean> getbit(String key, long offset);
+
+
+
+    Response<String> getrange(String key, long startOffset,
+                              long endOffset);
+
+    Response<String> getSet(String key, String value);
+
+    Response<Long> hdel(String key, String field);
+
+    Response<Boolean> hexists(String key, String field);
+
+    Response<String> hget(String key, String field);
+
+    Response<Map<String, String>> hgetAll(String key);
+
+    Response<Long> hincrBy(String key, String field, long value);
+
+    Response<Set<String>> hkeys(String key);
+
+    Response<Long> hlen(String key);
+
+    Response<List<String>> hmget(String key, String... fields);
+
+    Response<String> hmset(String key, Map<String, String> hash);
+
+    Response<Long> hset(String key, String field, String value);
+
+    Response<Long> hsetnx(String key, String field, String value);
+
+    Response<List<String>> hvals(String key);
+
+    Response<Long> incr(String key);
+
+    Response<Long> incrBy(String key, long integer);
+
+    Response<String> lindex(String key, int index);
+
+    Response<Long> linsert(String key, BinaryClient.LIST_POSITION where,
+                           String pivot, String value);
+
+    Response<Long> llen(String key);
+
+    Response<String> lpop(String key);
+
+    Response<Long> lpush(String key, String string);
+
+    Response<Long> lpushx(String key, String string);
+
+    Response<List<String>> lrange(String key, long start, long end);
+
+    Response<Long> lrem(String key, long count, String value);
+
+    Response<String> lset(String key, long index, String value);
+
+    Response<String> ltrim(String key, long start, long end);
+
+    Response<Long> persist(String key);
+
+    Response<String> rpop(String key);
+
+    Response<Long> rpush(String key, String string);
+
+    Response<Long> rpushx(String key, String string);
+
+    Response<Long> sadd(String key, String member);
+
+    Response<Long> scard(String key);
+
+    Response<Boolean> sismember(String key, String member);
+
+    Response<String> set(String key, String value);
+
+    Response<Boolean> setbit(String key, long offset, boolean value);
+
+    Response<String> setex(String key, int seconds, String value);
+
+    Response<Long> setnx(String key, String value);
+
+    Response<Set<String>> smembers(String key);
+
+    Response<Long> sort(String key);
+
+    Response<List<String>> sort(String key,
+                                SortingParams sortingParameters);
+
+    Response<String> spop(String key);
+
+    Response<String> srandmember(String key);
+
+    Response<Long> srem(String key, String member);
+
+    Response<Long> strlen(String key);
+
+    Response<String> substr(String key, int start, int end);
+
+    Response<Long> ttl(String key);
+
+    Response<String> type(String key);
+
+    Response<Long> zadd(String key, double score, String member);
+
+    Response<Long> zcard(String key);
+
+    Response<Long> zcount(String key, double min, double max);
+
+    Response<Double> zincrby(String key, double score, String member);
+
+    Response<Set<String>> zrange(String key, int start, int end);
+
+    Response<Set<String>> zrangeByScore(String key, double min,
+                                        double max);
+
+    Response<Set<String>> zrangeByScore(String key, String min,
+                                        String max);
+
+    Response<Set<String>> zrangeByScore(String key, double min,
+                                        double max, int offset, int count);
+
+    Response<Set<Tuple>> zrangeByScoreWithScores(String key, double min,
+                                                 double max);
+
+    Response<Set<Tuple>> zrangeByScoreWithScores(String key, double min,
+                                                 double max, int offset, int count);
+
+    Response<Set<String>> zrevrangeByScore(String key, double max,
+                                           double min);
+
+    Response<Set<String>> zrevrangeByScore(String key, String max,
+                                           String min);
+
+    Response<Set<String>> zrevrangeByScore(String key, double max,
+                                           double min, int offset, int count);
+
+    Response<Set<Tuple>> zrevrangeByScoreWithScores(String key,
+                                                    double max, double min);
+
+    Response<Set<Tuple>> zrevrangeByScoreWithScores(String key,
+                                                    double max, double min, int offset, int count);
+
+    Response<Set<Tuple>> zrangeWithScores(String key, int start, int end);
+
+    Response<Long> zrank(String key, String member);
+
+    Response<Long> zrem(String key, String member);
+
+    Response<Long> zremrangeByRank(String key, int start, int end);
+
+    Response<Long> zremrangeByScore(String key, double start, double end);
+
+    Response<Set<String>> zrevrange(String key, int start, int end);
+
+    Response<Set<Tuple>> zrevrangeWithScores(String key, int start,
+                                             int end);
+
+    Response<Long> zrevrank(String key, String member);
+
+    Response<Double> zscore(String key, String member);
+}