multi/exec block return formatted responses

This commit is contained in:
Jonathan Leibiusky
2011-04-06 01:38:19 -03:00
parent 6707b62342
commit 3fb7a52017
5 changed files with 1094 additions and 661 deletions

View File

@@ -1,11 +1,13 @@
package redis.clients.jedis;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.Set;
import redis.clients.jedis.BinaryClient.LIST_POSITION;
public class BinaryTransaction {
public class BinaryTransaction extends Queable {
protected Client client = null;
protected boolean inTransaction = true;
@@ -16,363 +18,533 @@ public class BinaryTransaction {
this.client = client;
}
public void ping() {
client.ping();
}
public void set(final byte[] key, final byte[] value) {
client.set(key, value);
}
public void get(final byte[] key) {
client.get(key);
}
public void exists(final byte[] key) {
client.exists(key);
}
public void del(final byte[]... keys) {
client.del(keys);
}
public void type(final byte[] key) {
client.type(key);
}
public void flushDB() {
client.flushDB();
}
public void keys(final byte[] pattern) {
client.keys(pattern);
}
public void randomBinaryKey() {
client.randomKey();
}
public void rename(final byte[] oldkey, final byte[] newkey) {
client.rename(oldkey, newkey);
}
public void renamenx(final byte[] oldkey, final byte[] newkey) {
client.renamenx(oldkey, newkey);
}
public void dbSize() {
client.dbSize();
}
public void expire(final byte[] key, final int seconds) {
client.expire(key, seconds);
}
public void expireAt(final byte[] key, final long unixTime) {
client.expireAt(key, unixTime);
}
public void ttl(final byte[] key) {
client.ttl(key);
}
public void select(final int index) {
client.select(index);
}
public void move(final byte[] key, final int dbIndex) {
client.move(key, dbIndex);
}
public void flushAll() {
client.flushAll();
}
public void getSet(final byte[] key, final byte[] value) {
client.getSet(key, value);
}
public void mget(final byte[]... keys) {
client.mget(keys);
}
public void setnx(final byte[] key, final byte[] value) {
client.setnx(key, value);
}
public void setex(final byte[] key, final int seconds, final byte[] value) {
client.setex(key, seconds, value);
}
public void mset(final byte[]... keysvalues) {
client.mset(keysvalues);
}
public void msetnx(final byte[]... keysvalues) {
client.msetnx(keysvalues);
}
public void decrBy(final byte[] key, final int integer) {
client.decrBy(key, integer);
}
public void decr(final byte[] key) {
client.decr(key);
}
public void incrBy(final byte[] key, final int integer) {
client.incrBy(key, integer);
}
public void incr(final byte[] key) {
client.incr(key);
}
public void append(final byte[] key, final byte[] value) {
client.append(key, value);
}
public void substr(final byte[] key, final int start, final int end) {
client.substr(key, start, end);
}
public void hset(final byte[] key, final byte[] field, final byte[] value) {
client.hset(key, field, value);
}
public void hget(final byte[] key, final byte[] field) {
client.hget(key, field);
}
public void hsetnx(final byte[] key, final byte[] field,
final byte[] value) {
client.hsetnx(key, field, value);
}
public void hmset(final byte[] key, final Map<byte[], byte[]> hash) {
client.hmset(key, hash);
}
public void hmget(final byte[] key, final byte[]... fields) {
client.hmget(key, fields);
}
public void hincrBy(final byte[] key, final byte[] field, final int value) {
client.hincrBy(key, field, value);
}
public void hexists(final byte[] key, final byte[] field) {
client.hexists(key, field);
}
public void hdel(final byte[] key, final byte[] field) {
client.hdel(key, field);
}
public void hlen(final byte[] key) {
client.hlen(key);
}
public void hkeys(final byte[] key) {
client.hkeys(key);
}
public void hvals(final byte[] key) {
client.hvals(key);
}
public void hgetAll(final byte[] key) {
client.hgetAll(key);
}
public void rpush(final byte[] key, final byte[] string) {
client.rpush(key, string);
}
public void lpush(final byte[] key, final byte[] string) {
client.lpush(key, string);
}
public void llen(final byte[] key) {
client.llen(key);
}
public void lrange(final byte[] key, final int start, final int end) {
client.lrange(key, start, end);
}
public void ltrim(final byte[] key, final int start, final int end) {
client.ltrim(key, start, end);
}
public void lindex(final byte[] key, final int index) {
client.lindex(key, index);
}
public void lset(final byte[] key, final int index, final byte[] value) {
client.lset(key, index, value);
}
public void lrem(final byte[] key, final int count, final byte[] value) {
client.lrem(key, count, value);
}
public void lpop(final byte[] key) {
client.lpop(key);
}
public void rpop(final byte[] key) {
client.rpop(key);
}
public void rpoplpush(final byte[] srckey, final byte[] dstkey) {
client.rpoplpush(srckey, dstkey);
}
public void sadd(final byte[] key, final byte[] member) {
client.sadd(key, member);
}
public void smembers(final byte[] key) {
client.smembers(key);
}
public void srem(final byte[] key, final byte[] member) {
client.srem(key, member);
}
public void spop(final byte[] key) {
client.spop(key);
}
public void smove(final byte[] srckey, final byte[] dstkey,
final byte[] member) {
client.smove(srckey, dstkey, member);
}
public void scard(final byte[] key) {
client.scard(key);
}
public void sismember(final byte[] key, final byte[] member) {
client.sismember(key, member);
}
public void sinter(final byte[]... keys) {
client.sinter(keys);
}
public void sinterstore(final byte[] dstkey, final byte[]... keys) {
client.sinterstore(dstkey, keys);
}
public void sunion(final byte[]... keys) {
client.sunion(keys);
}
public void sunionstore(final byte[] dstkey, final byte[]... keys) {
client.sunionstore(dstkey, keys);
}
public void sdiff(final byte[]... keys) {
client.sdiff(keys);
}
public void sdiffstore(final byte[] dstkey, final byte[]... keys) {
client.sdiffstore(dstkey, keys);
}
public void srandmember(final byte[] key) {
client.srandmember(key);
}
public void zadd(final byte[] key, final double score, final byte[] member) {
client.zadd(key, score, member);
}
public void zrange(final byte[] key, final int start, final int end) {
client.zrange(key, start, end);
}
public void zrem(final byte[] key, final byte[] member) {
client.zrem(key, member);
}
public void zincrby(final byte[] key, final double score,
final byte[] member) {
client.zincrby(key, score, member);
}
public void zrank(final byte[] key, final byte[] member) {
client.zrank(key, member);
}
public void zrevrank(final byte[] key, final byte[] member) {
client.zrevrank(key, member);
}
public void zrevrange(final byte[] key, final int start, final int end) {
client.zrevrange(key, start, end);
}
public void zrangeWithScores(final byte[] key, final int start,
final int end) {
client.zrangeWithScores(key, start, end);
}
public void zrevrangeWithScores(final byte[] key, final int start,
final int end) {
client.zrevrangeWithScores(key, start, end);
}
public void zcard(final byte[] key) {
client.zcard(key);
}
public void zscore(final byte[] key, final byte[] member) {
client.zscore(key, member);
}
public List<Object> exec() {
client.exec();
client.getAll(1); // Discard all but the last reply
return client.getObjectMultiBulkReply();
List<Object> unformatted = client.getObjectMultiBulkReply();
if (unformatted == null) {
return null;
}
List<Object> formatted = new ArrayList<Object>();
for (Object o : unformatted) {
formatted.add(generateResponse(o).get());
}
return formatted;
}
public String discard() {
client.discard();
client.getAll(1); // Discard all but the last reply
inTransaction = false;
clean();
return client.getStatusCodeReply();
}
public void sort(final byte[] key) {
client.sort(key);
public Response<Long> append(byte[] key, byte[] value) {
client.append(key, value);
return getResponse(BuilderFactory.LONG);
}
public void sort(final byte[] key, final SortingParams sortingParameters) {
client.sort(key, sortingParameters);
public Response<List<String>> blpop(byte[]... args) {
client.blpop(args);
return getResponse(BuilderFactory.STRING_LIST);
}
public void sort(final byte[] key, final SortingParams sortingParameters,
final byte[] dstkey) {
client.sort(key, sortingParameters, dstkey);
public Response<List<String>> brpop(byte[]... args) {
client.brpop(args);
return getResponse(BuilderFactory.STRING_LIST);
}
public void sort(final byte[] key, final byte[] dstkey) {
client.sort(key, dstkey);
public Response<Long> decr(byte[] key) {
client.decr(key);
return getResponse(BuilderFactory.LONG);
}
public void setbit(byte[] key, long offset, byte[] value) {
client.setbit(key, offset, value);
public Response<Long> decrBy(byte[] key, long integer) {
client.decrBy(key, integer);
return getResponse(BuilderFactory.LONG);
}
public void getbit(byte[] key, long offset) {
client.getbit(key, offset);
public Response<Long> del(byte[]... keys) {
client.del(keys);
return getResponse(BuilderFactory.LONG);
}
public void linsert(final byte[] key, final LIST_POSITION where,
final byte[] pivot, final byte[] value) {
public Response<String> echo(byte[] string) {
client.echo(string);
return getResponse(BuilderFactory.STRING);
}
public Response<Boolean> exists(byte[] key) {
client.exists(key);
return getResponse(BuilderFactory.BOOLEAN);
}
public Response<Long> expire(byte[] key, int seconds) {
client.expire(key, seconds);
return getResponse(BuilderFactory.LONG);
}
public Response<Long> expireAt(byte[] key, long unixTime) {
client.expireAt(key, unixTime);
return getResponse(BuilderFactory.LONG);
}
public Response<String> get(byte[] key) {
client.get(key);
return getResponse(BuilderFactory.STRING);
}
public Response<String> getSet(byte[] key, byte[] value) {
client.getSet(key, value);
return getResponse(BuilderFactory.STRING);
}
public Response<Long> hdel(byte[] key, byte[] field) {
client.hdel(key, field);
return getResponse(BuilderFactory.LONG);
}
public Response<Boolean> hexists(byte[] key, byte[] field) {
client.hexists(key, field);
return getResponse(BuilderFactory.BOOLEAN);
}
public Response<String> hget(byte[] key, byte[] field) {
client.hget(key, field);
return getResponse(BuilderFactory.STRING);
}
public Response<Map<String, String>> hgetAll(byte[] key) {
client.hgetAll(key);
return getResponse(BuilderFactory.STRING_MAP);
}
public Response<Long> hincrBy(byte[] key, byte[] field, long value) {
client.hincrBy(key, field, value);
return getResponse(BuilderFactory.LONG);
}
public Response<Set<String>> hkeys(byte[] key) {
client.hkeys(key);
return getResponse(BuilderFactory.STRING_SET);
}
public Response<Long> hlen(byte[] key) {
client.hlen(key);
return getResponse(BuilderFactory.LONG);
}
public Response<List<String>> hmget(byte[] key, byte[]... fields) {
client.hmget(key, fields);
return getResponse(BuilderFactory.STRING_LIST);
}
public Response<String> hmset(byte[] key, Map<byte[], byte[]> hash) {
client.hmset(key, hash);
return getResponse(BuilderFactory.STRING);
}
public Response<Long> hset(byte[] key, byte[] field, byte[] value) {
client.hset(key, field, value);
return getResponse(BuilderFactory.LONG);
}
public Response<Long> hsetnx(byte[] key, byte[] field, byte[] value) {
client.hsetnx(key, field, value);
return getResponse(BuilderFactory.LONG);
}
public Response<List<String>> hvals(byte[] key) {
client.hvals(key);
return getResponse(BuilderFactory.STRING_LIST);
}
public Response<Long> incr(byte[] key) {
client.incr(key);
return getResponse(BuilderFactory.LONG);
}
public Response<Long> incrBy(byte[] key, long integer) {
client.incrBy(key, integer);
return getResponse(BuilderFactory.LONG);
}
public Response<Set<String>> keys(byte[] pattern) {
client.keys(pattern);
return getResponse(BuilderFactory.STRING_SET);
}
public Response<String> lindex(byte[] key, int index) {
client.lindex(key, index);
return getResponse(BuilderFactory.STRING);
}
public Response<Long> linsert(byte[] key, LIST_POSITION where,
byte[] pivot, byte[] value) {
client.linsert(key, where, pivot, value);
return getResponse(BuilderFactory.LONG);
}
public Response<Long> llen(byte[] key) {
client.llen(key);
return getResponse(BuilderFactory.LONG);
}
public Response<String> lpop(byte[] key) {
client.lpop(key);
return getResponse(BuilderFactory.STRING);
}
public Response<Long> lpush(byte[] key, byte[] string) {
client.lpush(key, string);
return getResponse(BuilderFactory.LONG);
}
public Response<Long> lpushx(byte[] key, byte[] bytes) {
client.lpushx(key, bytes);
return getResponse(BuilderFactory.LONG);
}
public Response<List<String>> lrange(byte[] key, int start, int end) {
client.lrange(key, start, end);
return getResponse(BuilderFactory.STRING_LIST);
}
public Response<Long> lrem(byte[] key, int count, byte[] value) {
client.lrem(key, count, value);
return getResponse(BuilderFactory.LONG);
}
public Response<String> lset(byte[] key, int index, byte[] value) {
client.lset(key, index, value);
return getResponse(BuilderFactory.STRING);
}
public Response<String> ltrim(byte[] key, int start, int end) {
client.ltrim(key, start, end);
return getResponse(BuilderFactory.STRING);
}
public Response<List<String>> mget(byte[]... keys) {
client.mget(keys);
return getResponse(BuilderFactory.STRING_LIST);
}
public Response<Long> move(byte[] key, int dbIndex) {
client.move(key, dbIndex);
return getResponse(BuilderFactory.LONG);
}
public Response<String> mset(byte[]... keysvalues) {
client.mset(keysvalues);
return getResponse(BuilderFactory.STRING);
}
public Response<Long> msetnx(byte[]... keysvalues) {
client.msetnx(keysvalues);
return getResponse(BuilderFactory.LONG);
}
public Response<Long> persist(byte[] key) {
client.persist(key);
return getResponse(BuilderFactory.LONG);
}
public Response<String> rename(byte[] oldkey, byte[] newkey) {
client.rename(oldkey, newkey);
return getResponse(BuilderFactory.STRING);
}
public Response<Long> renamenx(byte[] oldkey, byte[] newkey) {
client.renamenx(oldkey, newkey);
return getResponse(BuilderFactory.LONG);
}
public Response<String> rpop(byte[] key) {
client.rpop(key);
return getResponse(BuilderFactory.STRING);
}
public Response<String> rpoplpush(byte[] srckey, byte[] dstkey) {
client.rpoplpush(srckey, dstkey);
return getResponse(BuilderFactory.STRING);
}
public Response<Long> rpush(byte[] key, byte[] string) {
client.rpush(key, string);
return getResponse(BuilderFactory.LONG);
}
public Response<Long> rpushx(byte[] key, byte[] string) {
client.rpushx(key, string);
return getResponse(BuilderFactory.LONG);
}
public Response<Long> sadd(byte[] key, byte[] member) {
client.sadd(key, member);
return getResponse(BuilderFactory.LONG);
}
public Response<Long> scard(byte[] key) {
client.scard(key);
return getResponse(BuilderFactory.LONG);
}
public Response<Set<String>> sdiff(byte[]... keys) {
client.sdiff(keys);
return getResponse(BuilderFactory.STRING_SET);
}
public Response<Long> sdiffstore(byte[] dstkey, byte[]... keys) {
client.sdiffstore(dstkey, keys);
return getResponse(BuilderFactory.LONG);
}
public Response<String> set(byte[] key, byte[] value) {
client.set(key, value);
return getResponse(BuilderFactory.STRING);
}
public Response<Boolean> setbit(String key, long offset, boolean value) {
client.setbit(key, offset, value);
return getResponse(BuilderFactory.BOOLEAN);
}
public Response<String> setex(byte[] key, int seconds, byte[] value) {
client.setex(key, seconds, value);
return getResponse(BuilderFactory.STRING);
}
public Response<Long> setnx(byte[] key, byte[] value) {
client.setnx(key, value);
return getResponse(BuilderFactory.LONG);
}
public Response<Set<String>> sinter(byte[]... keys) {
client.sinter(keys);
return getResponse(BuilderFactory.STRING_SET);
}
public Response<Long> sinterstore(byte[] dstkey, byte[]... keys) {
client.sinterstore(dstkey, keys);
return getResponse(BuilderFactory.LONG);
}
public Response<Boolean> sismember(byte[] key, byte[] member) {
client.sismember(key, member);
return getResponse(BuilderFactory.BOOLEAN);
}
public Response<Set<String>> smembers(byte[] key) {
client.smembers(key);
return getResponse(BuilderFactory.STRING_SET);
}
public Response<Long> smove(byte[] srckey, byte[] dstkey, byte[] member) {
client.smove(srckey, dstkey, member);
return getResponse(BuilderFactory.LONG);
}
public Response<List<String>> sort(byte[] key) {
client.sort(key);
return getResponse(BuilderFactory.STRING_LIST);
}
public Response<List<String>> sort(byte[] key,
SortingParams sortingParameters) {
client.sort(key, sortingParameters);
return getResponse(BuilderFactory.STRING_LIST);
}
public Response<List<String>> sort(byte[] key,
SortingParams sortingParameters, byte[] dstkey) {
client.sort(key, sortingParameters, dstkey);
return getResponse(BuilderFactory.STRING_LIST);
}
public Response<List<String>> sort(byte[] key, byte[] dstkey) {
client.sort(key, dstkey);
return getResponse(BuilderFactory.STRING_LIST);
}
public Response<String> spop(byte[] key) {
client.spop(key);
return getResponse(BuilderFactory.STRING);
}
public Response<String> srandmember(byte[] key) {
client.srandmember(key);
return getResponse(BuilderFactory.STRING);
}
public Response<Long> srem(byte[] key, byte[] member) {
client.srem(key, member);
return getResponse(BuilderFactory.LONG);
}
public Response<Long> strlen(byte[] key) {
client.strlen(key);
return getResponse(BuilderFactory.LONG);
}
public Response<String> substr(byte[] key, int start, int end) {
client.substr(key, start, end);
return getResponse(BuilderFactory.STRING);
}
public Response<Set<String>> sunion(byte[]... keys) {
client.sunion(keys);
return getResponse(BuilderFactory.STRING_SET);
}
public Response<Long> sunionstore(byte[] dstkey, byte[]... keys) {
client.sunionstore(dstkey, keys);
return getResponse(BuilderFactory.LONG);
}
public Response<Long> ttl(byte[] key) {
client.ttl(key);
return getResponse(BuilderFactory.LONG);
}
public Response<String> type(byte[] key) {
client.type(key);
return getResponse(BuilderFactory.STRING);
}
public Response<String> watch(byte[]... keys) {
client.watch(keys);
return getResponse(BuilderFactory.STRING);
}
public Response<Long> zadd(byte[] key, double score, byte[] member) {
client.zadd(key, score, member);
return getResponse(BuilderFactory.LONG);
}
public Response<Long> zcard(byte[] key) {
client.zcard(key);
return getResponse(BuilderFactory.LONG);
}
public Response<Long> zcount(byte[] key, double min, double max) {
client.zcount(key, min, max);
return getResponse(BuilderFactory.LONG);
}
public Response<Double> zincrby(byte[] key, double score, byte[] member) {
client.zincrby(key, score, member);
return getResponse(BuilderFactory.DOUBLE);
}
public Response<Long> zinterstore(byte[] dstkey, byte[]... sets) {
client.zinterstore(dstkey, sets);
return getResponse(BuilderFactory.LONG);
}
public Response<Long> zinterstore(byte[] dstkey, ZParams params,
byte[]... sets) {
client.zinterstore(dstkey, params, sets);
return getResponse(BuilderFactory.LONG);
}
public Response<Set<String>> zrange(byte[] key, int start, int end) {
client.zrange(key, start, end);
return getResponse(BuilderFactory.STRING_ZSET);
}
public Response<Set<String>> zrangeByScore(byte[] key, double min,
double max) {
client.zrangeByScore(key, min, max);
return getResponse(BuilderFactory.STRING_ZSET);
}
public Response<Set<String>> zrangeByScore(byte[] key, byte[] min,
byte[] max) {
client.zrangeByScore(key, min, max);
return getResponse(BuilderFactory.STRING_ZSET);
}
public Response<Set<String>> zrangeByScore(byte[] key, double min,
double max, int offset, int count) {
client.zrangeByScore(key, min, max, offset, count);
return getResponse(BuilderFactory.STRING_ZSET);
}
public Response<Set<Tuple>> zrangeByScoreWithScores(byte[] key, double min,
double max) {
client.zrangeByScoreWithScores(key, min, max);
return getResponse(BuilderFactory.TUPLE_ZSET);
}
public Response<Set<Tuple>> zrangeByScoreWithScores(byte[] key, double min,
double max, int offset, int count) {
client.zrangeByScoreWithScores(key, min, max, offset, count);
return getResponse(BuilderFactory.TUPLE_ZSET);
}
public Response<Set<Tuple>> zrangeWithScores(byte[] key, int start, int end) {
client.zrangeWithScores(key, start, end);
return getResponse(BuilderFactory.TUPLE_ZSET);
}
public Response<Long> zrank(byte[] key, byte[] member) {
client.zrank(key, member);
return getResponse(BuilderFactory.LONG);
}
public Response<Long> zrem(byte[] key, byte[] member) {
client.zrem(key, member);
return getResponse(BuilderFactory.LONG);
}
public Response<Long> zremrangeByRank(byte[] key, int start, int end) {
client.zremrangeByRank(key, start, end);
return getResponse(BuilderFactory.LONG);
}
public Response<Long> zremrangeByScore(byte[] key, double start, double end) {
client.zremrangeByScore(key, start, end);
return getResponse(BuilderFactory.LONG);
}
public Response<Set<String>> zrevrange(byte[] key, int start, int end) {
client.zrevrange(key, start, end);
return getResponse(BuilderFactory.STRING_ZSET);
}
public Response<Set<Tuple>> zrevrangeWithScores(byte[] key, int start,
int end) {
client.zrevrangeWithScores(key, start, end);
return getResponse(BuilderFactory.TUPLE_ZSET);
}
public Response<Long> zrevrank(byte[] key, byte[] member) {
client.zrevrank(key, member);
return getResponse(BuilderFactory.LONG);
}
public Response<Double> zscore(byte[] key, byte[] member) {
client.zscore(key, member);
return getResponse(BuilderFactory.DOUBLE);
}
public Response<Long> zunionstore(byte[] dstkey, byte[]... sets) {
client.zunionstore(dstkey, sets);
return getResponse(BuilderFactory.LONG);
}
public Response<Long> zunionstore(byte[] dstkey, ZParams params,
byte[]... sets) {
client.zunionstore(dstkey, params, sets);
return getResponse(BuilderFactory.LONG);
}
public Response<String> brpoplpush(byte[] source, byte[] destination,
int timeout) {
client.brpoplpush(source, destination, timeout);
return getResponse(BuilderFactory.STRING);
}
}

View File

@@ -1,30 +1,19 @@
package redis.clients.jedis;
import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.Queue;
import java.util.Set;
import redis.clients.jedis.BinaryClient.LIST_POSITION;
public class Pipeline {
public class Pipeline extends Queable {
private Client client;
private Queue<Response<?>> pipelinedResponses = new LinkedList<Response<?>>();
public void setClient(Client client) {
this.client = client;
}
private Response<?> generateResponse(Object data) {
Response<?> response = pipelinedResponses.poll();
if (response != null) {
response.set(data);
}
return response;
}
public List<Object> sync() {
List<Object> unformatted = client.getAll();
List<Object> formatted = new ArrayList<Object>();
@@ -34,12 +23,6 @@ public class Pipeline {
return formatted;
}
private <T> Response<T> getResponse(Builder<T> builder) {
Response<T> lr = new Response<T>(builder);
pipelinedResponses.add(lr);
return lr;
}
public Response<Long> append(String key, String value) {
client.append(key, value);
return getResponse(BuilderFactory.LONG);

View File

@@ -0,0 +1,27 @@
package redis.clients.jedis;
import java.util.LinkedList;
import java.util.Queue;
public class Queable {
private Queue<Response<?>> pipelinedResponses = new LinkedList<Response<?>>();
protected void clean() {
pipelinedResponses.clear();
}
protected Response<?> generateResponse(Object data) {
Response<?> response = pipelinedResponses.poll();
if (response != null) {
response.set(data);
}
return response;
}
protected <T> Response<T> getResponse(Builder<T> builder) {
Response<T> lr = new Response<T>(builder);
pipelinedResponses.add(lr);
return lr;
}
}

View File

@@ -1,6 +1,8 @@
package redis.clients.jedis;
import java.util.List;
import java.util.Map;
import java.util.Set;
import redis.clients.jedis.BinaryClient.LIST_POSITION;
@@ -12,339 +14,556 @@ public class Transaction extends BinaryTransaction {
super(client);
}
public void set(final String key, final String value) {
client.set(key, value);
}
public void get(final String key) {
client.get(key);
}
public void exists(final String key) {
client.exists(key);
}
public void del(final String... keys) {
client.del(keys);
}
public void type(final String key) {
client.type(key);
}
public void keys(final String pattern) {
client.keys(pattern);
}
public void randomKey() {
client.randomKey();
}
public void rename(final String oldkey, final String newkey) {
client.rename(oldkey, newkey);
}
public void renamenx(final String oldkey, final String newkey) {
client.renamenx(oldkey, newkey);
}
public void expire(final String key, final int seconds) {
client.expire(key, seconds);
}
public void expireAt(final String key, final long unixTime) {
client.expireAt(key, unixTime);
}
public void ttl(final String key) {
client.ttl(key);
}
public void move(final String key, final int dbIndex) {
client.move(key, dbIndex);
}
public void getSet(final String key, final String value) {
client.getSet(key, value);
}
public void mget(final String... keys) {
client.mget(keys);
}
public void setnx(final String key, final String value) {
client.setnx(key, value);
}
public void setex(final String key, final int seconds, final String value) {
client.setex(key, seconds, value);
}
public void mset(final String... keysvalues) {
client.mset(keysvalues);
}
public void msetnx(final String... keysvalues) {
client.msetnx(keysvalues);
}
public void decrBy(final String key, final int integer) {
client.decrBy(key, integer);
}
public void decr(final String key) {
client.decr(key);
}
public void incrBy(final String key, final int integer) {
client.incrBy(key, integer);
}
public void incr(final String key) {
client.incr(key);
}
public void append(final String key, final String value) {
public Response<Long> append(String key, String value) {
client.append(key, value);
return getResponse(BuilderFactory.LONG);
}
public void substr(final String key, final int start, final int end) {
client.substr(key, start, end);
public Response<List<String>> blpop(String... args) {
client.blpop(args);
return getResponse(BuilderFactory.STRING_LIST);
}
public void hset(final String key, final String field, final String value) {
client.hset(key, field, value);
public Response<List<String>> brpop(String... args) {
client.brpop(args);
return getResponse(BuilderFactory.STRING_LIST);
}
public void hget(final String key, final String field) {
client.hget(key, field);
public Response<Long> decr(String key) {
client.decr(key);
return getResponse(BuilderFactory.LONG);
}
public void hsetnx(final String key, final String field, final String value) {
client.hsetnx(key, field, value);
public Response<Long> decrBy(String key, long integer) {
client.decrBy(key, integer);
return getResponse(BuilderFactory.LONG);
}
public void hmset(final String key, final Map<String, String> hash) {
client.hmset(key, hash);
public Response<Long> del(String... keys) {
client.del(keys);
return getResponse(BuilderFactory.LONG);
}
public void hmget(final String key, final String... fields) {
client.hmget(key, fields);
public Response<String> echo(String string) {
client.echo(string);
return getResponse(BuilderFactory.STRING);
}
public void hincrBy(final String key, final String field, final int value) {
client.hincrBy(key, field, value);
public Response<Boolean> exists(String key) {
client.exists(key);
return getResponse(BuilderFactory.BOOLEAN);
}
public void hexists(final String key, final String field) {
client.hexists(key, field);
public Response<Long> expire(String key, int seconds) {
client.expire(key, seconds);
return getResponse(BuilderFactory.LONG);
}
public void hdel(final String key, final String field) {
client.hdel(key, field);
public Response<Long> expireAt(String key, long unixTime) {
client.expireAt(key, unixTime);
return getResponse(BuilderFactory.LONG);
}
public void hlen(final String key) {
client.hlen(key);
public Response<String> get(String key) {
client.get(key);
return getResponse(BuilderFactory.STRING);
}
public void hkeys(final String key) {
client.hkeys(key);
}
public void hvals(final String key) {
client.hvals(key);
}
public void hgetAll(final String key) {
client.hgetAll(key);
}
public void rpush(final String key, final String string) {
client.rpush(key, string);
}
public void lpush(final String key, final String string) {
client.lpush(key, string);
}
public void llen(final String key) {
client.llen(key);
}
public void lrange(final String key, final int start, final int end) {
client.lrange(key, start, end);
}
public void ltrim(String key, final int start, final int end) {
client.ltrim(key, start, end);
}
public void lindex(final String key, final int index) {
client.lindex(key, index);
}
public void lset(final String key, final int index, final String value) {
client.lset(key, index, value);
}
public void lrem(final String key, final int count, final String value) {
client.lrem(key, count, value);
}
public void lpop(final String key) {
client.lpop(key);
}
public void rpop(final String key) {
client.rpop(key);
}
public void rpoplpush(final String srckey, final String dstkey) {
client.rpoplpush(srckey, dstkey);
}
public void sadd(final String key, final String member) {
client.sadd(key, member);
}
public void smembers(final String key) {
client.smembers(key);
}
public void srem(final String key, final String member) {
client.srem(key, member);
}
public void spop(final String key) {
client.spop(key);
}
public void smove(final String srckey, final String dstkey,
final String member) {
client.smove(srckey, dstkey, member);
}
public void scard(final String key) {
client.scard(key);
}
public void sismember(final String key, final String member) {
client.sismember(key, member);
}
public void sinter(final String... keys) {
client.sinter(keys);
}
public void sinterstore(final String dstkey, final String... keys) {
client.sinterstore(dstkey, keys);
}
public void sunion(final String... keys) {
client.sunion(keys);
}
public void sunionstore(final String dstkey, final String... keys) {
client.sunionstore(dstkey, keys);
}
public void sdiff(final String... keys) {
client.sdiff(keys);
}
public void sdiffstore(final String dstkey, final String... keys) {
client.sdiffstore(dstkey, keys);
}
public void srandmember(final String key) {
client.srandmember(key);
}
public void zadd(final String key, final double score, final String member) {
client.zadd(key, score, member);
}
public void zrange(final String key, final int start, final int end) {
client.zrange(key, start, end);
}
public void zrem(final String key, final String member) {
client.zrem(key, member);
}
public void zincrby(final String key, final double score,
final String member) {
client.zincrby(key, score, member);
}
public void zrank(final String key, final String member) {
client.zrank(key, member);
}
public void zrevrank(final String key, final String member) {
client.zrevrank(key, member);
}
public void zrevrange(final String key, final int start, final int end) {
client.zrevrange(key, start, end);
}
public void zrangeWithScores(final String key, final int start,
final int end) {
client.zrangeWithScores(key, start, end);
}
public void zrevrangeWithScores(final String key, final int start,
final int end) {
client.zrevrangeWithScores(key, start, end);
}
public void zcard(final String key) {
client.zcard(key);
}
public void zscore(final String key, final String member) {
client.zscore(key, member);
}
public void sort(final String key) {
client.sort(key);
}
public void sort(final String key, final SortingParams sortingParameters) {
client.sort(key, sortingParameters);
}
public void sort(final String key, final String dstkey) {
client.sort(key, dstkey);
}
public void sort(final String key, final SortingParams sortingParameters,
final String dstkey) {
client.sort(key, sortingParameters, dstkey);
}
public void setbit(String key, long offset, boolean value) {
client.setbit(key, offset, value);
}
public void getbit(String key, long offset) {
public Response<Boolean> getbit(String key, long offset) {
client.getbit(key, offset);
return getResponse(BuilderFactory.BOOLEAN);
}
public long setrange(String key, long offset, String value) {
client.setrange(key, offset, value);
return client.getIntegerReply();
}
public String getrange(String key, long startOffset, long endOffset) {
public Response<String> getrange(String key, long startOffset,
long endOffset) {
client.getrange(key, startOffset, endOffset);
return client.getBulkReply();
return getResponse(BuilderFactory.STRING);
}
public void linsert(final String key, final LIST_POSITION where,
final String pivot, final String value) {
public Response<String> getSet(String key, String value) {
client.getSet(key, value);
return getResponse(BuilderFactory.STRING);
}
public Response<Long> hdel(String key, String field) {
client.hdel(key, field);
return getResponse(BuilderFactory.LONG);
}
public Response<Boolean> hexists(String key, String field) {
client.hexists(key, field);
return getResponse(BuilderFactory.BOOLEAN);
}
public Response<String> hget(String key, String field) {
client.hget(key, field);
return getResponse(BuilderFactory.STRING);
}
public Response<Map<String, String>> hgetAll(String key) {
client.hgetAll(key);
return getResponse(BuilderFactory.STRING_MAP);
}
public Response<Long> hincrBy(String key, String field, long value) {
client.hincrBy(key, field, value);
return getResponse(BuilderFactory.LONG);
}
public Response<Set<String>> hkeys(String key) {
client.hkeys(key);
return getResponse(BuilderFactory.STRING_SET);
}
public Response<Long> hlen(String key) {
client.hlen(key);
return getResponse(BuilderFactory.LONG);
}
public Response<List<String>> hmget(String key, String... fields) {
client.hmget(key, fields);
return getResponse(BuilderFactory.STRING_LIST);
}
public Response<String> hmset(String key, Map<String, String> hash) {
client.hmset(key, hash);
return getResponse(BuilderFactory.STRING);
}
public Response<Long> hset(String key, String field, String value) {
client.hset(key, field, value);
return getResponse(BuilderFactory.LONG);
}
public Response<Long> hsetnx(String key, String field, String value) {
client.hsetnx(key, field, value);
return getResponse(BuilderFactory.LONG);
}
public Response<List<String>> hvals(String key) {
client.hvals(key);
return getResponse(BuilderFactory.STRING_LIST);
}
public Response<Long> incr(String key) {
client.incr(key);
return getResponse(BuilderFactory.LONG);
}
public Response<Long> incrBy(String key, long integer) {
client.incrBy(key, integer);
return getResponse(BuilderFactory.LONG);
}
public Response<Set<String>> keys(String pattern) {
client.keys(pattern);
return getResponse(BuilderFactory.STRING_SET);
}
public Response<String> lindex(String key, int index) {
client.lindex(key, index);
return getResponse(BuilderFactory.STRING);
}
public Response<Long> linsert(String key, LIST_POSITION where,
String pivot, String value) {
client.linsert(key, where, pivot, value);
return getResponse(BuilderFactory.LONG);
}
public Response<Long> llen(String key) {
client.llen(key);
return getResponse(BuilderFactory.LONG);
}
public Response<String> lpop(String key) {
client.lpop(key);
return getResponse(BuilderFactory.STRING);
}
public Response<Long> lpush(String key, String string) {
client.lpush(key, string);
return getResponse(BuilderFactory.LONG);
}
public Response<Long> lpushx(String key, String string) {
client.lpushx(key, string);
return getResponse(BuilderFactory.LONG);
}
public Response<List<String>> lrange(String key, int start, int end) {
client.lrange(key, start, end);
return getResponse(BuilderFactory.STRING_LIST);
}
public Response<Long> lrem(String key, int count, String value) {
client.lrem(key, count, value);
return getResponse(BuilderFactory.LONG);
}
public Response<String> lset(String key, int index, String value) {
client.lset(key, index, value);
return getResponse(BuilderFactory.STRING);
}
public Response<String> ltrim(String key, int start, int end) {
client.ltrim(key, start, end);
return getResponse(BuilderFactory.STRING);
}
public Response<List<String>> mget(String... keys) {
client.mget(keys);
return getResponse(BuilderFactory.STRING_LIST);
}
public Response<Long> move(String key, int dbIndex) {
client.move(key, dbIndex);
return getResponse(BuilderFactory.LONG);
}
public Response<String> mset(String... keysvalues) {
client.mset(keysvalues);
return getResponse(BuilderFactory.STRING);
}
public Response<Long> msetnx(String... keysvalues) {
client.msetnx(keysvalues);
return getResponse(BuilderFactory.LONG);
}
public Response<Long> persist(String key) {
client.persist(key);
return getResponse(BuilderFactory.LONG);
}
public Response<String> rename(String oldkey, String newkey) {
client.rename(oldkey, newkey);
return getResponse(BuilderFactory.STRING);
}
public Response<Long> renamenx(String oldkey, String newkey) {
client.renamenx(oldkey, newkey);
return getResponse(BuilderFactory.LONG);
}
public Response<String> rpop(String key) {
client.rpop(key);
return getResponse(BuilderFactory.STRING);
}
public Response<String> rpoplpush(String srckey, String dstkey) {
client.rpoplpush(srckey, dstkey);
return getResponse(BuilderFactory.STRING);
}
public Response<Long> rpush(String key, String string) {
client.rpush(key, string);
return getResponse(BuilderFactory.LONG);
}
public Response<Long> rpushx(String key, String string) {
client.rpushx(key, string);
return getResponse(BuilderFactory.LONG);
}
public Response<Long> sadd(String key, String member) {
client.sadd(key, member);
return getResponse(BuilderFactory.LONG);
}
public Response<Long> scard(String key) {
client.scard(key);
return getResponse(BuilderFactory.LONG);
}
public Response<Set<String>> sdiff(String... keys) {
client.sdiff(keys);
return getResponse(BuilderFactory.STRING_SET);
}
public Response<Long> sdiffstore(String dstkey, String... keys) {
client.sdiffstore(dstkey, keys);
return getResponse(BuilderFactory.LONG);
}
public Response<String> set(String key, String value) {
client.set(key, value);
return getResponse(BuilderFactory.STRING);
}
public Response<Boolean> setbit(String key, long offset, boolean 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);
}
public Response<Long> setnx(String key, String value) {
client.setnx(key, value);
return getResponse(BuilderFactory.LONG);
}
public Response<Long> setrange(String key, long offset, String 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);
}
public Response<Long> sinterstore(String dstkey, String... keys) {
client.sinterstore(dstkey, keys);
return getResponse(BuilderFactory.LONG);
}
public Response<Boolean> sismember(String key, String member) {
client.sismember(key, member);
return getResponse(BuilderFactory.BOOLEAN);
}
public Response<Set<String>> smembers(String key) {
client.smembers(key);
return getResponse(BuilderFactory.STRING_SET);
}
public Response<Long> smove(String srckey, String dstkey, String member) {
client.smove(srckey, dstkey, member);
return getResponse(BuilderFactory.LONG);
}
public Response<List<String>> sort(String key) {
client.sort(key);
return getResponse(BuilderFactory.STRING_LIST);
}
public Response<List<String>> sort(String key,
SortingParams sortingParameters) {
client.sort(key, sortingParameters);
return getResponse(BuilderFactory.STRING_LIST);
}
public Response<List<String>> sort(String key,
SortingParams sortingParameters, String dstkey) {
client.sort(key, sortingParameters, dstkey);
return getResponse(BuilderFactory.STRING_LIST);
}
public Response<List<String>> sort(String key, String dstkey) {
client.sort(key, dstkey);
return getResponse(BuilderFactory.STRING_LIST);
}
public Response<String> spop(String key) {
client.spop(key);
return getResponse(BuilderFactory.STRING);
}
public Response<String> srandmember(String key) {
client.srandmember(key);
return getResponse(BuilderFactory.STRING);
}
public Response<Long> srem(String key, String member) {
client.srem(key, member);
return getResponse(BuilderFactory.LONG);
}
public Response<Long> strlen(String key) {
client.strlen(key);
return getResponse(BuilderFactory.LONG);
}
public Response<String> substr(String key, int start, int end) {
client.substr(key, start, end);
return getResponse(BuilderFactory.STRING);
}
public Response<Set<String>> sunion(String... keys) {
client.sunion(keys);
return getResponse(BuilderFactory.STRING_SET);
}
public Response<Long> sunionstore(String dstkey, String... keys) {
client.sunionstore(dstkey, keys);
return getResponse(BuilderFactory.LONG);
}
public Response<Long> ttl(String key) {
client.ttl(key);
return getResponse(BuilderFactory.LONG);
}
public Response<String> type(String key) {
client.type(key);
return getResponse(BuilderFactory.STRING);
}
public Response<Long> zadd(String key, double score, String member) {
client.zadd(key, score, member);
return getResponse(BuilderFactory.LONG);
}
public Response<Long> zcard(String key) {
client.zcard(key);
return getResponse(BuilderFactory.LONG);
}
public Response<Long> zcount(String key, double min, double max) {
client.zcount(key, min, max);
return getResponse(BuilderFactory.LONG);
}
public Response<Double> zincrby(String key, double score, String member) {
client.zincrby(key, score, member);
return getResponse(BuilderFactory.DOUBLE);
}
public Response<Long> zinterstore(String dstkey, String... sets) {
client.zinterstore(dstkey, sets);
return getResponse(BuilderFactory.LONG);
}
public Response<Long> zinterstore(String dstkey, ZParams params,
String... sets) {
client.zinterstore(dstkey, params, sets);
return getResponse(BuilderFactory.LONG);
}
public Response<Set<String>> zrange(String key, int start, int end) {
client.zrange(key, start, end);
return getResponse(BuilderFactory.STRING_ZSET);
}
public Response<Set<String>> zrangeByScore(String key, double min,
double max) {
client.zrangeByScore(key, min, max);
return getResponse(BuilderFactory.STRING_ZSET);
}
public Response<Set<String>> zrangeByScore(String key, String min,
String 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) {
client.zrangeByScore(key, min, max, offset, count);
return getResponse(BuilderFactory.STRING_ZSET);
}
public Response<Set<Tuple>> zrangeByScoreWithScores(String key, double min,
double 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) {
client.zrangeByScoreWithScores(key, min, max, offset, count);
return getResponse(BuilderFactory.TUPLE_ZSET);
}
public Response<Set<Tuple>> zrangeWithScores(String key, int start, int end) {
client.zrangeWithScores(key, start, end);
return getResponse(BuilderFactory.TUPLE_ZSET);
}
public Response<Long> zrank(String key, String member) {
client.zrank(key, member);
return getResponse(BuilderFactory.LONG);
}
public Response<Long> zrem(String key, String member) {
client.zrem(key, member);
return getResponse(BuilderFactory.LONG);
}
public Response<Long> zremrangeByRank(String key, int start, int end) {
client.zremrangeByRank(key, start, end);
return getResponse(BuilderFactory.LONG);
}
public Response<Long> zremrangeByScore(String key, double start, double end) {
client.zremrangeByScore(key, start, end);
return getResponse(BuilderFactory.LONG);
}
public Response<Set<String>> zrevrange(String key, int start, int end) {
client.zrevrange(key, start, end);
return getResponse(BuilderFactory.STRING_ZSET);
}
public Response<Set<Tuple>> zrevrangeWithScores(String key, int start,
int end) {
client.zrevrangeWithScores(key, start, end);
return getResponse(BuilderFactory.TUPLE_ZSET);
}
public Response<Long> zrevrank(String key, String member) {
client.zrevrank(key, member);
return getResponse(BuilderFactory.LONG);
}
public Response<Double> zscore(String key, String member) {
client.zscore(key, member);
return getResponse(BuilderFactory.DOUBLE);
}
public Response<Long> zunionstore(String dstkey, String... sets) {
client.zunionstore(dstkey, sets);
return getResponse(BuilderFactory.LONG);
}
public Response<Long> zunionstore(String dstkey, ZParams params,
String... sets) {
client.zunionstore(dstkey, params, sets);
return getResponse(BuilderFactory.LONG);
}
public Response<String> bgrewriteaof() {
client.bgrewriteaof();
return getResponse(BuilderFactory.STRING);
}
public Response<String> bgsave() {
client.bgsave();
return getResponse(BuilderFactory.STRING);
}
public Response<String> configGet(String pattern) {
client.configGet(pattern);
return getResponse(BuilderFactory.STRING);
}
public Response<String> configSet(String parameter, String value) {
client.configSet(parameter, value);
return getResponse(BuilderFactory.STRING);
}
public Response<String> brpoplpush(String source, String destination,
int timeout) {
client.brpoplpush(source, destination, timeout);
return getResponse(BuilderFactory.STRING);
}
public Response<String> configResetStat() {
client.configResetStat();
return getResponse(BuilderFactory.STRING);
}
public Response<String> save() {
client.save();
return getResponse(BuilderFactory.STRING);
}
public Response<Long> lastsave() {
client.lastsave();
return getResponse(BuilderFactory.LONG);
}
}