All Downloads are FREE. Search and download functionalities are using the official Maven repository.

redis.clients.jedis.PipelineBase Maven / Gradle / Ivy

Go to download 

package redis.clients.jedis;

import java.util.List;
import java.util.Map;
import java.util.Set;

import redis.clients.jedis.commands.BinaryRedisPipeline;
import redis.clients.jedis.commands.ProtocolCommand;
import redis.clients.jedis.commands.RedisPipeline;
import redis.clients.jedis.params.GeoAddParams;
import redis.clients.jedis.params.GeoRadiusParam;
import redis.clients.jedis.params.GetExParams;
import redis.clients.jedis.params.RestoreParams;
import redis.clients.jedis.params.SetParams;
import redis.clients.jedis.params.StrAlgoLCSParams;
import redis.clients.jedis.params.XAddParams;
import redis.clients.jedis.params.XAutoClaimParams;
import redis.clients.jedis.params.XClaimParams;
import redis.clients.jedis.params.XPendingParams;
import redis.clients.jedis.params.XTrimParams;
import redis.clients.jedis.params.ZAddParams;
import redis.clients.jedis.params.ZIncrByParams;
import redis.clients.jedis.params.LPosParams;
import redis.clients.jedis.resps.LCSMatchResult;

public abstract class PipelineBase extends Queable implements BinaryRedisPipeline, RedisPipeline {

  protected abstract Client getClient(String key);

  protected abstract Client getClient(byte[] key);

  @Override
  public Response append(final String key, final String value) {
    getClient(key).append(key, value);
    return getResponse(BuilderFactory.LONG);
  }

  @Override
  public Response append(final byte[] key, final byte[] value) {
    getClient(key).append(key, value);
    return getResponse(BuilderFactory.LONG);
  }

  @Override
  public Response> blpop(final String key) {
    String[] temp = new String[1];
    temp[0] = key;
    getClient(key).blpop(temp);
    return getResponse(BuilderFactory.STRING_LIST);
  }

  @Override
  public Response> brpop(final String key) {
    String[] temp = new String[1];
    temp[0] = key;
    getClient(key).brpop(temp);
    return getResponse(BuilderFactory.STRING_LIST);
  }

  @Override
  public Response> blpop(final byte[] key) {
    byte[][] temp = new byte[1][];
    temp[0] = key;
    getClient(key).blpop(temp);
    return getResponse(BuilderFactory.BYTE_ARRAY_LIST);
  }

  @Override
  public Response> brpop(final byte[] key) {
    byte[][] temp = new byte[1][];
    temp[0] = key;
    getClient(key).brpop(temp);
    return getResponse(BuilderFactory.BYTE_ARRAY_LIST);
  }

  @Override
  public Response decr(final String key) {
    getClient(key).decr(key);
    return getResponse(BuilderFactory.LONG);
  }

  @Override
  public Response decr(final byte[] key) {
    getClient(key).decr(key);
    return getResponse(BuilderFactory.LONG);
  }

  @Override
  public Response decrBy(final String key, final long decrement) {
    getClient(key).decrBy(key, decrement);
    return getResponse(BuilderFactory.LONG);
  }

  @Override
  public Response decrBy(final byte[] key, final long decrement) {
    getClient(key).decrBy(key, decrement);
    return getResponse(BuilderFactory.LONG);
  }

  @Override
  public Response del(final String key) {
    getClient(key).del(key);
    return getResponse(BuilderFactory.LONG);
  }

  @Override
  public Response del(final byte[] key) {
    getClient(key).del(key);
    return getResponse(BuilderFactory.LONG);
  }

  @Override
  public Response unlink(final String key) {
    getClient(key).unlink(key);
    return getResponse(BuilderFactory.LONG);
  }

  @Override
  public Response unlink(final byte[] key) {
    getClient(key).unlink(key);
    return getResponse(BuilderFactory.LONG);
  }

  @Override
  public Response echo(final String string) {
    getClient(string).echo(string);
    return getResponse(BuilderFactory.STRING);
  }

  @Override
  public Response echo(final byte[] string) {
    getClient(string).echo(string);
    return getResponse(BuilderFactory.BYTE_ARRAY);
  }

  @Override
  public Response exists(final String key) {
    getClient(key).exists(key);
    return getResponse(BuilderFactory.BOOLEAN);
  }

  @Override
  public Response exists(final byte[] key) {
    getClient(key).exists(key);
    return getResponse(BuilderFactory.BOOLEAN);
  }

  @Override
  public Response expire(final String key, final long seconds) {
    getClient(key).expire(key, seconds);
    return getResponse(BuilderFactory.LONG);
  }

  @Override
  public Response expire(final byte[] key, final long seconds) {
    getClient(key).expire(key, seconds);
    return getResponse(BuilderFactory.LONG);
  }

  @Override
  public Response expireAt(final String key, final long unixTime) {
    getClient(key).expireAt(key, unixTime);
    return getResponse(BuilderFactory.LONG);
  }

  @Override
  public Response expireAt(final byte[] key, final long unixTime) {
    getClient(key).expireAt(key, unixTime);
    return getResponse(BuilderFactory.LONG);
  }

  @Override
  public Response get(final String key) {
    getClient(key).get(key);
    return getResponse(BuilderFactory.STRING);
  }

  @Override
  public Response get(final byte[] key) {
    getClient(key).get(key);
    return getResponse(BuilderFactory.BYTE_ARRAY);
  }

  @Override
  public Response getDel(final String key) {
    getClient(key).getDel(key);
    return getResponse(BuilderFactory.STRING);
  }

  @Override
  public Response getDel(final byte[] key) {
    getClient(key).getDel(key);
    return getResponse(BuilderFactory.BYTE_ARRAY);
  }

  @Override
  public Response getEx(String key, GetExParams params) {
    getClient(key).getEx(key, params);
    return getResponse(BuilderFactory.STRING);
  }

  @Override
  public Response getEx(byte[] key, GetExParams params) {
    getClient(key).getEx(key, params);
    return getResponse(BuilderFactory.BYTE_ARRAY);
  }

  @Override
  public Response getbit(final String key, final long offset) {
    getClient(key).getbit(key, offset);
    return getResponse(BuilderFactory.BOOLEAN);
  }

  @Override
  public Response getbit(final byte[] key, final long offset) {
    getClient(key).getbit(key, offset);
    return getResponse(BuilderFactory.BOOLEAN);
  }

  @Override
  public Response bitpos(final String key, final boolean value) {
    return bitpos(key, value, new BitPosParams());
  }

  @Override
  public Response bitpos(final String key, final boolean value, final BitPosParams params) {
    getClient(key).bitpos(key, value, params);
    return getResponse(BuilderFactory.LONG);
  }

  @Override
  public Response bitpos(final byte[] key, final boolean value) {
    return bitpos(key, value, new BitPosParams());
  }

  @Override
  public Response bitpos(final byte[] key, final boolean value, final BitPosParams params) {
    getClient(key).bitpos(key, value, params);
    return getResponse(BuilderFactory.LONG);
  }

  @Override
  public Response getrange(final String key, final long startOffset, final long endOffset) {
    getClient(key).getrange(key, startOffset, endOffset);
    return getResponse(BuilderFactory.STRING);
  }

  @Override
  public Response getSet(final String key, final String value) {
    getClient(key).getSet(key, value);
    return getResponse(BuilderFactory.STRING);
  }

  @Override
  public Response getSet(final byte[] key, final byte[] value) {
    getClient(key).getSet(key, value);
    return getResponse(BuilderFactory.BYTE_ARRAY);
  }

  @Override
  public Response getrange(final byte[] key, final long startOffset, final long endOffset) {
    getClient(key).getrange(key, startOffset, endOffset);
    return getResponse(BuilderFactory.BYTE_ARRAY);
  }

  @Override
  public Response hdel(final String key, final String... field) {
    getClient(key).hdel(key, field);
    return getResponse(BuilderFactory.LONG);
  }

  @Override
  public Response hdel(final byte[] key, final byte[]... field) {
    getClient(key).hdel(key, field);
    return getResponse(BuilderFactory.LONG);
  }

  @Override
  public Response hexists(final String key, final String field) {
    getClient(key).hexists(key, field);
    return getResponse(BuilderFactory.BOOLEAN);
  }

  @Override
  public Response hexists(final byte[] key, final byte[] field) {
    getClient(key).hexists(key, field);
    return getResponse(BuilderFactory.BOOLEAN);
  }

  @Override
  public Response hget(final String key, final String field) {
    getClient(key).hget(key, field);
    return getResponse(BuilderFactory.STRING);
  }

  @Override
  public Response hget(final byte[] key, final byte[] field) {
    getClient(key).hget(key, field);
    return getResponse(BuilderFactory.BYTE_ARRAY);
  }

  @Override
  public Response> hgetAll(final String key) {
    getClient(key).hgetAll(key);
    return getResponse(BuilderFactory.STRING_MAP);
  }

  @Override
  public Response> hgetAll(final byte[] key) {
    getClient(key).hgetAll(key);
    return getResponse(BuilderFactory.BYTE_ARRAY_MAP);
  }

  @Override
  public Response hincrBy(final String key, final String field, final long value) {
    getClient(key).hincrBy(key, field, value);
    return getResponse(BuilderFactory.LONG);
  }

  @Override
  public Response hincrBy(final byte[] key, final byte[] field, final long value) {
    getClient(key).hincrBy(key, field, value);
    return getResponse(BuilderFactory.LONG);
  }

  @Override
  public Response> hkeys(final String key) {
    getClient(key).hkeys(key);
    return getResponse(BuilderFactory.STRING_SET);
  }

  @Override
  public Response> hkeys(final byte[] key) {
    getClient(key).hkeys(key);
    return getResponse(BuilderFactory.BYTE_ARRAY_ZSET);
  }

  @Override
  public Response hlen(final String key) {
    getClient(key).hlen(key);
    return getResponse(BuilderFactory.LONG);
  }

  @Override
  public Response hlen(final byte[] key) {
    getClient(key).hlen(key);
    return getResponse(BuilderFactory.LONG);
  }

  @Override
  public Response> hmget(final String key, final String... fields) {
    getClient(key).hmget(key, fields);
    return getResponse(BuilderFactory.STRING_LIST);
  }

  @Override
  public Response> hmget(final byte[] key, final byte[]... fields) {
    getClient(key).hmget(key, fields);
    return getResponse(BuilderFactory.BYTE_ARRAY_LIST);
  }

  @Override
  public Response hmset(final String key, final Map hash) {
    getClient(key).hmset(key, hash);
    return getResponse(BuilderFactory.STRING);
  }

  @Override
  public Response hmset(final byte[] key, final Map hash) {
    getClient(key).hmset(key, hash);
    return getResponse(BuilderFactory.STRING);
  }

  @Override
  public Response hset(final String key, final String field, final String value) {
    getClient(key).hset(key, field, value);
    return getResponse(BuilderFactory.LONG);
  }

  @Override
  public Response hset(final byte[] key, final byte[] field, final byte[] value) {
    getClient(key).hset(key, field, value);
    return getResponse(BuilderFactory.LONG);
  }

  @Override
  public Response hset(final String key, final Map hash) {
    getClient(key).hset(key, hash);
    return getResponse(BuilderFactory.LONG);
  }

  @Override
  public Response hset(final byte[] key, final Map hash) {
    getClient(key).hset(key, hash);
    return getResponse(BuilderFactory.LONG);
  }

  @Override
  public Response hsetnx(final String key, final String field, final String value) {
    getClient(key).hsetnx(key, field, value);
    return getResponse(BuilderFactory.LONG);
  }

  @Override
  public Response hsetnx(final byte[] key, final byte[] field, final byte[] value) {
    getClient(key).hsetnx(key, field, value);
    return getResponse(BuilderFactory.LONG);
  }

  @Override
  public Response> hvals(final String key) {
    getClient(key).hvals(key);
    return getResponse(BuilderFactory.STRING_LIST);
  }

  @Override
  public Response> hvals(final byte[] key) {
    getClient(key).hvals(key);
    return getResponse(BuilderFactory.BYTE_ARRAY_LIST);
  }

  @Override
  public Response hrandfield(final byte[] key) {
    getClient(key).hrandfield(key);
    return getResponse(BuilderFactory.BYTE_ARRAY);
  }

  @Override
  public Response> hrandfield(final byte[] key, final long count) {
    getClient(key).hrandfield(key, count);
    return getResponse(BuilderFactory.BYTE_ARRAY_LIST);
  }

  @Override
  public Response> hrandfieldWithValues(final byte[] key, final long count) {
    getClient(key).hrandfieldWithValues(key, count);
    return getResponse(BuilderFactory.BYTE_ARRAY_MAP);
  }

  @Override
  public Response hrandfield(final String key) {
    getClient(key).hrandfield(key);
    return getResponse(BuilderFactory.STRING);
  }

  @Override
  public Response> hrandfield(final String key, final long count) {
    getClient(key).hrandfield(key, count);
    return getResponse(BuilderFactory.STRING_LIST);
  }

  @Override
  public Response> hrandfieldWithValues(final String key, final long count) {
    getClient(key).hrandfieldWithValues(key, count);
    return getResponse(BuilderFactory.STRING_MAP);
  }

  @Override
  public Response incr(final String key) {
    getClient(key).incr(key);
    return getResponse(BuilderFactory.LONG);
  }

  @Override
  public Response incr(final byte[] key) {
    getClient(key).incr(key);
    return getResponse(BuilderFactory.LONG);
  }

  @Override
  public Response incrBy(final String key, final long increment) {
    getClient(key).incrBy(key, increment);
    return getResponse(BuilderFactory.LONG);
  }

  @Override
  public Response incrBy(final byte[] key, final long increment) {
    getClient(key).incrBy(key, increment);
    return getResponse(BuilderFactory.LONG);
  }

  @Override
  public Response lindex(final String key, final long index) {
    getClient(key).lindex(key, index);
    return getResponse(BuilderFactory.STRING);
  }

  @Override
  public Response lindex(final byte[] key, final long index) {
    getClient(key).lindex(key, index);
    return getResponse(BuilderFactory.BYTE_ARRAY);
  }

  @Override
  public Response linsert(final String key, final ListPosition where, final String pivot,
      final String value) {
    getClient(key).linsert(key, where, pivot, value);
    return getResponse(BuilderFactory.LONG);
  }

  @Override
  public Response linsert(final byte[] key, final ListPosition where, final byte[] pivot,
      final byte[] value) {
    getClient(key).linsert(key, where, pivot, value);
    return getResponse(BuilderFactory.LONG);
  }

  @Override
  public Response llen(final String key) {
    getClient(key).llen(key);
    return getResponse(BuilderFactory.LONG);
  }

  @Override
  public Response llen(final byte[] key) {
    getClient(key).llen(key);
    return getResponse(BuilderFactory.LONG);
  }

  @Override
  public Response lpop(final String key) {
    getClient(key).lpop(key);
    return getResponse(BuilderFactory.STRING);
  }

  @Override
  public Response lpop(final byte[] key) {
    getClient(key).lpop(key);
    return getResponse(BuilderFactory.BYTE_ARRAY);
  }

  @Override
  public Response> lpop(final String key, final int count) {
    getClient(key).lpop(key, count);
    return getResponse(BuilderFactory.STRING_LIST);
  }

  @Override
  public Response> lpop(final byte[] key, final int count) {
    getClient(key).lpop(key, count);
    return getResponse(BuilderFactory.BYTE_ARRAY_LIST);
  }

  @Override
  public Response lpos(final String key, final String element) {
    getClient(key).lpos(key, element);
    return getResponse(BuilderFactory.LONG);
  }

  @Override
  public Response lpos(final byte[] key, final byte[] element) {
    getClient(key).lpos(key, element);
    return getResponse(BuilderFactory.LONG);
  }

  @Override
  public Response lpos(final String key, final String element, final LPosParams params) {
    getClient(key).lpos(key, element, params);
    return getResponse(BuilderFactory.LONG);
  }

  @Override
  public Response lpos(final byte[] key, final byte[] element, final LPosParams params) {
    getClient(key).lpos(key, element, params);
    return getResponse(BuilderFactory.LONG);
  }

  @Override
  public Response> lpos(final String key, final String element, final LPosParams params,
      final long count) {
    getClient(key).lpos(key, element, params, count);
    return getResponse(BuilderFactory.LONG_LIST);
  }

  @Override
  public Response> lpos(final byte[] key, final byte[] element, final LPosParams params,
      final long count) {
    getClient(key).lpos(key, element, params, count);
    return getResponse(BuilderFactory.LONG_LIST);
  }

  @Override
  public Response lpush(final String key, final String... string) {
    getClient(key).lpush(key, string);
    return getResponse(BuilderFactory.LONG);
  }

  @Override
  public Response lpush(final byte[] key, final byte[]... string) {
    getClient(key).lpush(key, string);
    return getResponse(BuilderFactory.LONG);
  }

  @Override
  public Response lpushx(final String key, final String... string) {
    getClient(key).lpushx(key, string);
    return getResponse(BuilderFactory.LONG);
  }

  @Override
  public Response lpushx(final byte[] key, final byte[]... bytes) {
    getClient(key).lpushx(key, bytes);
    return getResponse(BuilderFactory.LONG);
  }

  @Override
  public Response> lrange(final String key, final long start, final long stop) {
    getClient(key).lrange(key, start, stop);
    return getResponse(BuilderFactory.STRING_LIST);
  }

  @Override
  public Response> lrange(final byte[] key, final long start, final long stop) {
    getClient(key).lrange(key, start, stop);
    return getResponse(BuilderFactory.BYTE_ARRAY_LIST);
  }

  @Override
  public Response lrem(final String key, final long count, final String value) {
    getClient(key).lrem(key, count, value);
    return getResponse(BuilderFactory.LONG);
  }

  @Override
  public Response lrem(final byte[] key, final long count, final byte[] value) {
    getClient(key).lrem(key, count, value);
    return getResponse(BuilderFactory.LONG);
  }

  @Override
  public Response lset(final String key, final long index, final String value) {
    getClient(key).lset(key, index, value);
    return getResponse(BuilderFactory.STRING);
  }

  @Override
  public Response lset(final byte[] key, final long index, final byte[] value) {
    getClient(key).lset(key, index, value);
    return getResponse(BuilderFactory.STRING);
  }

  @Override
  public Response ltrim(final String key, final long start, final long stop) {
    getClient(key).ltrim(key, start, stop);
    return getResponse(BuilderFactory.STRING);
  }

  @Override
  public Response ltrim(final byte[] key, final long start, final long stop) {
    getClient(key).ltrim(key, start, stop);
    return getResponse(BuilderFactory.STRING);
  }

  @Override
  public Response move(final String key, final int dbIndex) {
    getClient(key).move(key, dbIndex);
    return getResponse(BuilderFactory.LONG);
  }

  @Override
  public Response move(final byte[] key, final int dbIndex) {
    getClient(key).move(key, dbIndex);
    return getResponse(BuilderFactory.LONG);
  }

  @Override
  public Response persist(final String key) {
    getClient(key).persist(key);
    return getResponse(BuilderFactory.LONG);
  }

  @Override
  public Response persist(final byte[] key) {
    getClient(key).persist(key);
    return getResponse(BuilderFactory.LONG);
  }

  @Override
  public Response rpop(final String key) {
    getClient(key).rpop(key);
    return getResponse(BuilderFactory.STRING);
  }

  @Override
  public Response rpop(final byte[] key) {
    getClient(key).rpop(key);
    return getResponse(BuilderFactory.BYTE_ARRAY);
  }

  @Override
  public Response> rpop(final String key, final int count) {
    getClient(key).rpop(key, count);
    return getResponse(BuilderFactory.STRING_LIST);
  }

  @Override
  public Response> rpop(final byte[] key, final int count) {
    getClient(key).rpop(key, count);
    return getResponse(BuilderFactory.BYTE_ARRAY_LIST);
  }

  @Override
  public Response rpush(final String key, final String... string) {
    getClient(key).rpush(key, string);
    return getResponse(BuilderFactory.LONG);
  }

  @Override
  public Response rpush(final byte[] key, final byte[]... string) {
    getClient(key).rpush(key, string);
    return getResponse(BuilderFactory.LONG);
  }

  @Override
  public Response rpushx(final String key, final String... string) {
    getClient(key).rpushx(key, string);
    return getResponse(BuilderFactory.LONG);
  }

  @Override
  public Response rpushx(final byte[] key, final byte[]... string) {
    getClient(key).rpushx(key, string);
    return getResponse(BuilderFactory.LONG);
  }

  @Override
  public Response sadd(final String key, final String... member) {
    getClient(key).sadd(key, member);
    return getResponse(BuilderFactory.LONG);
  }

  @Override
  public Response sadd(final byte[] key, final byte[]... member) {
    getClient(key).sadd(key, member);
    return getResponse(BuilderFactory.LONG);
  }

  @Override
  public Response scard(final String key) {
    getClient(key).scard(key);
    return getResponse(BuilderFactory.LONG);
  }

  @Override
  public Response scard(final byte[] key) {
    getClient(key).scard(key);
    return getResponse(BuilderFactory.LONG);
  }

  @Override
  public Response set(final String key, final String value) {
    getClient(key).set(key, value);
    return getResponse(BuilderFactory.STRING);
  }

  @Override
  public Response set(final byte[] key, final byte[] value) {
    getClient(key).set(key, value);
    return getResponse(BuilderFactory.STRING);
  }

  @Override
  public Response set(final String key, final String value, SetParams params) {
    getClient(key).set(key, value, params);
    return getResponse(BuilderFactory.STRING);
  }

  @Override
  public Response set(final byte[] key, final byte[] value, SetParams params) {
    getClient(key).set(key, value, params);
    return getResponse(BuilderFactory.STRING);
  }

  @Override
  public Response setbit(final String key, final long offset, boolean value) {
    getClient(key).setbit(key, offset, value);
    return getResponse(BuilderFactory.BOOLEAN);
  }

  @Override
  public Response setbit(final byte[] key, final long offset, final byte[] value) {
    getClient(key).setbit(key, offset, value);
    return getResponse(BuilderFactory.BOOLEAN);
  }

  @Override
  public Response setex(final String key, final long seconds, final String value) {
    getClient(key).setex(key, seconds, value);
    return getResponse(BuilderFactory.STRING);
  }

  @Override
  public Response setex(final byte[] key, final long seconds, final byte[] value) {
    getClient(key).setex(key, seconds, value);
    return getResponse(BuilderFactory.STRING);
  }

  @Override
  public Response setnx(final String key, final String value) {
    getClient(key).setnx(key, value);
    return getResponse(BuilderFactory.LONG);
  }

  @Override
  public Response setnx(final byte[] key, final byte[] value) {
    getClient(key).setnx(key, value);
    return getResponse(BuilderFactory.LONG);
  }

  @Override
  public Response setrange(final String key, final long offset, final String value) {
    getClient(key).setrange(key, offset, value);
    return getResponse(BuilderFactory.LONG);
  }

  @Override
  public Response setrange(final byte[] key, final long offset, final byte[] value) {
    getClient(key).setrange(key, offset, value);
    return getResponse(BuilderFactory.LONG);
  }

  @Override
  public Response sismember(final String key, final String member) {
    getClient(key).sismember(key, member);
    return getResponse(BuilderFactory.BOOLEAN);
  }

  @Override
  public Response> smismember(final String key, final String... members) {
    getClient(key).smismember(key, members);
    return getResponse(BuilderFactory.BOOLEAN_LIST);
  }

  @Override
  public Response sismember(final byte[] key, final byte[] member) {
    getClient(key).sismember(key, member);
    return getResponse(BuilderFactory.BOOLEAN);
  }

  @Override
  public Response> smismember(final byte[] key, final byte[]... members) {
    getClient(key).smismember(key, members);
    return getResponse(BuilderFactory.BOOLEAN_LIST);
  }

  @Override
  public Response> smembers(final String key) {
    getClient(key).smembers(key);
    return getResponse(BuilderFactory.STRING_SET);
  }

  @Override
  public Response> smembers(final byte[] key) {
    getClient(key).smembers(key);
    return getResponse(BuilderFactory.BYTE_ARRAY_ZSET);
  }

  @Override
  public Response> sort(final String key) {
    getClient(key).sort(key);
    return getResponse(BuilderFactory.STRING_LIST);
  }

  @Override
  public Response> sort(final byte[] key) {
    getClient(key).sort(key);
    return getResponse(BuilderFactory.BYTE_ARRAY_LIST);
  }

  @Override
  public Response> sort(final String key, final SortingParams sortingParameters) {
    getClient(key).sort(key, sortingParameters);
    return getResponse(BuilderFactory.STRING_LIST);
  }

  @Override
  public Response> sort(final byte[] key, final SortingParams sortingParameters) {
    getClient(key).sort(key, sortingParameters);
    return getResponse(BuilderFactory.BYTE_ARRAY_LIST);
  }

  @Override
  public Response spop(final String key) {
    getClient(key).spop(key);
    return getResponse(BuilderFactory.STRING);
  }

  @Override
  public Response> spop(final String key, final long count) {
    getClient(key).spop(key, count);
    return getResponse(BuilderFactory.STRING_SET);
  }

  @Override
  public Response spop(final byte[] key) {
    getClient(key).spop(key);
    return getResponse(BuilderFactory.BYTE_ARRAY);
  }

  @Override
  public Response> spop(final byte[] key, final long count) {
    getClient(key).spop(key, count);
    return getResponse(BuilderFactory.BYTE_ARRAY_ZSET);
  }

  @Override
  public Response srandmember(final String key) {
    getClient(key).srandmember(key);
    return getResponse(BuilderFactory.STRING);
  }

  @Override
  public Response> srandmember(final String key, final int count) {
    getClient(key).srandmember(key, count);
    return getResponse(BuilderFactory.STRING_LIST);
  }

  @Override
  public Response srandmember(final byte[] key) {
    getClient(key).srandmember(key);
    return getResponse(BuilderFactory.BYTE_ARRAY);
  }

  @Override
  public Response> srandmember(final byte[] key, final int count) {
    getClient(key).srandmember(key, count);
    return getResponse(BuilderFactory.BYTE_ARRAY_LIST);
  }

  @Override
  public Response srem(final String key, final String... member) {
    getClient(key).srem(key, member);
    return getResponse(BuilderFactory.LONG);
  }

  @Override
  public Response srem(final byte[] key, final byte[]... member) {
    getClient(key).srem(key, member);
    return getResponse(BuilderFactory.LONG);
  }

  @Override
  public Response strlen(final String key) {
    getClient(key).strlen(key);
    return getResponse(BuilderFactory.LONG);
  }

  @Override
  public Response strlen(final byte[] key) {
    getClient(key).strlen(key);
    return getResponse(BuilderFactory.LONG);
  }

  @Override
  public Response substr(final String key, final int start, final int end) {
    getClient(key).substr(key, start, end);
    return getResponse(BuilderFactory.STRING);
  }

  @Override
  public Response substr(final byte[] key, final int start, final int end) {
    getClient(key).substr(key, start, end);
    return getResponse(BuilderFactory.STRING);
  }

  @Override
  public Response touch(final String key) {
    getClient(key).touch(key);
    return getResponse(BuilderFactory.LONG);
  }

  @Override
  public Response touch(final byte[] key) {
    getClient(key).touch(key);
    return getResponse(BuilderFactory.LONG);
  }

  @Override
  public Response ttl(final String key) {
    getClient(key).ttl(key);
    return getResponse(BuilderFactory.LONG);
  }

  @Override
  public Response ttl(final byte[] key) {
    getClient(key).ttl(key);
    return getResponse(BuilderFactory.LONG);
  }

  @Override
  public Response type(final String key) {
    getClient(key).type(key);
    return getResponse(BuilderFactory.STRING);
  }

  @Override
  public Response type(final byte[] key) {
    getClient(key).type(key);
    return getResponse(BuilderFactory.STRING);
  }

  @Override
  public Response zadd(final String key, final double score, final String member) {
    getClient(key).zadd(key, score, member);
    return getResponse(BuilderFactory.LONG);
  }

  @Override
  public Response zadd(final String key, final double score, final String member,
      final ZAddParams params) {
    getClient(key).zadd(key, score, member, params);
    return getResponse(BuilderFactory.LONG);
  }

  @Override
  public Response zadd(final String key, final Map scoreMembers) {
    getClient(key).zadd(key, scoreMembers);
    return getResponse(BuilderFactory.LONG);
  }

  @Override
  public Response zadd(final String key, final Map scoreMembers,
      final ZAddParams params) {
    getClient(key).zadd(key, scoreMembers, params);
    return getResponse(BuilderFactory.LONG);
  }

  @Override
  public Response zadd(final byte[] key, final double score, final byte[] member) {
    getClient(key).zadd(key, score, member);
    return getResponse(BuilderFactory.LONG);
  }

  @Override
  public Response zadd(final byte[] key, final double score, final byte[] member,
      final ZAddParams params) {
    getClient(key).zadd(key, score, member, params);
    return getResponse(BuilderFactory.LONG);
  }

  @Override
  public Response zadd(final byte[] key, final Map scoreMembers) {
    getClient(key).zadd(key, scoreMembers);
    return getResponse(BuilderFactory.LONG);
  }

  @Override
  public Response zadd(final byte[] key, final Map scoreMembers,
      final ZAddParams params) {
    getClient(key).zadd(key, scoreMembers, params);
    return getResponse(BuilderFactory.LONG);
  }

  @Override
  public Response zaddIncr(String key, double score, String member, ZAddParams params) {
    getClient(key).zaddIncr(key, score, member, params);
    return getResponse(BuilderFactory.DOUBLE);
  }

  @Override
  public Response zaddIncr(byte[] key, double score, byte[] member, ZAddParams params) {
    getClient(key).zaddIncr(key, score, member, params);
    return getResponse(BuilderFactory.DOUBLE);
  }

  @Override
  public Response zcard(final String key) {
    getClient(key).zcard(key);
    return getResponse(BuilderFactory.LONG);
  }

  @Override
  public Response zcard(final byte[] key) {
    getClient(key).zcard(key);
    return getResponse(BuilderFactory.LONG);
  }

  @Override
  public Response zcount(final String key, final double min, final double max) {
    getClient(key).zcount(key, min, max);
    return getResponse(BuilderFactory.LONG);
  }

  @Override
  public Response zcount(final String key, final String min, final String max) {
    getClient(key).zcount(key, min, max);
    return getResponse(BuilderFactory.LONG);
  }

  @Override
  public Response zcount(final byte[] key, final double min, final double max) {
    getClient(key).zcount(key, min, max);
    return getResponse(BuilderFactory.LONG);
  }

  @Override
  public Response zcount(final byte[] key, final byte[] min, final byte[] max) {
    getClient(key).zcount(key, min, max);
    return getResponse(BuilderFactory.LONG);
  }

  @Override
  public Response zincrby(final String key, final double increment, final String member) {
    getClient(key).zincrby(key, increment, member);
    return getResponse(BuilderFactory.DOUBLE);
  }

  @Override
  public Response zincrby(final String key, final double increment, final String member,
      ZIncrByParams params) {
    getClient(key).zincrby(key, increment, member, params);
    return getResponse(BuilderFactory.DOUBLE);
  }

  @Override
  public Response zincrby(final byte[] key, final double increment, final byte[] member) {
    getClient(key).zincrby(key, increment, member);
    return getResponse(BuilderFactory.DOUBLE);
  }

  @Override
  public Response zincrby(final byte[] key, final double increment, final byte[] member,
      ZIncrByParams params) {
    getClient(key).zincrby(key, increment, member);
    return getResponse(BuilderFactory.DOUBLE);
  }

  @Override
  public Response> zrange(final String key, final long start, final long stop) {
    getClient(key).zrange(key, start, stop);
    return getResponse(BuilderFactory.STRING_ZSET);
  }

  @Override
  public Response> zrange(final byte[] key, final long start, final long stop) {
    getClient(key).zrange(key, start, stop);
    return getResponse(BuilderFactory.BYTE_ARRAY_ZSET);
  }

  @Override
  public Response> zrangeByScore(final String key, final double min, final double max) {
    getClient(key).zrangeByScore(key, min, max);
    return getResponse(BuilderFactory.STRING_ZSET);
  }

  @Override
  public Response> zrangeByScore(final byte[] key, final double min, final double max) {
    getClient(key).zrangeByScore(key, min, max);
    return getResponse(BuilderFactory.BYTE_ARRAY_ZSET);
  }

  @Override
  public Response> zrangeByScore(final String key, final String min, final String max) {
    getClient(key).zrangeByScore(key, min, max);
    return getResponse(BuilderFactory.STRING_ZSET);
  }

  @Override
  public Response> zrangeByScore(final byte[] key, final byte[] min, final byte[] max) {
    getClient(key).zrangeByScore(key, min, max);
    return getResponse(BuilderFactory.BYTE_ARRAY_ZSET);
  }

  @Override
  public Response> zrangeByScore(final String key, final double min, final double max,
      final int offset, final int count) {
    getClient(key).zrangeByScore(key, min, max, offset, count);
    return getResponse(BuilderFactory.STRING_ZSET);
  }

  @Override
  public Response> zrangeByScore(final String key, final String min, final String max,
      final int offset, final int count) {
    getClient(key).zrangeByScore(key, min, max, offset, count);
    return getResponse(BuilderFactory.STRING_ZSET);
  }

  @Override
  public Response> zrangeByScore(final byte[] key, final double min, final double max,
      final int offset, final int count) {
    getClient(key).zrangeByScore(key, min, max, offset, count);
    return getResponse(BuilderFactory.BYTE_ARRAY_ZSET);
  }

  @Override
  public Response> zrangeByScore(final byte[] key, final byte[] min, final byte[] max,
      final int offset, final int count) {
    getClient(key).zrangeByScore(key, min, max, offset, count);
    return getResponse(BuilderFactory.BYTE_ARRAY_ZSET);
  }

  @Override
  public Response> zrangeByScoreWithScores(final String key, final double min,
      final double max) {
    getClient(key).zrangeByScoreWithScores(key, min, max);
    return getResponse(BuilderFactory.TUPLE_ZSET);
  }

  @Override
  public Response> zrangeByScoreWithScores(final String key, final String min,
      final String max) {
    getClient(key).zrangeByScoreWithScores(key, min, max);
    return getResponse(BuilderFactory.TUPLE_ZSET);
  }

  @Override
  public Response> zrangeByScoreWithScores(final byte[] key, final double min,
      final double max) {
    getClient(key).zrangeByScoreWithScores(key, min, max);
    return getResponse(BuilderFactory.TUPLE_ZSET);
  }

  @Override
  public Response> zrangeByScoreWithScores(final byte[] key, final byte[] min,
      final byte[] max) {
    getClient(key).zrangeByScoreWithScores(key, min, max);
    return getResponse(BuilderFactory.TUPLE_ZSET);
  }

  @Override
  public Response> zrangeByScoreWithScores(final String key, final double min,
      final double max, final int offset, final int count) {
    getClient(key).zrangeByScoreWithScores(key, min, max, offset, count);
    return getResponse(BuilderFactory.TUPLE_ZSET);
  }

  @Override
  public Response> zrangeByScoreWithScores(final String key, final String min,
      final String max, final int offset, final int count) {
    getClient(key).zrangeByScoreWithScores(key, min, max, offset, count);
    return getResponse(BuilderFactory.TUPLE_ZSET);
  }

  @Override
  public Response> zrangeByScoreWithScores(final byte[] key, final double min,
      final double max, final int offset, final int count) {
    getClient(key).zrangeByScoreWithScores(key, min, max, offset, count);
    return getResponse(BuilderFactory.TUPLE_ZSET);
  }

  @Override
  public Response> zrangeByScoreWithScores(final byte[] key, final byte[] min,
      final byte[] max, final int offset, final int count) {
    getClient(key).zrangeByScoreWithScores(key, min, max, offset, count);
    return getResponse(BuilderFactory.TUPLE_ZSET);
  }

  @Override
  public Response> zrevrangeByScore(final String key, final double max, final double min) {
    getClient(key).zrevrangeByScore(key, max, min);
    return getResponse(BuilderFactory.STRING_ZSET);
  }

  @Override
  public Response> zrevrangeByScore(final byte[] key, final double max, final double min) {
    getClient(key).zrevrangeByScore(key, max, min);
    return getResponse(BuilderFactory.BYTE_ARRAY_ZSET);
  }

  @Override
  public Response> zrevrangeByScore(final String key, final String max, final String min) {
    getClient(key).zrevrangeByScore(key, max, min);
    return getResponse(BuilderFactory.STRING_ZSET);
  }

  @Override
  public Response> zrevrangeByScore(final byte[] key, final byte[] max, final byte[] min) {
    getClient(key).zrevrangeByScore(key, max, min);
    return getResponse(BuilderFactory.BYTE_ARRAY_ZSET);
  }

  @Override
  public Response> zrevrangeByScore(final String key, final double max,
      final double min, final int offset, final int count) {
    getClient(key).zrevrangeByScore(key, max, min, offset, count);
    return getResponse(BuilderFactory.STRING_ZSET);
  }

  @Override
  public Response> zrevrangeByScore(final String key, final String max,
      final String min, final int offset, final int count) {
    getClient(key).zrevrangeByScore(key, max, min, offset, count);
    return getResponse(BuilderFactory.STRING_ZSET);
  }

  @Override
  public Response> zrevrangeByScore(final byte[] key, final double max,
      final double min, final int offset, final int count) {
    getClient(key).zrevrangeByScore(key, max, min, offset, count);
    return getResponse(BuilderFactory.BYTE_ARRAY_ZSET);
  }

  @Override
  public Response> zrevrangeByScore(final byte[] key, final byte[] max,
      final byte[] min, final int offset, final int count) {
    getClient(key).zrevrangeByScore(key, max, min, offset, count);
    return getResponse(BuilderFactory.BYTE_ARRAY_ZSET);
  }

  @Override
  public Response> zrevrangeByScoreWithScores(final String key, final double max,
      final double min) {
    getClient(key).zrevrangeByScoreWithScores(key, max, min);
    return getResponse(BuilderFactory.TUPLE_ZSET);
  }

  @Override
  public Response> zrevrangeByScoreWithScores(final String key, final String max,
      final String min) {
    getClient(key).zrevrangeByScoreWithScores(key, max, min);
    return getResponse(BuilderFactory.TUPLE_ZSET);
  }

  @Override
  public Response> zrevrangeByScoreWithScores(final byte[] key, final double max,
      final double min) {
    getClient(key).zrevrangeByScoreWithScores(key, max, min);
    return getResponse(BuilderFactory.TUPLE_ZSET);
  }

  @Override
  public Response> zrevrangeByScoreWithScores(final byte[] key, final byte[] max,
      final byte[] min) {
    getClient(key).zrevrangeByScoreWithScores(key, max, min);
    return getResponse(BuilderFactory.TUPLE_ZSET);
  }

  @Override
  public Response> zrevrangeByScoreWithScores(final String key, final double max,
      final double min, final int offset, final int count) {
    getClient(key).zrevrangeByScoreWithScores(key, max, min, offset, count);
    return getResponse(BuilderFactory.TUPLE_ZSET);
  }

  @Override
  public Response> zrevrangeByScoreWithScores(final String key, final String max,
      final String min, final int offset, final int count) {
    getClient(key).zrevrangeByScoreWithScores(key, max, min, offset, count);
    return getResponse(BuilderFactory.TUPLE_ZSET);
  }

  @Override
  public Response> zrevrangeByScoreWithScores(final byte[] key, final double max,
      final double min, final int offset, final int count) {
    getClient(key).zrevrangeByScoreWithScores(key, max, min, offset, count);
    return getResponse(BuilderFactory.TUPLE_ZSET);
  }

  @Override
  public Response> zrevrangeByScoreWithScores(final byte[] key, final byte[] max,
      final byte[] min, final int offset, final int count) {
    getClient(key).zrevrangeByScoreWithScores(key, max, min, offset, count);
    return getResponse(BuilderFactory.TUPLE_ZSET);
  }

  @Override
  public Response> zrangeWithScores(final String key, final long start, final long stop) {
    getClient(key).zrangeWithScores(key, start, stop);
    return getResponse(BuilderFactory.TUPLE_ZSET);
  }

  @Override
  public Response> zrangeWithScores(final byte[] key, final long start, final long stop) {
    getClient(key).zrangeWithScores(key, start, stop);
    return getResponse(BuilderFactory.TUPLE_ZSET);
  }

  @Override
  public Response zrank(final String key, final String member) {
    getClient(key).zrank(key, member);
    return getResponse(BuilderFactory.LONG);
  }

  @Override
  public Response zrank(final byte[] key, final byte[] member) {
    getClient(key).zrank(key, member);
    return getResponse(BuilderFactory.LONG);
  }

  @Override
  public Response zrem(final String key, final String... members) {
    getClient(key).zrem(key, members);
    return getResponse(BuilderFactory.LONG);
  }

  @Override
  public Response zrem(final byte[] key, final byte[]... members) {
    getClient(key).zrem(key, members);
    return getResponse(BuilderFactory.LONG);
  }

  @Override
  public Response zremrangeByRank(final String key, final long start, final long stop) {
    getClient(key).zremrangeByRank(key, start, stop);
    return getResponse(BuilderFactory.LONG);
  }

  @Override
  public Response zremrangeByRank(final byte[] key, final long start, final long stop) {
    getClient(key).zremrangeByRank(key, start, stop);
    return getResponse(BuilderFactory.LONG);
  }

  @Override
  public Response zremrangeByScore(final String key, final double min, final double max) {
    getClient(key).zremrangeByScore(key, min, max);
    return getResponse(BuilderFactory.LONG);
  }

  @Override
  public Response zremrangeByScore(final String key, final String min, final String max) {
    getClient(key).zremrangeByScore(key, min, max);
    return getResponse(BuilderFactory.LONG);
  }

  @Override
  public Response zremrangeByScore(final byte[] key, final double min, final double max) {
    getClient(key).zremrangeByScore(key, min, max);
    return getResponse(BuilderFactory.LONG);
  }

  @Override
  public Response zremrangeByScore(final byte[] key, final byte[] min, final byte[] max) {
    getClient(key).zremrangeByScore(key, min, max);
    return getResponse(BuilderFactory.LONG);
  }

  @Override
  public Response> zrevrange(final String key, final long start, final long stop) {
    getClient(key).zrevrange(key, start, stop);
    return getResponse(BuilderFactory.STRING_ZSET);
  }

  @Override
  public Response> zrevrange(final byte[] key, final long start, final long stop) {
    getClient(key).zrevrange(key, start, stop);
    return getResponse(BuilderFactory.BYTE_ARRAY_ZSET);
  }

  @Override
  public Response> zrevrangeWithScores(final String key, final long start,
      final long stop) {
    getClient(key).zrevrangeWithScores(key, start, stop);
    return getResponse(BuilderFactory.TUPLE_ZSET);
  }

  @Override
  public Response> zrevrangeWithScores(final byte[] key, final long start,
      final long stop) {
    getClient(key).zrevrangeWithScores(key, start, stop);
    return getResponse(BuilderFactory.TUPLE_ZSET);
  }

  @Override
  public Response zrandmember(final byte[] key) {
    getClient(key).zrandmember(key);
    return getResponse(BuilderFactory.BYTE_ARRAY);
  }

  @Override
  public Response> zrandmember(final byte[] key, final long count) {
    getClient(key).zrandmember(key, count);
    return getResponse(BuilderFactory.BYTE_ARRAY_ZSET);
  }

  @Override
  public Response> zrandmemberWithScores(final byte[] key, final long count) {
    getClient(key).zrandmemberWithScores(key, count);
    return getResponse(BuilderFactory.TUPLE_ZSET);
  }

  @Override
  public Response zrandmember(final String key) {
    getClient(key).zrandmember(key);
    return getResponse(BuilderFactory.STRING);
  }

  @Override
  public Response> zrandmember(final String key, final long count) {
    getClient(key).zrandmember(key, count);
    return getResponse(BuilderFactory.STRING_ZSET);
  }

  @Override
  public Response> zrandmemberWithScores(final String key, final long count) {
    getClient(key).zrandmemberWithScores(key, count);
    return getResponse(BuilderFactory.TUPLE_ZSET);
  }

  @Override
  public Response zrevrank(final String key, final String member) {
    getClient(key).zrevrank(key, member);
    return getResponse(BuilderFactory.LONG);
  }

  @Override
  public Response zrevrank(final byte[] key, final byte[] member) {
    getClient(key).zrevrank(key, member);
    return getResponse(BuilderFactory.LONG);
  }

  @Override
  public Response zscore(final String key, final String member) {
    getClient(key).zscore(key, member);
    return getResponse(BuilderFactory.DOUBLE);
  }

  @Override
  public Response> zmscore(final String key, final String... members) {
    getClient(key).zmscore(key, members);
    return getResponse(BuilderFactory.DOUBLE_LIST);
  }

  @Override
  public Response zscore(final byte[] key, final byte[] member) {
    getClient(key).zscore(key, member);
    return getResponse(BuilderFactory.DOUBLE);
  }

  @Override
  public Response> zmscore(final byte[] key, final byte[]... members) {
    getClient(key).zmscore(key, members);
    return getResponse(BuilderFactory.DOUBLE_LIST);
  }

  @Override
  public Response zpopmax(final String key) {
    getClient(key).zpopmax(key);
    return getResponse(BuilderFactory.TUPLE);
  }

  @Override
  public Response zpopmax(final byte[] key) {
    getClient(key).zpopmax(key);
    return getResponse(BuilderFactory.TUPLE);
  }

  @Override
  public Response> zpopmax(final String key, final int count) {
    getClient(key).zpopmax(key, count);
    return getResponse(BuilderFactory.TUPLE_ZSET);
  }

  @Override
  public Response> zpopmax(final byte[] key, final int count) {
    getClient(key).zpopmax(key, count);
    return getResponse(BuilderFactory.TUPLE_ZSET);
  }

  @Override
  public Response zpopmin(final String key) {
    getClient(key).zpopmin(key);
    return getResponse(BuilderFactory.TUPLE);
  }

  @Override
  public Response zpopmin(final byte[] key) {
    getClient(key).zpopmin(key);
    return getResponse(BuilderFactory.TUPLE);
  }

  @Override
  public Response> zpopmin(final byte[] key, final int count) {
    getClient(key).zpopmin(key, count);
    return getResponse(BuilderFactory.TUPLE_ZSET);
  }

  @Override
  public Response> zpopmin(final String key, final int count) {
    getClient(key).zpopmin(key, count);
    return getResponse(BuilderFactory.TUPLE_ZSET);
  }

  @Override
  public Response zlexcount(final byte[] key, final byte[] min, final byte[] max) {
    getClient(key).zlexcount(key, min, max);
    return getResponse(BuilderFactory.LONG);
  }

  @Override
  public Response zlexcount(final String key, final String min, final String max) {
    getClient(key).zlexcount(key, min, max);
    return getResponse(BuilderFactory.LONG);
  }

  @Override
  public Response> zrangeByLex(final byte[] key, final byte[] min, final byte[] max) {
    getClient(key).zrangeByLex(key, min, max);
    return getResponse(BuilderFactory.BYTE_ARRAY_ZSET);
  }

  @Override
  public Response> zrangeByLex(final String key, final String min, final String max) {
    getClient(key).zrangeByLex(key, min, max);
    return getResponse(BuilderFactory.STRING_ZSET);
  }

  @Override
  public Response> zrangeByLex(final byte[] key, final byte[] min, final byte[] max,
      final int offset, final int count) {
    getClient(key).zrangeByLex(key, min, max, offset, count);
    return getResponse(BuilderFactory.BYTE_ARRAY_ZSET);
  }

  @Override
  public Response> zrangeByLex(final String key, final String min, final String max,
      final int offset, final int count) {
    getClient(key).zrangeByLex(key, min, max, offset, count);
    return getResponse(BuilderFactory.STRING_ZSET);
  }

  @Override
  public Response> zrevrangeByLex(final byte[] key, final byte[] max, final byte[] min) {
    getClient(key).zrevrangeByLex(key, max, min);
    return getResponse(BuilderFactory.BYTE_ARRAY_ZSET);
  }

  @Override
  public Response> zrevrangeByLex(final String key, final String max, final String min) {
    getClient(key).zrevrangeByLex(key, max, min);
    return getResponse(BuilderFactory.STRING_ZSET);
  }

  @Override
  public Response> zrevrangeByLex(final byte[] key, final byte[] max, final byte[] min,
      final int offset, final int count) {
    getClient(key).zrevrangeByLex(key, max, min, offset, count);
    return getResponse(BuilderFactory.BYTE_ARRAY_ZSET);
  }

  @Override
  public Response> zrevrangeByLex(final String key, final String max, final String min,
      final int offset, final int count) {
    getClient(key).zrevrangeByLex(key, max, min, offset, count);
    return getResponse(BuilderFactory.STRING_ZSET);
  }

  @Override
  public Response zremrangeByLex(final byte[] key, final byte[] min, final byte[] max) {
    getClient(key).zremrangeByLex(key, min, max);
    return getResponse(BuilderFactory.LONG);
  }

  @Override
  public Response zremrangeByLex(final String key, final String min, final String max) {
    getClient(key).zremrangeByLex(key, min, max);
    return getResponse(BuilderFactory.LONG);
  }

  @Override
  public Response bitcount(final String key) {
    getClient(key).bitcount(key);
    return getResponse(BuilderFactory.LONG);
  }

  @Override
  public Response bitcount(final String key, final long start, final long end) {
    getClient(key).bitcount(key, start, end);
    return getResponse(BuilderFactory.LONG);
  }

  @Override
  public Response bitcount(final byte[] key) {
    getClient(key).bitcount(key);
    return getResponse(BuilderFactory.LONG);
  }

  @Override
  public Response bitcount(final byte[] key, final long start, final long end) {
    getClient(key).bitcount(key, start, end);
    return getResponse(BuilderFactory.LONG);
  }

  @Override
  public Response dump(final String key) {
    getClient(key).dump(key);
    return getResponse(BuilderFactory.BYTE_ARRAY);
  }

  @Override
  public Response dump(final byte[] key) {
    getClient(key).dump(key);
    return getResponse(BuilderFactory.BYTE_ARRAY);
  }

  @Override
  public Response migrate(final String host, final int port, final String key,
      final int destinationDb, final int timeout) {
    getClient(key).migrate(host, port, key, destinationDb, timeout);
    return getResponse(BuilderFactory.STRING);
  }

  @Override
  public Response migrate(final String host, final int port, final byte[] key,
      final int destinationDb, final int timeout) {
    getClient(key).migrate(host, port, key, destinationDb, timeout);
    return getResponse(BuilderFactory.STRING);
  }

  @Override
  public Response objectRefcount(final String key) {
    getClient(key).objectRefcount(key);
    return getResponse(BuilderFactory.LONG);
  }

  @Override
  public Response objectRefcount(final byte[] key) {
    getClient(key).objectRefcount(key);
    return getResponse(BuilderFactory.LONG);
  }

  @Override
  public Response objectEncoding(final String key) {
    getClient(key).objectEncoding(key);
    return getResponse(BuilderFactory.STRING);
  }

  @Override
  public Response objectEncoding(final byte[] key) {
    getClient(key).objectEncoding(key);
    return getResponse(BuilderFactory.BYTE_ARRAY);
  }

  @Override
  public Response objectIdletime(final String key) {
    getClient(key).objectIdletime(key);
    return getResponse(BuilderFactory.LONG);
  }

  @Override
  public Response objectIdletime(final byte[] key) {
    getClient(key).objectIdletime(key);
    return getResponse(BuilderFactory.LONG);
  }

  @Override
  public Response objectFreq(byte[] key) {
    getClient(key).objectFreq(key);
    return getResponse(BuilderFactory.LONG);
  }

  @Override
  public Response objectFreq(String key) {
    getClient(key).objectFreq(key);
    return getResponse(BuilderFactory.LONG);
  }

  @Override
  public Response pexpire(final String key, final long milliseconds) {
    getClient(key).pexpire(key, milliseconds);
    return getResponse(BuilderFactory.LONG);
  }

  @Override
  public Response pexpire(final byte[] key, final long milliseconds) {
    getClient(key).pexpire(key, milliseconds);
    return getResponse(BuilderFactory.LONG);
  }

  @Override
  public Response pexpireAt(final String key, final long millisecondsTimestamp) {
    getClient(key).pexpireAt(key, millisecondsTimestamp);
    return getResponse(BuilderFactory.LONG);
  }

  @Override
  public Response pexpireAt(final byte[] key, final long millisecondsTimestamp) {
    getClient(key).pexpireAt(key, millisecondsTimestamp);
    return getResponse(BuilderFactory.LONG);
  }

  @Override
  public Response pttl(final String key) {
    getClient(key).pttl(key);
    return getResponse(BuilderFactory.LONG);
  }

  @Override
  public Response pttl(final byte[] key) {
    getClient(key).pttl(key);
    return getResponse(BuilderFactory.LONG);
  }

  @Override
  public Response restore(final String key, final long ttl, final byte[] serializedValue) {
    getClient(key).restore(key, ttl, serializedValue);
    return getResponse(BuilderFactory.STRING);
  }

  @Override
  public Response restore(final byte[] key, final long ttl, final byte[] serializedValue) {
    getClient(key).restore(key, ttl, serializedValue);
    return getResponse(BuilderFactory.STRING);
  }

  @Override
  public Response restoreReplace(final String key, final long ttl,
      final byte[] serializedValue) {
    getClient(key).restoreReplace(key, ttl, serializedValue);
    return getResponse(BuilderFactory.STRING);
  }

  @Override
  public Response restoreReplace(final byte[] key, final long ttl,
      final byte[] serializedValue) {
    getClient(key).restoreReplace(key, ttl, serializedValue);
    return getResponse(BuilderFactory.STRING);
  }

  @Override
  public Response restore(final byte[] key, final long ttl, final byte[] serializedValue,
      final RestoreParams params) {
    getClient(key).restore(key, ttl, serializedValue, params);
    return getResponse(BuilderFactory.STRING);
  }

  @Override
  public Response restore(final String key, final long ttl, final byte[] serializedValue,
      final RestoreParams params) {
    getClient(key).restore(key, ttl, serializedValue, params);
    return getResponse(BuilderFactory.STRING);
  }

  @Override
  public Response incrByFloat(final String key, final double increment) {
    getClient(key).incrByFloat(key, increment);
    return getResponse(BuilderFactory.DOUBLE);
  }

  @Override
  public Response incrByFloat(final byte[] key, final double increment) {
    getClient(key).incrByFloat(key, increment);
    return getResponse(BuilderFactory.DOUBLE);
  }

  @Override
  public Response psetex(final String key, final long milliseconds, final String value) {
    getClient(key).psetex(key, milliseconds, value);
    return getResponse(BuilderFactory.STRING);
  }

  @Override
  public Response psetex(final byte[] key, final long milliseconds, final byte[] value) {
    getClient(key).psetex(key, milliseconds, value);
    return getResponse(BuilderFactory.STRING);
  }

  @Override
  public Response hincrByFloat(final String key, final String field, final double increment) {
    getClient(key).hincrByFloat(key, field, increment);
    return getResponse(BuilderFactory.DOUBLE);
  }

  @Override
  public Response hincrByFloat(final byte[] key, final byte[] field, final double increment) {
    getClient(key).hincrByFloat(key, field, increment);
    return getResponse(BuilderFactory.DOUBLE);
  }

  @Override
  public Response pfadd(final byte[] key, final byte[]... elements) {
    getClient(key).pfadd(key, elements);
    return getResponse(BuilderFactory.LONG);
  }

  @Override
  public Response pfcount(final byte[] key) {
    getClient(key).pfcount(key);
    return getResponse(BuilderFactory.LONG);
  }

  @Override
  public Response pfadd(final String key, final String... elements) {
    getClient(key).pfadd(key, elements);
    return getResponse(BuilderFactory.LONG);
  }

  @Override
  public Response pfcount(final String key) {
    getClient(key).pfcount(key);
    return getResponse(BuilderFactory.LONG);
  }

  @Override
  public Response geoadd(final byte[] key, final double longitude, final double latitude,
      final byte[] member) {
    getClient(key).geoadd(key, longitude, latitude, member);
    return getResponse(BuilderFactory.LONG);
  }

  @Override
  public Response geoadd(final byte[] key,
      final Map memberCoordinateMap) {
    getClient(key).geoadd(key, memberCoordinateMap);
    return getResponse(BuilderFactory.LONG);
  }

  @Override
  public Response geoadd(final String key, final double longitude, final double latitude,
      final String member) {
    getClient(key).geoadd(key, longitude, latitude, member);
    return getResponse(BuilderFactory.LONG);
  }

  @Override
  public Response geoadd(final String key,
      final Map memberCoordinateMap) {
    getClient(key).geoadd(key, memberCoordinateMap);
    return getResponse(BuilderFactory.LONG);
  }

  @Override
  public Response geoadd(String key, GeoAddParams params, Map memberCoordinateMap) {
    getClient(key).geoadd(key, params, memberCoordinateMap);
    return getResponse(BuilderFactory.LONG);
  }

  @Override
  public Response geoadd(byte[] key, GeoAddParams params, Map memberCoordinateMap) {
    getClient(key).geoadd(key, params, memberCoordinateMap);
    return getResponse(BuilderFactory.LONG);
  }

  @Override
  public Response geodist(final byte[] key, final byte[] member1, final byte[] member2) {
    getClient(key).geodist(key, member1, member2);
    return getResponse(BuilderFactory.DOUBLE);
  }

  @Override
  public Response geodist(final byte[] key, final byte[] member1, final byte[] member2,
      final GeoUnit unit) {
    getClient(key).geodist(key, member1, member2, unit);
    return getResponse(BuilderFactory.DOUBLE);
  }

  @Override
  public Response geodist(final String key, final String member1, final String member2) {
    getClient(key).geodist(key, member1, member2);
    return getResponse(BuilderFactory.DOUBLE);
  }

  @Override
  public Response geodist(final String key, final String member1, final String member2,
      final GeoUnit unit) {
    getClient(key).geodist(key, member1, member2);
    return getResponse(BuilderFactory.DOUBLE);
  }

  @Override
  public Response> geohash(final byte[] key, final byte[]... members) {
    getClient(key).geohash(key, members);
    return getResponse(BuilderFactory.BYTE_ARRAY_LIST);
  }

  @Override
  public Response> geohash(final String key, final String... members) {
    getClient(key).geohash(key, members);
    return getResponse(BuilderFactory.STRING_LIST);
  }

  @Override
  public Response> geopos(final byte[] key, final byte[]... members) {
    getClient(key).geopos(key, members);
    return getResponse(BuilderFactory.GEO_COORDINATE_LIST);
  }

  @Override
  public Response> geopos(final String key, final String... members) {
    getClient(key).geopos(key, members);
    return getResponse(BuilderFactory.GEO_COORDINATE_LIST);
  }

  @Override
  public Response> georadius(final byte[] key, final double longitude,
      final double latitude, final double radius, final GeoUnit unit) {
    getClient(key).georadius(key, longitude, latitude, radius, unit);
    return getResponse(BuilderFactory.GEORADIUS_WITH_PARAMS_RESULT);
  }

  @Override
  public Response> georadiusReadonly(final byte[] key,
      final double longitude, final double latitude, final double radius, final GeoUnit unit) {
    getClient(key).georadiusReadonly(key, longitude, latitude, radius, unit);
    return getResponse(BuilderFactory.GEORADIUS_WITH_PARAMS_RESULT);
  }

  @Override
  public Response> georadius(final byte[] key, final double longitude,
      final double latitude, final double radius, final GeoUnit unit, final GeoRadiusParam param) {
    getClient(key).georadius(key, longitude, latitude, radius, unit, param);
    return getResponse(BuilderFactory.GEORADIUS_WITH_PARAMS_RESULT);
  }

  @Override
  public Response> georadiusReadonly(final byte[] key,
      final double longitude, final double latitude, final double radius, final GeoUnit unit,
      final GeoRadiusParam param) {
    getClient(key).georadiusReadonly(key, longitude, latitude, radius, unit, param);
    return getResponse(BuilderFactory.GEORADIUS_WITH_PARAMS_RESULT);
  }

  @Override
  public Response> georadius(final String key, final double longitude,
      final double latitude, final double radius, final GeoUnit unit) {
    getClient(key).georadius(key, longitude, latitude, radius, unit);
    return getResponse(BuilderFactory.GEORADIUS_WITH_PARAMS_RESULT);
  }

  @Override
  public Response> georadiusReadonly(final String key,
      final double longitude, final double latitude, final double radius, final GeoUnit unit) {
    getClient(key).georadiusReadonly(key, longitude, latitude, radius, unit);
    return getResponse(BuilderFactory.GEORADIUS_WITH_PARAMS_RESULT);
  }

  @Override
  public Response> georadius(final String key, final double longitude,
      final double latitude, final double radius, final GeoUnit unit, final GeoRadiusParam param) {
    getClient(key).georadius(key, longitude, latitude, radius, unit, param);
    return getResponse(BuilderFactory.GEORADIUS_WITH_PARAMS_RESULT);
  }

  @Override
  public Response> georadiusReadonly(final String key,
      final double longitude, final double latitude, final double radius, final GeoUnit unit,
      final GeoRadiusParam param) {
    getClient(key).georadiusReadonly(key, longitude, latitude, radius, unit, param);
    return getResponse(BuilderFactory.GEORADIUS_WITH_PARAMS_RESULT);
  }

  @Override
  public Response> georadiusByMember(final byte[] key, final byte[] member,
      final double radius, final GeoUnit unit) {
    getClient(key).georadiusByMember(key, member, radius, unit);
    return getResponse(BuilderFactory.GEORADIUS_WITH_PARAMS_RESULT);
  }

  @Override
  public Response> georadiusByMemberReadonly(final byte[] key,
      final byte[] member, final double radius, final GeoUnit unit) {
    getClient(key).georadiusByMemberReadonly(key, member, radius, unit);
    return getResponse(BuilderFactory.GEORADIUS_WITH_PARAMS_RESULT);
  }

  @Override
  public Response> georadiusByMember(final byte[] key, final byte[] member,
      final double radius, final GeoUnit unit, final GeoRadiusParam param) {
    getClient(key).georadiusByMember(key, member, radius, unit, param);
    return getResponse(BuilderFactory.GEORADIUS_WITH_PARAMS_RESULT);
  }

  @Override
  public Response> georadiusByMemberReadonly(final byte[] key,
      final byte[] member, final double radius, final GeoUnit unit, final GeoRadiusParam param) {
    getClient(key).georadiusByMemberReadonly(key, member, radius, unit, param);
    return getResponse(BuilderFactory.GEORADIUS_WITH_PARAMS_RESULT);
  }

  @Override
  public Response> georadiusByMember(final String key, final String member,
      final double radius, final GeoUnit unit) {
    getClient(key).georadiusByMember(key, member, radius, unit);
    return getResponse(BuilderFactory.GEORADIUS_WITH_PARAMS_RESULT);
  }

  @Override
  public Response> georadiusByMemberReadonly(final String key,
      final String member, final double radius, final GeoUnit unit) {
    getClient(key).georadiusByMemberReadonly(key, member, radius, unit);
    return getResponse(BuilderFactory.GEORADIUS_WITH_PARAMS_RESULT);
  }

  @Override
  public Response> georadiusByMember(final String key, final String member,
      final double radius, final GeoUnit unit, final GeoRadiusParam param) {
    getClient(key).georadiusByMember(key, member, radius, unit, param);
    return getResponse(BuilderFactory.GEORADIUS_WITH_PARAMS_RESULT);
  }

  @Override
  public Response> georadiusByMemberReadonly(final String key,
      final String member, final double radius, final GeoUnit unit, final GeoRadiusParam param) {
    getClient(key).georadiusByMemberReadonly(key, member, radius, unit, param);
    return getResponse(BuilderFactory.GEORADIUS_WITH_PARAMS_RESULT);
  }

  @Override
  public Response> bitfield(final String key, final String... elements) {
    getClient(key).bitfield(key, elements);
    return getResponse(BuilderFactory.LONG_LIST);
  }

  @Override
  public Response> bitfield(final byte[] key, final byte[]... elements) {
    getClient(key).bitfield(key, elements);
    return getResponse(BuilderFactory.LONG_LIST);
  }

  @Override
  public Response> bitfieldReadonly(byte[] key, final byte[]... arguments) {
    getClient(key).bitfieldReadonly(key, arguments);
    return getResponse(BuilderFactory.LONG_LIST);
  }

  @Override
  public Response> bitfieldReadonly(String key, final String... arguments) {
    getClient(key).bitfieldReadonly(key, arguments);
    return getResponse(BuilderFactory.LONG_LIST);
  }

  @Override
  public Response hstrlen(final String key, final String field) {
    getClient(key).hstrlen(key, field);
    return getResponse(BuilderFactory.LONG);
  }

  @Override
  public Response hstrlen(final byte[] key, final byte[] field) {
    getClient(key).hstrlen(key, field);
    return getResponse(BuilderFactory.LONG);
  }

  @Override
  public Response xadd(String key, StreamEntryID id, Map hash) {
    return xadd(key, id, hash, Long.MAX_VALUE, true);
  }

  @Override
  public Response xadd(byte[] key, byte[] id, Map hash) {
    return xadd(key, id, hash, Long.MAX_VALUE, true);
  }

  @Override
  public Response xadd(String key, StreamEntryID id, Map hash,
      long maxLen, boolean approximateLength) {
    getClient(key).xadd(key, id, hash, maxLen, approximateLength);
    return getResponse(BuilderFactory.STREAM_ENTRY_ID);
  }

  @Override
  public Response xadd(byte[] key, byte[] id, Map hash, long maxLen,
      boolean approximateLength) {
    getClient(key).xadd(key, id, hash, maxLen, approximateLength);
    return getResponse(BuilderFactory.BYTE_ARRAY);
  }

  @Override
  public Response xadd(final byte[] key, final Map hash, final XAddParams params) {
    getClient(key).xadd(key, hash, params);
    return getResponse(BuilderFactory.BYTE_ARRAY);
  }

  @Override
  public Response xadd(final String key, final Map hash, final XAddParams params) {
    getClient(key).xadd(key, hash, params);
    return getResponse(BuilderFactory.STREAM_ENTRY_ID);
  }

  @Override
  public Response xlen(String key) {
    getClient(key).xlen(key);
    return getResponse(BuilderFactory.LONG);
  }

  @Override
  public Response xlen(byte[] key) {
    getClient(key).xlen(key);
    return getResponse(BuilderFactory.LONG);
  }

  @Override
  public Response> xrange(String key, StreamEntryID start, StreamEntryID end) {
    getClient(key).xrange(key, start, end);
    return getResponse(BuilderFactory.STREAM_ENTRY_LIST);
  }

  @Override
  public Response> xrange(byte[] key, byte[] start, byte[] end) {
    getClient(key).xrange(key, start, end);
    return getResponse(BuilderFactory.BYTE_ARRAY_LIST);
  }

  @Override
  public Response> xrange(String key, StreamEntryID start, StreamEntryID end,
      int count) {
    getClient(key).xrange(key, start, end, count);
    return getResponse(BuilderFactory.STREAM_ENTRY_LIST);
  }

  @Override
  public Response> xrange(byte[] key, byte[] start, byte[] end, int count) {
    getClient(key).xrange(key, start, end, count);
    return getResponse(BuilderFactory.BYTE_ARRAY_LIST);
  }

  @Override
  public Response> xrevrange(String key, StreamEntryID end, StreamEntryID start) {
    getClient(key).xrevrange(key, end, start);
    return getResponse(BuilderFactory.STREAM_ENTRY_LIST);
  }

  @Override
  public Response> xrevrange(byte[] key, byte[] end, byte[] start) {
    getClient(key).xrevrange(key, end, start);
    return getResponse(BuilderFactory.BYTE_ARRAY_LIST);
  }

  @Override
  public Response> xrevrange(String key, StreamEntryID end, StreamEntryID start,
      int count) {
    getClient(key).xrevrange(key, end, start, count);
    return getResponse(BuilderFactory.STREAM_ENTRY_LIST);
  }

  @Override
  public Response> xrevrange(byte[] key, byte[] end, byte[] start, int count) {
    getClient(key).xrevrange(key, end, start, count);
    return getResponse(BuilderFactory.BYTE_ARRAY_LIST);
  }

  @Override
  public Response xack(String key, String group, StreamEntryID... ids) {
    getClient(key).xack(key, group, ids);
    return getResponse(BuilderFactory.LONG);
  }

  @Override
  public Response xack(byte[] key, byte[] group, byte[]... ids) {
    getClient(key).xack(key, group, ids);
    return getResponse(BuilderFactory.LONG);
  }

  @Override
  public Response xgroupCreate(String key, String groupname, StreamEntryID id,
      boolean makeStream) {
    getClient(key).xgroupCreate(key, groupname, id, makeStream);
    return getResponse(BuilderFactory.STRING);
  }

  @Override
  public Response xgroupCreate(byte[] key, byte[] groupname, byte[] id, boolean makeStream) {
    getClient(key).xgroupCreate(key, groupname, id, makeStream);
    return getResponse(BuilderFactory.STRING);
  }

  @Override
  public Response xgroupSetID(String key, String groupname, StreamEntryID id) {
    getClient(key).xgroupSetID(key, groupname, id);
    return getResponse(BuilderFactory.STRING);
  }

  @Override
  public Response xgroupSetID(byte[] key, byte[] groupname, byte[] id) {
    getClient(key).xgroupSetID(key, groupname, id);
    return getResponse(BuilderFactory.STRING);
  }

  @Override
  public Response xgroupDestroy(String key, String groupname) {
    getClient(key).xgroupDestroy(key, groupname);
    return getResponse(BuilderFactory.LONG);
  }

  @Override
  public Response xgroupDestroy(byte[] key, byte[] groupname) {
    getClient(key).xgroupDestroy(key, groupname);
    return getResponse(BuilderFactory.LONG);
  }

  @Override
  public Response xgroupDelConsumer(String key, String groupname, String consumername) {
    getClient(key).xgroupDelConsumer(key, groupname, consumername);
    return getResponse(BuilderFactory.LONG);
  }

  @Override
  public Response xgroupDelConsumer(byte[] key, byte[] groupname, byte[] consumername) {
    getClient(key).xgroupDelConsumer(key, groupname, consumername);
    return getResponse(BuilderFactory.LONG);
  }

  @Override
  public Response xpending(String key, String groupname) {
    getClient(key).xpending(key, groupname);
    return getResponse(BuilderFactory.STREAM_PENDING_SUMMARY);
  }

  @Override
  public Response xpending(byte[] key, byte[] groupname) {
    getClient(key).xpending(key, groupname);
    return getResponse(BuilderFactory.RAW_OBJECT);
  }

  @Override
  public Response> xpending(String key, String groupname,
      StreamEntryID start, StreamEntryID end, int count, String consumername) {
    getClient(key).xpending(key, groupname, start, end, count, consumername);
    return getResponse(BuilderFactory.STREAM_PENDING_ENTRY_LIST);
  }

  @Override
  public Response> xpending(byte[] key, byte[] groupname, byte[] start,
      byte[] end, int count, byte[] consumername) {
    getClient(key).xpending(key, groupname, start, end, count, consumername);
    return getResponse(BuilderFactory.STREAM_PENDING_ENTRY_LIST);
  }

  @Override
  public Response> xpendingBinary(byte[] key, byte[] groupname, byte[] start,
      byte[] end, int count, byte[] consumername) {
    getClient(key).xpending(key, groupname, start, end, count, consumername);
    return getResponse(BuilderFactory.RAW_OBJECT_LIST);
  }

  @Override
  public Response> xpending(byte[] key, byte[] groupname, XPendingParams params) {
    getClient(key).xpending(key, groupname, params);
    return getResponse(BuilderFactory.RAW_OBJECT_LIST);
  }

  @Override
  public Response> xpending(String key, String groupname, XPendingParams params) {
    getClient(key).xpending(key, groupname, params);
    return getResponse(BuilderFactory.STREAM_PENDING_ENTRY_LIST);
  }

  @Override
  public Response xdel(String key, StreamEntryID... ids) {
    getClient(key).xdel(key, ids);
    return getResponse(BuilderFactory.LONG);
  }

  @Override
  public Response xdel(byte[] key, byte[]... ids) {
    getClient(key).xdel(key, ids);
    return getResponse(BuilderFactory.LONG);
  }

  @Override
  public Response xtrim(String key, long maxLen, boolean approximateLength) {
    getClient(key).xtrim(key, maxLen, approximateLength);
    return getResponse(BuilderFactory.LONG);
  }

  @Override
  public Response xtrim(byte[] key, long maxLen, boolean approximateLength) {
    getClient(key).xtrim(key, maxLen, approximateLength);
    return getResponse(BuilderFactory.LONG);
  }

  @Override
  public Response xtrim(byte[] key, XTrimParams params) {
    getClient(key).xtrim(key, params);
    return getResponse(BuilderFactory.LONG);
  }

  @Override
  public Response xtrim(String key, XTrimParams params) {
    getClient(key).xtrim(key, params);
    return getResponse(BuilderFactory.LONG);
  }

  @Override
  public Response> xclaim(String key, String group, String consumername,
      long minIdleTime, long newIdleTime, int retries, boolean force, StreamEntryID... ids) {
    getClient(key).xclaim(key, group, consumername, minIdleTime, newIdleTime, retries, force, ids);
    return getResponse(BuilderFactory.STREAM_ENTRY_LIST);
  }

  @Override
  public Response> xclaim(byte[] key, byte[] group, byte[] consumername,
      long minIdleTime, long newIdleTime, int retries, boolean force, byte[]... ids) {
    getClient(key).xclaim(key, group, consumername, minIdleTime, newIdleTime, retries, force, ids);
    return getResponse(BuilderFactory.BYTE_ARRAY_LIST);
  }

  @Override
  public Response> xclaim(String key, String group, String consumername,
      long minIdleTime, XClaimParams params, StreamEntryID... ids) {
    getClient(key).xclaim(key, group, consumername, minIdleTime, params, ids);
    return getResponse(BuilderFactory.STREAM_ENTRY_LIST);
  }

  @Override
  public Response> xclaim(byte[] key, byte[] group, byte[] consumername,
      long minIdleTime, XClaimParams params, byte[]... ids) {
    getClient(key).xclaim(key, group, consumername, minIdleTime, params, ids);
    return getResponse(BuilderFactory.BYTE_ARRAY_LIST);
  }

  @Override
  public Response> xclaimJustId(String key, String group, String consumername,
      long minIdleTime, XClaimParams params, StreamEntryID... ids) {
    getClient(key).xclaimJustId(key, group, consumername, minIdleTime, params, ids);
    return getResponse(BuilderFactory.STREAM_ENTRY_ID_LIST);
  }

  @Override
  public Response> xclaimJustId(byte[] key, byte[] group, byte[] consumername,
      long minIdleTime, XClaimParams params, byte[]... ids) {
    getClient(key).xclaimJustId(key, group, consumername, minIdleTime, params, ids);
    return getResponse(BuilderFactory.BYTE_ARRAY_LIST);
  }

  @Override
  public Response>> xautoclaim(String key, String group, String consumerName,
      long minIdleTime, StreamEntryID start, XAutoClaimParams params) {
    getClient(key).xautoclaim(key, group, consumerName, minIdleTime, start, params);
    return getResponse(BuilderFactory.STREAM_AUTO_CLAIM_RESPONSE);
  }

  @Override
  public Response> xautoclaim(byte[] key, byte[] group, byte[] consumerName,
      long minIdleTime, byte[] start, XAutoClaimParams params) {
    getClient(key).xautoclaim(key, group, consumerName, minIdleTime, start, params);
    return getResponse(BuilderFactory.RAW_OBJECT_LIST);
  }

  @Override
  public Response>> xautoclaimJustId(String key, String group, String consumerName,
      long minIdleTime, StreamEntryID start, XAutoClaimParams params) {
    getClient(key).xautoclaimJustId(key, group, consumerName, minIdleTime, start, params);
    return getResponse(BuilderFactory.STREAM_AUTO_CLAIM_ID_RESPONSE);
  }

  @Override
  public Response> xautoclaimJustId(byte[] key, byte[] group, byte[] consumerName,
      long minIdleTime, byte[] start, XAutoClaimParams params) {
    getClient(key).xautoclaimJustId(key, group, consumerName, minIdleTime, start, params);
    return getResponse(BuilderFactory.RAW_OBJECT_LIST);
  }

  public Response sendCommand(final String sampleKey, final ProtocolCommand cmd,
      final String... args) {
    getClient(sampleKey).sendCommand(cmd, args);
    return getResponse(BuilderFactory.RAW_OBJECT);
  }

  public Response sendCommand(final byte[] sampleKey, final ProtocolCommand cmd,
      final byte[]... args) {
    getClient(sampleKey).sendCommand(cmd, args);
    return getResponse(BuilderFactory.RAW_OBJECT);
  }

  @Override
  public Response strAlgoLCSStrings(final String strA, final String strB,
      final StrAlgoLCSParams params) {
    getClient("").strAlgoLCSStrings(strA, strB, params);
    return getResponse(BuilderFactory.STR_ALGO_LCS_RESULT_BUILDER);
  }

  @Override
  public Response strAlgoLCSStrings(final byte[] strA, final byte[] strB,
      final StrAlgoLCSParams params) {
    getClient("").strAlgoLCSStrings(strA, strB, params);
    return getResponse(BuilderFactory.STR_ALGO_LCS_RESULT_BUILDER);
  }
}
 















© 2015 - 2024 Weber Informatics LLC | Privacy Policy