Uses of Class
redis.clients.jedis.Response

Packages that use Response

Package	Description
redis.clients.jedis
redis.clients.jedis.commands

Uses of Response in redis.clients.jedis

Methods in redis.clients.jedis that return Response

Modifier and Type	Method	Description
Response<Long>	PipelineBase.append(byte[] key, byte[] value)
Response<Long>	PipelineBase.append(String key, String value)
Response<String>	MultiKeyPipelineBase.bgrewriteaof()
Response<String>	MultiKeyPipelineBase.bgsave()
Response<Long>	PipelineBase.bitcount(byte[] key)
Response<Long>	PipelineBase.bitcount(byte[] key, long start, long end)
Response<Long>	PipelineBase.bitcount(String key)
Response<Long>	PipelineBase.bitcount(String key, long start, long end)
Response<List<Long>>	PipelineBase.bitfield(byte[] key, byte[]... elements)
Response<List<Long>>	PipelineBase.bitfield(String key, String... elements)
Response<List<Long>>	PipelineBase.bitfieldReadonly(byte[] key, byte[]... arguments)
Response<List<Long>>	PipelineBase.bitfieldReadonly(String key, String... arguments)
Response<Long>	MultiKeyPipelineBase.bitop(BitOP op, byte[] destKey, byte[]... srcKeys)
Response<Long>	MultiKeyPipelineBase.bitop(BitOP op, String destKey, String... srcKeys)
Response<Long>	PipelineBase.bitpos(byte[] key, boolean value)
Response<Long>	PipelineBase.bitpos(byte[] key, boolean value, BitPosParams params)
Response<Long>	PipelineBase.bitpos(String key, boolean value)
Response<Long>	PipelineBase.bitpos(String key, boolean value, BitPosParams params)
Response<List<byte[]>>	MultiKeyPipelineBase.blpop(byte[]... args)
Response<List<String>>	MultiKeyPipelineBase.blpop(int timeout, byte[]... keys)
Response<List<String>>	MultiKeyPipelineBase.blpop(int timeout, String... keys)
Response<List<String>>	MultiKeyPipelineBase.blpop(String... args)
Response<List<byte[]>>	PipelineBase.blpop(byte[] key)
Response<List<String>>	PipelineBase.blpop(String key)
Response<Map<String,String>>	MultiKeyPipelineBase.blpopMap(int timeout, String... keys)
Response<List<byte[]>>	MultiKeyPipelineBase.brpop(byte[]... args)
Response<List<String>>	MultiKeyPipelineBase.brpop(int timeout, byte[]... keys)
Response<List<String>>	MultiKeyPipelineBase.brpop(int timeout, String... keys)
Response<List<String>>	MultiKeyPipelineBase.brpop(String... args)
Response<List<byte[]>>	PipelineBase.brpop(byte[] key)
Response<List<String>>	PipelineBase.brpop(String key)
Response<byte[]>	MultiKeyPipelineBase.brpoplpush(byte[] source, byte[] destination, int timeout)
Response<String>	MultiKeyPipelineBase.brpoplpush(String source, String destination, int timeout)
Response<Map<String,String>>	MultiKeyPipelineBase.brpopMap(int timeout, String... keys)
Response<String>	MultiKeyPipelineBase.clusterAddSlots(int... slots)
Response<String>	MultiKeyPipelineBase.clusterDelSlots(int... slots)
Response<List<String>>	MultiKeyPipelineBase.clusterGetKeysInSlot(int slot, int count)
Response<String>	MultiKeyPipelineBase.clusterInfo()
Response<String>	MultiKeyPipelineBase.clusterMeet(String ip, int port)
Response<String>	MultiKeyPipelineBase.clusterNodes()
Response<String>	MultiKeyPipelineBase.clusterSetSlotImporting(int slot, String nodeId)
Response<String>	MultiKeyPipelineBase.clusterSetSlotMigrating(int slot, String nodeId)
Response<String>	MultiKeyPipelineBase.clusterSetSlotNode(int slot, String nodeId)
Response<List<String>>	MultiKeyPipelineBase.configGet(String pattern)
Response<String>	MultiKeyPipelineBase.configResetStat()
Response<String>	MultiKeyPipelineBase.configSet(String parameter, String value)
Response<Long>	MultiKeyPipelineBase.dbSize()
Response<Long>	PipelineBase.decr(byte[] key)
Response<Long>	PipelineBase.decr(String key)
Response<Long>	PipelineBase.decrBy(byte[] key, long decrement)
Response<Long>	PipelineBase.decrBy(String key, long decrement)
Response<Long>	MultiKeyPipelineBase.del(byte[]... keys)
Response<Long>	MultiKeyPipelineBase.del(String... keys)
Response<Long>	PipelineBase.del(byte[] key)
Response<Long>	PipelineBase.del(String key)
Response<String>	Pipeline.discard()
Response<byte[]>	PipelineBase.dump(byte[] key)
Response<byte[]>	PipelineBase.dump(String key)
Response<byte[]>	PipelineBase.echo(byte[] string)
Response<String>	PipelineBase.echo(String string)
Response<Object>	MultiKeyPipelineBase.eval(byte[] script)
Response<Object>	MultiKeyPipelineBase.eval(byte[] script, byte[] keyCount, byte[]... params)
Response<Object>	MultiKeyPipelineBase.eval(byte[] script, int keyCount, byte[]... params)
Response<Object>	MultiKeyPipelineBase.eval(byte[] script, List<byte[]> keys, List<byte[]> args)
Response<Object>	MultiKeyPipelineBase.eval(String script)
Response<Object>	MultiKeyPipelineBase.eval(String script, int keyCount, String... params)
Response<Object>	MultiKeyPipelineBase.eval(String script, List<String> keys, List<String> args)
Response<Object>	MultiKeyPipelineBase.evalsha(byte[] sha1)
Response<Object>	MultiKeyPipelineBase.evalsha(byte[] sha1, int keyCount, byte[]... params)
Response<Object>	MultiKeyPipelineBase.evalsha(byte[] sha1, List<byte[]> keys, List<byte[]> args)
Response<Object>	MultiKeyPipelineBase.evalsha(String sha1)
Response<Object>	MultiKeyPipelineBase.evalsha(String sha1, int keyCount, String... params)
Response<Object>	MultiKeyPipelineBase.evalsha(String sha1, List<String> keys, List<String> args)
Response<List<Object>>	Pipeline.exec()
Response<Long>	MultiKeyPipelineBase.exists(byte[]... keys)
Response<Long>	MultiKeyPipelineBase.exists(String... keys)
Response<Boolean>	PipelineBase.exists(byte[] key)
Response<Boolean>	PipelineBase.exists(String key)
Response<Long>	PipelineBase.expire(byte[] key, int seconds)
Response<Long>	PipelineBase.expire(String key, int seconds)
Response<Long>	PipelineBase.expireAt(byte[] key, long unixTime)
Response<Long>	PipelineBase.expireAt(String key, long unixTime)
Response<String>	MultiKeyPipelineBase.flushAll()
Response<String>	MultiKeyPipelineBase.flushDB()
protected Response<?>	Queable.generateResponse(Object data)
Response<Long>	PipelineBase.geoadd(byte[] key, double longitude, double latitude, byte[] member)
Response<Long>	PipelineBase.geoadd(byte[] key, Map<byte[],GeoCoordinate> memberCoordinateMap)
Response<Long>	PipelineBase.geoadd(String key, double longitude, double latitude, String member)
Response<Long>	PipelineBase.geoadd(String key, Map<String,GeoCoordinate> memberCoordinateMap)
Response<Double>	PipelineBase.geodist(byte[] key, byte[] member1, byte[] member2)
Response<Double>	PipelineBase.geodist(byte[] key, byte[] member1, byte[] member2, GeoUnit unit)
Response<Double>	PipelineBase.geodist(String key, String member1, String member2)
Response<Double>	PipelineBase.geodist(String key, String member1, String member2, GeoUnit unit)
Response<List<byte[]>>	PipelineBase.geohash(byte[] key, byte[]... members)
Response<List<String>>	PipelineBase.geohash(String key, String... members)
Response<List<GeoCoordinate>>	PipelineBase.geopos(byte[] key, byte[]... members)
Response<List<GeoCoordinate>>	PipelineBase.geopos(String key, String... members)
Response<List<GeoRadiusResponse>>	PipelineBase.georadius(byte[] key, double longitude, double latitude, double radius, GeoUnit unit)
Response<List<GeoRadiusResponse>>	PipelineBase.georadius(byte[] key, double longitude, double latitude, double radius, GeoUnit unit, GeoRadiusParam param)
Response<List<GeoRadiusResponse>>	PipelineBase.georadius(String key, double longitude, double latitude, double radius, GeoUnit unit)
Response<List<GeoRadiusResponse>>	PipelineBase.georadius(String key, double longitude, double latitude, double radius, GeoUnit unit, GeoRadiusParam param)
Response<List<GeoRadiusResponse>>	PipelineBase.georadiusByMember(byte[] key, byte[] member, double radius, GeoUnit unit)
Response<List<GeoRadiusResponse>>	PipelineBase.georadiusByMember(byte[] key, byte[] member, double radius, GeoUnit unit, GeoRadiusParam param)
Response<List<GeoRadiusResponse>>	PipelineBase.georadiusByMember(String key, String member, double radius, GeoUnit unit)
Response<List<GeoRadiusResponse>>	PipelineBase.georadiusByMember(String key, String member, double radius, GeoUnit unit, GeoRadiusParam param)
Response<List<GeoRadiusResponse>>	PipelineBase.georadiusByMemberReadonly(byte[] key, byte[] member, double radius, GeoUnit unit)
Response<List<GeoRadiusResponse>>	PipelineBase.georadiusByMemberReadonly(byte[] key, byte[] member, double radius, GeoUnit unit, GeoRadiusParam param)
Response<List<GeoRadiusResponse>>	PipelineBase.georadiusByMemberReadonly(String key, String member, double radius, GeoUnit unit)
Response<List<GeoRadiusResponse>>	PipelineBase.georadiusByMemberReadonly(String key, String member, double radius, GeoUnit unit, GeoRadiusParam param)
Response<Long>	MultiKeyPipelineBase.georadiusByMemberStore(byte[] key, byte[] member, double radius, GeoUnit unit, GeoRadiusParam param, GeoRadiusStoreParam storeParam)
Response<Long>	MultiKeyPipelineBase.georadiusByMemberStore(String key, String member, double radius, GeoUnit unit, GeoRadiusParam param, GeoRadiusStoreParam storeParam)
Response<List<GeoRadiusResponse>>	PipelineBase.georadiusReadonly(byte[] key, double longitude, double latitude, double radius, GeoUnit unit)
Response<List<GeoRadiusResponse>>	PipelineBase.georadiusReadonly(byte[] key, double longitude, double latitude, double radius, GeoUnit unit, GeoRadiusParam param)
Response<List<GeoRadiusResponse>>	PipelineBase.georadiusReadonly(String key, double longitude, double latitude, double radius, GeoUnit unit)
Response<List<GeoRadiusResponse>>	PipelineBase.georadiusReadonly(String key, double longitude, double latitude, double radius, GeoUnit unit, GeoRadiusParam param)
Response<Long>	MultiKeyPipelineBase.georadiusStore(byte[] key, double longitude, double latitude, double radius, GeoUnit unit, GeoRadiusParam param, GeoRadiusStoreParam storeParam)
Response<Long>	MultiKeyPipelineBase.georadiusStore(String key, double longitude, double latitude, double radius, GeoUnit unit, GeoRadiusParam param, GeoRadiusStoreParam storeParam)
Response<byte[]>	PipelineBase.get(byte[] key)
Response<String>	PipelineBase.get(String key)
Response<Boolean>	PipelineBase.getbit(byte[] key, long offset)
Response<Boolean>	PipelineBase.getbit(String key, long offset)
Response<byte[]>	PipelineBase.getrange(byte[] key, long startOffset, long endOffset)
Response<String>	PipelineBase.getrange(String key, long startOffset, long endOffset)
protected <T> Response<T>	Pipeline.getResponse(Builder<T> builder)
protected <T> Response<T>	Queable.getResponse(Builder<T> builder)
Response<byte[]>	PipelineBase.getSet(byte[] key, byte[] value)
Response<String>	PipelineBase.getSet(String key, String value)
Response<Long>	PipelineBase.hdel(byte[] key, byte[]... field)
Response<Long>	PipelineBase.hdel(String key, String... field)
Response<Boolean>	PipelineBase.hexists(byte[] key, byte[] field)
Response<Boolean>	PipelineBase.hexists(String key, String field)
Response<byte[]>	PipelineBase.hget(byte[] key, byte[] field)
Response<String>	PipelineBase.hget(String key, String field)
Response<Map<byte[],byte[]>>	PipelineBase.hgetAll(byte[] key)
Response<Map<String,String>>	PipelineBase.hgetAll(String key)
Response<Long>	PipelineBase.hincrBy(byte[] key, byte[] field, long value)
Response<Long>	PipelineBase.hincrBy(String key, String field, long value)
Response<Double>	PipelineBase.hincrByFloat(byte[] key, byte[] field, double increment)
Response<Double>	PipelineBase.hincrByFloat(String key, String field, double increment)
Response<Set<byte[]>>	PipelineBase.hkeys(byte[] key)
Response<Set<String>>	PipelineBase.hkeys(String key)
Response<Long>	PipelineBase.hlen(byte[] key)
Response<Long>	PipelineBase.hlen(String key)
Response<List<byte[]>>	PipelineBase.hmget(byte[] key, byte[]... fields)
Response<List<String>>	PipelineBase.hmget(String key, String... fields)
Response<String>	PipelineBase.hmset(byte[] key, Map<byte[],byte[]> hash)
Response<String>	PipelineBase.hmset(String key, Map<String,String> hash)
Response<Long>	PipelineBase.hset(byte[] key, byte[] field, byte[] value)
Response<Long>	PipelineBase.hset(byte[] key, Map<byte[],byte[]> hash)
Response<Long>	PipelineBase.hset(String key, String field, String value)
Response<Long>	PipelineBase.hset(String key, Map<String,String> hash)
Response<Long>	PipelineBase.hsetnx(byte[] key, byte[] field, byte[] value)
Response<Long>	PipelineBase.hsetnx(String key, String field, String value)
Response<Long>	PipelineBase.hstrlen(byte[] key, byte[] field)
Response<Long>	PipelineBase.hstrlen(String key, String field)
Response<List<byte[]>>	PipelineBase.hvals(byte[] key)
Response<List<String>>	PipelineBase.hvals(String key)
Response<Long>	PipelineBase.incr(byte[] key)
Response<Long>	PipelineBase.incr(String key)
Response<Long>	PipelineBase.incrBy(byte[] key, long increment)
Response<Long>	PipelineBase.incrBy(String key, long increment)
Response<Double>	PipelineBase.incrByFloat(byte[] key, double increment)
Response<Double>	PipelineBase.incrByFloat(String key, double increment)
Response<String>	MultiKeyPipelineBase.info()
Response<String>	MultiKeyPipelineBase.info(String section)
Response<Set<byte[]>>	MultiKeyPipelineBase.keys(byte[] pattern)
Response<Set<String>>	MultiKeyPipelineBase.keys(String pattern)
Response<Long>	MultiKeyPipelineBase.lastsave()
Response<byte[]>	PipelineBase.lindex(byte[] key, long index)
Response<String>	PipelineBase.lindex(String key, long index)
Response<Long>	PipelineBase.linsert(byte[] key, ListPosition where, byte[] pivot, byte[] value)
Response<Long>	PipelineBase.linsert(String key, ListPosition where, String pivot, String value)
Response<Long>	PipelineBase.llen(byte[] key)
Response<Long>	PipelineBase.llen(String key)
Response<byte[]>	PipelineBase.lpop(byte[] key)
Response<List<byte[]>>	PipelineBase.lpop(byte[] key, int count)
Response<String>	PipelineBase.lpop(String key)
Response<List<String>>	PipelineBase.lpop(String key, int count)
Response<Long>	PipelineBase.lpos(byte[] key, byte[] element)
Response<Long>	PipelineBase.lpos(byte[] key, byte[] element, LPosParams params)
Response<List<Long>>	PipelineBase.lpos(byte[] key, byte[] element, LPosParams params, long count)
Response<Long>	PipelineBase.lpos(String key, String element)
Response<Long>	PipelineBase.lpos(String key, String element, LPosParams params)
Response<List<Long>>	PipelineBase.lpos(String key, String element, LPosParams params, long count)
Response<Long>	PipelineBase.lpush(byte[] key, byte[]... string)
Response<Long>	PipelineBase.lpush(String key, String... string)
Response<Long>	PipelineBase.lpushx(byte[] key, byte[]... bytes)
Response<Long>	PipelineBase.lpushx(String key, String... string)
Response<List<byte[]>>	PipelineBase.lrange(byte[] key, long start, long stop)
Response<List<String>>	PipelineBase.lrange(String key, long start, long stop)
Response<Long>	PipelineBase.lrem(byte[] key, long count, byte[] value)
Response<Long>	PipelineBase.lrem(String key, long count, String value)
Response<String>	PipelineBase.lset(byte[] key, long index, byte[] value)
Response<String>	PipelineBase.lset(String key, long index, String value)
Response<String>	PipelineBase.ltrim(byte[] key, long start, long stop)
Response<String>	PipelineBase.ltrim(String key, long start, long stop)
Response<List<byte[]>>	MultiKeyPipelineBase.mget(byte[]... keys)
Response<List<String>>	MultiKeyPipelineBase.mget(String... keys)
Response<String>	MultiKeyPipelineBase.migrate(String host, int port, int destinationDB, int timeout, MigrateParams params, byte[]... keys)
Response<String>	MultiKeyPipelineBase.migrate(String host, int port, int destinationDB, int timeout, MigrateParams params, String... keys)
Response<String>	PipelineBase.migrate(String host, int port, byte[] key, int destinationDb, int timeout)
Response<String>	PipelineBase.migrate(String host, int port, String key, int destinationDb, int timeout)
Response<List<Module>>	MultiKeyPipelineBase.moduleList()
Response<String>	MultiKeyPipelineBase.moduleLoad(String path)
Response<String>	MultiKeyPipelineBase.moduleUnload(String name)
Response<Long>	PipelineBase.move(byte[] key, int dbIndex)
Response<Long>	PipelineBase.move(String key, int dbIndex)
Response<String>	MultiKeyPipelineBase.mset(byte[]... keysvalues)
Response<String>	MultiKeyPipelineBase.mset(String... keysvalues)
Response<Long>	MultiKeyPipelineBase.msetnx(byte[]... keysvalues)
Response<Long>	MultiKeyPipelineBase.msetnx(String... keysvalues)
Response<String>	Pipeline.multi()
Response<byte[]>	PipelineBase.objectEncoding(byte[] key)
Response<String>	PipelineBase.objectEncoding(String key)
Response<Long>	PipelineBase.objectFreq(byte[] key)
Response<Long>	PipelineBase.objectFreq(String key)
Response<Long>	PipelineBase.objectIdletime(byte[] key)
Response<Long>	PipelineBase.objectIdletime(String key)
Response<Long>	PipelineBase.objectRefcount(byte[] key)
Response<Long>	PipelineBase.objectRefcount(String key)
Response<Long>	PipelineBase.persist(byte[] key)
Response<Long>	PipelineBase.persist(String key)
Response<Long>	PipelineBase.pexpire(byte[] key, long milliseconds)
Response<Long>	PipelineBase.pexpire(String key, long milliseconds)
Response<Long>	PipelineBase.pexpireAt(byte[] key, long millisecondsTimestamp)
Response<Long>	PipelineBase.pexpireAt(String key, long millisecondsTimestamp)
Response<Long>	PipelineBase.pfadd(byte[] key, byte[]... elements)
Response<Long>	PipelineBase.pfadd(String key, String... elements)
Response<Long>	MultiKeyPipelineBase.pfcount(byte[]... keys)
Response<Long>	MultiKeyPipelineBase.pfcount(String... keys)
Response<Long>	PipelineBase.pfcount(byte[] key)
Response<Long>	PipelineBase.pfcount(String key)
Response<String>	MultiKeyPipelineBase.pfmerge(byte[] destkey, byte[]... sourcekeys)
Response<String>	MultiKeyPipelineBase.pfmerge(String destkey, String... sourcekeys)
Response<String>	MultiKeyPipelineBase.ping()
Response<String>	PipelineBase.psetex(byte[] key, long milliseconds, byte[] value)
Response<String>	PipelineBase.psetex(String key, long milliseconds, String value)
Response<Long>	PipelineBase.pttl(byte[] key)
Response<Long>	PipelineBase.pttl(String key)
Response<Long>	MultiKeyPipelineBase.publish(byte[] channel, byte[] message)
Response<Long>	MultiKeyPipelineBase.publish(String channel, String message)
Response<String>	MultiKeyPipelineBase.randomKey()
Response<byte[]>	MultiKeyPipelineBase.randomKeyBinary()
Response<String>	MultiKeyPipelineBase.rename(byte[] oldkey, byte[] newkey)
Response<String>	MultiKeyPipelineBase.rename(String oldkey, String newkey)
Response<Long>	MultiKeyPipelineBase.renamenx(byte[] oldkey, byte[] newkey)
Response<Long>	MultiKeyPipelineBase.renamenx(String oldkey, String newkey)
Response<String>	PipelineBase.restore(byte[] key, int ttl, byte[] serializedValue)
Response<String>	PipelineBase.restore(String key, int ttl, byte[] serializedValue)
Response<String>	PipelineBase.restoreReplace(byte[] key, int ttl, byte[] serializedValue)
Response<String>	PipelineBase.restoreReplace(String key, int ttl, byte[] serializedValue)
Response<byte[]>	PipelineBase.rpop(byte[] key)
Response<List<byte[]>>	PipelineBase.rpop(byte[] key, int count)
Response<String>	PipelineBase.rpop(String key)
Response<List<String>>	PipelineBase.rpop(String key, int count)
Response<byte[]>	MultiKeyPipelineBase.rpoplpush(byte[] srckey, byte[] dstkey)
Response<String>	MultiKeyPipelineBase.rpoplpush(String srckey, String dstkey)
Response<Long>	PipelineBase.rpush(byte[] key, byte[]... string)
Response<Long>	PipelineBase.rpush(String key, String... string)
Response<Long>	PipelineBase.rpushx(byte[] key, byte[]... string)
Response<Long>	PipelineBase.rpushx(String key, String... string)
Response<Long>	PipelineBase.sadd(byte[] key, byte[]... member)
Response<Long>	PipelineBase.sadd(String key, String... member)
Response<String>	MultiKeyPipelineBase.save()
Response<Long>	PipelineBase.scard(byte[] key)
Response<Long>	PipelineBase.scard(String key)
Response<Set<byte[]>>	MultiKeyPipelineBase.sdiff(byte[]... keys)
Response<Set<String>>	MultiKeyPipelineBase.sdiff(String... keys)
Response<Long>	MultiKeyPipelineBase.sdiffstore(byte[] dstkey, byte[]... keys)
Response<Long>	MultiKeyPipelineBase.sdiffstore(String dstkey, String... keys)
Response<String>	MultiKeyPipelineBase.select(int index)
Response<Object>	MultiKeyPipelineBase.sendCommand(ProtocolCommand cmd, byte[]... args)
Response<Object>	MultiKeyPipelineBase.sendCommand(ProtocolCommand cmd, String... args)
Response<Object>	PipelineBase.sendCommand(byte[] sampleKey, ProtocolCommand cmd, byte[]... args)
Response<Object>	PipelineBase.sendCommand(String sampleKey, ProtocolCommand cmd, String... args)
Response<String>	PipelineBase.set(byte[] key, byte[] value)
Response<String>	PipelineBase.set(byte[] key, byte[] value, SetParams params)
Response<String>	PipelineBase.set(String key, String value)
Response<String>	PipelineBase.set(String key, String value, SetParams params)
Response<Boolean>	PipelineBase.setbit(byte[] key, long offset, byte[] value)
Response<Boolean>	PipelineBase.setbit(String key, long offset, boolean value)
Response<String>	PipelineBase.setex(byte[] key, int seconds, byte[] value)
Response<String>	PipelineBase.setex(String key, int seconds, String value)
Response<Long>	PipelineBase.setnx(byte[] key, byte[] value)
Response<Long>	PipelineBase.setnx(String key, String value)
Response<Long>	PipelineBase.setrange(byte[] key, long offset, byte[] value)
Response<Long>	PipelineBase.setrange(String key, long offset, String value)
Response<String>	MultiKeyPipelineBase.shutdown()
Response<Set<byte[]>>	MultiKeyPipelineBase.sinter(byte[]... keys)
Response<Set<String>>	MultiKeyPipelineBase.sinter(String... keys)
Response<Long>	MultiKeyPipelineBase.sinterstore(byte[] dstkey, byte[]... keys)
Response<Long>	MultiKeyPipelineBase.sinterstore(String dstkey, String... keys)
Response<Boolean>	PipelineBase.sismember(byte[] key, byte[] member)
Response<Boolean>	PipelineBase.sismember(String key, String member)
Response<Set<byte[]>>	PipelineBase.smembers(byte[] key)
Response<Set<String>>	PipelineBase.smembers(String key)
Response<List<Boolean>>	PipelineBase.smismember(byte[] key, byte[]... members)
Response<List<Boolean>>	PipelineBase.smismember(String key, String... members)
Response<Long>	MultiKeyPipelineBase.smove(byte[] srckey, byte[] dstkey, byte[] member)
Response<Long>	MultiKeyPipelineBase.smove(String srckey, String dstkey, String member)
Response<Long>	MultiKeyPipelineBase.sort(byte[] key, byte[] dstkey)
Response<Long>	MultiKeyPipelineBase.sort(byte[] key, SortingParams sortingParameters, byte[] dstkey)
Response<Long>	MultiKeyPipelineBase.sort(String key, String dstkey)
Response<Long>	MultiKeyPipelineBase.sort(String key, SortingParams sortingParameters, String dstkey)
Response<List<byte[]>>	PipelineBase.sort(byte[] key)
Response<List<byte[]>>	PipelineBase.sort(byte[] key, SortingParams sortingParameters)
Response<List<String>>	PipelineBase.sort(String key)
Response<List<String>>	PipelineBase.sort(String key, SortingParams sortingParameters)
Response<byte[]>	PipelineBase.spop(byte[] key)
Response<Set<byte[]>>	PipelineBase.spop(byte[] key, long count)
Response<String>	PipelineBase.spop(String key)
Response<Set<String>>	PipelineBase.spop(String key, long count)
Response<byte[]>	PipelineBase.srandmember(byte[] key)
Response<List<byte[]>>	PipelineBase.srandmember(byte[] key, int count)
Response<String>	PipelineBase.srandmember(String key)
Response<List<String>>	PipelineBase.srandmember(String key, int count)
Response<Long>	PipelineBase.srem(byte[] key, byte[]... member)
Response<Long>	PipelineBase.srem(String key, String... member)
Response<Long>	PipelineBase.strlen(byte[] key)
Response<Long>	PipelineBase.strlen(String key)
Response<String>	PipelineBase.substr(byte[] key, int start, int end)
Response<String>	PipelineBase.substr(String key, int start, int end)
Response<Set<byte[]>>	MultiKeyPipelineBase.sunion(byte[]... keys)
Response<Set<String>>	MultiKeyPipelineBase.sunion(String... keys)
Response<Long>	MultiKeyPipelineBase.sunionstore(byte[] dstkey, byte[]... keys)
Response<Long>	MultiKeyPipelineBase.sunionstore(String dstkey, String... keys)
Response<String>	MultiKeyPipelineBase.swapDB(int index1, int index2)
Response<List<String>>	MultiKeyPipelineBase.time()
Response<Long>	MultiKeyPipelineBase.touch(byte[]... keys)
Response<Long>	MultiKeyPipelineBase.touch(String... keys)
Response<Long>	PipelineBase.touch(byte[] key)
Response<Long>	PipelineBase.touch(String key)
Response<Long>	PipelineBase.ttl(byte[] key)
Response<Long>	PipelineBase.ttl(String key)
Response<String>	PipelineBase.type(byte[] key)
Response<String>	PipelineBase.type(String key)
Response<Long>	MultiKeyPipelineBase.unlink(byte[]... keys)
Response<Long>	MultiKeyPipelineBase.unlink(String... keys)
Response<Long>	PipelineBase.unlink(byte[] key)
Response<Long>	PipelineBase.unlink(String key)
Response<String>	MultiKeyPipelineBase.unwatch()
Response<String>	MultiKeyPipelineBase.watch(byte[]... keys)
Response<String>	MultiKeyPipelineBase.watch(String... keys)
Response<Long>	PipelineBase.xack(byte[] key, byte[] group, byte[]... ids)
Response<Long>	PipelineBase.xack(String key, String group, StreamEntryID... ids)
Response<byte[]>	PipelineBase.xadd(byte[] key, byte[] id, Map<byte[],byte[]> hash)
Response<byte[]>	PipelineBase.xadd(byte[] key, byte[] id, Map<byte[],byte[]> hash, long maxLen, boolean approximateLength)
Response<StreamEntryID>	PipelineBase.xadd(String key, StreamEntryID id, Map<String,String> hash)
Response<StreamEntryID>	PipelineBase.xadd(String key, StreamEntryID id, Map<String,String> hash, long maxLen, boolean approximateLength)
Response<List<byte[]>>	PipelineBase.xclaim(byte[] key, byte[] group, byte[] consumername, long minIdleTime, long newIdleTime, int retries, boolean force, byte[]... ids)
Response<List<StreamEntry>>	PipelineBase.xclaim(String key, String group, String consumername, long minIdleTime, long newIdleTime, int retries, boolean force, StreamEntryID... ids)
Response<Long>	PipelineBase.xdel(byte[] key, byte[]... ids)
Response<Long>	PipelineBase.xdel(String key, StreamEntryID... ids)
Response<String>	PipelineBase.xgroupCreate(byte[] key, byte[] groupname, byte[] id, boolean makeStream)
Response<String>	PipelineBase.xgroupCreate(String key, String groupname, StreamEntryID id, boolean makeStream)
Response<Long>	PipelineBase.xgroupDelConsumer(byte[] key, byte[] groupname, byte[] consumername)
Response<Long>	PipelineBase.xgroupDelConsumer(String key, String groupname, String consumername)
Response<Long>	PipelineBase.xgroupDestroy(byte[] key, byte[] groupname)
Response<Long>	PipelineBase.xgroupDestroy(String key, String groupname)
Response<String>	PipelineBase.xgroupSetID(byte[] key, byte[] groupname, byte[] id)
Response<String>	PipelineBase.xgroupSetID(String key, String groupname, StreamEntryID id)
Response<Long>	PipelineBase.xlen(byte[] key)
Response<Long>	PipelineBase.xlen(String key)
Response<List<StreamPendingEntry>>	PipelineBase.xpending(byte[] key, byte[] groupname, byte[] start, byte[] end, int count, byte[] consumername)
Response<List<StreamPendingEntry>>	PipelineBase.xpending(String key, String groupname, StreamEntryID start, StreamEntryID end, int count, String consumername)
Response<List<byte[]>>	PipelineBase.xrange(byte[] key, byte[] start, byte[] end, int count)
Response<List<StreamEntry>>	PipelineBase.xrange(String key, StreamEntryID start, StreamEntryID end, int count)
Response<List<byte[]>>	PipelineBase.xrevrange(byte[] key, byte[] end, byte[] start, int count)
Response<List<StreamEntry>>	PipelineBase.xrevrange(String key, StreamEntryID end, StreamEntryID start, int count)
Response<Long>	PipelineBase.xtrim(byte[] key, long maxLen, boolean approximateLength)
Response<Long>	PipelineBase.xtrim(String key, long maxLen, boolean approximateLength)
Response<Long>	PipelineBase.zadd(byte[] key, double score, byte[] member)
Response<Long>	PipelineBase.zadd(byte[] key, double score, byte[] member, ZAddParams params)
Response<Long>	PipelineBase.zadd(byte[] key, Map<byte[],Double> scoreMembers)
Response<Long>	PipelineBase.zadd(byte[] key, Map<byte[],Double> scoreMembers, ZAddParams params)
Response<Long>	PipelineBase.zadd(String key, double score, String member)
Response<Long>	PipelineBase.zadd(String key, double score, String member, ZAddParams params)
Response<Long>	PipelineBase.zadd(String key, Map<String,Double> scoreMembers)
Response<Long>	PipelineBase.zadd(String key, Map<String,Double> scoreMembers, ZAddParams params)
Response<Long>	PipelineBase.zcard(byte[] key)
Response<Long>	PipelineBase.zcard(String key)
Response<Long>	PipelineBase.zcount(byte[] key, byte[] min, byte[] max)
Response<Long>	PipelineBase.zcount(byte[] key, double min, double max)
Response<Long>	PipelineBase.zcount(String key, double min, double max)
Response<Long>	PipelineBase.zcount(String key, String min, String max)
Response<Double>	PipelineBase.zincrby(byte[] key, double increment, byte[] member)
Response<Double>	PipelineBase.zincrby(byte[] key, double increment, byte[] member, ZIncrByParams params)
Response<Double>	PipelineBase.zincrby(String key, double increment, String member)
Response<Double>	PipelineBase.zincrby(String key, double increment, String member, ZIncrByParams params)
Response<Long>	MultiKeyPipelineBase.zinterstore(byte[] dstkey, byte[]... sets)
Response<Long>	MultiKeyPipelineBase.zinterstore(byte[] dstkey, ZParams params, byte[]... sets)
Response<Long>	MultiKeyPipelineBase.zinterstore(String dstkey, String... sets)
Response<Long>	MultiKeyPipelineBase.zinterstore(String dstkey, ZParams params, String... sets)
Response<Long>	PipelineBase.zlexcount(byte[] key, byte[] min, byte[] max)
Response<Long>	PipelineBase.zlexcount(String key, String min, String max)
Response<List<Double>>	PipelineBase.zmscore(byte[] key, byte[]... members)
Response<List<Double>>	PipelineBase.zmscore(String key, String... members)
Response<Tuple>	PipelineBase.zpopmax(byte[] key)
Response<Set<Tuple>>	PipelineBase.zpopmax(byte[] key, int count)
Response<Tuple>	PipelineBase.zpopmax(String key)
Response<Set<Tuple>>	PipelineBase.zpopmax(String key, int count)
Response<Tuple>	PipelineBase.zpopmin(byte[] key)
Response<Set<Tuple>>	PipelineBase.zpopmin(byte[] key, int count)
Response<Tuple>	PipelineBase.zpopmin(String key)
Response<Set<Tuple>>	PipelineBase.zpopmin(String key, int count)
Response<Set<byte[]>>	PipelineBase.zrange(byte[] key, long start, long stop)
Response<Set<String>>	PipelineBase.zrange(String key, long start, long stop)
Response<Set<byte[]>>	PipelineBase.zrangeByLex(byte[] key, byte[] min, byte[] max)
Response<Set<byte[]>>	PipelineBase.zrangeByLex(byte[] key, byte[] min, byte[] max, int offset, int count)
Response<Set<String>>	PipelineBase.zrangeByLex(String key, String min, String max)
Response<Set<String>>	PipelineBase.zrangeByLex(String key, String min, String max, int offset, int count)
Response<Set<byte[]>>	PipelineBase.zrangeByScore(byte[] key, byte[] min, byte[] max)
Response<Set<byte[]>>	PipelineBase.zrangeByScore(byte[] key, byte[] min, byte[] max, int offset, int count)
Response<Set<byte[]>>	PipelineBase.zrangeByScore(byte[] key, double min, double max)
Response<Set<byte[]>>	PipelineBase.zrangeByScore(byte[] key, double min, double max, int offset, int count)
Response<Set<String>>	PipelineBase.zrangeByScore(String key, double min, double max)
Response<Set<String>>	PipelineBase.zrangeByScore(String key, double min, double max, int offset, int count)
Response<Set<String>>	PipelineBase.zrangeByScore(String key, String min, String max)
Response<Set<String>>	PipelineBase.zrangeByScore(String key, String min, String max, int offset, int count)
Response<Set<Tuple>>	PipelineBase.zrangeByScoreWithScores(byte[] key, byte[] min, byte[] max)
Response<Set<Tuple>>	PipelineBase.zrangeByScoreWithScores(byte[] key, byte[] min, byte[] max, int offset, int count)
Response<Set<Tuple>>	PipelineBase.zrangeByScoreWithScores(byte[] key, double min, double max)
Response<Set<Tuple>>	PipelineBase.zrangeByScoreWithScores(byte[] key, double min, double max, int offset, int count)
Response<Set<Tuple>>	PipelineBase.zrangeByScoreWithScores(String key, double min, double max)
Response<Set<Tuple>>	PipelineBase.zrangeByScoreWithScores(String key, double min, double max, int offset, int count)
Response<Set<Tuple>>	PipelineBase.zrangeByScoreWithScores(String key, String min, String max)
Response<Set<Tuple>>	PipelineBase.zrangeByScoreWithScores(String key, String min, String max, int offset, int count)
Response<Set<Tuple>>	PipelineBase.zrangeWithScores(byte[] key, long start, long stop)
Response<Set<Tuple>>	PipelineBase.zrangeWithScores(String key, long start, long stop)
Response<Long>	PipelineBase.zrank(byte[] key, byte[] member)
Response<Long>	PipelineBase.zrank(String key, String member)
Response<Long>	PipelineBase.zrem(byte[] key, byte[]... members)
Response<Long>	PipelineBase.zrem(String key, String... members)
Response<Long>	PipelineBase.zremrangeByLex(byte[] key, byte[] min, byte[] max)
Response<Long>	PipelineBase.zremrangeByLex(String key, String min, String max)
Response<Long>	PipelineBase.zremrangeByRank(byte[] key, long start, long stop)
Response<Long>	PipelineBase.zremrangeByRank(String key, long start, long stop)
Response<Long>	PipelineBase.zremrangeByScore(byte[] key, byte[] min, byte[] max)
Response<Long>	PipelineBase.zremrangeByScore(byte[] key, double min, double max)
Response<Long>	PipelineBase.zremrangeByScore(String key, double min, double max)
Response<Long>	PipelineBase.zremrangeByScore(String key, String min, String max)
Response<Set<byte[]>>	PipelineBase.zrevrange(byte[] key, long start, long stop)
Response<Set<String>>	PipelineBase.zrevrange(String key, long start, long stop)
Response<Set<byte[]>>	PipelineBase.zrevrangeByLex(byte[] key, byte[] max, byte[] min)
Response<Set<byte[]>>	PipelineBase.zrevrangeByLex(byte[] key, byte[] max, byte[] min, int offset, int count)
Response<Set<String>>	PipelineBase.zrevrangeByLex(String key, String max, String min)
Response<Set<String>>	PipelineBase.zrevrangeByLex(String key, String max, String min, int offset, int count)
Response<Set<byte[]>>	PipelineBase.zrevrangeByScore(byte[] key, byte[] max, byte[] min)
Response<Set<byte[]>>	PipelineBase.zrevrangeByScore(byte[] key, byte[] max, byte[] min, int offset, int count)
Response<Set<byte[]>>	PipelineBase.zrevrangeByScore(byte[] key, double max, double min)
Response<Set<byte[]>>	PipelineBase.zrevrangeByScore(byte[] key, double max, double min, int offset, int count)
Response<Set<String>>	PipelineBase.zrevrangeByScore(String key, double max, double min)
Response<Set<String>>	PipelineBase.zrevrangeByScore(String key, double max, double min, int offset, int count)
Response<Set<String>>	PipelineBase.zrevrangeByScore(String key, String max, String min)
Response<Set<String>>	PipelineBase.zrevrangeByScore(String key, String max, String min, int offset, int count)
Response<Set<Tuple>>	PipelineBase.zrevrangeByScoreWithScores(byte[] key, byte[] max, byte[] min)
Response<Set<Tuple>>	PipelineBase.zrevrangeByScoreWithScores(byte[] key, byte[] max, byte[] min, int offset, int count)
Response<Set<Tuple>>	PipelineBase.zrevrangeByScoreWithScores(byte[] key, double max, double min)
Response<Set<Tuple>>	PipelineBase.zrevrangeByScoreWithScores(byte[] key, double max, double min, int offset, int count)
Response<Set<Tuple>>	PipelineBase.zrevrangeByScoreWithScores(String key, double max, double min)
Response<Set<Tuple>>	PipelineBase.zrevrangeByScoreWithScores(String key, double max, double min, int offset, int count)
Response<Set<Tuple>>	PipelineBase.zrevrangeByScoreWithScores(String key, String max, String min)
Response<Set<Tuple>>	PipelineBase.zrevrangeByScoreWithScores(String key, String max, String min, int offset, int count)
Response<Set<Tuple>>	PipelineBase.zrevrangeWithScores(byte[] key, long start, long stop)
Response<Set<Tuple>>	PipelineBase.zrevrangeWithScores(String key, long start, long stop)
Response<Long>	PipelineBase.zrevrank(byte[] key, byte[] member)
Response<Long>	PipelineBase.zrevrank(String key, String member)
Response<Double>	PipelineBase.zscore(byte[] key, byte[] member)
Response<Double>	PipelineBase.zscore(String key, String member)
Response<Long>	MultiKeyPipelineBase.zunionstore(byte[] dstkey, byte[]... sets)
Response<Long>	MultiKeyPipelineBase.zunionstore(byte[] dstkey, ZParams params, byte[]... sets)
Response<Long>	MultiKeyPipelineBase.zunionstore(String dstkey, String... sets)
Response<Long>	MultiKeyPipelineBase.zunionstore(String dstkey, ZParams params, String... sets)

Methods in redis.clients.jedis that return types with arguments of type Response

Modifier and Type	Method	Description
List<Response<?>>	Transaction.execGetResponse()

Methods in redis.clients.jedis with parameters of type Response

Modifier and Type	Method	Description
void	Response.setDependency(Response<?> dependency)

Uses of Response in redis.clients.jedis.commands

Methods in redis.clients.jedis.commands that return Response

Modifier and Type	Method	Description
Response<Long>	BinaryRedisPipeline.append(byte[] key, byte[] value)
Response<Long>	RedisPipeline.append(String key, String value)
Response<String>	BasicRedisPipeline.bgrewriteaof()
Response<String>	BasicRedisPipeline.bgsave()
Response<Long>	BinaryRedisPipeline.bitcount(byte[] key)
Response<Long>	BinaryRedisPipeline.bitcount(byte[] key, long start, long end)
Response<Long>	RedisPipeline.bitcount(String key)
Response<Long>	RedisPipeline.bitcount(String key, long start, long end)
Response<List<Long>>	BinaryRedisPipeline.bitfield(byte[] key, byte[]... elements)
Response<List<Long>>	RedisPipeline.bitfield(String key, String... arguments)
Response<List<Long>>	BinaryRedisPipeline.bitfieldReadonly(byte[] key, byte[]... elements)
Response<List<Long>>	RedisPipeline.bitfieldReadonly(String key, String... arguments)
Response<Long>	MultiKeyBinaryRedisPipeline.bitop(BitOP op, byte[] destKey, byte[]... srcKeys)
Response<Long>	MultiKeyCommandsPipeline.bitop(BitOP op, String destKey, String... srcKeys)
Response<Long>	BinaryRedisPipeline.bitpos(byte[] key, boolean value)
Response<Long>	BinaryRedisPipeline.bitpos(byte[] key, boolean value, BitPosParams params)
Response<Long>	RedisPipeline.bitpos(String key, boolean value)
Response<Long>	RedisPipeline.bitpos(String key, boolean value, BitPosParams params)
Response<List<byte[]>>	BinaryRedisPipeline.blpop(byte[] arg)
Response<List<byte[]>>	MultiKeyBinaryRedisPipeline.blpop(byte[]... args)
Response<List<String>>	MultiKeyCommandsPipeline.blpop(String... args)
Response<List<String>>	RedisPipeline.blpop(String arg)
Response<List<byte[]>>	BinaryRedisPipeline.brpop(byte[] arg)
Response<List<byte[]>>	MultiKeyBinaryRedisPipeline.brpop(byte[]... args)
Response<List<String>>	MultiKeyCommandsPipeline.brpop(String... args)
Response<List<String>>	RedisPipeline.brpop(String arg)
Response<byte[]>	MultiKeyBinaryRedisPipeline.brpoplpush(byte[] source, byte[] destination, int timeout)
Response<String>	MultiKeyCommandsPipeline.brpoplpush(String source, String destination, int timeout)
Response<String>	ClusterPipeline.clusterAddSlots(int... slots)
Response<String>	ClusterPipeline.clusterDelSlots(int... slots)
Response<List<String>>	ClusterPipeline.clusterGetKeysInSlot(int slot, int count)
Response<String>	ClusterPipeline.clusterInfo()
Response<String>	ClusterPipeline.clusterMeet(String ip, int port)
Response<String>	ClusterPipeline.clusterNodes()
Response<String>	ClusterPipeline.clusterSetSlotImporting(int slot, String nodeId)
Response<String>	ClusterPipeline.clusterSetSlotMigrating(int slot, String nodeId)
Response<String>	ClusterPipeline.clusterSetSlotNode(int slot, String nodeId)
Response<List<String>>	BasicRedisPipeline.configGet(String pattern)
Response<String>	BasicRedisPipeline.configResetStat()
Response<String>	BasicRedisPipeline.configSet(String parameter, String value)
Response<Long>	BasicRedisPipeline.dbSize()
Response<Long>	BinaryRedisPipeline.decr(byte[] key)
Response<Long>	RedisPipeline.decr(String key)
Response<Long>	BinaryRedisPipeline.decrBy(byte[] key, long decrement)
Response<Long>	RedisPipeline.decrBy(String key, long decrement)
Response<Long>	BinaryRedisPipeline.del(byte[] keys)
Response<Long>	MultiKeyBinaryRedisPipeline.del(byte[]... keys)
Response<Long>	MultiKeyCommandsPipeline.del(String... keys)
Response<Long>	RedisPipeline.del(String key)
Response<byte[]>	BinaryRedisPipeline.dump(byte[] key)
Response<byte[]>	RedisPipeline.dump(String key)
Response<byte[]>	BinaryRedisPipeline.echo(byte[] string)
Response<String>	RedisPipeline.echo(String string)
Response<Object>	BinaryScriptingCommandsPipeline.eval(byte[] script)
Response<Object>	BinaryScriptingCommandsPipeline.eval(byte[] script, byte[] keyCount, byte[]... params)
Response<Object>	BinaryScriptingCommandsPipeline.eval(byte[] script, int keyCount, byte[]... params)
Response<Object>	BinaryScriptingCommandsPipeline.eval(byte[] script, List<byte[]> keys, List<byte[]> args)
Response<Object>	ScriptingCommandsPipeline.eval(String script)
Response<Object>	ScriptingCommandsPipeline.eval(String script, int keyCount, String... params)
Response<Object>	ScriptingCommandsPipeline.eval(String script, List<String> keys, List<String> args)
Response<Object>	BinaryScriptingCommandsPipeline.evalsha(byte[] sha1)
Response<Object>	BinaryScriptingCommandsPipeline.evalsha(byte[] sha1, int keyCount, byte[]... params)
Response<Object>	BinaryScriptingCommandsPipeline.evalsha(byte[] sha1, List<byte[]> keys, List<byte[]> args)
Response<Object>	ScriptingCommandsPipeline.evalsha(String sha1)
Response<Object>	ScriptingCommandsPipeline.evalsha(String sha1, int keyCount, String... params)
Response<Object>	ScriptingCommandsPipeline.evalsha(String sha1, List<String> keys, List<String> args)
Response<Boolean>	BinaryRedisPipeline.exists(byte[] key)
Response<Long>	MultiKeyBinaryRedisPipeline.exists(byte[]... keys)
Response<Long>	MultiKeyCommandsPipeline.exists(String... keys)
Response<Boolean>	RedisPipeline.exists(String key)
Response<Long>	BinaryRedisPipeline.expire(byte[] key, int seconds)
Response<Long>	RedisPipeline.expire(String key, int seconds)
Response<Long>	BinaryRedisPipeline.expireAt(byte[] key, long unixTime)
Response<Long>	RedisPipeline.expireAt(String key, long unixTime)
Response<String>	BasicRedisPipeline.flushAll()
Response<String>	BasicRedisPipeline.flushDB()
Response<Long>	BinaryRedisPipeline.geoadd(byte[] key, double longitude, double latitude, byte[] member)
Response<Long>	BinaryRedisPipeline.geoadd(byte[] key, Map<byte[],GeoCoordinate> memberCoordinateMap)
Response<Long>	RedisPipeline.geoadd(String key, double longitude, double latitude, String member)
Response<Long>	RedisPipeline.geoadd(String key, Map<String,GeoCoordinate> memberCoordinateMap)
Response<Double>	BinaryRedisPipeline.geodist(byte[] key, byte[] member1, byte[] member2)
Response<Double>	BinaryRedisPipeline.geodist(byte[] key, byte[] member1, byte[] member2, GeoUnit unit)
Response<Double>	RedisPipeline.geodist(String key, String member1, String member2)
Response<Double>	RedisPipeline.geodist(String key, String member1, String member2, GeoUnit unit)
Response<List<byte[]>>	BinaryRedisPipeline.geohash(byte[] key, byte[]... members)
Response<List<String>>	RedisPipeline.geohash(String key, String... members)
Response<List<GeoCoordinate>>	BinaryRedisPipeline.geopos(byte[] key, byte[]... members)
Response<List<GeoCoordinate>>	RedisPipeline.geopos(String key, String... members)
Response<List<GeoRadiusResponse>>	BinaryRedisPipeline.georadius(byte[] key, double longitude, double latitude, double radius, GeoUnit unit)
Response<List<GeoRadiusResponse>>	BinaryRedisPipeline.georadius(byte[] key, double longitude, double latitude, double radius, GeoUnit unit, GeoRadiusParam param)
Response<List<GeoRadiusResponse>>	RedisPipeline.georadius(String key, double longitude, double latitude, double radius, GeoUnit unit)
Response<List<GeoRadiusResponse>>	RedisPipeline.georadius(String key, double longitude, double latitude, double radius, GeoUnit unit, GeoRadiusParam param)
Response<List<GeoRadiusResponse>>	BinaryRedisPipeline.georadiusByMember(byte[] key, byte[] member, double radius, GeoUnit unit)
Response<List<GeoRadiusResponse>>	BinaryRedisPipeline.georadiusByMember(byte[] key, byte[] member, double radius, GeoUnit unit, GeoRadiusParam param)
Response<List<GeoRadiusResponse>>	RedisPipeline.georadiusByMember(String key, String member, double radius, GeoUnit unit)
Response<List<GeoRadiusResponse>>	RedisPipeline.georadiusByMember(String key, String member, double radius, GeoUnit unit, GeoRadiusParam param)
Response<List<GeoRadiusResponse>>	BinaryRedisPipeline.georadiusByMemberReadonly(byte[] key, byte[] member, double radius, GeoUnit unit)
Response<List<GeoRadiusResponse>>	BinaryRedisPipeline.georadiusByMemberReadonly(byte[] key, byte[] member, double radius, GeoUnit unit, GeoRadiusParam param)
Response<List<GeoRadiusResponse>>	RedisPipeline.georadiusByMemberReadonly(String key, String member, double radius, GeoUnit unit)
Response<List<GeoRadiusResponse>>	RedisPipeline.georadiusByMemberReadonly(String key, String member, double radius, GeoUnit unit, GeoRadiusParam param)
Response<Long>	MultiKeyBinaryRedisPipeline.georadiusByMemberStore(byte[] key, byte[] member, double radius, GeoUnit unit, GeoRadiusParam param, GeoRadiusStoreParam storeParam)
Response<Long>	MultiKeyCommandsPipeline.georadiusByMemberStore(String key, String member, double radius, GeoUnit unit, GeoRadiusParam param, GeoRadiusStoreParam storeParam)
Response<List<GeoRadiusResponse>>	BinaryRedisPipeline.georadiusReadonly(byte[] key, double longitude, double latitude, double radius, GeoUnit unit)
Response<List<GeoRadiusResponse>>	BinaryRedisPipeline.georadiusReadonly(byte[] key, double longitude, double latitude, double radius, GeoUnit unit, GeoRadiusParam param)
Response<List<GeoRadiusResponse>>	RedisPipeline.georadiusReadonly(String key, double longitude, double latitude, double radius, GeoUnit unit)
Response<List<GeoRadiusResponse>>	RedisPipeline.georadiusReadonly(String key, double longitude, double latitude, double radius, GeoUnit unit, GeoRadiusParam param)
Response<Long>	MultiKeyBinaryRedisPipeline.georadiusStore(byte[] key, double longitude, double latitude, double radius, GeoUnit unit, GeoRadiusParam param, GeoRadiusStoreParam storeParam)
Response<Long>	MultiKeyCommandsPipeline.georadiusStore(String key, double longitude, double latitude, double radius, GeoUnit unit, GeoRadiusParam param, GeoRadiusStoreParam storeParam)
Response<byte[]>	BinaryRedisPipeline.get(byte[] key)
Response<String>	RedisPipeline.get(String key)
Response<Boolean>	BinaryRedisPipeline.getbit(byte[] key, long offset)
Response<Boolean>	RedisPipeline.getbit(String key, long offset)
Response<byte[]>	BinaryRedisPipeline.getrange(byte[] key, long startOffset, long endOffset)
Response<String>	RedisPipeline.getrange(String key, long startOffset, long endOffset)
Response<byte[]>	BinaryRedisPipeline.getSet(byte[] key, byte[] value)
Response<String>	RedisPipeline.getSet(String key, String value)
Response<Long>	BinaryRedisPipeline.hdel(byte[] key, byte[]... field)
Response<Long>	RedisPipeline.hdel(String key, String... field)
Response<Boolean>	BinaryRedisPipeline.hexists(byte[] key, byte[] field)
Response<Boolean>	RedisPipeline.hexists(String key, String field)
Response<byte[]>	BinaryRedisPipeline.hget(byte[] key, byte[] field)
Response<String>	RedisPipeline.hget(String key, String field)
Response<Map<byte[],byte[]>>	BinaryRedisPipeline.hgetAll(byte[] key)
Response<Map<String,String>>	RedisPipeline.hgetAll(String key)
Response<Long>	BinaryRedisPipeline.hincrBy(byte[] key, byte[] field, long value)
Response<Long>	RedisPipeline.hincrBy(String key, String field, long value)
Response<Double>	BinaryRedisPipeline.hincrByFloat(byte[] key, byte[] field, double increment)
Response<Double>	RedisPipeline.hincrByFloat(String key, String field, double increment)
Response<Set<byte[]>>	BinaryRedisPipeline.hkeys(byte[] key)
Response<Set<String>>	RedisPipeline.hkeys(String key)
Response<Long>	BinaryRedisPipeline.hlen(byte[] key)
Response<Long>	RedisPipeline.hlen(String key)
Response<List<byte[]>>	BinaryRedisPipeline.hmget(byte[] key, byte[]... fields)
Response<List<String>>	RedisPipeline.hmget(String key, String... fields)
Response<String>	BinaryRedisPipeline.hmset(byte[] key, Map<byte[],byte[]> hash)
Response<String>	RedisPipeline.hmset(String key, Map<String,String> hash)
Response<Long>	BinaryRedisPipeline.hset(byte[] key, byte[] field, byte[] value)
Response<Long>	BinaryRedisPipeline.hset(byte[] key, Map<byte[],byte[]> hash)
Response<Long>	RedisPipeline.hset(String key, String field, String value)
Response<Long>	RedisPipeline.hset(String key, Map<String,String> hash)
Response<Long>	BinaryRedisPipeline.hsetnx(byte[] key, byte[] field, byte[] value)
Response<Long>	RedisPipeline.hsetnx(String key, String field, String value)
Response<Long>	BinaryRedisPipeline.hstrlen(byte[] key, byte[] field)
Response<Long>	RedisPipeline.hstrlen(String key, String field)
Response<List<byte[]>>	BinaryRedisPipeline.hvals(byte[] key)
Response<List<String>>	RedisPipeline.hvals(String key)
Response<Long>	BinaryRedisPipeline.incr(byte[] key)
Response<Long>	RedisPipeline.incr(String key)
Response<Long>	BinaryRedisPipeline.incrBy(byte[] key, long increment)
Response<Long>	RedisPipeline.incrBy(String key, long increment)
Response<Double>	BinaryRedisPipeline.incrByFloat(byte[] key, double increment)
Response<Double>	RedisPipeline.incrByFloat(String key, double increment)
Response<String>	BasicRedisPipeline.info()
Response<Set<byte[]>>	MultiKeyBinaryRedisPipeline.keys(byte[] pattern)
Response<Set<String>>	MultiKeyCommandsPipeline.keys(String pattern)
Response<Long>	BasicRedisPipeline.lastsave()
Response<byte[]>	BinaryRedisPipeline.lindex(byte[] key, long index)
Response<String>	RedisPipeline.lindex(String key, long index)
Response<Long>	BinaryRedisPipeline.linsert(byte[] key, ListPosition where, byte[] pivot, byte[] value)
Response<Long>	RedisPipeline.linsert(String key, ListPosition where, String pivot, String value)
Response<Long>	BinaryRedisPipeline.llen(byte[] key)
Response<Long>	RedisPipeline.llen(String key)
Response<byte[]>	BinaryRedisPipeline.lpop(byte[] key)
Response<List<byte[]>>	BinaryRedisPipeline.lpop(byte[] key, int count)
Response<String>	RedisPipeline.lpop(String key)
Response<List<String>>	RedisPipeline.lpop(String key, int count)
Response<Long>	BinaryRedisPipeline.lpos(byte[] key, byte[] element)
Response<Long>	BinaryRedisPipeline.lpos(byte[] key, byte[] element, LPosParams params)
Response<List<Long>>	BinaryRedisPipeline.lpos(byte[] key, byte[] element, LPosParams params, long count)
Response<Long>	RedisPipeline.lpos(String key, String element)
Response<Long>	RedisPipeline.lpos(String key, String element, LPosParams params)
Response<List<Long>>	RedisPipeline.lpos(String key, String element, LPosParams params, long count)
Response<Long>	BinaryRedisPipeline.lpush(byte[] key, byte[]... string)
Response<Long>	RedisPipeline.lpush(String key, String... string)
Response<Long>	BinaryRedisPipeline.lpushx(byte[] key, byte[]... bytes)
Response<Long>	RedisPipeline.lpushx(String key, String... string)
Response<List<byte[]>>	BinaryRedisPipeline.lrange(byte[] key, long start, long stop)
Response<List<String>>	RedisPipeline.lrange(String key, long start, long stop)
Response<Long>	BinaryRedisPipeline.lrem(byte[] key, long count, byte[] value)
Response<Long>	RedisPipeline.lrem(String key, long count, String value)
Response<String>	BinaryRedisPipeline.lset(byte[] key, long index, byte[] value)
Response<String>	RedisPipeline.lset(String key, long index, String value)
Response<String>	BinaryRedisPipeline.ltrim(byte[] key, long start, long stop)
Response<String>	RedisPipeline.ltrim(String key, long start, long stop)
Response<List<byte[]>>	MultiKeyBinaryRedisPipeline.mget(byte[]... keys)
Response<List<String>>	MultiKeyCommandsPipeline.mget(String... keys)
Response<String>	BasicRedisPipeline.migrate(String host, int port, String key, int destinationDB, int timeout)
Response<String>	BinaryRedisPipeline.migrate(String host, int port, byte[] key, int destinationDB, int timeout)
Response<String>	MultiKeyBinaryRedisPipeline.migrate(String host, int port, int destinationDB, int timeout, MigrateParams params, byte[]... keys)
Response<String>	MultiKeyCommandsPipeline.migrate(String host, int port, int destinationDB, int timeout, MigrateParams params, String... keys)
Response<String>	RedisPipeline.migrate(String host, int port, String key, int destinationDB, int timeout)
Response<List<Module>>	BasicRedisPipeline.moduleList()
Response<String>	BasicRedisPipeline.moduleLoad(String path)
Response<String>	BasicRedisPipeline.moduleUnload(String name)
Response<Long>	BinaryRedisPipeline.move(byte[] key, int dbIndex)
Response<Long>	RedisPipeline.move(String key, int dbIndex)
Response<String>	MultiKeyBinaryRedisPipeline.mset(byte[]... keysvalues)
Response<String>	MultiKeyCommandsPipeline.mset(String... keysvalues)
Response<Long>	MultiKeyBinaryRedisPipeline.msetnx(byte[]... keysvalues)
Response<Long>	MultiKeyCommandsPipeline.msetnx(String... keysvalues)
Response<byte[]>	BinaryRedisPipeline.objectEncoding(byte[] key)
Response<String>	RedisPipeline.objectEncoding(String key)
Response<Long>	BinaryRedisPipeline.objectFreq(byte[] key)
Response<Long>	RedisPipeline.objectFreq(String key)
Response<Long>	BinaryRedisPipeline.objectIdletime(byte[] key)
Response<Long>	RedisPipeline.objectIdletime(String key)
Response<Long>	BinaryRedisPipeline.objectRefcount(byte[] key)
Response<Long>	RedisPipeline.objectRefcount(String key)
Response<Long>	BinaryRedisPipeline.persist(byte[] key)
Response<Long>	RedisPipeline.persist(String key)
Response<Long>	BinaryRedisPipeline.pexpire(byte[] key, long milliseconds)
Response<Long>	RedisPipeline.pexpire(String key, long milliseconds)
Response<Long>	BinaryRedisPipeline.pexpireAt(byte[] key, long millisecondsTimestamp)
Response<Long>	RedisPipeline.pexpireAt(String key, long millisecondsTimestamp)
Response<Long>	BinaryRedisPipeline.pfadd(byte[] key, byte[]... elements)
Response<Long>	RedisPipeline.pfadd(String key, String... elements)
Response<Long>	BinaryRedisPipeline.pfcount(byte[] key)
Response<Long>	MultiKeyBinaryRedisPipeline.pfcount(byte[]... keys)
Response<Long>	MultiKeyCommandsPipeline.pfcount(String... keys)
Response<Long>	RedisPipeline.pfcount(String key)
Response<String>	MultiKeyBinaryRedisPipeline.pfmerge(byte[] destkey, byte[]... sourcekeys)
Response<String>	MultiKeyCommandsPipeline.pfmerge(String destkey, String... sourcekeys)
Response<String>	BasicRedisPipeline.ping()
Response<String>	BinaryRedisPipeline.psetex(byte[] key, long milliseconds, byte[] value)
Response<String>	RedisPipeline.psetex(String key, long milliseconds, String value)
Response<Long>	BinaryRedisPipeline.pttl(byte[] key)
Response<Long>	RedisPipeline.pttl(String key)
Response<Long>	MultiKeyBinaryRedisPipeline.publish(byte[] channel, byte[] message)
Response<Long>	MultiKeyCommandsPipeline.publish(String channel, String message)
Response<String>	MultiKeyCommandsPipeline.randomKey()
Response<byte[]>	MultiKeyBinaryRedisPipeline.randomKeyBinary()
Response<String>	MultiKeyBinaryRedisPipeline.rename(byte[] oldkey, byte[] newkey)
Response<String>	MultiKeyCommandsPipeline.rename(String oldkey, String newkey)
Response<Long>	MultiKeyBinaryRedisPipeline.renamenx(byte[] oldkey, byte[] newkey)
Response<Long>	MultiKeyCommandsPipeline.renamenx(String oldkey, String newkey)
Response<String>	BinaryRedisPipeline.restore(byte[] key, int ttl, byte[] serializedValue)
Response<String>	RedisPipeline.restore(String key, int ttl, byte[] serializedValue)
Response<String>	BinaryRedisPipeline.restoreReplace(byte[] key, int ttl, byte[] serializedValue)
Response<String>	RedisPipeline.restoreReplace(String key, int ttl, byte[] serializedValue)
Response<byte[]>	BinaryRedisPipeline.rpop(byte[] key)
Response<List<byte[]>>	BinaryRedisPipeline.rpop(byte[] key, int count)
Response<String>	RedisPipeline.rpop(String key)
Response<List<String>>	RedisPipeline.rpop(String key, int count)
Response<byte[]>	MultiKeyBinaryRedisPipeline.rpoplpush(byte[] srckey, byte[] dstkey)
Response<String>	MultiKeyCommandsPipeline.rpoplpush(String srckey, String dstkey)
Response<Long>	BinaryRedisPipeline.rpush(byte[] key, byte[]... string)
Response<Long>	RedisPipeline.rpush(String key, String... string)
Response<Long>	BinaryRedisPipeline.rpushx(byte[] key, byte[]... string)
Response<Long>	RedisPipeline.rpushx(String key, String... string)
Response<Long>	BinaryRedisPipeline.sadd(byte[] key, byte[]... member)
Response<Long>	RedisPipeline.sadd(String key, String... member)
Response<String>	BasicRedisPipeline.save()
Response<Long>	BinaryRedisPipeline.scard(byte[] key)
Response<Long>	RedisPipeline.scard(String key)
Response<Set<byte[]>>	MultiKeyBinaryRedisPipeline.sdiff(byte[]... keys)
Response<Set<String>>	MultiKeyCommandsPipeline.sdiff(String... keys)
Response<Long>	MultiKeyBinaryRedisPipeline.sdiffstore(byte[] dstkey, byte[]... keys)
Response<Long>	MultiKeyCommandsPipeline.sdiffstore(String dstkey, String... keys)
Response<String>	BasicRedisPipeline.select(int index)
Response<String>	BinaryRedisPipeline.set(byte[] key, byte[] value)
Response<String>	BinaryRedisPipeline.set(byte[] key, byte[] value, SetParams params)
Response<String>	RedisPipeline.set(String key, String value)
Response<String>	RedisPipeline.set(String key, String value, SetParams params)
Response<Boolean>	BinaryRedisPipeline.setbit(byte[] key, long offset, byte[] value)
Response<Boolean>	RedisPipeline.setbit(String key, long offset, boolean value)
Response<String>	BinaryRedisPipeline.setex(byte[] key, int seconds, byte[] value)
Response<String>	RedisPipeline.setex(String key, int seconds, String value)
Response<Long>	BinaryRedisPipeline.setnx(byte[] key, byte[] value)
Response<Long>	RedisPipeline.setnx(String key, String value)
Response<Long>	BinaryRedisPipeline.setrange(byte[] key, long offset, byte[] value)
Response<Long>	BinaryRedisPipeline.setrange(String key, long offset, String value)
Response<Long>	RedisPipeline.setrange(String key, long offset, String value)
Response<String>	BasicRedisPipeline.shutdown()
Response<Set<byte[]>>	MultiKeyBinaryRedisPipeline.sinter(byte[]... keys)
Response<Set<String>>	MultiKeyCommandsPipeline.sinter(String... keys)
Response<Long>	MultiKeyBinaryRedisPipeline.sinterstore(byte[] dstkey, byte[]... keys)
Response<Long>	MultiKeyCommandsPipeline.sinterstore(String dstkey, String... keys)
Response<Boolean>	BinaryRedisPipeline.sismember(byte[] key, byte[] member)
Response<Boolean>	RedisPipeline.sismember(String key, String member)
Response<Set<byte[]>>	BinaryRedisPipeline.smembers(byte[] key)
Response<Set<String>>	RedisPipeline.smembers(String key)
Response<List<Boolean>>	BinaryRedisPipeline.smismember(byte[] key, byte[]... members)
Response<List<Boolean>>	RedisPipeline.smismember(String key, String... members)
Response<Long>	MultiKeyBinaryRedisPipeline.smove(byte[] srckey, byte[] dstkey, byte[] member)
Response<Long>	MultiKeyCommandsPipeline.smove(String srckey, String dstkey, String member)
Response<List<byte[]>>	BinaryRedisPipeline.sort(byte[] key)
Response<List<byte[]>>	BinaryRedisPipeline.sort(byte[] key, SortingParams sortingParameters)
Response<Long>	MultiKeyBinaryRedisPipeline.sort(byte[] key, byte[] dstkey)
Response<Long>	MultiKeyBinaryRedisPipeline.sort(byte[] key, SortingParams sortingParameters, byte[] dstkey)
Response<Long>	MultiKeyCommandsPipeline.sort(String key, String dstkey)
Response<Long>	MultiKeyCommandsPipeline.sort(String key, SortingParams sortingParameters, String dstkey)
Response<List<String>>	RedisPipeline.sort(String key)
Response<List<String>>	RedisPipeline.sort(String key, SortingParams sortingParameters)
Response<byte[]>	BinaryRedisPipeline.spop(byte[] key)
Response<Set<byte[]>>	BinaryRedisPipeline.spop(byte[] key, long count)
Response<String>	RedisPipeline.spop(String key)
Response<Set<String>>	RedisPipeline.spop(String key, long count)
Response<byte[]>	BinaryRedisPipeline.srandmember(byte[] key)
Response<List<byte[]>>	BinaryRedisPipeline.srandmember(byte[] key, int count)
Response<String>	RedisPipeline.srandmember(String key)
Response<List<String>>	RedisPipeline.srandmember(String key, int count)
Response<Long>	BinaryRedisPipeline.srem(byte[] key, byte[]... member)
Response<Long>	RedisPipeline.srem(String key, String... member)
Response<Long>	BinaryRedisPipeline.strlen(byte[] key)
Response<Long>	RedisPipeline.strlen(String key)
Response<String>	BinaryRedisPipeline.substr(byte[] key, int start, int end)
Response<String>	RedisPipeline.substr(String key, int start, int end)
Response<Set<byte[]>>	MultiKeyBinaryRedisPipeline.sunion(byte[]... keys)
Response<Set<String>>	MultiKeyCommandsPipeline.sunion(String... keys)
Response<Long>	MultiKeyBinaryRedisPipeline.sunionstore(byte[] dstkey, byte[]... keys)
Response<Long>	MultiKeyCommandsPipeline.sunionstore(String dstkey, String... keys)
Response<String>	BasicRedisPipeline.swapDB(int index1, int index2)
Response<List<String>>	BasicRedisPipeline.time()
Response<Long>	BinaryRedisPipeline.touch(byte[] keys)
Response<Long>	MultiKeyBinaryRedisPipeline.touch(byte[]... keys)
Response<Long>	MultiKeyCommandsPipeline.touch(String... keys)
Response<Long>	RedisPipeline.touch(String key)
Response<Long>	BinaryRedisPipeline.ttl(byte[] key)
Response<Long>	RedisPipeline.ttl(String key)
Response<String>	BinaryRedisPipeline.type(byte[] key)
Response<String>	RedisPipeline.type(String key)
Response<Long>	BinaryRedisPipeline.unlink(byte[] keys)
Response<Long>	MultiKeyBinaryRedisPipeline.unlink(byte[]... keys)
Response<Long>	MultiKeyCommandsPipeline.unlink(String... keys)
Response<Long>	RedisPipeline.unlink(String key)
Response<String>	MultiKeyBinaryRedisPipeline.unwatch()
Response<String>	MultiKeyCommandsPipeline.unwatch()
Response<String>	MultiKeyBinaryRedisPipeline.watch(byte[]... keys)
Response<String>	MultiKeyCommandsPipeline.watch(String... keys)
Response<Long>	BinaryRedisPipeline.xack(byte[] key, byte[] group, byte[]... ids)
Response<Long>	RedisPipeline.xack(String key, String group, StreamEntryID... ids)
Response<byte[]>	BinaryRedisPipeline.xadd(byte[] key, byte[] id, Map<byte[],byte[]> hash)
Response<byte[]>	BinaryRedisPipeline.xadd(byte[] key, byte[] id, Map<byte[],byte[]> hash, long maxLen, boolean approximateLength)
Response<StreamEntryID>	RedisPipeline.xadd(String key, StreamEntryID id, Map<String,String> hash)
Response<StreamEntryID>	RedisPipeline.xadd(String key, StreamEntryID id, Map<String,String> hash, long maxLen, boolean approximateLength)
Response<List<byte[]>>	BinaryRedisPipeline.xclaim(byte[] key, byte[] group, byte[] consumername, long minIdleTime, long newIdleTime, int retries, boolean force, byte[]... ids)
Response<List<StreamEntry>>	RedisPipeline.xclaim(String key, String group, String consumername, long minIdleTime, long newIdleTime, int retries, boolean force, StreamEntryID... ids)
Response<Long>	BinaryRedisPipeline.xdel(byte[] key, byte[]... ids)
Response<Long>	RedisPipeline.xdel(String key, StreamEntryID... ids)
Response<String>	BinaryRedisPipeline.xgroupCreate(byte[] key, byte[] groupname, byte[] id, boolean makeStream)
Response<String>	RedisPipeline.xgroupCreate(String key, String groupname, StreamEntryID id, boolean makeStream)
Response<Long>	BinaryRedisPipeline.xgroupDelConsumer(byte[] key, byte[] groupname, byte[] consumername)
Response<Long>	RedisPipeline.xgroupDelConsumer(String key, String groupname, String consumername)
Response<Long>	BinaryRedisPipeline.xgroupDestroy(byte[] key, byte[] groupname)
Response<Long>	RedisPipeline.xgroupDestroy(String key, String groupname)
Response<String>	BinaryRedisPipeline.xgroupSetID(byte[] key, byte[] groupname, byte[] id)
Response<String>	RedisPipeline.xgroupSetID(String key, String groupname, StreamEntryID id)
Response<Long>	BinaryRedisPipeline.xlen(byte[] key)
Response<Long>	RedisPipeline.xlen(String key)
Response<List<StreamPendingEntry>>	BinaryRedisPipeline.xpending(byte[] key, byte[] groupname, byte[] start, byte[] end, int count, byte[] consumername)
Response<List<StreamPendingEntry>>	RedisPipeline.xpending(String key, String groupname, StreamEntryID start, StreamEntryID end, int count, String consumername)
Response<List<byte[]>>	BinaryRedisPipeline.xrange(byte[] key, byte[] start, byte[] end, int count)
Response<List<StreamEntry>>	RedisPipeline.xrange(String key, StreamEntryID start, StreamEntryID end, int count)
Response<List<byte[]>>	BinaryRedisPipeline.xrevrange(byte[] key, byte[] end, byte[] start, int count)
Response<List<StreamEntry>>	RedisPipeline.xrevrange(String key, StreamEntryID end, StreamEntryID start, int count)
Response<Long>	BinaryRedisPipeline.xtrim(byte[] key, long maxLen, boolean approximateLength)
Response<Long>	RedisPipeline.xtrim(String key, long maxLen, boolean approximateLength)
Response<Long>	BinaryRedisPipeline.zadd(byte[] key, double score, byte[] member)
Response<Long>	BinaryRedisPipeline.zadd(byte[] key, double score, byte[] member, ZAddParams params)
Response<Long>	BinaryRedisPipeline.zadd(byte[] key, Map<byte[],Double> scoreMembers)
Response<Long>	BinaryRedisPipeline.zadd(byte[] key, Map<byte[],Double> scoreMembers, ZAddParams params)
Response<Long>	RedisPipeline.zadd(String key, double score, String member)
Response<Long>	RedisPipeline.zadd(String key, double score, String member, ZAddParams params)
Response<Long>	RedisPipeline.zadd(String key, Map<String,Double> scoreMembers)
Response<Long>	RedisPipeline.zadd(String key, Map<String,Double> scoreMembers, ZAddParams params)
Response<Long>	BinaryRedisPipeline.zcard(byte[] key)
Response<Long>	RedisPipeline.zcard(String key)
Response<Long>	BinaryRedisPipeline.zcount(byte[] key, byte[] min, byte[] max)
Response<Long>	BinaryRedisPipeline.zcount(byte[] key, double min, double max)
Response<Long>	RedisPipeline.zcount(String key, double min, double max)
Response<Long>	RedisPipeline.zcount(String key, String min, String max)
Response<Double>	BinaryRedisPipeline.zincrby(byte[] key, double increment, byte[] member)
Response<Double>	BinaryRedisPipeline.zincrby(byte[] key, double increment, byte[] member, ZIncrByParams params)
Response<Double>	RedisPipeline.zincrby(String key, double increment, String member)
Response<Double>	RedisPipeline.zincrby(String key, double increment, String member, ZIncrByParams params)
Response<Long>	MultiKeyBinaryRedisPipeline.zinterstore(byte[] dstkey, byte[]... sets)
Response<Long>	MultiKeyBinaryRedisPipeline.zinterstore(byte[] dstkey, ZParams params, byte[]... sets)
Response<Long>	MultiKeyCommandsPipeline.zinterstore(String dstkey, String... sets)
Response<Long>	MultiKeyCommandsPipeline.zinterstore(String dstkey, ZParams params, String... sets)
Response<Long>	BinaryRedisPipeline.zlexcount(byte[] key, byte[] min, byte[] max)
Response<Long>	RedisPipeline.zlexcount(String key, String min, String max)
Response<List<Double>>	BinaryRedisPipeline.zmscore(byte[] key, byte[]... members)
Response<List<Double>>	RedisPipeline.zmscore(String key, String... members)
Response<Tuple>	BinaryRedisPipeline.zpopmax(byte[] key)
Response<Set<Tuple>>	BinaryRedisPipeline.zpopmax(byte[] key, int count)
Response<Tuple>	RedisPipeline.zpopmax(String key)
Response<Set<Tuple>>	RedisPipeline.zpopmax(String key, int count)
Response<Tuple>	BinaryRedisPipeline.zpopmin(byte[] key)
Response<Set<Tuple>>	BinaryRedisPipeline.zpopmin(byte[] key, int count)
Response<Tuple>	RedisPipeline.zpopmin(String key)
Response<Set<Tuple>>	RedisPipeline.zpopmin(String key, int count)
Response<Set<byte[]>>	BinaryRedisPipeline.zrange(byte[] key, long start, long stop)
Response<Set<String>>	RedisPipeline.zrange(String key, long start, long stop)
Response<Set<byte[]>>	BinaryRedisPipeline.zrangeByLex(byte[] key, byte[] min, byte[] max)
Response<Set<byte[]>>	BinaryRedisPipeline.zrangeByLex(byte[] key, byte[] min, byte[] max, int offset, int count)
Response<Set<String>>	RedisPipeline.zrangeByLex(String key, String min, String max)
Response<Set<String>>	RedisPipeline.zrangeByLex(String key, String min, String max, int offset, int count)
Response<Set<byte[]>>	BinaryRedisPipeline.zrangeByScore(byte[] key, byte[] min, byte[] max)
Response<Set<byte[]>>	BinaryRedisPipeline.zrangeByScore(byte[] key, byte[] min, byte[] max, int offset, int count)
Response<Set<byte[]>>	BinaryRedisPipeline.zrangeByScore(byte[] key, double min, double max)
Response<Set<byte[]>>	BinaryRedisPipeline.zrangeByScore(byte[] key, double min, double max, int offset, int count)
Response<Set<String>>	RedisPipeline.zrangeByScore(String key, double min, double max)
Response<Set<String>>	RedisPipeline.zrangeByScore(String key, double min, double max, int offset, int count)
Response<Set<String>>	RedisPipeline.zrangeByScore(String key, String min, String max)
Response<Set<String>>	RedisPipeline.zrangeByScore(String key, String min, String max, int offset, int count)
Response<Set<Tuple>>	BinaryRedisPipeline.zrangeByScoreWithScores(byte[] key, byte[] min, byte[] max)
Response<Set<Tuple>>	BinaryRedisPipeline.zrangeByScoreWithScores(byte[] key, byte[] min, byte[] max, int offset, int count)
Response<Set<Tuple>>	BinaryRedisPipeline.zrangeByScoreWithScores(byte[] key, double min, double max)
Response<Set<Tuple>>	BinaryRedisPipeline.zrangeByScoreWithScores(byte[] key, double min, double max, int offset, int count)
Response<Set<Tuple>>	RedisPipeline.zrangeByScoreWithScores(String key, double min, double max)
Response<Set<Tuple>>	RedisPipeline.zrangeByScoreWithScores(String key, double min, double max, int offset, int count)
Response<Set<Tuple>>	RedisPipeline.zrangeByScoreWithScores(String key, String min, String max)
Response<Set<Tuple>>	RedisPipeline.zrangeByScoreWithScores(String key, String min, String max, int offset, int count)
Response<Set<Tuple>>	BinaryRedisPipeline.zrangeWithScores(byte[] key, long start, long stop)
Response<Set<Tuple>>	RedisPipeline.zrangeWithScores(String key, long start, long stop)
Response<Long>	BinaryRedisPipeline.zrank(byte[] key, byte[] member)
Response<Long>	RedisPipeline.zrank(String key, String member)
Response<Long>	BinaryRedisPipeline.zrem(byte[] key, byte[]... members)
Response<Long>	RedisPipeline.zrem(String key, String... members)
Response<Long>	BinaryRedisPipeline.zremrangeByLex(byte[] key, byte[] min, byte[] max)
Response<Long>	RedisPipeline.zremrangeByLex(String key, String min, String max)
Response<Long>	BinaryRedisPipeline.zremrangeByRank(byte[] key, long start, long stop)
Response<Long>	RedisPipeline.zremrangeByRank(String key, long start, long stop)
Response<Long>	BinaryRedisPipeline.zremrangeByScore(byte[] key, byte[] min, byte[] max)
Response<Long>	BinaryRedisPipeline.zremrangeByScore(byte[] key, double min, double max)
Response<Long>	RedisPipeline.zremrangeByScore(String key, double min, double max)
Response<Long>	RedisPipeline.zremrangeByScore(String key, String min, String max)
Response<Set<byte[]>>	BinaryRedisPipeline.zrevrange(byte[] key, long start, long stop)
Response<Set<String>>	RedisPipeline.zrevrange(String key, long start, long stop)
Response<Set<byte[]>>	BinaryRedisPipeline.zrevrangeByLex(byte[] key, byte[] max, byte[] min)
Response<Set<byte[]>>	BinaryRedisPipeline.zrevrangeByLex(byte[] key, byte[] max, byte[] min, int offset, int count)
Response<Set<String>>	RedisPipeline.zrevrangeByLex(String key, String max, String min)
Response<Set<String>>	RedisPipeline.zrevrangeByLex(String key, String max, String min, int offset, int count)
Response<Set<byte[]>>	BinaryRedisPipeline.zrevrangeByScore(byte[] key, byte[] max, byte[] min)
Response<Set<byte[]>>	BinaryRedisPipeline.zrevrangeByScore(byte[] key, byte[] max, byte[] min, int offset, int count)
Response<Set<byte[]>>	BinaryRedisPipeline.zrevrangeByScore(byte[] key, double max, double min)
Response<Set<byte[]>>	BinaryRedisPipeline.zrevrangeByScore(byte[] key, double max, double min, int offset, int count)
Response<Set<String>>	RedisPipeline.zrevrangeByScore(String key, double max, double min)
Response<Set<String>>	RedisPipeline.zrevrangeByScore(String key, double max, double min, int offset, int count)
Response<Set<String>>	RedisPipeline.zrevrangeByScore(String key, String max, String min)
Response<Set<String>>	RedisPipeline.zrevrangeByScore(String key, String max, String min, int offset, int count)
Response<Set<Tuple>>	BinaryRedisPipeline.zrevrangeByScoreWithScores(byte[] key, byte[] max, byte[] min)
Response<Set<Tuple>>	BinaryRedisPipeline.zrevrangeByScoreWithScores(byte[] key, byte[] max, byte[] min, int offset, int count)
Response<Set<Tuple>>	BinaryRedisPipeline.zrevrangeByScoreWithScores(byte[] key, double max, double min)
Response<Set<Tuple>>	BinaryRedisPipeline.zrevrangeByScoreWithScores(byte[] key, double max, double min, int offset, int count)
Response<Set<Tuple>>	RedisPipeline.zrevrangeByScoreWithScores(String key, double max, double min)
Response<Set<Tuple>>	RedisPipeline.zrevrangeByScoreWithScores(String key, double max, double min, int offset, int count)
Response<Set<Tuple>>	RedisPipeline.zrevrangeByScoreWithScores(String key, String max, String min)
Response<Set<Tuple>>	RedisPipeline.zrevrangeByScoreWithScores(String key, String max, String min, int offset, int count)
Response<Set<Tuple>>	BinaryRedisPipeline.zrevrangeWithScores(byte[] key, long start, long stop)
Response<Set<Tuple>>	RedisPipeline.zrevrangeWithScores(String key, long start, long stop)
Response<Long>	BinaryRedisPipeline.zrevrank(byte[] key, byte[] member)
Response<Long>	RedisPipeline.zrevrank(String key, String member)
Response<Double>	BinaryRedisPipeline.zscore(byte[] key, byte[] member)
Response<Double>	RedisPipeline.zscore(String key, String member)
Response<Long>	MultiKeyBinaryRedisPipeline.zunionstore(byte[] dstkey, byte[]... sets)
Response<Long>	MultiKeyBinaryRedisPipeline.zunionstore(byte[] dstkey, ZParams params, byte[]... sets)
Response<Long>	MultiKeyCommandsPipeline.zunionstore(String dstkey, String... sets)
Response<Long>	MultiKeyCommandsPipeline.zunionstore(String dstkey, ZParams params, String... sets)