Uses of Class
redis.clients.jedis.Tuple

Packages that use Tuple

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

Uses of Tuple in redis.clients.jedis

Fields in redis.clients.jedis with type parameters of type Tuple

Modifier and Type	Field and Description
static Builder<Tuple>	BuilderFactory.TUPLE
static Builder<Set<Tuple>>	BuilderFactory.TUPLE_ZSET

Methods in redis.clients.jedis that return Tuple

Modifier and Type	Method and Description
Tuple	BinaryJedisCluster.zpopmax(byte[] key)
Tuple	BinaryJedis.zpopmax(byte[] key)
Tuple	BinaryShardedJedis.zpopmax(byte[] key)
Tuple	Jedis.zpopmax(String key)
Tuple	ShardedJedis.zpopmax(String key)
Tuple	JedisCluster.zpopmax(String key)
Tuple	BinaryJedisCluster.zpopmin(byte[] key)
Tuple	BinaryJedis.zpopmin(byte[] key)
Tuple	BinaryShardedJedis.zpopmin(byte[] key)
Tuple	Jedis.zpopmin(String key)
Tuple	ShardedJedis.zpopmin(String key)
Tuple	JedisCluster.zpopmin(String key)

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

Modifier and Type	Method and Description
protected Set<Tuple>	BinaryJedis.getTupledSet()
Response<Tuple>	PipelineBase.zpopmax(byte[] key)
Set<Tuple>	BinaryJedisCluster.zpopmax(byte[] key, int count)
Set<Tuple>	BinaryJedis.zpopmax(byte[] key, int count)
Response<Set<Tuple>>	PipelineBase.zpopmax(byte[] key, int count)
Set<Tuple>	BinaryShardedJedis.zpopmax(byte[] key, int count)
Response<Tuple>	PipelineBase.zpopmax(String key)
Set<Tuple>	Jedis.zpopmax(String key, int count)
Set<Tuple>	ShardedJedis.zpopmax(String key, int count)
Response<Set<Tuple>>	PipelineBase.zpopmax(String key, int count)
Set<Tuple>	JedisCluster.zpopmax(String key, int count)
Response<Tuple>	PipelineBase.zpopmin(byte[] key)
Set<Tuple>	BinaryJedisCluster.zpopmin(byte[] key, int count)
Set<Tuple>	BinaryJedis.zpopmin(byte[] key, int count)
Response<Set<Tuple>>	PipelineBase.zpopmin(byte[] key, int count)
Set<Tuple>	BinaryShardedJedis.zpopmin(byte[] key, int count)
Response<Tuple>	PipelineBase.zpopmin(String key)
Set<Tuple>	Jedis.zpopmin(String key, int count)
Set<Tuple>	ShardedJedis.zpopmin(String key, int count)
Response<Set<Tuple>>	PipelineBase.zpopmin(String key, int count)
Set<Tuple>	JedisCluster.zpopmin(String key, int count)
Set<Tuple>	BinaryJedisCluster.zrangeByScoreWithScores(byte[] key, byte[] min, byte[] max)
Set<Tuple>	BinaryJedis.zrangeByScoreWithScores(byte[] key, byte[] min, byte[] max)
Response<Set<Tuple>>	PipelineBase.zrangeByScoreWithScores(byte[] key, byte[] min, byte[] max)
Set<Tuple>	BinaryShardedJedis.zrangeByScoreWithScores(byte[] key, byte[] min, byte[] max)
Set<Tuple>	BinaryJedisCluster.zrangeByScoreWithScores(byte[] key, byte[] min, byte[] max, int offset, int count)
Set<Tuple>	BinaryJedis.zrangeByScoreWithScores(byte[] key, byte[] min, byte[] max, int offset, int count)
Response<Set<Tuple>>	PipelineBase.zrangeByScoreWithScores(byte[] key, byte[] min, byte[] max, int offset, int count)
Set<Tuple>	BinaryShardedJedis.zrangeByScoreWithScores(byte[] key, byte[] min, byte[] max, int offset, int count)
Set<Tuple>	BinaryJedisCluster.zrangeByScoreWithScores(byte[] key, double min, double max)
Set<Tuple>	BinaryJedis.zrangeByScoreWithScores(byte[] key, double min, double max) Return the all the elements in the sorted set at key with a score between min and max (including elements with score equal to min or max).
Response<Set<Tuple>>	PipelineBase.zrangeByScoreWithScores(byte[] key, double min, double max)
Set<Tuple>	BinaryShardedJedis.zrangeByScoreWithScores(byte[] key, double min, double max)
Set<Tuple>	BinaryJedisCluster.zrangeByScoreWithScores(byte[] key, double min, double max, int offset, int count)
Set<Tuple>	BinaryJedis.zrangeByScoreWithScores(byte[] key, double min, double max, int offset, int count) Return the all the elements in the sorted set at key with a score between min and max (including elements with score equal to min or max).
Response<Set<Tuple>>	PipelineBase.zrangeByScoreWithScores(byte[] key, double min, double max, int offset, int count)
Set<Tuple>	BinaryShardedJedis.zrangeByScoreWithScores(byte[] key, double min, double max, int offset, int count)
Set<Tuple>	Jedis.zrangeByScoreWithScores(String key, double min, double max) Return the all the elements in the sorted set at key with a score between min and max (including elements with score equal to min or max).
Set<Tuple>	ShardedJedis.zrangeByScoreWithScores(String key, double min, double max)
Response<Set<Tuple>>	PipelineBase.zrangeByScoreWithScores(String key, double min, double max)
Set<Tuple>	JedisCluster.zrangeByScoreWithScores(String key, double min, double max)
Set<Tuple>	Jedis.zrangeByScoreWithScores(String key, double min, double max, int offset, int count) Return the all the elements in the sorted set at key with a score between min and max (including elements with score equal to min or max).
Set<Tuple>	ShardedJedis.zrangeByScoreWithScores(String key, double min, double max, int offset, int count)
Response<Set<Tuple>>	PipelineBase.zrangeByScoreWithScores(String key, double min, double max, int offset, int count)
Set<Tuple>	JedisCluster.zrangeByScoreWithScores(String key, double min, double max, int offset, int count)
Set<Tuple>	Jedis.zrangeByScoreWithScores(String key, String min, String max)
Set<Tuple>	ShardedJedis.zrangeByScoreWithScores(String key, String min, String max)
Response<Set<Tuple>>	PipelineBase.zrangeByScoreWithScores(String key, String min, String max)
Set<Tuple>	JedisCluster.zrangeByScoreWithScores(String key, String min, String max)
Set<Tuple>	Jedis.zrangeByScoreWithScores(String key, String min, String max, int offset, int count)
Set<Tuple>	ShardedJedis.zrangeByScoreWithScores(String key, String min, String max, int offset, int count)
Response<Set<Tuple>>	PipelineBase.zrangeByScoreWithScores(String key, String min, String max, int offset, int count)
Set<Tuple>	JedisCluster.zrangeByScoreWithScores(String key, String min, String max, int offset, int count)
Set<Tuple>	BinaryJedisCluster.zrangeWithScores(byte[] key, long start, long stop)
Set<Tuple>	BinaryJedis.zrangeWithScores(byte[] key, long start, long stop)
Response<Set<Tuple>>	PipelineBase.zrangeWithScores(byte[] key, long start, long stop)
Set<Tuple>	BinaryShardedJedis.zrangeWithScores(byte[] key, long start, long stop)
Set<Tuple>	Jedis.zrangeWithScores(String key, long start, long stop)
Set<Tuple>	ShardedJedis.zrangeWithScores(String key, long start, long stop)
Response<Set<Tuple>>	PipelineBase.zrangeWithScores(String key, long start, long stop)
Set<Tuple>	JedisCluster.zrangeWithScores(String key, long start, long stop)
Set<Tuple>	BinaryJedisCluster.zrevrangeByScoreWithScores(byte[] key, byte[] max, byte[] min)
Set<Tuple>	BinaryJedis.zrevrangeByScoreWithScores(byte[] key, byte[] max, byte[] min)
Response<Set<Tuple>>	PipelineBase.zrevrangeByScoreWithScores(byte[] key, byte[] max, byte[] min)
Set<Tuple>	BinaryShardedJedis.zrevrangeByScoreWithScores(byte[] key, byte[] max, byte[] min)
Set<Tuple>	BinaryJedisCluster.zrevrangeByScoreWithScores(byte[] key, byte[] max, byte[] min, int offset, int count)
Set<Tuple>	BinaryJedis.zrevrangeByScoreWithScores(byte[] key, byte[] max, byte[] min, int offset, int count)
Response<Set<Tuple>>	PipelineBase.zrevrangeByScoreWithScores(byte[] key, byte[] max, byte[] min, int offset, int count)
Set<Tuple>	BinaryShardedJedis.zrevrangeByScoreWithScores(byte[] key, byte[] max, byte[] min, int offset, int count)
Set<Tuple>	BinaryJedisCluster.zrevrangeByScoreWithScores(byte[] key, double max, double min)
Set<Tuple>	BinaryJedis.zrevrangeByScoreWithScores(byte[] key, double max, double min)
Response<Set<Tuple>>	PipelineBase.zrevrangeByScoreWithScores(byte[] key, double max, double min)
Set<Tuple>	BinaryShardedJedis.zrevrangeByScoreWithScores(byte[] key, double max, double min)
Set<Tuple>	BinaryJedisCluster.zrevrangeByScoreWithScores(byte[] key, double max, double min, int offset, int count)
Set<Tuple>	BinaryJedis.zrevrangeByScoreWithScores(byte[] key, double max, double min, int offset, int count)
Response<Set<Tuple>>	PipelineBase.zrevrangeByScoreWithScores(byte[] key, double max, double min, int offset, int count)
Set<Tuple>	BinaryShardedJedis.zrevrangeByScoreWithScores(byte[] key, double max, double min, int offset, int count)
Set<Tuple>	Jedis.zrevrangeByScoreWithScores(String key, double max, double min)
Set<Tuple>	ShardedJedis.zrevrangeByScoreWithScores(String key, double max, double min)
Response<Set<Tuple>>	PipelineBase.zrevrangeByScoreWithScores(String key, double max, double min)
Set<Tuple>	JedisCluster.zrevrangeByScoreWithScores(String key, double max, double min)
Set<Tuple>	Jedis.zrevrangeByScoreWithScores(String key, double max, double min, int offset, int count)
Set<Tuple>	ShardedJedis.zrevrangeByScoreWithScores(String key, double max, double min, int offset, int count)
Response<Set<Tuple>>	PipelineBase.zrevrangeByScoreWithScores(String key, double max, double min, int offset, int count)
Set<Tuple>	JedisCluster.zrevrangeByScoreWithScores(String key, double max, double min, int offset, int count)
Set<Tuple>	Jedis.zrevrangeByScoreWithScores(String key, String max, String min)
Set<Tuple>	ShardedJedis.zrevrangeByScoreWithScores(String key, String max, String min)
Response<Set<Tuple>>	PipelineBase.zrevrangeByScoreWithScores(String key, String max, String min)
Set<Tuple>	JedisCluster.zrevrangeByScoreWithScores(String key, String max, String min)
Set<Tuple>	Jedis.zrevrangeByScoreWithScores(String key, String max, String min, int offset, int count)
Set<Tuple>	ShardedJedis.zrevrangeByScoreWithScores(String key, String max, String min, int offset, int count)
Response<Set<Tuple>>	PipelineBase.zrevrangeByScoreWithScores(String key, String max, String min, int offset, int count)
Set<Tuple>	JedisCluster.zrevrangeByScoreWithScores(String key, String max, String min, int offset, int count)
Set<Tuple>	BinaryJedisCluster.zrevrangeWithScores(byte[] key, long start, long stop)
Set<Tuple>	BinaryJedis.zrevrangeWithScores(byte[] key, long start, long stop)
Response<Set<Tuple>>	PipelineBase.zrevrangeWithScores(byte[] key, long start, long stop)
Set<Tuple>	BinaryShardedJedis.zrevrangeWithScores(byte[] key, long start, long stop)
Set<Tuple>	Jedis.zrevrangeWithScores(String key, long start, long stop)
Set<Tuple>	ShardedJedis.zrevrangeWithScores(String key, long start, long stop)
Response<Set<Tuple>>	PipelineBase.zrevrangeWithScores(String key, long start, long stop)
Set<Tuple>	JedisCluster.zrevrangeWithScores(String key, long start, long stop)
ScanResult<Tuple>	BinaryJedisCluster.zscan(byte[] key, byte[] cursor)
ScanResult<Tuple>	BinaryJedis.zscan(byte[] key, byte[] cursor)
ScanResult<Tuple>	BinaryShardedJedis.zscan(byte[] key, byte[] cursor)
ScanResult<Tuple>	BinaryJedisCluster.zscan(byte[] key, byte[] cursor, ScanParams params)
ScanResult<Tuple>	BinaryJedis.zscan(byte[] key, byte[] cursor, ScanParams params)
ScanResult<Tuple>	BinaryShardedJedis.zscan(byte[] key, byte[] cursor, ScanParams params)
ScanResult<Tuple>	Jedis.zscan(String key, String cursor)
ScanResult<Tuple>	ShardedJedis.zscan(String key, String cursor)
ScanResult<Tuple>	JedisCluster.zscan(String key, String cursor)
ScanResult<Tuple>	Jedis.zscan(String key, String cursor, ScanParams params)
ScanResult<Tuple>	ShardedJedis.zscan(String key, String cursor, ScanParams params)

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

Modifier and Type	Method and Description
static int	Tuple.compare(Tuple t1, Tuple t2)
int	Tuple.compareTo(Tuple other)

Uses of Tuple in redis.clients.jedis.commands

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

Modifier and Type	Method and Description
Tuple	BinaryJedisCommands.zpopmax(byte[] key)
Tuple	BinaryJedisClusterCommands.zpopmax(byte[] key)
Tuple	JedisClusterCommands.zpopmax(String key)
Tuple	JedisCommands.zpopmax(String key)
Tuple	BinaryJedisCommands.zpopmin(byte[] key)
Tuple	BinaryJedisClusterCommands.zpopmin(byte[] key)
Tuple	JedisClusterCommands.zpopmin(String key)
Tuple	JedisCommands.zpopmin(String key)

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

Modifier and Type	Method and Description
Response<Tuple>	BinaryRedisPipeline.zpopmax(byte[] key)
Set<Tuple>	BinaryJedisCommands.zpopmax(byte[] key, int count)
Response<Set<Tuple>>	BinaryRedisPipeline.zpopmax(byte[] key, int count)
Set<Tuple>	BinaryJedisClusterCommands.zpopmax(byte[] key, int count)
Response<Tuple>	RedisPipeline.zpopmax(String key)
Set<Tuple>	JedisClusterCommands.zpopmax(String key, int count)
Response<Set<Tuple>>	RedisPipeline.zpopmax(String key, int count)
Set<Tuple>	JedisCommands.zpopmax(String key, int count)
Response<Tuple>	BinaryRedisPipeline.zpopmin(byte[] key)
Set<Tuple>	BinaryJedisCommands.zpopmin(byte[] key, int count)
Response<Set<Tuple>>	BinaryRedisPipeline.zpopmin(byte[] key, int count)
Set<Tuple>	BinaryJedisClusterCommands.zpopmin(byte[] key, int count)
Response<Tuple>	RedisPipeline.zpopmin(String key)
Set<Tuple>	JedisClusterCommands.zpopmin(String key, int count)
Response<Set<Tuple>>	RedisPipeline.zpopmin(String key, int count)
Set<Tuple>	JedisCommands.zpopmin(String key, int count)
Set<Tuple>	BinaryJedisCommands.zrangeByScoreWithScores(byte[] key, byte[] min, byte[] max)
Response<Set<Tuple>>	BinaryRedisPipeline.zrangeByScoreWithScores(byte[] key, byte[] min, byte[] max)
Set<Tuple>	BinaryJedisClusterCommands.zrangeByScoreWithScores(byte[] key, byte[] min, byte[] max)
Set<Tuple>	BinaryJedisCommands.zrangeByScoreWithScores(byte[] key, byte[] min, byte[] max, int offset, int count)
Response<Set<Tuple>>	BinaryRedisPipeline.zrangeByScoreWithScores(byte[] key, byte[] min, byte[] max, int offset, int count)
Set<Tuple>	BinaryJedisClusterCommands.zrangeByScoreWithScores(byte[] key, byte[] min, byte[] max, int offset, int count)
Set<Tuple>	BinaryJedisCommands.zrangeByScoreWithScores(byte[] key, double min, double max)
Response<Set<Tuple>>	BinaryRedisPipeline.zrangeByScoreWithScores(byte[] key, double min, double max)
Set<Tuple>	BinaryJedisClusterCommands.zrangeByScoreWithScores(byte[] key, double min, double max)
Set<Tuple>	BinaryJedisCommands.zrangeByScoreWithScores(byte[] key, double min, double max, int offset, int count)
Response<Set<Tuple>>	BinaryRedisPipeline.zrangeByScoreWithScores(byte[] key, double min, double max, int offset, int count)
Set<Tuple>	BinaryJedisClusterCommands.zrangeByScoreWithScores(byte[] key, double min, double max, int offset, int count)
Set<Tuple>	JedisClusterCommands.zrangeByScoreWithScores(String key, double min, double max)
Response<Set<Tuple>>	RedisPipeline.zrangeByScoreWithScores(String key, double min, double max)
Set<Tuple>	JedisCommands.zrangeByScoreWithScores(String key, double min, double max)
Set<Tuple>	JedisClusterCommands.zrangeByScoreWithScores(String key, double min, double max, int offset, int count)
Response<Set<Tuple>>	RedisPipeline.zrangeByScoreWithScores(String key, double min, double max, int offset, int count)
Set<Tuple>	JedisCommands.zrangeByScoreWithScores(String key, double min, double max, int offset, int count)
Set<Tuple>	JedisClusterCommands.zrangeByScoreWithScores(String key, String min, String max)
Response<Set<Tuple>>	RedisPipeline.zrangeByScoreWithScores(String key, String min, String max)
Set<Tuple>	JedisCommands.zrangeByScoreWithScores(String key, String min, String max)
Set<Tuple>	JedisClusterCommands.zrangeByScoreWithScores(String key, String min, String max, int offset, int count)
Response<Set<Tuple>>	RedisPipeline.zrangeByScoreWithScores(String key, String min, String max, int offset, int count)
Set<Tuple>	JedisCommands.zrangeByScoreWithScores(String key, String min, String max, int offset, int count)
Set<Tuple>	BinaryJedisCommands.zrangeWithScores(byte[] key, long start, long stop)
Response<Set<Tuple>>	BinaryRedisPipeline.zrangeWithScores(byte[] key, long start, long stop)
Set<Tuple>	BinaryJedisClusterCommands.zrangeWithScores(byte[] key, long start, long stop)
Set<Tuple>	JedisClusterCommands.zrangeWithScores(String key, long start, long stop)
Response<Set<Tuple>>	RedisPipeline.zrangeWithScores(String key, long start, long stop)
Set<Tuple>	JedisCommands.zrangeWithScores(String key, long start, long stop)
Set<Tuple>	BinaryJedisCommands.zrevrangeByScoreWithScores(byte[] key, byte[] max, byte[] min)
Response<Set<Tuple>>	BinaryRedisPipeline.zrevrangeByScoreWithScores(byte[] key, byte[] max, byte[] min)
Set<Tuple>	BinaryJedisClusterCommands.zrevrangeByScoreWithScores(byte[] key, byte[] max, byte[] min)
Set<Tuple>	BinaryJedisCommands.zrevrangeByScoreWithScores(byte[] key, byte[] max, byte[] min, int offset, int count)
Response<Set<Tuple>>	BinaryRedisPipeline.zrevrangeByScoreWithScores(byte[] key, byte[] max, byte[] min, int offset, int count)
Set<Tuple>	BinaryJedisClusterCommands.zrevrangeByScoreWithScores(byte[] key, byte[] max, byte[] min, int offset, int count)
Set<Tuple>	BinaryJedisCommands.zrevrangeByScoreWithScores(byte[] key, double max, double min)
Response<Set<Tuple>>	BinaryRedisPipeline.zrevrangeByScoreWithScores(byte[] key, double max, double min)
Set<Tuple>	BinaryJedisClusterCommands.zrevrangeByScoreWithScores(byte[] key, double max, double min)
Set<Tuple>	BinaryJedisCommands.zrevrangeByScoreWithScores(byte[] key, double max, double min, int offset, int count)
Response<Set<Tuple>>	BinaryRedisPipeline.zrevrangeByScoreWithScores(byte[] key, double max, double min, int offset, int count)
Set<Tuple>	BinaryJedisClusterCommands.zrevrangeByScoreWithScores(byte[] key, double max, double min, int offset, int count)
Set<Tuple>	JedisClusterCommands.zrevrangeByScoreWithScores(String key, double max, double min)
Response<Set<Tuple>>	RedisPipeline.zrevrangeByScoreWithScores(String key, double max, double min)
Set<Tuple>	JedisCommands.zrevrangeByScoreWithScores(String key, double max, double min)
Set<Tuple>	JedisClusterCommands.zrevrangeByScoreWithScores(String key, double max, double min, int offset, int count)
Response<Set<Tuple>>	RedisPipeline.zrevrangeByScoreWithScores(String key, double max, double min, int offset, int count)
Set<Tuple>	JedisCommands.zrevrangeByScoreWithScores(String key, double max, double min, int offset, int count)
Set<Tuple>	JedisClusterCommands.zrevrangeByScoreWithScores(String key, String max, String min)
Response<Set<Tuple>>	RedisPipeline.zrevrangeByScoreWithScores(String key, String max, String min)
Set<Tuple>	JedisCommands.zrevrangeByScoreWithScores(String key, String max, String min)
Set<Tuple>	JedisClusterCommands.zrevrangeByScoreWithScores(String key, String max, String min, int offset, int count)
Response<Set<Tuple>>	RedisPipeline.zrevrangeByScoreWithScores(String key, String max, String min, int offset, int count)
Set<Tuple>	JedisCommands.zrevrangeByScoreWithScores(String key, String max, String min, int offset, int count)
Set<Tuple>	BinaryJedisCommands.zrevrangeWithScores(byte[] key, long start, long stop)
Response<Set<Tuple>>	BinaryRedisPipeline.zrevrangeWithScores(byte[] key, long start, long stop)
Set<Tuple>	BinaryJedisClusterCommands.zrevrangeWithScores(byte[] key, long start, long stop)
Set<Tuple>	JedisClusterCommands.zrevrangeWithScores(String key, long start, long stop)
Response<Set<Tuple>>	RedisPipeline.zrevrangeWithScores(String key, long start, long stop)
Set<Tuple>	JedisCommands.zrevrangeWithScores(String key, long start, long stop)
ScanResult<Tuple>	BinaryJedisCommands.zscan(byte[] key, byte[] cursor)
ScanResult<Tuple>	BinaryJedisClusterCommands.zscan(byte[] key, byte[] cursor)
ScanResult<Tuple>	BinaryJedisCommands.zscan(byte[] key, byte[] cursor, ScanParams params)
ScanResult<Tuple>	BinaryJedisClusterCommands.zscan(byte[] key, byte[] cursor, ScanParams params)
ScanResult<Tuple>	JedisClusterCommands.zscan(String key, String cursor)
ScanResult<Tuple>	JedisCommands.zscan(String key, String cursor)
ScanResult<Tuple>	JedisCommands.zscan(String key, String cursor, ScanParams params)