Implementation of Pipeline for EmbeddedRedis

EmbeddedPipeline.groovy

import com.lordofthejars.nosqlunit.redis.embedded.EmbeddedJedis
import redis.clients.jedis.BinaryClient
import redis.clients.jedis.Builder
import redis.clients.jedis.BuilderFactory
import redis.clients.jedis.Pipeline
import redis.clients.jedis.Response
import redis.clients.jedis.SortingParams
import redis.clients.jedis.Tuple
import redis.clients.jedis.ZParams
import redis.clients.jedis.exceptions.JedisDataException

@SuppressWarnings(['MethodCount', 'ClassSize'])
class EmbeddedPipeline extends Pipeline {

    EmbeddedJedis jedis
    private MultiResponseBuilder currentMulti
    
    EmbeddedPipeline(EmbeddedJedis jedis) {
        this.jedis = jedis
    }

    @Override
    Response<Long> append(String key, String value) {
        def response = getResponse(BuilderFactory.LONG)
        response.set(jedis.append(key, value))
        return response
    }

    @Override
    Response<Long> append(byte[] key, byte[] value) {
        def response = getResponse(BuilderFactory.LONG)
        response.set(jedis.append(key, value))
        return response
    }

    @Override
    Response<List<String>> blpop(String... args) {
        throw new UnsupportedOperationException()
    }

    @Override
    Response<List<String>> blpop(byte[] ... args) {
        throw new UnsupportedOperationException()
    }

    @Override
    Response<List<String>> brpop(String... args) {
        throw new UnsupportedOperationException()
    }

    @Override
    Response<List<String>> brpop(byte[] ... args) {
        throw new UnsupportedOperationException()
    }

    @Override
    Response<Long> decr(String key) {
        def response = getResponse(BuilderFactory.LONG)
        response.set(jedis.decr(key))
        return response
    }

    @Override
    Response<Long> decr(byte[] key) {
        def response = getResponse(BuilderFactory.LONG)
        response.set(jedis.decr(key))
        return response
    }

    @Override
    Response<Long> decrBy(String key, long integer) {
        def response = getResponse(BuilderFactory.LONG)
        response.set(jedis.decrBy(key, integer))
        return response
    }

    @Override
    Response<Long> decrBy(byte[] key, long integer) {
        def response = getResponse(BuilderFactory.LONG)
        response.set(jedis.decrBy(key, integer))
        return response
    }

    @Override
    Response<Long> del(String... keys) {
        def response = getResponse(BuilderFactory.LONG)
        response.set(jedis.del(keys))
        return response
    }

    @Override
    Response<Long> del(byte[] ... keys) {
        def response = getResponse(BuilderFactory.LONG)
        response.set(jedis.del(keys))
        return response
    }

    @Override
    Response<String> echo(String string) {
        def response = getResponse(BuilderFactory.STRING)
        response.set(jedis.echo(string))
        return response
    }

    @Override
    Response<String> echo(byte[] string) {
        def response = getResponse(BuilderFactory.STRING)
        response.set(jedis.echo(string))
        return response
    }

    @Override
    Response<Boolean> exists(String key) {
        def response = getResponse(BuilderFactory.BOOLEAN)
        response.set(jedis.exists(string))
        return response
    }

    @Override
    Response<Boolean> exists(byte[] key) {
        def response = getResponse(BuilderFactory.BOOLEAN)
        response.set(jedis.exists(string))
        return response
    }

    @Override
    Response<Long> expire(String key, int seconds) {
        def response = getResponse(BuilderFactory.LONG)
        response.set(jedis.expire(key, seconds))
        return response
    }

    @Override
    Response<Long> expire(byte[] key, int seconds) {
        def response = getResponse(BuilderFactory.LONG)
        response.set(jedis.expire(key, seconds))
        return response
    }

    @Override
    Response<Long> expireAt(String key, long unixTime) {
        def response = getResponse(BuilderFactory.LONG)
        response.set(jedis.expireAt(key, unixTime))
        return response
    }

    @Override
    Response<Long> expireAt(byte[] key, long unixTime) {
        def response = getResponse(BuilderFactory.LONG)
        response.set(jedis.expireAt(key, unixTime))
        return response
    }

    @Override
    Response<String> get(String key) {
        def response = getResponse(BuilderFactory.STRING)
        response.set(jedis.get(key))
        return response
    }

    @Override
    Response<byte[]> get(byte[] key) {
        def response = getResponse(BuilderFactory.BYTE_ARRAY)
        response.set(jedis.get(key))
        return response
    }

    @Override
    Response<Boolean> getbit(String key, long offset) {
        def response = getResponse(BuilderFactory.BOOLEAN)
        response.set(jedis.getbit(key, offset))
        return response
    }

    @Override
    Response<String> getrange(String key, long startOffset, long endOffset) {
        def response = getResponse(BuilderFactory.STRING)
        response.set(jedis.getrange(key, startOffset, endOffset))
        return response
    }

    @Override
    Response<String> getSet(String key, String value) {
        def response = getResponse(BuilderFactory.STRING)
        response.set(jedis.getSet(key, value))
        return response
    }

    @Override
    Response<byte[]> getSet(byte[] key, byte[] value) {
        def response = getResponse(BuilderFactory.BYTE_ARRAY)
        response.set(jedis.getSet(key, value))
        return response
    }

    @Override
    Response<Long> hdel(String key, String field) {
        def response = getResponse(BuilderFactory.LONG)
        response.set(jedis.hdel(key, field))
        return response
    }

    @Override
    Response<Long> hdel(byte[] key, byte[] field) {
        def response = getResponse(BuilderFactory.LONG)
        response.set(jedis.hdel(key, field))
        return response
    }

    @Override
    Response<Boolean> hexists(String key, String field) {
        def response = getResponse(BuilderFactory.BOOLEAN)
        response.set(jedis.hexists(key, field))
        return response
    }

    @Override
    Response<Boolean> hexists(byte[] key, byte[] field) {
        def response = getResponse(BuilderFactory.BOOLEAN)
        response.set(jedis.hexists(key, field))
        return response
    }

    @Override
    Response<String> hget(String key, String field) {
        def response = getResponse(BuilderFactory.STRING)
        response.set(jedis.hget(key, field))
        return response
    }

    @Override
    Response<String> hget(byte[] key, byte[] field) {
        def response = getResponse(BuilderFactory.STRING)
        response.set(jedis.hget(key, field))
        return response
    }

    @Override
    Response<Map<String, String>> hgetAll(String key) {
        def response = getResponse(BuilderFactory.STRING_MAP)
        response.set(jedis.hgetAll(key))
        return response
    }

    @Override
    Response<Map<String, String>> hgetAll(byte[] key) {
        def response = getResponse(BuilderFactory.STRING_MAP)
        response.set(jedis.hgetAll(key))
        return response
    }

    @Override
    Response<Long> hincrBy(String key, String field, long value) {
        def response = getResponse(BuilderFactory.LONG)
        response.set(jedis.hincrBy(key, field, value))
        return response
    }

    @Override
    Response<Long> hincrBy(byte[] key, byte[] field, long value) {
        def response = getResponse(BuilderFactory.LONG)
        response.set(jedis.hincrBy(key, field, value))
        return response
    }

    @Override
    Response<Set<String>> hkeys(String key) {
        def response = getResponse(BuilderFactory.STRING_SET)
        response.set(jedis.hkeys(key))
        return response
    }

    @Override
    Response<Set<String>> hkeys(byte[] key) {
        def response = getResponse(BuilderFactory.STRING_SET)
        response.set(jedis.hkeys(key))
        return response
    }

    @Override
    Response<Long> hlen(String key) {
        def response = getResponse(BuilderFactory.LONG)
        response.set(jedis.hlen(key))
        return response
    }

    @Override
    Response<Long> hlen(byte[] key) {
        def response = getResponse(BuilderFactory.LONG)
        response.set(jedis.hlen(key))
        return response
    }

    @Override
    Response<List<String>> hmget(String key, String... fields) {
        def response = getResponse(BuilderFactory.STRING_LIST)
        response.set(jedis.hmget(key, fields))
        return response
    }

    @Override
    Response<List<String>> hmget(byte[] key, byte[] ... fields) {
        def response = getResponse(BuilderFactory.STRING_LIST)
        response.set(jedis.hmget(key, fields))
        return response
    }

    @Override
    Response<String> hmset(String key, Map<String, String> hash) {
        def response = getResponse(BuilderFactory.STRING)
        response.set(jedis.hmset(key, hash))
        return response
    }

    @Override
    Response<String> hmset(byte[] key, Map<byte[], byte[]> hash) {
        def response = getResponse(BuilderFactory.STRING)
        response.set(jedis.hmset(key, hash))
        return response
    }

    @Override
    Response<Long> hset(String key, String field, String value) {
        def response = getResponse(BuilderFactory.LONG)
        response.set(jedis.hset(key, field, value))
        return response
    }

    @Override
    Response<Long> hset(byte[] key, byte[] field, byte[] value) {
        def response = getResponse(BuilderFactory.LONG)
        response.set(jedis.hset(key, field, value))
        return response
    }

    @Override
    Response<Long> hsetnx(String key, String field, String value) {
        def response = getResponse(BuilderFactory.LONG)
        response.set(jedis.hsetnx(key, field, value))
        return response
    }

    @Override
    Response<Long> hsetnx(byte[] key, byte[] field, byte[] value) {
        def response = getResponse(BuilderFactory.LONG)
        response.set(jedis.hsetnx(key, field, value))
        return response
    }

    @Override
    Response<List<String>> hvals(String key) {
        def response = getResponse(BuilderFactory.STRING_LIST)
        response.set(jedis.hvals(key))
        return response
    }

    @Override
    Response<List<String>> hvals(byte[] key) {
        def response = getResponse(BuilderFactory.STRING_LIST)
        response.set(jedis.hvals(key))
        return response
    }

    @Override
    Response<Long> incr(String key) {
        def response = getResponse(BuilderFactory.LONG)
        response.set(jedis.incr(key))
        return response
    }

    @Override
    Response<Long> incr(byte[] key) {
        def response = getResponse(BuilderFactory.LONG)
        response.set(jedis.incr(key))
        return response
    }

    @Override
    Response<Long> incrBy(String key, long integer) {
        def response = getResponse(BuilderFactory.LONG)
        response.set(jedis.incrBy(key, integer))
        return response
    }

    @Override
    Response<Long> incrBy(byte[] key, long integer) {
        def response = getResponse(BuilderFactory.LONG)
        response.set(jedis.incrBy(key, integer))
        return response
    }

    @Override
    Response<Set<String>> keys(String pattern) {
        def response = getResponse(BuilderFactory.STRING_SET)
        response.set(jedis.keys(pattern))
        return response
    }

    @Override
    Response<Set<String>> keys(byte[] pattern) {
        def response = getResponse(BuilderFactory.STRING_SET)
        response.set(jedis.keys(pattern))
        return response
    }

    @Override
    Response<String> lindex(String key, int index) {
        def response = getResponse(BuilderFactory.STRING)
        response.set(jedis.lindex(key, index))
        return response
    }

    @Override
    Response<String> lindex(byte[] key, int index) {
        def response = getResponse(BuilderFactory.STRING)
        response.set(jedis.lindex(key, index))
        return response
    }

    @Override
    Response<Long> linsert(String key, BinaryClient.LIST_POSITION where, String pivot, String value) {
        def response = getResponse(BuilderFactory.LONG)
        response.set(jedis.linsert(key, where, pivot, value))
        return response
    }

    @Override
    Response<Long> linsert(byte[] key, BinaryClient.LIST_POSITION where, byte[] pivot, byte[] value) {
        def response = getResponse(BuilderFactory.LONG)
        response.set(jedis.linsert(key, where, pivot, value))
        return response
    }

    @Override
    Response<Long> llen(String key) {
        def response = getResponse(BuilderFactory.LONG)
        response.set(jedis.llen(key))
        return response
    }

    @Override
    Response<Long> llen(byte[] key) {
        def response = getResponse(BuilderFactory.LONG)
        response.set(jedis.llen(key))
        return response
    }

    @Override
    Response<String> lpop(String key) {
        def response = getResponse(BuilderFactory.STRING)
        response.set(jedis.lpop(key))
        return response
    }

    @Override
    Response<String> lpop(byte[] key) {
        def response = getResponse(BuilderFactory.STRING)
        response.set(jedis.lpop(key))
        return response
    }

    @Override
    Response<Long> lpush(String key, String string) {
        def response = getResponse(BuilderFactory.LONG)
        response.set(jedis.lpush(key, string))
        return response
    }

    @Override
    Response<Long> lpush(byte[] key, byte[] string) {
        def response = getResponse(BuilderFactory.LONG)
        response.set(jedis.lpush(key, string))
        return response
    }

    @Override
    Response<Long> lpushx(String key, String string) {
        def response = getResponse(BuilderFactory.LONG)
        response.set(jedis.lpushx(key, string))
        return response
    }

    @Override
    Response<Long> lpushx(byte[] key, byte[] bytes) {
        def response = getResponse(BuilderFactory.LONG)
        response.set(jedis.lpushx(key, bytes))
        return response
    }

    @Override
    Response<List<String>> lrange(String key, long start, long end) {
        def response = getResponse(BuilderFactory.STRING_LIST)
        response.set(jedis.lrange(key, start, end))
        return response
    }

    @Override
    Response<List<String>> lrange(byte[] key, long start, long end) {
        def response = getResponse(BuilderFactory.STRING_LIST)
        response.set(jedis.lrange(key, (int) start, (int) end))
        return response
    }

    @Override
    Response<Long> lrem(String key, long count, String value) {
        def response = getResponse(BuilderFactory.LONG)
        response.set(jedis.lrem(key, count, value))
        return response
    }

    @Override
    Response<Long> lrem(byte[] key, long count, byte[] value) {
        def response = getResponse(BuilderFactory.LONG)
        response.set(jedis.lrem(key, (int) count, value))
        return response
    }

    @Override
    Response<String> lset(String key, long index, String value) {
        def response = getResponse(BuilderFactory.STRING)
        response.set(jedis.lset(key, index, value))
        return response
    }

    @Override
    Response<String> lset(byte[] key, long index, byte[] value) {
        def response = getResponse(BuilderFactory.STRING)
        response.set(jedis.lset(key, (int) index, value))
        return response
    }

    @Override
    Response<String> ltrim(String key, long start, long end) {
        def response = getResponse(BuilderFactory.STRING)
        response.set(jedis.ltrim(key, start, end))
        return response
    }

    @Override
    Response<String> ltrim(byte[] key, long start, long end) {
        def response = getResponse(BuilderFactory.STRING)
        response.set(jedis.ltrim(key, (int) start, (int) end))
        return response
    }

    @Override
    Response<List<String>> mget(String... keys) {
        throw new UnsupportedOperationException()
    }

    @Override
    Response<List<String>> mget(byte[] ... keys) {
        throw new UnsupportedOperationException()
    }

    @Override
    Response<Long> move(String key, int dbIndex) {
        throw new UnsupportedOperationException()
    }

    @Override
    Response<Long> move(byte[] key, int dbIndex) {
        def response = getResponse(BuilderFactory.LONG)
        response.set(jedis.move(key, dbIndex))
        return response
    }

    @Override
    Response<String> mset(String... keysvalues) {
        throw new UnsupportedOperationException()
    }

    @Override
    Response<String> mset(byte[] ... keysvalues) {
        throw new UnsupportedOperationException()
    }

    @Override
    Response<Long> msetnx(String... keysvalues) {
        throw new UnsupportedOperationException()
    }

    @Override
    Response<Long> msetnx(byte[] ... keysvalues) {
        throw new UnsupportedOperationException()
    }

    @Override
    Response<Long> persist(String key) {
        def response = getResponse(BuilderFactory.LONG)
        response.set(jedis.persist(key))
        return response
    }

    @Override
    Response<Long> persist(byte[] key) {
        def response = getResponse(BuilderFactory.LONG)
        response.set(jedis.persist(key))
        return response
    }

    @Override
    Response<String> rename(String oldkey, String newkey) {
        def response = getResponse(BuilderFactory.STRING)
        response.set(jedis.rename(oldkey, newkey))
        return response
    }

    @Override
    Response<String> rename(byte[] oldkey, byte[] newkey) {
        def response = getResponse(BuilderFactory.STRING)
        response.set(jedis.rename(oldkey, newkey))
        return response
    }

    @Override
    Response<Long> renamenx(String oldkey, String newkey) {
        def response = getResponse(BuilderFactory.LONG)
        response.set(jedis.renamenx(oldkey, newkey))
        return response
    }

    @Override
    Response<Long> renamenx(byte[] oldkey, byte[] newkey) {
        def response = getResponse(BuilderFactory.LONG)
        response.set(jedis.renamenx(oldkey, newkey))
        return response
    }

    @Override
    Response<String> rpop(String key) {
        def response = getResponse(BuilderFactory.STRING)
        response.set(jedis.rpop(key))
        return response
    }

    @Override
    Response<String> rpop(byte[] key) {
        def response = getResponse(BuilderFactory.STRING)
        response.set(jedis.rpop(key))
        return response
    }

    @Override
    Response<String> rpoplpush(String srckey, String dstkey) {
        throw new UnsupportedOperationException()
    }

    @Override
    Response<String> rpoplpush(byte[] srckey, byte[] dstkey) {
        throw new UnsupportedOperationException()
    }

    @Override
    Response<Long> rpush(String key, String string) {
        def response = getResponse(BuilderFactory.LONG)
        response.set(jedis.rpush(key, string))
        return response
    }

    @Override
    Response<Long> rpush(byte[] key, byte[] string) {
        def response = getResponse(BuilderFactory.LONG)
        response.set(jedis.rpush(key, string))
        return response
    }

    @Override
    Response<Long> rpushx(String key, String string) {
        def response = getResponse(BuilderFactory.LONG)
        response.set(jedis.rpushx(key, string))
        return response
    }

    @Override
    Response<Long> rpushx(byte[] key, byte[] string) {
        def response = getResponse(BuilderFactory.LONG)
        response.set(jedis.rpushx(key, string))
        return response
    }

    @Override
    Response<Long> sadd(String key, String member) {
        def response = getResponse(BuilderFactory.LONG)
        response.set(jedis.sadd(key, member))
        return response
    }

    @Override
    Response<Long> sadd(byte[] key, byte[] member) {
        def response = getResponse(BuilderFactory.LONG)
        response.set(jedis.sadd(key, member))
        return response
    }

    @Override
    Response<Long> scard(String key) {
        def response = getResponse(BuilderFactory.LONG)
        response.set(jedis.scard(key))
        return response
    }

    @Override
    Response<Long> scard(byte[] key) {
        def response = getResponse(BuilderFactory.LONG)
        response.set(jedis.scard(key))
        return response
    }

    @Override
    Response<Set<String>> sdiff(String... keys) {
        throw new UnsupportedOperationException()
    }

    @Override
    Response<Set<String>> sdiff(byte[] ... keys) {
        throw new UnsupportedOperationException()
    }

    @Override
    Response<Long> sdiffstore(String dstkey, String... keys) {
        throw new UnsupportedOperationException()
    }

    @Override
    Response<Long> sdiffstore(byte[] dstkey, byte[] ... keys) {
        throw new UnsupportedOperationException()
    }

    @Override
    Response<String> set(String key, String value) {
        def response = getResponse(BuilderFactory.STRING)
        response.set(jedis.set(key, value))
        return response
    }

    @Override
    Response<String> set(byte[] key, byte[] value) {
        def response = getResponse(BuilderFactory.STRING)
        response.set(jedis.set(key, value))
        return response
    }

    @Override
    Response<Boolean> setbit(String key, long offset, boolean value) {
        def response = getResponse(BuilderFactory.BOOLEAN)
        response.set(jedis.setbit(key, offset, value))
        return response
    }

    @Override
    Response<String> setex(String key, int seconds, String value) {
        def response = getResponse(BuilderFactory.STRING)
        response.set(jedis.setex(key, seconds, value))
        return response
    }

    @Override
    Response<String> setex(byte[] key, int seconds, byte[] value) {
        def response = getResponse(BuilderFactory.STRING)
        response.set(jedis.setex(key, seconds, value))
        return response
    }

    @Override
    Response<Long> setnx(String key, String value) {
        def response = getResponse(BuilderFactory.LONG)
        response.set(jedis.setnx(key, value))
        return response
    }

    @Override
    Response<Long> setnx(byte[] key, byte[] value) {
        def response = getResponse(BuilderFactory.LONG)
        response.set(jedis.setnx(key, value))
        return response
    }

    @Override
    Response<Long> setrange(String key, long offset, String value) {
        def response = getResponse(BuilderFactory.LONG)
        response.set(jedis.setrange(key, offset, value))
        return response
    }

    @Override
    Response<Set<String>> sinter(String... keys) {
        throw new UnsupportedOperationException()
    }

    @Override
    Response<Set<String>> sinter(byte[] ... keys) {
        throw new UnsupportedOperationException()
    }

    @Override
    Response<Long> sinterstore(String dstkey, String... keys) {
        throw new UnsupportedOperationException()
    }

    @Override
    Response<Long> sinterstore(byte[] dstkey, byte[] ... keys) {
        throw new UnsupportedOperationException()
    }

    @Override
    Response<Boolean> sismember(String key, String member) {
        def response = getResponse(BuilderFactory.BOOLEAN)
        response.set(jedis.sismember(key, member))
        return response
    }

    @Override
    Response<Boolean> sismember(byte[] key, byte[] member) {
        def response = getResponse(BuilderFactory.BOOLEAN)
        response.set(jedis.sismember(key, member))
        return response
    }

    @Override
    Response<Set<String>> smembers(String key) {
        def response = getResponse(BuilderFactory.STRING_SET)
        response.set(jedis.smembers(key))
        return response
    }

    @Override
    Response<Set<String>> smembers(byte[] key) {
        def response = getResponse(BuilderFactory.STRING_SET)
        response.set(jedis.smembers(key))
        return response
    }

    @Override
    Response<Long> smove(String srckey, String dstkey, String member) {
        throw new UnsupportedOperationException()
    }

    @Override
    Response<Long> smove(byte[] srckey, byte[] dstkey, byte[] member) {
        throw new UnsupportedOperationException()
    }

    @Override
    Response<Long> sort(String key) {
        def response = getResponse(BuilderFactory.LONG)
        response.set(jedis.sort(key))
        return response
    }

    @Override
    Response<Long> sort(byte[] key) {
        def response = getResponse(BuilderFactory.LONG)
        response.set(jedis.sort(key))
        return response
    }

    @Override
    Response<List<String>> sort(String key, SortingParams sortingParameters) {
        def response = getResponse(BuilderFactory.STRING_LIST)
        response.set(jedis.sort(key, sortingParameters))
        return response
    }

    @Override
    Response<List<String>> sort(byte[] key, SortingParams sortingParameters) {
        def response = getResponse(BuilderFactory.STRING_LIST)
        response.set(jedis.sort(key, sortingParameters))
        return response
    }

    @Override
    Response<List<String>> sort(String key, SortingParams sortingParameters, String dstkey) {
        throw new UnsupportedOperationException()
    }

    @Override
    Response<List<String>> sort(byte[] key, SortingParams sortingParameters, byte[] dstkey) {
        throw new UnsupportedOperationException()
    }

    @Override
    Response<List<String>> sort(String key, String dstkey) {
        throw new UnsupportedOperationException()
    }

    @Override
    Response<List<String>> sort(byte[] key, byte[] dstkey) {
        throw new UnsupportedOperationException()
    }

    @Override
    Response<String> spop(String key) {
        def response = getResponse(BuilderFactory.STRING)
        response.set(jedis.spop(key))
        return response
    }

    @Override
    Response<String> spop(byte[] key) {
        def response = getResponse(BuilderFactory.STRING)
        response.set(jedis.spop(key))
        return response
    }

    @Override
    Response<String> srandmember(String key) {
        def response = getResponse(BuilderFactory.STRING)
        response.set(jedis.srandmember(key))
        return response
    }

    @Override
    Response<String> srandmember(byte[] key) {
        def response = getResponse(BuilderFactory.STRING)
        response.set(jedis.srandmember(key))
        return response
    }

    @Override
    Response<Long> srem(String key, String member) {
        def response = getResponse(BuilderFactory.LONG)
        response.set(jedis.srem(key, member))
        return response
    }

    @Override
    Response<Long> srem(byte[] key, byte[] member) {
        def response = getResponse(BuilderFactory.LONG)
        response.set(jedis.srem(key, member))
        return response
    }

    @Override
    Response<Long> strlen(String key) {
        throw new UnsupportedOperationException()
    }

    @Override
    Response<Long> strlen(byte[] key) {
        throw new UnsupportedOperationException()
    }

    @Override
    Response<String> substr(String key, int start, int end) {
        def response = getResponse(BuilderFactory.STRING)
        response.set(jedis.substr(key, start, end))
        return response
    }

    @Override
    Response<String> substr(byte[] key, int start, int end) {
        def response = getResponse(BuilderFactory.STRING)
        response.set(jedis.substr(key, start, end))
        return response
    }

    @Override
    Response<Set<String>> sunion(String... keys) {
        throw new UnsupportedOperationException()
    }

    @Override
    Response<Set<String>> sunion(byte[] ... keys) {
        throw new UnsupportedOperationException()
    }

    @Override
    Response<Long> sunionstore(String dstkey, String... keys) {
        throw new UnsupportedOperationException()
    }

    @Override
    Response<Long> sunionstore(byte[] dstkey, byte[] ... keys) {
        throw new UnsupportedOperationException()
    }

    @Override
    Response<Long> ttl(String key) {
        def response = getResponse(BuilderFactory.LONG)
        response.set(jedis.ttl(key))
        return response
    }

    @Override
    Response<Long> ttl(byte[] key) {
        def response = getResponse(BuilderFactory.LONG)
        response.set(jedis.ttl(key))
        return response
    }

    @Override
    Response<String> type(String key) {
        def response = getResponse(BuilderFactory.STRING)
        response.set(jedis.type(key))
        return response
    }

    @Override
    Response<String> type(byte[] key) {
        def response = getResponse(BuilderFactory.STRING)
        response.set(jedis.type(key))
        return response
    }

    @Override
    Response<String> watch(String... keys) {
        def response = getResponse(BuilderFactory.STRING)
        response.set(jedis.watch(keys))
        return response
    }

    @Override
    Response<String> watch(byte[] ... keys) {
        def response = getResponse(BuilderFactory.STRING)
        response.set(jedis.watch(keys))
        return response
    }

    @Override
    Response<Long> zadd(String key, double score, String member) {
        def response = getResponse(BuilderFactory.LONG)
        response.set(jedis.zadd(key, score, member))
        return response
    }

    @Override
    Response<Long> zadd(byte[] key, double score, byte[] member) {
        def response = getResponse(BuilderFactory.LONG)
        response.set(jedis.zadd(key, score, member))
        return response
    }

    @Override
    Response<Long> zcard(String key) {
        def response = getResponse(BuilderFactory.LONG)
        response.set(jedis.zcard(key))
        return response
    }

    @Override
    Response<Long> zcard(byte[] key) {
        def response = getResponse(BuilderFactory.LONG)
        response.set(jedis.zcard(key))
        return response
    }

    @Override
    Response<Long> zcount(String key, double min, double max) {
        def response = getResponse(BuilderFactory.LONG)
        response.set(jedis.zcount(key, min, max))
        return response
    }

    @Override
    Response<Long> zcount(byte[] key, double min, double max) {
        def response = getResponse(BuilderFactory.LONG)
        response.set(jedis.zcount(key, min, max))
        return response
    }

    @Override
    Response<Double> zincrby(String key, double score, String member) {
        def response = getResponse(BuilderFactory.DOUBLE)
        response.set(jedis.zincrby(key, score, member))
        return response
    }

    @Override
    Response<Double> zincrby(byte[] key, double score, byte[] member) {
        def response = getResponse(BuilderFactory.DOUBLE)
        response.set(jedis.zincrby(key, score, member))
        return response
    }

    @Override
    Response<Long> zinterstore(String dstkey, String... sets) {
        throw new UnsupportedOperationException()
    }

    @Override
    Response<Long> zinterstore(byte[] dstkey, byte[] ... sets) {
        throw new UnsupportedOperationException()
    }

    @Override
    Response<Long> zinterstore(String dstkey, ZParams params, String... sets) {
        throw new UnsupportedOperationException()
    }

    @Override
    Response<Long> zinterstore(byte[] dstkey, ZParams params, byte[] ... sets) {
        throw new UnsupportedOperationException()
    }

    @Override
    Response<Set<String>> zrange(String key, int start, int end) {
        def response = getResponse(BuilderFactory.STRING_SET)
        response.set(jedis.zrange(key, start, end))
        return response
    }

    @Override
    Response<Set<String>> zrange(byte[] key, int start, int end) {
        def response = getResponse(BuilderFactory.STRING_SET)
        response.set(jedis.zrange(key, start, end))
        return response
    }

    @Override
    Response<Set<String>> zrangeByScore(String key, double min, double max) {
        def response = getResponse(BuilderFactory.STRING_SET)
        response.set(jedis.zrangeByScore(key, min, max))
        return response
    }

    @Override
    Response<Set<String>> zrangeByScore(byte[] key, double min, double max) {
        def response = getResponse(BuilderFactory.STRING_SET)
        response.set(jedis.zrangeByScore(key, min, max))
        return response
    }

    @Override
    Response<Set<String>> zrangeByScore(String key, String min, String max) {
        def response = getResponse(BuilderFactory.STRING_SET)
        response.set(jedis.zrangeByScore(key, min, max))
        return response
    }

    @Override
    Response<Set<String>> zrangeByScore(byte[] key, byte[] min, byte[] max) {
        def response = getResponse(BuilderFactory.STRING_SET)
        response.set(jedis.zrangeByScore(key, min, max))
        return response
    }

    @Override
    Response<Set<String>> zrangeByScore(String key, double min, double max, int offset, int count) {
        def response = getResponse(BuilderFactory.STRING_SET)
        response.set(jedis.zrangeByScore(key, min, max, offset, count))
        return response
    }

    @Override
    Response<Set<String>> zrangeByScore(byte[] key, double min, double max, int offset, int count) {
        def response = getResponse(BuilderFactory.STRING_SET)
        response.set(jedis.zrangeByScore(key, min, max, offset, count))
        return response
    }

    @Override
    Response<Set<String>> zrangeByScore(byte[] key, byte[] min, byte[] max, int offset, int count) {
        def response = getResponse(BuilderFactory.STRING_SET)
        response.set(jedis.zrangeByScore(key, min, max, offset, count))
        return response
    }

    @Override
    Response<Set<Tuple>> zrangeByScoreWithScores(String key, double min, double max) {
        def response = getResponse(BuilderFactory.TUPLE_ZSET)
        response.set(jedis.zrangeByScoreWithScores(key, min, max))
        return response
    }

    @Override
    Response<Set<Tuple>> zrangeByScoreWithScores(byte[] key, double min, double max) {
        def response = getResponse(BuilderFactory.TUPLE_ZSET)
        response.set(jedis.zrangeByScoreWithScores(key, min, max))
        return response
    }

    @Override
    Response<Set<Tuple>> zrangeByScoreWithScores(byte[] key, byte[] min, byte[] max) {
        def response = getResponse(BuilderFactory.TUPLE_ZSET)
        response.set(jedis.zrangeByScoreWithScores(key, min, max))
        return response
    }

    @Override
    Response<Set<Tuple>> zrangeByScoreWithScores(String key, double min, double max, int offset, int count) {
        def response = getResponse(BuilderFactory.TUPLE_ZSET)
        response.set(jedis.zrangeByScoreWithScores(key, min, max, offset, count))
        return response
    }

    @Override
    Response<Set<Tuple>> zrangeByScoreWithScores(byte[] key, double min, double max, int offset, int count) {
        def response = getResponse(BuilderFactory.TUPLE_ZSET)
        response.set(jedis.zrangeByScoreWithScores(key, min, max, offset, count))
        return response
    }

    @Override
    Response<Set<Tuple>> zrangeByScoreWithScores(byte[] key, byte[] min, byte[] max, int offset, int count) {
        def response = getResponse(BuilderFactory.TUPLE_ZSET)
        response.set(jedis.zrangeByScoreWithScores(key, min, max, offset, count))
        return response
    }

    @Override
    Response<Set<String>> zrevrangeByScore(String key, double max, double min) {
        def response = getResponse(BuilderFactory.STRING_SET)
        response.set(jedis.zrevrange(key, (long) max, (long) min))
        return response
    }

    @Override
    Response<Set<String>> zrevrangeByScore(byte[] key, double max, double min) {
        def response = getResponse(BuilderFactory.STRING_SET)
        response.set(jedis.zrevrange(key, (int) max, (int) min))
        return response
    }

    @Override
    Response<Set<String>> zrevrangeByScore(String key, String max, String min) {
        throw new UnsupportedOperationException()
    }

    @Override
    Response<Set<String>> zrevrangeByScore(byte[] key, byte[] max, byte[] min) {
        throw new UnsupportedOperationException()
    }

    @Override
    Response<Set<String>> zrevrangeByScore(String key, double max, double min, int offset, int count) {
        throw new UnsupportedOperationException()
    }

    @Override
    Response<Set<String>> zrevrangeByScore(byte[] key, double max, double min, int offset, int count) {
        throw new UnsupportedOperationException()
    }

    @Override
    Response<Set<String>> zrevrangeByScore(byte[] key, byte[] max, byte[] min, int offset, int count) {
        throw new UnsupportedOperationException()
    }

    @Override
    Response<Set<Tuple>> zrevrangeByScoreWithScores(String key, double max, double min) {
        def response = getResponse(BuilderFactory.TUPLE_ZSET)
        response.set(jedis.zrevrangeByScoreWithScores(key, max, min))
        return response
    }

    @Override
    Response<Set<Tuple>> zrevrangeByScoreWithScores(byte[] key, double max, double min) {
        def response = getResponse(BuilderFactory.TUPLE_ZSET)
        response.set(jedis.zrevrangeByScoreWithScores(key, max, min))
        return response
    }

    @Override
    Response<Set<Tuple>> zrevrangeByScoreWithScores(byte[] key, byte[] max, byte[] min) {
        def response = getResponse(BuilderFactory.TUPLE_ZSET)
        response.set(jedis.zrevrangeByScoreWithScores(key, max, min))
        return response
    }

    @Override
    Response<Set<Tuple>> zrevrangeByScoreWithScores(String key, double max, double min, int offset, int count) {
        def response = getResponse(BuilderFactory.TUPLE_ZSET)
        response.set(jedis.zrevrangeByScoreWithScores(key, max, min, offset, count))
        return response
    }

    @Override
    Response<Set<Tuple>> zrevrangeByScoreWithScores(byte[] key, double max, double min, int offset, int count) {
        def response = getResponse(BuilderFactory.TUPLE_ZSET)
        response.set(jedis.zrevrangeByScoreWithScores(key, max, min, offset, count))
        return response
    }

    @Override
    Response<Set<Tuple>> zrevrangeByScoreWithScores(byte[] key, byte[] max, byte[] min, int offset, int count) {
        def response = getResponse(BuilderFactory.TUPLE_ZSET)
        response.set(jedis.zrevrangeByScoreWithScores(key, max, min, offset, count))
        return response
    }

    @Override
    Response<Set<Tuple>> zrangeWithScores(String key, int start, int end) {
        def response = getResponse(BuilderFactory.TUPLE_ZSET)
        response.set(jedis.zrangeWithScores(key, (long) start, (long) end))
        return response
    }

    @Override
    Response<Set<Tuple>> zrangeWithScores(byte[] key, int start, int end) {
        def response = getResponse(BuilderFactory.TUPLE_ZSET)
        response.set(jedis.zrangeWithScores(key, start, end))
        return response
    }

    @Override
    Response<Long> zrank(String key, String member) {
        def response = getResponse(BuilderFactory.LONG)
        response.set(jedis.zrank(key, member))
        return response
    }

    @Override
    Response<Long> zrank(byte[] key, byte[] member) {
        def response = getResponse(BuilderFactory.LONG)
        response.set(jedis.zrank(key, member))
        return response
    }

    @Override
    Response<Long> zrem(String key, String member) {
        def response = getResponse(BuilderFactory.LONG)
        response.set(jedis.zrem(key, member))
        return response
    }

    @Override
    Response<Long> zrem(byte[] key, byte[] member) {
        def response = getResponse(BuilderFactory.LONG)
        response.set(jedis.zrem(key, member))
        return response
    }

    @Override
    Response<Long> zremrangeByRank(String key, int start, int end) {
        def response = getResponse(BuilderFactory.LONG)
        response.set(jedis.zremrangeByRank(key, start, end))
        return response
    }

    @Override
    Response<Long> zremrangeByRank(byte[] key, int start, int end) {
        def response = getResponse(BuilderFactory.LONG)
        response.set(jedis.zremrangeByRank(key, start, end))
        return response
    }

    @Override
    Response<Long> zremrangeByScore(String key, double start, double end) {
        def response = getResponse(BuilderFactory.LONG)
        response.set(jedis.zremrangeByScore(key, start, end))
        return response
    }

    @Override
    Response<Long> zremrangeByScore(byte[] key, double start, double end) {
        def response = getResponse(BuilderFactory.LONG)
        response.set(jedis.zremrangeByScore(key, start, end))
        return response
    }

    @Override
    Response<Long> zremrangeByScore(byte[] key, byte[] start, byte[] end) {
        def response = getResponse(BuilderFactory.LONG)
        response.set(jedis.zremrangeByScore(key, start, end))
        return response
    }

    @Override
    Response<Set<String>> zrevrange(String key, int start, int end) {
        def response = getResponse(BuilderFactory.STRING_SET)
        response.set(jedis.zrevrange(key, start, end))
        return response
    }

    @Override
    Response<Set<String>> zrevrange(byte[] key, int start, int end) {
        def response = getResponse(BuilderFactory.STRING_SET)
        response.set(jedis.zrevrange(key, start, end))
        return response
    }

    @Override
    Response<Set<Tuple>> zrevrangeWithScores(String key, int start, int end) {
        def response = getResponse(BuilderFactory.TUPLE_ZSET)
        response.set(jedis.zrevrangeWithScores(key, start, end))
        return response
    }

    @Override
    Response<Set<Tuple>> zrevrangeWithScores(byte[] key, int start, int end) {
        def response = getResponse(BuilderFactory.TUPLE_ZSET)
        response.set(jedis.zrevrangeWithScores(key, start, end))
        return response
    }

    @Override
    Response<Long> zrevrank(String key, String member) {
        def response = getResponse(BuilderFactory.LONG)
        response.set(jedis.zrevrank(key, member))
        return response
    }

    @Override
    Response<Long> zrevrank(byte[] key, byte[] member) {
        def response = getResponse(BuilderFactory.LONG)
        response.set(jedis.zrevrank(key, member))
        return response
    }

    @Override
    Response<Double> zscore(String key, String member) {
        def response = getResponse(BuilderFactory.DOUBLE)
        response.set(jedis.zscore(key, member))
        return response
    }

    @Override
    Response<Double> zscore(byte[] key, byte[] member) {
        def response = getResponse(BuilderFactory.DOUBLE)
        response.set(jedis.zscore(key, member))
        return response
    }

    @Override
    Response<Long> zunionstore(String dstkey, String... sets) {
        throw new UnsupportedOperationException()
    }

    @Override
    Response<Long> zunionstore(byte[] dstkey, byte[] ... sets) {
        throw new UnsupportedOperationException()
    }

    @Override
    Response<Long> zunionstore(String dstkey, ZParams params, String... sets) {
        throw new UnsupportedOperationException()
    }

    @Override
    Response<Long> zunionstore(byte[] dstkey, ZParams params, byte[] ... sets) {
        throw new UnsupportedOperationException()
    }

    @Override
    Response<String> bgrewriteaof() {
        def response = getResponse(BuilderFactory.STRING)
        response.set(jedis.bgrewriteaof())
        return response
    }

    @Override
    Response<String> bgsave() {
        def response = getResponse(BuilderFactory.STRING)
        response.set(jedis.bgsave())
        return response
    }

    @Override
    Response<String> configGet(String pattern) {
        def response = getResponse(BuilderFactory.STRING)
        response.set(jedis.configGet(pattern))
        return response
    }

    @Override
    Response<String> configSet(String parameter, String value) {
        def response = getResponse(BuilderFactory.STRING)
        response.set(jedis.configSet(parameter, value))
        return response
    }

    @Override
    Response<String> brpoplpush(String source, String destination, int timeout) {
        throw new UnsupportedOperationException()
    }

    @Override
    Response<String> brpoplpush(byte[] source, byte[] destination, int timeout) {
        throw new UnsupportedOperationException()
    }

    @Override
    Response<String> configResetStat() {
        def response = getResponse(BuilderFactory.STRING)
        response.set(jedis.configResetStat())
        return response
    }

    @Override
    Response<String> save() {
        def response = getResponse(BuilderFactory.STRING)
        response.set(jedis.save())
        return response
    }

    @Override
    Response<Long> lastsave() {
        def response = getResponse(BuilderFactory.LONG)
        response.set(jedis.lastsave())
        return response
    }

    @Override
    Response<String> discard() {
        throw new UnsupportedOperationException()
    }

    @Override
    Response<List<Object>> exec() {
        Response<List<Object>> response = super.getResponse(currentMulti)
        currentMulti = null
        return response
    }

    @Override
    void multi() {
        getResponse(BuilderFactory.STRING); //Expecting OK
        currentMulti = new MultiResponseBuilder()
    }

    @Override
    Response<Long> publish(String channel, String message) {
        def response = getResponse(BuilderFactory.LONG)
        response.set(jedis.publish(channel, message))
        return response
    }

    @Override
    Response<Long> publish(byte[] channel, byte[] message) {
        def response = getResponse(BuilderFactory.LONG)
        response.set(jedis.publish(channel, message))
        return response
    }

    @Override
    Response<String> flushDB() {
        def response = getResponse(BuilderFactory.STRING)
        response.set(jedis.flushDB())
        return response
    }

    @Override
    Response<String> flushAll() {
        def response = getResponse(BuilderFactory.STRING)
        response.set(jedis.flushAll())
        return response
    }

    @Override
    Response<String> info() {
        def response = getResponse(BuilderFactory.STRING)
        response.set(jedis.info())
        return response
    }

    @Override
    Response<Long> dbSize() {
        def response = getResponse(BuilderFactory.LONG)
        response.set(jedis.dbSize())
        return response
    }

    @Override
    Response<String> shutdown() {
        def response = getResponse(BuilderFactory.STRING)
        response.set(jedis.shutdown())
        return response
    }

    @Override
    Response<String> ping() {
        def response = getResponse(BuilderFactory.STRING)
        response.set(jedis.ping())
        return response
    }

    @Override
    Response<String> randomKey() {
        throw new UnsupportedOperationException()
    }

    @Override
    Response<String> select(int index) {
        def response = getResponse(BuilderFactory.STRING)
        response.set(jedis.select(index))
        return response
    }

    @Override
    public void sync() {
    }

    @Override
    public List<Object> syncAndReturnAll() {
        return []
    }

    @Override
    protected <T> Response<T> getResponse(Builder<T> builder) {
        if (currentMulti != null){
            super.getResponse(BuilderFactory.STRING) //Expected QUEUED

            Response<T> lr = new Response<T>(builder)
            currentMulti.addResponse(lr)
            return lr
        }
        return super.getResponse(builder)
    }

    private class MultiResponseBuilder extends Builder<List<Object>>{
        private final List<Response<?>> responses = []

        @Override
        public List<Object> build(Object data) {
            @SuppressWarnings('unchecked')
            List<Object> list = (List<Object>)data
            List<Object> values = []

            if (list.size() != responses.size()){
                throw new JedisDataException('Expected data size ' + responses.size() + ' but was ' + list.size())
            }

            for (int i = 0; i < list.size(); i++){
                Response<?> response = responses.get(i)
                response.set(list.get(i))
                values.add(response.get())
            }
            return values
        }

        public void addResponse(Response<?> response){
            responses.add(response)
        }
    }
}