Package io.quarkus.redis.runtime.datasource

Class AbstractSortedSetCommands<K,V>

java.lang.Object

io.quarkus.redis.runtime.datasource.AbstractRedisCommands

io.quarkus.redis.runtime.datasource.ReactiveSortable<K,V>

io.quarkus.redis.runtime.datasource.AbstractSortedSetCommands<K,V>

Direct Known Subclasses:

ReactiveSortedSetCommandsImpl

class AbstractSortedSetCommands<K,V>
extends ReactiveSortable<K,V>

Field Summary

Fields

Modifier and Type	Field	Description
static io.vertx.mutiny.redis.client.Command	BZMPOP
protected static ZAggregateArgs	DEFAULT_INSTANCE_AGG
protected static ZRangeArgs	DEFAULT_INSTANCE_RANGE
protected Class<K>	typeOfKey
protected Class<V>	typeOfValue
static io.vertx.mutiny.redis.client.Command	ZINTERCARD
static io.vertx.mutiny.redis.client.Command	ZMPOP

Fields inherited from class io.quarkus.redis.runtime.datasource.AbstractRedisCommands

marshaller, redis

Constructor Summary

Constructors

Constructor	Description
AbstractSortedSetCommands(RedisCommandExecutor redis, Class<K> k, Class<V> v)

Method Summary

Modifier and Type	Method	Description
(package private) io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response>	_bzmpopMax(Duration timeout, int count, K... keys)
(package private) io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response>	_bzmpopMax(Duration timeout, K... keys)
(package private) io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response>	_bzmpopMin(Duration timeout, int count, K... keys)
(package private) io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response>	_bzmpopMin(Duration timeout, K... keys)
(package private) io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response>	_bzpopmax(Duration timeout, K... keys)
(package private) io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response>	_bzpopmin(Duration timeout, K... keys)
(package private) io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response>	_zadd(K key, double score, V value)
(package private) io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response>	_zadd(K key, ScoredValue<V>... items)
(package private) io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response>	_zadd(K key, ZAddArgs args, double score, V value)
(package private) io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response>	_zadd(K key, ZAddArgs args, ScoredValue<V>... items)
(package private) io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response>	_zadd(K key, ZAddArgs args, Map<V,Double> items)
(package private) io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response>	_zadd(K key, Map<V,Double> items)
(package private) io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response>	_zaddincr(K key, double score, V value)
(package private) io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response>	_zaddincr(K key, ZAddArgs args, double score, V value)
(package private) io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response>	_zcard(K key)
(package private) io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response>	_zcount(K key, ScoreRange<Double> range)
(package private) io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response>	_zdiff(K... keys)
(package private) io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response>	_zdiffstore(K destination, K... keys)
(package private) io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response>	_zdiffWithScores(K... keys)
(package private) io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response>	_zincrby(K key, double increment, V value)
(package private) io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response>	_zinter(ZAggregateArgs args, K... keys)
(package private) io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response>	_zinter(K... keys)
(package private) io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response>	_zintercard(long limit, K... keys)
(package private) io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response>	_zintercard(K... keys)
(package private) io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response>	_zinterstore(K destination, ZAggregateArgs arguments, K... keys)
(package private) io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response>	_zinterstore(K destination, K... keys)
(package private) io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response>	_zinterWithScores(ZAggregateArgs arguments, K... keys)
(package private) io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response>	_zinterWithScores(K... keys)
(package private) io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response>	_zlexcount(K key, Range<String> range)
(package private) io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response>	_zmpopMax(int count, K... keys)
(package private) io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response>	_zmpopMax(K... keys)
(package private) io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response>	_zmpopMin(int count, K... keys)
(package private) io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response>	_zmpopMin(K... keys)
(package private) io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response>	_zmscore(K key, V... values)
(package private) io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response>	_zpopmax(K key)
(package private) io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response>	_zpopmax(K key, int count)
(package private) io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response>	_zpopmin(K key)
(package private) io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response>	_zpopmin(K key, int count)
(package private) io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response>	_zrandmember(K key)
(package private) io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response>	_zrandmember(K key, int count)
(package private) io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response>	_zrandmemberWithScores(K key)
(package private) io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response>	_zrandmemberWithScores(K key, int count)
(package private) io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response>	_zrange(K key, long start, long stop)
(package private) io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response>	_zrange(K key, long start, long stop, ZRangeArgs args)
(package private) io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response>	_zrangebylex(K key, Range<String> range)
(package private) io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response>	_zrangebylex(K key, Range<String> range, ZRangeArgs args)
(package private) io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response>	_zrangebyscore(K key, ScoreRange<Double> range)
(package private) io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response>	_zrangebyscore(K key, ScoreRange<Double> range, ZRangeArgs args)
(package private) io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response>	_zrangebyscoreWithScores(K key, ScoreRange<Double> range)
(package private) io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response>	_zrangebyscoreWithScores(K key, ScoreRange<Double> range, ZRangeArgs args)
(package private) io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response>	_zrangestore(K dst, K src, long min, long max)
(package private) io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response>	_zrangestore(K dst, K src, long min, long max, ZRangeArgs args)
(package private) io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response>	_zrangestorebylex(K dst, K src, Range<String> range)
(package private) io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response>	_zrangestorebylex(K dst, K src, Range<String> range, ZRangeArgs args)
(package private) io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response>	_zrangestorebyscore(K dst, K src, ScoreRange<Double> range)
(package private) io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response>	_zrangestorebyscore(K dst, K src, ScoreRange<Double> range, ZRangeArgs args)
(package private) io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response>	_zrangeWithScores(K key, long start, long stop)
(package private) io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response>	_zrangeWithScores(K key, long start, long stop, ZRangeArgs args)
(package private) io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response>	_zrank(K key, V value)
(package private) io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response>	_zrem(K key, V... values)
(package private) io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response>	_zremrangebylex(K key, Range<String> range)
(package private) io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response>	_zremrangebyrank(K key, long start, long stop)
(package private) io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response>	_zremrangebyscore(K key, ScoreRange<Double> range)
(package private) io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response>	_zrevrank(K key, V value)
(package private) ReactiveZScanCursor<V>	_zscan(K key)
(package private) ReactiveZScanCursor<V>	_zscan(K key, ScanArgs args)
(package private) io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response>	_zscore(K key, V value)
(package private) io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response>	_zunion(ZAggregateArgs args, K... keys)
(package private) io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response>	_zunion(K... keys)
(package private) io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response>	_zunionstore(K destination, ZAggregateArgs args, K... keys)
(package private) io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response>	_zunionstore(K destination, K... keys)
(package private) io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response>	_zunionWithScores(ZAggregateArgs args, K... keys)
(package private) io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response>	_zunionWithScores(K... keys)
(package private) Double	decodeAsDouble(io.vertx.mutiny.redis.client.Response r)
(package private) KeyValue<K,ScoredValue<V>>	decodeAsKeyValue(io.vertx.mutiny.redis.client.Response r)
(package private) List<Double>	decodeAsListOfDouble(io.vertx.mutiny.redis.client.Response response)
(package private) List<ScoredValue<V>>	decodeAsListOfScoredValues(io.vertx.mutiny.redis.client.Response response)
(package private) List<V>	decodeAsListOfValues(io.vertx.mutiny.redis.client.Response r)
(package private) Long	decodeAsLong(io.vertx.mutiny.redis.client.Response r)
(package private) ScoredValue<V>	decodeAsScoredValue(io.vertx.mutiny.redis.client.Response r)
(package private) ScoredValue<V>	decodeAsScoredValueOrEmpty(io.vertx.mutiny.redis.client.Response r)
(package private) boolean	decodeIntAsBoolean(io.vertx.mutiny.redis.client.Response r)
(package private) long	decodeLongOrZero(io.vertx.mutiny.redis.client.Response r)
(package private) ScoredValue<V>	decodePopResponse(io.vertx.mutiny.redis.client.Response r)
(package private) List<ScoredValue<V>>	decodePopResponseWithCount(io.vertx.mutiny.redis.client.Response r)
(package private) V	decodeV(io.vertx.mutiny.redis.client.Response r)
protected String	getScoreAsString(double score)

Methods inherited from class io.quarkus.redis.runtime.datasource.ReactiveSortable

sort, sort, sortAndStore, sortAndStore

Methods inherited from class io.quarkus.redis.runtime.datasource.AbstractRedisCommands

execute

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Field Detail

typeOfValue

protected final Class<V> typeOfValue

typeOfKey

protected final Class<K> typeOfKey

DEFAULT_INSTANCE_AGG

protected static final ZAggregateArgs DEFAULT_INSTANCE_AGG

DEFAULT_INSTANCE_RANGE

protected static final ZRangeArgs DEFAULT_INSTANCE_RANGE

ZINTERCARD

public static final io.vertx.mutiny.redis.client.Command ZINTERCARD

ZMPOP

public static final io.vertx.mutiny.redis.client.Command ZMPOP

BZMPOP

public static final io.vertx.mutiny.redis.client.Command BZMPOP

Constructor Detail

AbstractSortedSetCommands

AbstractSortedSetCommands(RedisCommandExecutor redis,
                          Class<K> k,
                          Class<V> v)

Method Detail

_zadd

io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response> _zadd(K key,
                                                                    double score,
                                                                    V value)

_zadd

io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response> _zadd(K key,
                                                                    Map<V,Double> items)

_zadd

io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response> _zadd(K key,
                                                                    ScoredValue<V>... items)

_zadd

io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response> _zadd(K key,
                                                                    ZAddArgs args,
                                                                    double score,
                                                                    V value)

_zadd

io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response> _zadd(K key,
                                                                    ZAddArgs args,
                                                                    Map<V,Double> items)

_zadd

io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response> _zadd(K key,
                                                                    ZAddArgs args,
                                                                    ScoredValue<V>... items)

_zaddincr

io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response> _zaddincr(K key,
                                                                        double score,
                                                                        V value)

_zaddincr

io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response> _zaddincr(K key,
                                                                        ZAddArgs args,
                                                                        double score,
                                                                        V value)

_zcard

io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response> _zcard(K key)

_zcount

io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response> _zcount(K key,
                                                                      ScoreRange<Double> range)

_zdiff

io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response> _zdiff(K... keys)

_zdiffWithScores

io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response> _zdiffWithScores(K... keys)

_zdiffstore

io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response> _zdiffstore(K destination,
                                                                          K... keys)

_zincrby

io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response> _zincrby(K key,
                                                                       double increment,
                                                                       V value)

_zinter

io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response> _zinter(ZAggregateArgs args,
                                                                      K... keys)

_zinter

io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response> _zinter(K... keys)

_zinterWithScores

io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response> _zinterWithScores(ZAggregateArgs arguments,
                                                                                K... keys)

_zinterWithScores

io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response> _zinterWithScores(K... keys)

_zintercard

io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response> _zintercard(K... keys)

_zintercard

io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response> _zintercard(long limit,
                                                                          K... keys)

_zinterstore

io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response> _zinterstore(K destination,
                                                                           ZAggregateArgs arguments,
                                                                           K... keys)

_zinterstore

@SafeVarargs
final io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response> _zinterstore(K destination,
                                                                                 K... keys)

_zlexcount

io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response> _zlexcount(K key,
                                                                         Range<String> range)

_zmpopMin

io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response> _zmpopMin(K... keys)

_zmpopMin

io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response> _zmpopMin(int count,
                                                                        K... keys)

_zmpopMax

io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response> _zmpopMax(K... keys)

_zmpopMax

io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response> _zmpopMax(int count,
                                                                        K... keys)

_bzmpopMin

io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response> _bzmpopMin(Duration timeout,
                                                                         K... keys)

_bzmpopMin

io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response> _bzmpopMin(Duration timeout,
                                                                         int count,
                                                                         K... keys)

_bzmpopMax

io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response> _bzmpopMax(Duration timeout,
                                                                         K... keys)

_bzmpopMax

io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response> _bzmpopMax(Duration timeout,
                                                                         int count,
                                                                         K... keys)

_zmscore

io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response> _zmscore(K key,
                                                                       V... values)

_zpopmax

io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response> _zpopmax(K key)

_zpopmax

io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response> _zpopmax(K key,
                                                                       int count)

_zpopmin

io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response> _zpopmin(K key)

_zpopmin

io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response> _zpopmin(K key,
                                                                       int count)

_zrandmember

io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response> _zrandmember(K key)

_zrandmember

io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response> _zrandmember(K key,
                                                                           int count)

_zrandmemberWithScores

io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response> _zrandmemberWithScores(K key)

_zrandmemberWithScores

io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response> _zrandmemberWithScores(K key,
                                                                                     int count)

_bzpopmin

@SafeVarargs
final io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response> _bzpopmin(Duration timeout,
                                                                              K... keys)

_bzpopmax

@SafeVarargs
final io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response> _bzpopmax(Duration timeout,
                                                                              K... keys)

_zrange

io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response> _zrange(K key,
                                                                      long start,
                                                                      long stop,
                                                                      ZRangeArgs args)

_zrangeWithScores

io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response> _zrangeWithScores(K key,
                                                                                long start,
                                                                                long stop,
                                                                                ZRangeArgs args)

_zrange

io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response> _zrange(K key,
                                                                      long start,
                                                                      long stop)

_zrangeWithScores

io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response> _zrangeWithScores(K key,
                                                                                long start,
                                                                                long stop)

_zrangebylex

io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response> _zrangebylex(K key,
                                                                           Range<String> range,
                                                                           ZRangeArgs args)

_zrangebylex

io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response> _zrangebylex(K key,
                                                                           Range<String> range)

_zrangebyscore

io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response> _zrangebyscore(K key,
                                                                             ScoreRange<Double> range,
                                                                             ZRangeArgs args)

_zrangebyscoreWithScores

io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response> _zrangebyscoreWithScores(K key,
                                                                                       ScoreRange<Double> range,
                                                                                       ZRangeArgs args)

_zrangebyscore

io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response> _zrangebyscore(K key,
                                                                             ScoreRange<Double> range)

_zrangebyscoreWithScores

io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response> _zrangebyscoreWithScores(K key,
                                                                                       ScoreRange<Double> range)

_zrangestore

io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response> _zrangestore(K dst,
                                                                           K src,
                                                                           long min,
                                                                           long max,
                                                                           ZRangeArgs args)

_zrangestore

io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response> _zrangestore(K dst,
                                                                           K src,
                                                                           long min,
                                                                           long max)

_zrangestorebylex

io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response> _zrangestorebylex(K dst,
                                                                                K src,
                                                                                Range<String> range,
                                                                                ZRangeArgs args)

_zrangestorebylex

io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response> _zrangestorebylex(K dst,
                                                                                K src,
                                                                                Range<String> range)

_zrangestorebyscore

io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response> _zrangestorebyscore(K dst,
                                                                                  K src,
                                                                                  ScoreRange<Double> range,
                                                                                  ZRangeArgs args)

_zrangestorebyscore

io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response> _zrangestorebyscore(K dst,
                                                                                  K src,
                                                                                  ScoreRange<Double> range)

_zrank

io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response> _zrank(K key,
                                                                     V value)

_zrem

io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response> _zrem(K key,
                                                                    V... values)

_zremrangebylex

io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response> _zremrangebylex(K key,
                                                                              Range<String> range)

_zremrangebyrank

io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response> _zremrangebyrank(K key,
                                                                               long start,
                                                                               long stop)

_zremrangebyscore

io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response> _zremrangebyscore(K key,
                                                                                ScoreRange<Double> range)

_zrevrank

io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response> _zrevrank(K key,
                                                                        V value)

_zscan

ReactiveZScanCursor<V> _zscan(K key)

_zscan

ReactiveZScanCursor<V> _zscan(K key,
                              ScanArgs args)

_zscore

io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response> _zscore(K key,
                                                                      V value)

_zunion

io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response> _zunion(ZAggregateArgs args,
                                                                      K... keys)

_zunion

io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response> _zunion(K... keys)

_zunionWithScores

io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response> _zunionWithScores(K... keys)

_zunionWithScores

io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response> _zunionWithScores(ZAggregateArgs args,
                                                                                K... keys)

_zunionstore

io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response> _zunionstore(K destination,
                                                                           ZAggregateArgs args,
                                                                           K... keys)

_zunionstore

io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response> _zunionstore(K destination,
                                                                           K... keys)

getScoreAsString

protected String getScoreAsString(double score)

decodeAsListOfScoredValues

final List<ScoredValue<V>> decodeAsListOfScoredValues(io.vertx.mutiny.redis.client.Response response)

decodeAsScoredValue

ScoredValue<V> decodeAsScoredValue(io.vertx.mutiny.redis.client.Response r)

decodeAsDouble

Double decodeAsDouble(io.vertx.mutiny.redis.client.Response r)

decodeAsLong

Long decodeAsLong(io.vertx.mutiny.redis.client.Response r)

decodeLongOrZero

long decodeLongOrZero(io.vertx.mutiny.redis.client.Response r)

decodeAsListOfDouble

List<Double> decodeAsListOfDouble(io.vertx.mutiny.redis.client.Response response)

decodeAsListOfValues

List<V> decodeAsListOfValues(io.vertx.mutiny.redis.client.Response r)

decodeAsScoredValueOrEmpty

ScoredValue<V> decodeAsScoredValueOrEmpty(io.vertx.mutiny.redis.client.Response r)

decodePopResponseWithCount

List<ScoredValue<V>> decodePopResponseWithCount(io.vertx.mutiny.redis.client.Response r)

decodePopResponse

ScoredValue<V> decodePopResponse(io.vertx.mutiny.redis.client.Response r)

decodeV

V decodeV(io.vertx.mutiny.redis.client.Response r)

decodeIntAsBoolean

boolean decodeIntAsBoolean(io.vertx.mutiny.redis.client.Response r)

decodeAsKeyValue

KeyValue<K,ScoredValue<V>> decodeAsKeyValue(io.vertx.mutiny.redis.client.Response r)