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 Type	typeOfKey
protected Type	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, Type k, Type 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, isMap

Methods inherited from class java.lang.Object

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

Field Detail

typeOfValue

protected final Type typeOfValue

typeOfKey

protected final Type 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,
                          Type k,
                          Type 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)