All Downloads are FREE. Search and download functionalities are using the official Maven repository.
  • Log In
  • Register

    • com.lambdaworks.redis.AbstractRedisReactiveCommands Maven / Gradle / Ivy

    Go to download

    Advanced and thread-safe Java Redis client for synchronous, asynchronous, and reactive usage. Supports Cluster, Sentinel, Pipelining, Auto-Reconnect, Codecs and much more.

    The newest version!
    /*
 * Copyright 2011-2016 the original author or authors.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package com.lambdaworks.redis;

import static com.lambdaworks.redis.protocol.CommandType.EXEC;

import java.util.Date;
import java.util.Map;
import java.util.concurrent.TimeUnit;
import java.util.function.Supplier;

import com.lambdaworks.redis.GeoArgs.Unit;
import com.lambdaworks.redis.api.StatefulConnection;
import com.lambdaworks.redis.api.reactive.*;
import com.lambdaworks.redis.cluster.api.reactive.RedisClusterReactiveCommands;
import com.lambdaworks.redis.codec.RedisCodec;
import com.lambdaworks.redis.internal.LettuceAssert;
import com.lambdaworks.redis.output.*;
import com.lambdaworks.redis.protocol.*;
import reactor.core.publisher.Flux;
import reactor.core.publisher.Mono;

/**
 * A reactive and thread-safe API for a Redis connection.
 *
 * @param  Key type.
 * @param  Value type.
 * @author Mark Paluch
 * @since 4.0
 */
public abstract class AbstractRedisReactiveCommands implements RedisHashReactiveCommands,
        RedisKeyReactiveCommands, RedisStringReactiveCommands, RedisListReactiveCommands,
        RedisSetReactiveCommands, RedisSortedSetReactiveCommands, RedisScriptingReactiveCommands,
        RedisServerReactiveCommands, RedisHLLReactiveCommands, BaseRedisReactiveCommands,
        RedisTransactionalReactiveCommands, RedisGeoReactiveCommands, RedisClusterReactiveCommands {

    protected MultiOutput multi;
    protected RedisCommandBuilder commandBuilder;
    protected RedisCodec codec;
    protected StatefulConnection connection;

    /**
     * Initialize a new instance.
     *
     * @param connection the connection to operate on
     * @param codec the codec for command encoding
     */
    public AbstractRedisReactiveCommands(StatefulConnection connection, RedisCodec codec) {
        this.connection = connection;
        this.codec = codec;
        commandBuilder = new RedisCommandBuilder(codec);
    }

    @Override
    public Mono append(K key, V value) {
        return createMono(() -> commandBuilder.append(key, value));
    }

    @Override
    public Mono auth(String password) {
        return createMono(() -> commandBuilder.auth(password));

    }

    @Override
    public Mono bgrewriteaof() {
        return createMono(commandBuilder::bgrewriteaof);
    }

    @Override
    public Mono bgsave() {
        return createMono(commandBuilder::bgsave);
    }

    @Override
    public Mono bitcount(K key) {
        return createMono(() -> commandBuilder.bitcount(key));
    }

    @Override
    public Mono bitcount(K key, long start, long end) {
        return createMono(() -> commandBuilder.bitcount(key, start, end));
    }

    @Override
    public Flux> bitfield(K key, BitFieldArgs args) {
        return createDissolvingFlux(() -> commandBuilder.bitfieldValue(key, args));
    }

    @Override
    public Mono bitpos(K key, boolean state) {
        return createMono(() -> commandBuilder.bitpos(key, state));
    }

    @Override
    public Mono bitpos(K key, boolean state, long start, long end) {
        return createMono(() -> commandBuilder.bitpos(key, state, start, end));
    }

    @Override
    public Mono bitopAnd(K destination, K... keys) {
        return createMono(() -> commandBuilder.bitopAnd(destination, keys));
    }

    @Override
    public Mono bitopNot(K destination, K source) {
        return createMono(() -> commandBuilder.bitopNot(destination, source));
    }

    @Override
    public Mono bitopOr(K destination, K... keys) {
        return createMono(() -> commandBuilder.bitopOr(destination, keys));
    }

    @Override
    public Mono bitopXor(K destination, K... keys) {
        return createMono(() -> commandBuilder.bitopXor(destination, keys));
    }

    @Override
    public Mono> blpop(long timeout, K... keys) {
        return createMono(() -> commandBuilder.blpop(timeout, keys));
    }

    @Override
    public Mono> brpop(long timeout, K... keys) {
        return createMono(() -> commandBuilder.brpop(timeout, keys));
    }

    @Override
    public Mono brpoplpush(long timeout, K source, K destination) {
        return createMono(() -> commandBuilder.brpoplpush(timeout, source, destination));
    }

    @Override
    public Mono clientGetname() {
        return createMono(commandBuilder::clientGetname);
    }

    @Override
    public Mono clientSetname(K name) {
        return createMono(() -> commandBuilder.clientSetname(name));
    }

    @Override
    public Mono clientKill(String addr) {
        return createMono(() -> commandBuilder.clientKill(addr));
    }

    @Override
    public Mono clientKill(KillArgs killArgs) {
        return createMono(() -> commandBuilder.clientKill(killArgs));
    }

    @Override
    public Mono clientPause(long timeout) {
        return createMono(() -> commandBuilder.clientPause(timeout));
    }

    @Override
    public Mono clientList() {
        return createMono(commandBuilder::clientList);
    }

    @Override
    public Flux command() {
        return createDissolvingFlux(commandBuilder::command);
    }

    @Override
    public Flux commandInfo(String... commands) {
        return createDissolvingFlux(() -> commandBuilder.commandInfo(commands));
    }

    @Override
    public Flux commandInfo(CommandType... commands) {
        String[] stringCommands = new String[commands.length];
        for (int i = 0; i < commands.length; i++) {
            stringCommands[i] = commands[i].name();
        }

        return commandInfo(stringCommands);
    }

    @Override
    public Mono commandCount() {
        return createMono(commandBuilder::commandCount);
    }

    @Override
    public Flux configGet(String parameter) {
        return createDissolvingFlux(() -> commandBuilder.configGet(parameter));
    }

    @Override
    public Mono configResetstat() {
        return createMono(commandBuilder::configResetstat);
    }

    @Override
    public Mono configSet(String parameter, String value) {
        return createMono(() -> commandBuilder.configSet(parameter, value));
    }

    @Override
    public Mono configRewrite() {
        return createMono(commandBuilder::configRewrite);
    }

    @Override
    public Mono dbsize() {
        return createMono(commandBuilder::dbsize);
    }

    @Override
    public Mono debugCrashAndRecover(Long delay) {
        return createMono(() -> (commandBuilder.debugCrashAndRecover(delay)));
    }

    @Override
    public Mono debugHtstats(int db) {
        return createMono(() -> commandBuilder.debugHtstats(db));
    }

    @Override
    public Mono debugObject(K key) {
        return createMono(() -> commandBuilder.debugObject(key));
    }

    @Override
    public Mono debugOom() {
        return createMono(commandBuilder::debugOom).then();
    }

    @Override
    public Mono debugReload() {
        return createMono(() -> (commandBuilder.debugReload()));
    }

    @Override
    public Mono debugRestart(Long delay) {
        return createMono(() -> (commandBuilder.debugRestart(delay)));
    }

    @Override
    public Mono debugSdslen(K key) {
        return createMono(() -> (commandBuilder.debugSdslen(key)));
    }

    @Override
    public Mono debugSegfault() {
        return createFlux(commandBuilder::debugSegfault).then();
    }

    @Override
    public Mono decr(K key) {
        return createMono(() -> commandBuilder.decr(key));
    }

    @Override
    public Mono decrby(K key, long amount) {
        return createMono(() -> commandBuilder.decrby(key, amount));
    }

    @Override
    public Mono del(K... keys) {
        return createMono(() -> commandBuilder.del(keys));
    }

    public Mono del(Iterable keys) {
        return createMono(() -> commandBuilder.del(keys));
    }

    @Override
    public Mono unlink(K... keys) {
        return createMono(() -> commandBuilder.unlink(keys));
    }

    public Mono unlink(Iterable keys) {
        return createMono(() -> commandBuilder.unlink(keys));
    }

    @Override
    public Mono discard() {
        return createMono(commandBuilder::discard);
    }

    @Override
    public Mono dump(K key) {
        return createMono(() -> commandBuilder.dump(key));
    }

    @Override
    public Mono echo(V msg) {
        return createMono(() -> commandBuilder.echo(msg));
    }

    @Override
    @SuppressWarnings("unchecked")
    public  Flux eval(String script, ScriptOutputType type, K... keys) {
        return (Flux) createFlux(() -> commandBuilder.eval(script, type, keys));
    }

    @Override
    @SuppressWarnings("unchecked")
    public  Flux eval(String script, ScriptOutputType type, K[] keys, V... values) {
        return (Flux) createFlux(() -> commandBuilder.eval(script, type, keys, values));
    }

    @Override
    @SuppressWarnings("unchecked")
    public  Flux evalsha(String digest, ScriptOutputType type, K... keys) {
        return (Flux) createFlux(() -> commandBuilder.evalsha(digest, type, keys));
    }

    @Override
    @SuppressWarnings("unchecked")
    public  Flux evalsha(String digest, ScriptOutputType type, K[] keys, V... values) {
        return (Flux) createFlux(() -> commandBuilder.evalsha(digest, type, keys, values));
    }

    public Mono exists(K key) {
        return createMono(() -> commandBuilder.exists(key));
    }

    @Override
    public Mono exists(K... keys) {
        return createMono(() -> commandBuilder.exists(keys));
    }

    public Mono exists(Iterable keys) {
        return createMono(() -> commandBuilder.exists(keys));
    }

    @Override
    public Mono expire(K key, long seconds) {
        return createMono(() -> commandBuilder.expire(key, seconds));
    }

    @Override
    public Mono expireat(K key, long timestamp) {
        return createMono(() -> commandBuilder.expireat(key, timestamp));
    }

    @Override
    public Mono expireat(K key, Date timestamp) {
        return expireat(key, timestamp.getTime() / 1000);
    }

    @Override
    public Mono exec() {
        return createMono(EXEC, null, null);
    }

    @Override
    public Mono flushall() {
        return createMono(commandBuilder::flushall);
    }

    @Override
    public Mono flushallAsync() {
        return createMono(commandBuilder::flushallAsync);
    }

    @Override
    public Mono flushdb() {
        return createMono(commandBuilder::flushdb);
    }

    @Override
    public Mono flushdbAsync() {
        return createMono(commandBuilder::flushdbAsync);
    }

    @Override
    public Mono get(K key) {
        return createMono(() -> commandBuilder.get(key));
    }

    @Override
    public Mono getbit(K key, long offset) {
        return createMono(() -> commandBuilder.getbit(key, offset));
    }

    @Override
    public Mono getrange(K key, long start, long end) {
        return createMono(() -> commandBuilder.getrange(key, start, end));
    }

    @Override
    public Mono getset(K key, V value) {
        return createMono(() -> commandBuilder.getset(key, value));
    }

    @Override
    public Mono hdel(K key, K... fields) {
        return createMono(() -> commandBuilder.hdel(key, fields));
    }

    @Override
    public Mono hexists(K key, K field) {
        return createMono(() -> commandBuilder.hexists(key, field));
    }

    @Override
    public Mono hget(K key, K field) {
        return createMono(() -> commandBuilder.hget(key, field));
    }

    @Override
    public Mono hincrby(K key, K field, long amount) {
        return createMono(() -> commandBuilder.hincrby(key, field, amount));
    }

    @Override
    public Mono hincrbyfloat(K key, K field, double amount) {
        return createMono(() -> commandBuilder.hincrbyfloat(key, field, amount));
    }

    @Override
    public Mono> hgetall(K key) {
        return createMono(() -> commandBuilder.hgetall(key));
    }

    @Override
    public Mono hgetall(KeyValueStreamingChannel channel, K key) {
        return createMono(() -> commandBuilder.hgetall(channel, key));
    }

    @Override
    public Flux hkeys(K key) {
        return createDissolvingFlux(() -> commandBuilder.hkeys(key));
    }

    @Override
    public Mono hkeys(KeyStreamingChannel channel, K key) {
        return createMono(() -> commandBuilder.hkeys(channel, key));
    }

    @Override
    public Mono hlen(K key) {
        return createMono(() -> commandBuilder.hlen(key));
    }

    @Override
    public Mono hstrlen(K key, K field) {
        return createMono(() -> commandBuilder.hstrlen(key, field));
    }

    @Override
    public Flux> hmget(K key, K... fields) {
        return createDissolvingFlux(() -> commandBuilder.hmgetKeyValue(key, fields));
    }

    @Override
    public Mono hmget(KeyValueStreamingChannel channel, K key, K... fields) {
        return createMono(() -> commandBuilder.hmget(channel, key, fields));
    }

    @Override
    public Mono hmset(K key, Map map) {
        return createMono(() -> commandBuilder.hmset(key, map));
    }

    @Override
    public Mono hset(K key, K field, V value) {
        return createMono(() -> commandBuilder.hset(key, field, value));
    }

    @Override
    public Mono hsetnx(K key, K field, V value) {
        return createMono(() -> commandBuilder.hsetnx(key, field, value));
    }

    @Override
    public Flux hvals(K key) {
        return createDissolvingFlux(() -> commandBuilder.hvals(key));
    }

    @Override
    public Mono hvals(ValueStreamingChannel channel, K key) {
        return createMono(() -> commandBuilder.hvals(channel, key));
    }

    @Override
    public Mono incr(K key) {
        return createMono(() -> commandBuilder.incr(key));
    }

    @Override
    public Mono incrby(K key, long amount) {
        return createMono(() -> commandBuilder.incrby(key, amount));
    }

    @Override
    public Mono incrbyfloat(K key, double amount) {
        return createMono(() -> commandBuilder.incrbyfloat(key, amount));
    }

    @Override
    public Mono info() {
        return createMono(commandBuilder::info);
    }

    @Override
    public Mono info(String section) {
        return createMono(() -> commandBuilder.info(section));
    }

    @Override
    public Flux keys(K pattern) {
        return createDissolvingFlux(() -> commandBuilder.keys(pattern));
    }

    @Override
    public Mono keys(KeyStreamingChannel channel, K pattern) {
        return createMono(() -> commandBuilder.keys(channel, pattern));
    }

    @Override
    public Mono lastsave() {
        return createMono(commandBuilder::lastsave);
    }

    @Override
    public Mono lindex(K key, long index) {
        return createMono(() -> commandBuilder.lindex(key, index));
    }

    @Override
    public Mono linsert(K key, boolean before, V pivot, V value) {
        return createMono(() -> commandBuilder.linsert(key, before, pivot, value));
    }

    @Override
    public Mono llen(K key) {
        return createMono(() -> commandBuilder.llen(key));
    }

    @Override
    public Mono lpop(K key) {
        return createMono(() -> commandBuilder.lpop(key));
    }

    @Override
    public Mono lpush(K key, V... values) {
        return createMono(() -> commandBuilder.lpush(key, values));
    }

    @Override
    public Mono lpushx(K key, V... values) {
        return createMono(() -> commandBuilder.lpushx(key, values));
    }

    @Override
    public Flux lrange(K key, long start, long stop) {
        return createDissolvingFlux(() -> commandBuilder.lrange(key, start, stop));
    }

    @Override
    public Mono lrange(ValueStreamingChannel channel, K key, long start, long stop) {
        return createMono(() -> commandBuilder.lrange(channel, key, start, stop));
    }

    @Override
    public Mono lrem(K key, long count, V value) {
        return createMono(() -> commandBuilder.lrem(key, count, value));
    }

    @Override
    public Mono lset(K key, long index, V value) {
        return createMono(() -> commandBuilder.lset(key, index, value));
    }

    @Override
    public Mono ltrim(K key, long start, long stop) {
        return createMono(() -> commandBuilder.ltrim(key, start, stop));
    }

    @Override
    public Mono migrate(String host, int port, K key, int db, long timeout) {
        return createMono(() -> commandBuilder.migrate(host, port, key, db, timeout));
    }

    @Override
    public Mono migrate(String host, int port, int db, long timeout, MigrateArgs migrateArgs) {
        return createMono(() -> commandBuilder.migrate(host, port, db, timeout, migrateArgs));
    }

    @Override
    public Flux> mget(K... keys) {
        return createDissolvingFlux(() -> commandBuilder.mgetKeyValue(keys));
    }

    public Flux> mget(Iterable keys) {
        return createDissolvingFlux(() -> commandBuilder.mgetKeyValue(keys));
    }

    @Override
    public Mono mget(KeyValueStreamingChannel channel, K... keys) {
        return createMono(() -> commandBuilder.mget(channel, keys));
    }

    public Mono mget(ValueStreamingChannel channel, Iterable keys) {
        return createMono(() -> commandBuilder.mget(channel, keys));
    }

    public Mono mget(KeyValueStreamingChannel channel, Iterable keys) {
        return createMono(() -> commandBuilder.mget(channel, keys));
    }

    @Override
    public Mono move(K key, int db) {
        return createMono(() -> commandBuilder.move(key, db));
    }

    @Override
    public Mono multi() {
        return createMono(commandBuilder::multi);
    }

    @Override
    public Mono mset(Map map) {
        return createMono(() -> commandBuilder.mset(map));
    }

    @Override
    public Mono msetnx(Map map) {
        return createMono(() -> commandBuilder.msetnx(map));
    }

    @Override
    public Mono objectEncoding(K key) {
        return createMono(() -> commandBuilder.objectEncoding(key));
    }

    @Override
    public Mono objectIdletime(K key) {
        return createMono(() -> commandBuilder.objectIdletime(key));
    }

    @Override
    public Mono objectRefcount(K key) {
        return createMono(() -> commandBuilder.objectRefcount(key));
    }

    @Override
    public Mono persist(K key) {
        return createMono(() -> commandBuilder.persist(key));
    }

    @Override
    public Mono pexpire(K key, long milliseconds) {
        return createMono(() -> commandBuilder.pexpire(key, milliseconds));
    }

    @Override
    public Mono pexpireat(K key, Date timestamp) {
        return pexpireat(key, timestamp.getTime());
    }

    @Override
    public Mono pexpireat(K key, long timestamp) {
        return createMono(() -> commandBuilder.pexpireat(key, timestamp));
    }

    @Override
    public Mono ping() {
        return createMono(commandBuilder::ping);
    }

    @Override
    public Mono readOnly() {
        return createMono(commandBuilder::readOnly);
    }

    @Override
    public Mono readWrite() {
        return createMono(commandBuilder::readWrite);
    }

    @Override
    public Mono pttl(K key) {
        return createMono(() -> commandBuilder.pttl(key));
    }

    @Override
    public Mono publish(K channel, V message) {
        return createMono(() -> commandBuilder.publish(channel, message));
    }

    @Override
    public Flux pubsubChannels() {
        return createDissolvingFlux(commandBuilder::pubsubChannels);
    }

    @Override
    public Flux pubsubChannels(K channel) {
        return createDissolvingFlux(() -> commandBuilder.pubsubChannels(channel));
    }

    @Override
    public Mono> pubsubNumsub(K... channels) {
        return createMono(() -> commandBuilder.pubsubNumsub(channels));
    }

    @Override
    public Mono pubsubNumpat() {
        return createMono(commandBuilder::pubsubNumpat);
    }

    @Override
    public Mono quit() {
        return createMono(commandBuilder::quit);
    }

    @Override
    public Flux role() {
        return createDissolvingFlux(commandBuilder::role);
    }

    @Override
    public Mono randomkey() {
        return createMono(commandBuilder::randomkey);
    }

    @Override
    public Mono rename(K key, K newKey) {
        return createMono(() -> commandBuilder.rename(key, newKey));
    }

    @Override
    public Mono renamenx(K key, K newKey) {
        return createMono(() -> commandBuilder.renamenx(key, newKey));
    }

    @Override
    public Mono restore(K key, long ttl, byte[] value) {
        return createMono(() -> commandBuilder.restore(key, ttl, value));
    }

    @Override
    public Mono rpop(K key) {
        return createMono(() -> commandBuilder.rpop(key));
    }

    @Override
    public Mono rpoplpush(K source, K destination) {
        return createMono(() -> commandBuilder.rpoplpush(source, destination));
    }

    @Override
    public Mono rpush(K key, V... values) {
        return createMono(() -> commandBuilder.rpush(key, values));
    }

    @Override
    public Mono rpushx(K key, V... values) {
        return createMono(() -> commandBuilder.rpushx(key, values));
    }

    @Override
    public Mono sadd(K key, V... members) {
        return createMono(() -> commandBuilder.sadd(key, members));
    }

    @Override
    public Mono save() {
        return createMono(commandBuilder::save);
    }

    @Override
    public Mono scard(K key) {
        return createMono(() -> commandBuilder.scard(key));
    }

    @Override
    public Flux scriptExists(String... digests) {
        return createDissolvingFlux(() -> commandBuilder.scriptExists(digests));
    }

    @Override
    public Mono scriptFlush() {
        return createMono(commandBuilder::scriptFlush);
    }

    @Override
    public Mono scriptKill() {
        return createMono(commandBuilder::scriptKill);
    }

    @Override
    public Mono scriptLoad(V script) {
        return createMono(() -> commandBuilder.scriptLoad(script));
    }

    @Override
    public Flux sdiff(K... keys) {
        return createDissolvingFlux(() -> commandBuilder.sdiff(keys));
    }

    @Override
    public Mono sdiff(ValueStreamingChannel channel, K... keys) {
        return createMono(() -> commandBuilder.sdiff(channel, keys));
    }

    @Override
    public Mono sdiffstore(K destination, K... keys) {
        return createMono(() -> commandBuilder.sdiffstore(destination, keys));
    }

    public Mono select(int db) {
        return createMono(() -> commandBuilder.select(db));
    }

    public Mono swapdb(int db1, int db2) {
        return createMono(() -> commandBuilder.swapdb(db1, db2));
    }

    @Override
    public Mono set(K key, V value) {
        return createMono(() -> commandBuilder.set(key, value));
    }

    @Override
    public Mono set(K key, V value, SetArgs setArgs) {
        return createMono(() -> commandBuilder.set(key, value, setArgs));
    }

    @Override
    public Mono setbit(K key, long offset, int value) {
        return createMono(() -> commandBuilder.setbit(key, offset, value));
    }

    @Override
    public Mono setex(K key, long seconds, V value) {
        return createMono(() -> commandBuilder.setex(key, seconds, value));
    }

    @Override
    public Mono psetex(K key, long milliseconds, V value) {
        return createMono(() -> commandBuilder.psetex(key, milliseconds, value));
    }

    @Override
    public Mono setnx(K key, V value) {
        return createMono(() -> commandBuilder.setnx(key, value));
    }

    @Override
    public Mono setrange(K key, long offset, V value) {
        return createMono(() -> commandBuilder.setrange(key, offset, value));
    }

    @Override
    public Mono shutdown(boolean save) {
        return createMono(() -> commandBuilder.shutdown(save)).then();
    }

    @Override
    public Flux sinter(K... keys) {
        return createDissolvingFlux(() -> commandBuilder.sinter(keys));
    }

    @Override
    public Mono sinter(ValueStreamingChannel channel, K... keys) {
        return createMono(() -> commandBuilder.sinter(channel, keys));
    }

    @Override
    public Mono sinterstore(K destination, K... keys) {
        return createMono(() -> commandBuilder.sinterstore(destination, keys));
    }

    @Override
    public Mono sismember(K key, V member) {
        return createMono(() -> commandBuilder.sismember(key, member));
    }

    @Override
    public Mono smove(K source, K destination, V member) {
        return createMono(() -> commandBuilder.smove(source, destination, member));
    }

    @Override
    public Mono slaveof(String host, int port) {
        return createMono(() -> commandBuilder.slaveof(host, port));
    }

    @Override
    public Mono slaveofNoOne() {
        return createMono(() -> commandBuilder.slaveofNoOne());
    }

    @Override
    public Flux slowlogGet() {
        return createDissolvingFlux(() -> commandBuilder.slowlogGet());
    }

    @Override
    public Flux slowlogGet(int count) {
        return createDissolvingFlux(() -> commandBuilder.slowlogGet(count));
    }

    @Override
    public Mono slowlogLen() {
        return createMono(() -> commandBuilder.slowlogLen());
    }

    @Override
    public Mono slowlogReset() {
        return createMono(() -> commandBuilder.slowlogReset());
    }

    @Override
    public Flux smembers(K key) {
        return createDissolvingFlux(() -> commandBuilder.smembers(key));
    }

    @Override
    public Mono smembers(ValueStreamingChannel channel, K key) {
        return createMono(() -> commandBuilder.smembers(channel, key));
    }

    @Override
    public Flux sort(K key) {
        return createDissolvingFlux(() -> commandBuilder.sort(key));
    }

    @Override
    public Mono sort(ValueStreamingChannel channel, K key) {
        return createMono(() -> commandBuilder.sort(channel, key));
    }

    @Override
    public Flux sort(K key, SortArgs sortArgs) {
        return createDissolvingFlux(() -> commandBuilder.sort(key, sortArgs));
    }

    @Override
    public Mono sort(ValueStreamingChannel channel, K key, SortArgs sortArgs) {
        return createMono(() -> commandBuilder.sort(channel, key, sortArgs));
    }

    @Override
    public Mono sortStore(K key, SortArgs sortArgs, K destination) {
        return createMono(() -> commandBuilder.sortStore(key, sortArgs, destination));
    }

    @Override
    public Mono spop(K key) {
        return createMono(() -> commandBuilder.spop(key));
    }

    @Override
    public Flux spop(K key, long count) {
        return createDissolvingFlux(() -> commandBuilder.spop(key, count));
    }

    @Override
    public Mono srandmember(K key) {
        return createMono(() -> commandBuilder.srandmember(key));
    }

    @Override
    public Flux srandmember(K key, long count) {
        return createDissolvingFlux(() -> commandBuilder.srandmember(key, count));
    }

    @Override
    public Mono srandmember(ValueStreamingChannel channel, K key, long count) {
        return createMono(() -> commandBuilder.srandmember(channel, key, count));
    }

    @Override
    public Mono srem(K key, V... members) {
        return createMono(() -> commandBuilder.srem(key, members));
    }

    @Override
    public Flux sunion(K... keys) {
        return createDissolvingFlux(() -> commandBuilder.sunion(keys));
    }

    @Override
    public Mono sunion(ValueStreamingChannel channel, K... keys) {
        return createMono(() -> commandBuilder.sunion(channel, keys));
    }

    @Override
    public Mono sunionstore(K destination, K... keys) {
        return createMono(() -> commandBuilder.sunionstore(destination, keys));
    }

    @Override
    public Mono strlen(K key) {
        return createMono(() -> commandBuilder.strlen(key));
    }

    @Override
    public Mono touch(K... keys) {
        return createMono(() -> commandBuilder.touch(keys));
    }

    public Mono touch(Iterable keys) {
        return createMono(() -> commandBuilder.touch(keys));
    }

    @Override
    public Mono ttl(K key) {
        return createMono(() -> commandBuilder.ttl(key));
    }

    @Override
    public Mono type(K key) {
        return createMono(() -> commandBuilder.type(key));
    }

    @Override
    public Mono watch(K... keys) {
        return createMono(() -> commandBuilder.watch(keys));
    }

    @Override
    public Mono unwatch() {
        return createMono(commandBuilder::unwatch);
    }

    @Override
    public Mono zadd(K key, double score, V member) {
        return createMono(() -> commandBuilder.zadd(key, null, score, member));
    }

    @Override
    public Mono zadd(K key, Object... scoresAndValues) {
        return createMono(() -> commandBuilder.zadd(key, null, scoresAndValues));
    }

    @Override
    public Mono zadd(K key, ScoredValue... scoredValues) {
        return createMono(() -> commandBuilder.zadd(key, null, (Object[]) scoredValues));
    }

    @Override
    public Mono zadd(K key, ZAddArgs zAddArgs, double score, V member) {
        return createMono(() -> commandBuilder.zadd(key, zAddArgs, score, member));
    }

    @Override
    public Mono zadd(K key, ZAddArgs zAddArgs, Object... scoresAndValues) {
        return createMono(() -> commandBuilder.zadd(key, zAddArgs, scoresAndValues));
    }

    @Override
    public Mono zadd(K key, ZAddArgs zAddArgs, ScoredValue... scoredValues) {
        return createMono(() -> commandBuilder.zadd(key, zAddArgs, (Object[]) scoredValues));
    }

    @Override
    public Mono zaddincr(K key, double score, V member) {
        return createMono(() -> commandBuilder.zaddincr(key, null, score, member));
    }

    @Override
    public Mono zaddincr(K key, ZAddArgs zAddArgs, double score, V member) {
        return createMono(() -> commandBuilder.zaddincr(key, zAddArgs, score, member));
    }

    @Override
    public Mono zcard(K key) {
        return createMono(() -> commandBuilder.zcard(key));
    }

    public Mono zcount(K key, double min, double max) {
        return createMono(() -> commandBuilder.zcount(key, min, max));
    }

    @Override
    public Mono zcount(K key, String min, String max) {
        return createMono(() -> commandBuilder.zcount(key, min, max));
    }

    @Override
    public Mono zincrby(K key, double amount, K member) {
        return createMono(() -> commandBuilder.zincrby(key, amount, member));
    }

    @Override
    public Mono zinterstore(K destination, K... keys) {
        return createMono(() -> commandBuilder.zinterstore(destination, keys));
    }

    @Override
    public Mono zcount(K key, Range range) {
        return createMono(() -> commandBuilder.zcount(key, range));
    }

    @Override
    public Mono zinterstore(K destination, ZStoreArgs storeArgs, K... keys) {
        return createMono(() -> commandBuilder.zinterstore(destination, storeArgs, keys));
    }

    @Override
    public Flux zrange(K key, long start, long stop) {
        return createDissolvingFlux(() -> commandBuilder.zrange(key, start, stop));
    }

    @Override
    public Flux> zrangeWithScores(K key, long start, long stop) {
        return createDissolvingFlux(() -> commandBuilder.zrangeWithScores(key, start, stop));
    }

    @Override
    public Flux zrangebyscore(K key, double min, double max) {
        return createDissolvingFlux(() -> commandBuilder.zrangebyscore(key, min, max));
    }

    @Override
    public Flux zrangebyscore(K key, String min, String max) {
        return createDissolvingFlux(() -> commandBuilder.zrangebyscore(key, min, max));
    }

    @Override
    public Flux zrangebyscore(K key, double min, double max, long offset, long count) {
        return createDissolvingFlux(() -> commandBuilder.zrangebyscore(key, min, max, offset, count));
    }

    @Override
    public Flux zrangebyscore(K key, String min, String max, long offset, long count) {
        return createDissolvingFlux(() -> commandBuilder.zrangebyscore(key, min, max, offset, count));
    }

    @Override
    public Flux zrangebyscore(K key, Range range) {
        return createDissolvingFlux(() -> commandBuilder.zrangebyscore(key, range, Limit.unlimited()));
    }

    @Override
    public Flux> zrangebyscoreWithScores(K key, double min, double max) {
        return createDissolvingFlux(() -> commandBuilder.zrangebyscoreWithScores(key, min, max));
    }

    @Override
    public Flux> zrangebyscoreWithScores(K key, String min, String max) {
        return createDissolvingFlux(() -> commandBuilder.zrangebyscoreWithScores(key, min, max));
    }

    @Override
    public Flux zrangebyscore(K key, Range range, Limit limit) {
        return createDissolvingFlux(() -> commandBuilder.zrangebyscore(key, range, limit));
    }

    @Override
    public Flux> zrangebyscoreWithScores(K key, double min, double max, long offset, long count) {
        return createDissolvingFlux(() -> commandBuilder.zrangebyscoreWithScores(key, min, max, offset, count));
    }

    @Override
    public Flux> zrangebyscoreWithScores(K key, String min, String max, long offset, long count) {
        return createDissolvingFlux(() -> commandBuilder.zrangebyscoreWithScores(key, min, max, offset, count));
    }

    @Override
    public Flux> zrangebyscoreWithScores(K key, Range range) {
        return createDissolvingFlux(() -> commandBuilder.zrangebyscoreWithScores(key, range, Limit.unlimited()));
    }

    @Override
    public Mono zrange(ValueStreamingChannel channel, K key, long start, long stop) {
        return createMono(() -> commandBuilder.zrange(channel, key, start, stop));
    }

    @Override
    public Mono zrangeWithScores(ScoredValueStreamingChannel channel, K key, long start, long stop) {
        return createMono(() -> commandBuilder.zrangeWithScores(channel, key, start, stop));
    }

    @Override
    public Flux> zrangebyscoreWithScores(K key, Range range, Limit limit) {
        return createDissolvingFlux(() -> commandBuilder.zrangebyscoreWithScores(key, range, limit));
    }

    @Override
    public Mono zrangebyscore(ValueStreamingChannel channel, K key, double min, double max) {
        return createMono(() -> commandBuilder.zrangebyscore(channel, key, min, max));
    }

    @Override
    public Mono zrangebyscore(ValueStreamingChannel channel, K key, String min, String max) {
        return createMono(() -> commandBuilder.zrangebyscore(channel, key, min, max));
    }

    @Override
    public Mono zrangebyscore(ValueStreamingChannel channel, K key, double min, double max, long offset,
            long count) {
        return createMono(() -> commandBuilder.zrangebyscore(channel, key, min, max, offset, count));
    }

    @Override
    public Mono zrangebyscore(ValueStreamingChannel channel, K key, Range range) {
        return createMono(() -> commandBuilder.zrangebyscore(channel, key, range, Limit.unlimited()));
    }

    @Override
    public Mono zrangebyscore(ValueStreamingChannel channel, K key, String min, String max, long offset,
            long count) {
        return createMono(() -> commandBuilder.zrangebyscore(channel, key, min, max, offset, count));
    }

    @Override
    public Mono zrangebyscore(ValueStreamingChannel channel, K key, Range range, Limit limit) {
        return createMono(() -> commandBuilder.zrangebyscore(channel, key, range, limit));
    }

    @Override
    public Mono zrangebyscoreWithScores(ScoredValueStreamingChannel channel, K key, double min, double max) {
        return createMono(() -> commandBuilder.zrangebyscoreWithScores(channel, key, min, max));
    }

    @Override
    public Mono zrangebyscoreWithScores(ScoredValueStreamingChannel channel, K key, String min, String max) {
        return createMono(() -> commandBuilder.zrangebyscoreWithScores(channel, key, min, max));
    }

    @Override
    public Mono zrangebyscoreWithScores(ScoredValueStreamingChannel channel, K key, Range range) {
        return createMono(() -> commandBuilder.zrangebyscoreWithScores(channel, key, range, Limit.unlimited()));
    }

    @Override
    public Mono zrangebyscoreWithScores(ScoredValueStreamingChannel channel, K key, double min, double max,
            long offset, long count) {
        return createMono(() -> commandBuilder.zrangebyscoreWithScores(channel, key, min, max, offset, count));
    }

    @Override
    public Mono zrangebyscoreWithScores(ScoredValueStreamingChannel channel, K key, String min, String max,
            long offset, long count) {
        return createMono(() -> commandBuilder.zrangebyscoreWithScores(channel, key, min, max, offset, count));
    }

    @Override
    public Mono zrangebyscoreWithScores(ScoredValueStreamingChannel channel, K key, Range range,
            Limit limit) {
        return createMono(() -> commandBuilder.zrangebyscoreWithScores(channel, key, range, limit));
    }

    @Override
    public Mono zrank(K key, V member) {
        return createMono(() -> commandBuilder.zrank(key, member));
    }

    @Override
    public Mono zrem(K key, V... members) {
        return createMono(() -> commandBuilder.zrem(key, members));
    }

    @Override
    public Mono zremrangebyrank(K key, long start, long stop) {
        return createMono(() -> commandBuilder.zremrangebyrank(key, start, stop));
    }

    @Override
    public Mono zremrangebyscore(K key, double min, double max) {
        return createMono(() -> commandBuilder.zremrangebyscore(key, min, max));
    }

    @Override
    public Mono zremrangebyscore(K key, String min, String max) {
        return createMono(() -> commandBuilder.zremrangebyscore(key, min, max));
    }

    @Override
    public Mono zremrangebyscore(K key, Range range) {
        return createMono(() -> commandBuilder.zremrangebyscore(key, range));
    }

    @Override
    public Flux zrevrange(K key, long start, long stop) {
        return createDissolvingFlux(() -> commandBuilder.zrevrange(key, start, stop));
    }

    @Override
    public Flux> zrevrangeWithScores(K key, long start, long stop) {
        return createDissolvingFlux(() -> commandBuilder.zrevrangeWithScores(key, start, stop));
    }

    @Override
    public Flux zrevrangebylex(K key, Range range) {
        return createDissolvingFlux(() -> commandBuilder.zrevrangebylex(key, range, Limit.unlimited()));
    }

    @Override
    public Flux zrevrangebylex(K key, Range range, Limit limit) {
        return createDissolvingFlux(() -> commandBuilder.zrevrangebylex(key, range, limit));
    }

    @Override
    public Flux zrevrangebyscore(K key, double max, double min) {
        return createDissolvingFlux(() -> commandBuilder.zrevrangebyscore(key, max, min));
    }

    @Override
    public Flux zrevrangebyscore(K key, String max, String min) {
        return createDissolvingFlux(() -> commandBuilder.zrevrangebyscore(key, max, min));
    }

    @Override
    public Flux zrevrangebyscore(K key, Range range) {
        return createDissolvingFlux(() -> commandBuilder.zrevrangebyscore(key, range, Limit.unlimited()));
    }

    @Override
    public Flux zrevrangebyscore(K key, double max, double min, long offset, long count) {
        return createDissolvingFlux(() -> commandBuilder.zrevrangebyscore(key, max, min, offset, count));
    }

    @Override
    public Flux zrevrangebyscore(K key, String max, String min, long offset, long count) {
        return createDissolvingFlux(() -> commandBuilder.zrevrangebyscore(key, max, min, offset, count));
    }

    @Override
    public Flux zrevrangebyscore(K key, Range range, Limit limit) {
        return createDissolvingFlux(() -> commandBuilder.zrevrangebyscore(key, range, limit));
    }

    @Override
    public Flux> zrevrangebyscoreWithScores(K key, double max, double min) {
        return createDissolvingFlux(() -> commandBuilder.zrevrangebyscoreWithScores(key, max, min));
    }

    @Override
    public Flux> zrevrangebyscoreWithScores(K key, String max, String min) {
        return createDissolvingFlux(() -> commandBuilder.zrevrangebyscoreWithScores(key, max, min));
    }

    @Override
    public Flux> zrevrangebyscoreWithScores(K key, Range range) {
        return createDissolvingFlux(() -> commandBuilder.zrevrangebyscoreWithScores(key, range, Limit.unlimited()));
    }

    @Override
    public Flux> zrevrangebyscoreWithScores(K key, double max, double min, long offset, long count) {
        return createDissolvingFlux(() -> commandBuilder.zrevrangebyscoreWithScores(key, max, min, offset, count));
    }

    @Override
    public Flux> zrevrangebyscoreWithScores(K key, String max, String min, long offset, long count) {
        return createDissolvingFlux(() -> commandBuilder.zrevrangebyscoreWithScores(key, max, min, offset, count));
    }

    @Override
    public Flux> zrevrangebyscoreWithScores(K key, Range range, Limit limit) {
        return createDissolvingFlux(() -> commandBuilder.zrevrangebyscoreWithScores(key, range, limit));
    }

    @Override
    public Mono zrevrange(ValueStreamingChannel channel, K key, long start, long stop) {
        return createMono(() -> commandBuilder.zrevrange(channel, key, start, stop));
    }

    @Override
    public Mono zrevrangeWithScores(ScoredValueStreamingChannel channel, K key, long start, long stop) {
        return createMono(() -> commandBuilder.zrevrangeWithScores(channel, key, start, stop));
    }

    @Override
    public Mono zrevrangebyscore(ValueStreamingChannel channel, K key, double max, double min) {
        return createMono(() -> commandBuilder.zrevrangebyscore(channel, key, max, min));
    }

    @Override
    public Mono zrevrangebyscore(ValueStreamingChannel channel, K key, String max, String min) {
        return createMono(() -> commandBuilder.zrevrangebyscore(channel, key, max, min));
    }

    @Override
    public Mono zrevrangebyscore(ValueStreamingChannel channel, K key, Range range) {
        return createMono(() -> commandBuilder.zrevrangebyscore(channel, key, range, Limit.unlimited()));
    }

    @Override
    public Mono zrevrangebyscore(ValueStreamingChannel channel, K key, double max, double min, long offset,
            long count) {
        return createMono(() -> commandBuilder.zrevrangebyscore(channel, key, max, min, offset, count));
    }

    @Override
    public Mono zrevrangebyscore(ValueStreamingChannel channel, K key, String max, String min, long offset,
            long count) {
        return createMono(() -> commandBuilder.zrevrangebyscore(channel, key, max, min, offset, count));
    }

    @Override
    public Mono zrevrangebyscore(ValueStreamingChannel channel, K key, Range range, Limit limit) {
        return createMono(() -> commandBuilder.zrevrangebyscore(channel, key, range, limit));
    }

    @Override
    public Mono zrevrangebyscoreWithScores(ScoredValueStreamingChannel channel, K key, double max, double min) {
        return createMono(() -> commandBuilder.zrevrangebyscoreWithScores(channel, key, max, min));
    }

    @Override
    public Mono zrevrangebyscoreWithScores(ScoredValueStreamingChannel channel, K key, String max, String min) {
        return createMono(() -> commandBuilder.zrevrangebyscoreWithScores(channel, key, max, min));
    }

    @Override
    public Mono zrevrangebyscoreWithScores(ScoredValueStreamingChannel channel, K key, Range range) {
        return createMono(() -> commandBuilder.zrevrangebyscoreWithScores(channel, key, range, Limit.unlimited()));
    }

    @Override
    public Mono zrevrangebyscoreWithScores(ScoredValueStreamingChannel channel, K key, double max, double min,
            long offset, long count) {
        return createMono(() -> commandBuilder.zrevrangebyscoreWithScores(channel, key, max, min, offset, count));
    }

    @Override
    public Mono zrevrangebyscoreWithScores(ScoredValueStreamingChannel channel, K key, String max, String min,
            long offset, long count) {
        return createMono(() -> commandBuilder.zrevrangebyscoreWithScores(channel, key, max, min, offset, count));
    }

    @Override
    public Mono zrevrangebyscoreWithScores(ScoredValueStreamingChannel channel, K key, Range range,
            Limit limit) {
        return createMono(() -> commandBuilder.zrevrangebyscoreWithScores(channel, key, range, limit));
    }

    @Override
    public Mono zrevrank(K key, V member) {
        return createMono(() -> commandBuilder.zrevrank(key, member));
    }

    @Override
    public Mono zscore(K key, V member) {
        return createMono(() -> commandBuilder.zscore(key, member));
    }

    @Override
    public Mono zunionstore(K destination, K... keys) {
        return createMono(() -> commandBuilder.zunionstore(destination, keys));
    }

    @Override
    public Mono zunionstore(K destination, ZStoreArgs storeArgs, K... keys) {
        return createMono(() -> commandBuilder.zunionstore(destination, storeArgs, keys));
    }

    @Override
    public Mono> scan() {
        return createMono(commandBuilder::scan);
    }

    @Override
    public Mono> scan(ScanArgs scanArgs) {
        return createMono(() -> commandBuilder.scan(scanArgs));
    }

    @Override
    public Mono> scan(ScanCursor scanCursor, ScanArgs scanArgs) {
        return createMono(() -> commandBuilder.scan(scanCursor, scanArgs));
    }

    @Override
    public Mono> scan(ScanCursor scanCursor) {
        return createMono(() -> commandBuilder.scan(scanCursor));
    }

    @Override
    public Mono scan(KeyStreamingChannel channel) {
        return createMono(() -> commandBuilder.scanStreaming(channel));
    }

    @Override
    public Mono scan(KeyStreamingChannel channel, ScanArgs scanArgs) {
        return createMono(() -> commandBuilder.scanStreaming(channel, scanArgs));
    }

    @Override
    public Mono scan(KeyStreamingChannel channel, ScanCursor scanCursor, ScanArgs scanArgs) {
        return createMono(() -> commandBuilder.scanStreaming(channel, scanCursor, scanArgs));
    }

    @Override
    public Mono scan(KeyStreamingChannel channel, ScanCursor scanCursor) {
        return createMono(() -> commandBuilder.scanStreaming(channel, scanCursor));
    }

    @Override
    public Mono> sscan(K key) {
        return createMono(() -> commandBuilder.sscan(key));
    }

    @Override
    public Mono> sscan(K key, ScanArgs scanArgs) {
        return createMono(() -> commandBuilder.sscan(key, scanArgs));
    }

    @Override
    public Mono> sscan(K key, ScanCursor scanCursor, ScanArgs scanArgs) {
        return createMono(() -> commandBuilder.sscan(key, scanCursor, scanArgs));
    }

    @Override
    public Mono> sscan(K key, ScanCursor scanCursor) {
        return createMono(() -> commandBuilder.sscan(key, scanCursor));
    }

    @Override
    public Mono sscan(ValueStreamingChannel channel, K key) {
        return createMono(() -> commandBuilder.sscanStreaming(channel, key));
    }

    @Override
    public Mono sscan(ValueStreamingChannel channel, K key, ScanArgs scanArgs) {
        return createMono(() -> commandBuilder.sscanStreaming(channel, key, scanArgs));
    }

    @Override
    public Mono sscan(ValueStreamingChannel channel, K key, ScanCursor scanCursor, ScanArgs scanArgs) {
        return createMono(() -> commandBuilder.sscanStreaming(channel, key, scanCursor, scanArgs));
    }

    @Override
    public Mono sscan(ValueStreamingChannel channel, K key, ScanCursor scanCursor) {
        return createMono(() -> commandBuilder.sscanStreaming(channel, key, scanCursor));
    }

    @Override
    public Mono> hscan(K key) {
        return createMono(() -> commandBuilder.hscan(key));
    }

    @Override
    public Mono> hscan(K key, ScanArgs scanArgs) {
        return createMono(() -> commandBuilder.hscan(key, scanArgs));
    }

    @Override
    public Mono> hscan(K key, ScanCursor scanCursor, ScanArgs scanArgs) {
        return createMono(() -> commandBuilder.hscan(key, scanCursor, scanArgs));
    }

    @Override
    public Mono> hscan(K key, ScanCursor scanCursor) {
        return createMono(() -> commandBuilder.hscan(key, scanCursor));
    }

    @Override
    public Mono hscan(KeyValueStreamingChannel channel, K key) {
        return createMono(() -> commandBuilder.hscanStreaming(channel, key));
    }

    @Override
    public Mono hscan(KeyValueStreamingChannel channel, K key, ScanArgs scanArgs) {
        return createMono(() -> commandBuilder.hscanStreaming(channel, key, scanArgs));
    }

    @Override
    public Mono hscan(KeyValueStreamingChannel channel, K key, ScanCursor scanCursor,
            ScanArgs scanArgs) {
        return createMono(() -> commandBuilder.hscanStreaming(channel, key, scanCursor, scanArgs));
    }

    @Override
    public Mono hscan(KeyValueStreamingChannel channel, K key, ScanCursor scanCursor) {
        return createMono(() -> commandBuilder.hscanStreaming(channel, key, scanCursor));
    }

    @Override
    public Mono> zscan(K key) {
        return createMono(() -> commandBuilder.zscan(key));
    }

    @Override
    public Mono> zscan(K key, ScanArgs scanArgs) {
        return createMono(() -> commandBuilder.zscan(key, scanArgs));
    }

    @Override
    public Mono> zscan(K key, ScanCursor scanCursor, ScanArgs scanArgs) {
        return createMono(() -> commandBuilder.zscan(key, scanCursor, scanArgs));
    }

    @Override
    public Mono> zscan(K key, ScanCursor scanCursor) {
        return createMono(() -> commandBuilder.zscan(key, scanCursor));
    }

    @Override
    public Mono zscan(ScoredValueStreamingChannel channel, K key) {
        return createMono(() -> commandBuilder.zscanStreaming(channel, key));
    }

    @Override
    public Mono zscan(ScoredValueStreamingChannel channel, K key, ScanArgs scanArgs) {
        return createMono(() -> commandBuilder.zscanStreaming(channel, key, scanArgs));
    }

    @Override
    public Mono zscan(ScoredValueStreamingChannel channel, K key, ScanCursor scanCursor,
            ScanArgs scanArgs) {
        return createMono(() -> commandBuilder.zscanStreaming(channel, key, scanCursor, scanArgs));
    }

    @Override
    public Mono zscan(ScoredValueStreamingChannel channel, K key, ScanCursor scanCursor) {
        return createMono(() -> commandBuilder.zscanStreaming(channel, key, scanCursor));
    }

    @Override
    public String digest(V script) {
        return LettuceStrings.digest(codec.encodeValue(script));
    }

    @Override
    public Flux time() {
        return createDissolvingFlux(commandBuilder::time);
    }

    @Override
    public Mono waitForReplication(int replicas, long timeout) {
        return createMono(() -> commandBuilder.wait(replicas, timeout));
    }

    @Override
    public Mono pfadd(K key, V... values) {
        return createMono(() -> commandBuilder.pfadd(key, values));
    }

    public Mono pfadd(K key, V value, V... values) {
        return createMono(() -> commandBuilder.pfadd(key, value, values));
    }

    @Override
    public Mono pfmerge(K destkey, K... sourcekeys) {
        return createMono(() -> commandBuilder.pfmerge(destkey, sourcekeys));
    }

    public Mono pfmerge(K destkey, K sourceKey, K... sourcekeys) {
        return createMono(() -> commandBuilder.pfmerge(destkey, sourceKey, sourcekeys));
    }

    @Override
    public Mono pfcount(K... keys) {
        return createMono(() -> commandBuilder.pfcount(keys));
    }

    public Mono pfcount(K key, K... keys) {
        return createMono(() -> commandBuilder.pfcount(key, keys));
    }

    @Override
    public Mono clusterBumpepoch() {
        return createMono(() -> commandBuilder.clusterBumpepoch());
    }

    @Override
    public Mono clusterMeet(String ip, int port) {
        return createMono(() -> commandBuilder.clusterMeet(ip, port));
    }

    @Override
    public Mono clusterForget(String nodeId) {
        return createMono(() -> commandBuilder.clusterForget(nodeId));
    }

    @Override
    public Mono clusterAddSlots(int... slots) {
        return createMono(() -> commandBuilder.clusterAddslots(slots));
    }

    @Override
    public Mono clusterDelSlots(int... slots) {
        return createMono(() -> commandBuilder.clusterDelslots(slots));
    }

    @Override
    public Mono clusterInfo() {
        return createMono(commandBuilder::clusterInfo);
    }

    @Override
    public Mono clusterMyId() {
        return createMono(commandBuilder::clusterMyId);
    }

    @Override
    public Mono clusterNodes() {
        return createMono(commandBuilder::clusterNodes);
    }

    @Override
    public Flux clusterGetKeysInSlot(int slot, int count) {
        return createDissolvingFlux(() -> commandBuilder.clusterGetKeysInSlot(slot, count));
    }

    @Override
    public Mono clusterCountKeysInSlot(int slot) {
        return createMono(() -> commandBuilder.clusterCountKeysInSlot(slot));
    }

    @Override
    public Mono clusterCountFailureReports(String nodeId) {
        return createMono(() -> commandBuilder.clusterCountFailureReports(nodeId));
    }

    @Override
    public Mono clusterKeyslot(K key) {
        return createMono(() -> commandBuilder.clusterKeyslot(key));
    }

    @Override
    public Mono clusterSaveconfig() {
        return createMono(() -> commandBuilder.clusterSaveconfig());
    }

    @Override
    public Mono clusterSetConfigEpoch(long configEpoch) {
        return createMono(() -> commandBuilder.clusterSetConfigEpoch(configEpoch));
    }

    @Override
    public Flux clusterSlots() {
        return createDissolvingFlux(commandBuilder::clusterSlots);
    }

    @Override
    public Mono clusterSetSlotNode(int slot, String nodeId) {
        return createMono(() -> commandBuilder.clusterSetSlotNode(slot, nodeId));
    }

    @Override
    public Mono clusterSetSlotStable(int slot) {
        return createMono(() -> commandBuilder.clusterSetSlotStable(slot));
    }

    @Override
    public Mono clusterSetSlotMigrating(int slot, String nodeId) {
        return createMono(() -> commandBuilder.clusterSetSlotMigrating(slot, nodeId));
    }

    @Override
    public Mono clusterSetSlotImporting(int slot, String nodeId) {
        return createMono(() -> commandBuilder.clusterSetSlotImporting(slot, nodeId));
    }

    @Override
    public Mono clusterFailover(boolean force) {
        return createMono(() -> commandBuilder.clusterFailover(force));
    }

    @Override
    public Mono clusterReset(boolean hard) {
        return createMono(() -> commandBuilder.clusterReset(hard));
    }

    @Override
    public Mono asking() {
        return createMono(commandBuilder::asking);
    }

    @Override
    public Mono clusterReplicate(String nodeId) {
        return createMono(() -> commandBuilder.clusterReplicate(nodeId));
    }

    @Override
    public Mono clusterFlushslots() {
        return createMono(commandBuilder::clusterFlushslots);
    }

    @Override
    public Flux clusterSlaves(String nodeId) {
        return createDissolvingFlux(() -> commandBuilder.clusterSlaves(nodeId));
    }

    @Override
    public Mono zlexcount(K key, String min, String max) {
        return createMono(() -> commandBuilder.zlexcount(key, min, max));
    }

    @Override
    public Mono zlexcount(K key, Range range) {
        return createMono(() -> commandBuilder.zlexcount(key, range));
    }

    @Override
    public Mono zremrangebylex(K key, String min, String max) {
        return createMono(() -> commandBuilder.zremrangebylex(key, min, max));
    }

    @Override
    public Mono zremrangebylex(K key, Range range) {
        return createMono(() -> commandBuilder.zremrangebylex(key, range));
    }

    @Override
    public Flux zrangebylex(K key, String min, String max) {
        return createDissolvingFlux(() -> commandBuilder.zrangebylex(key, min, max));
    }

    @Override
    public Flux zrangebylex(K key, Range range) {
        return createDissolvingFlux(() -> commandBuilder.zrangebylex(key, range, Limit.unlimited()));
    }

    @Override
    public Flux zrangebylex(K key, String min, String max, long offset, long count) {
        return createDissolvingFlux(() -> commandBuilder.zrangebylex(key, min, max, offset, count));
    }

    @Override
    public Flux zrangebylex(K key, Range range, Limit limit) {
        return createDissolvingFlux(() -> commandBuilder.zrangebylex(key, range, limit));
    }

    @Override
    public Mono geoadd(K key, double longitude, double latitude, V member) {
        return createMono(() -> commandBuilder.geoadd(key, longitude, latitude, member));
    }

    @Override
    public Mono geoadd(K key, Object... lngLatMember) {
        return createMono(() -> commandBuilder.geoadd(key, lngLatMember));
    }

    @Override
    public Flux> geohash(K key, V... members) {
        return createDissolvingFlux(() -> commandBuilder.geohash(key, members));
    }

    @Override
    public Flux georadius(K key, double longitude, double latitude, double distance, Unit unit) {
        return createDissolvingFlux(() -> commandBuilder.georadius(key, longitude, latitude, distance, unit.name()));
    }

    @Override
    public Flux> georadius(K key, double longitude, double latitude, double distance, Unit unit,
            GeoArgs geoArgs) {
        return createDissolvingFlux(() -> commandBuilder.georadius(key, longitude, latitude, distance, unit.name(),
                geoArgs));
    }

    @Override
    public Mono georadius(K key, double longitude, double latitude, double distance, Unit unit,
            GeoRadiusStoreArgs geoRadiusStoreArgs) {
        return createMono(
                () -> commandBuilder.georadius(key, longitude, latitude, distance, unit.name(), geoRadiusStoreArgs));
    }

    @Override
    public Flux georadiusbymember(K key, V member, double distance, Unit unit) {
        return createDissolvingFlux(() -> commandBuilder.georadiusbymember(key, member, distance, unit.name()));
    }

    @Override
    public Flux> georadiusbymember(K key, V member, double distance, Unit unit, GeoArgs geoArgs) {
        return createDissolvingFlux(() -> commandBuilder.georadiusbymember(key, member, distance, unit.name(), geoArgs));
    }

    @Override
    public Mono georadiusbymember(K key, V member, double distance, Unit unit,
            GeoRadiusStoreArgs geoRadiusStoreArgs) {
        return createMono(
                () -> commandBuilder.georadiusbymember(key, member, distance, unit.name(), geoRadiusStoreArgs));
    }

    @Override
    public Flux> geopos(K key, V... members) {
        return createDissolvingFlux(() -> commandBuilder.geoposValues(key, members));
    }

    @Override
    public Mono geodist(K key, V from, V to, Unit unit) {
        return createMono(() -> commandBuilder.geodist(key, from, to, unit));
    }

    @SuppressWarnings("unchecked")
    public  Flux dispatch(ProtocolKeyword type, CommandOutput output) {

        LettuceAssert.notNull(type, "Command type must not be null");
        LettuceAssert.notNull(output, "CommandOutput type must not be null");

        return (Flux) createFlux(() -> new Command<>(type, output));
    }

    @SuppressWarnings("unchecked")
    public  Flux dispatch(ProtocolKeyword type, CommandOutput output, CommandArgs args) {

        LettuceAssert.notNull(type, "Command type must not be null");
        LettuceAssert.notNull(output, "CommandOutput type must not be null");
        LettuceAssert.notNull(args, "CommandArgs type must not be null");

        return (Flux) createFlux(() -> new Command<>(type, output, args));
    }

    public  Flux createFlux(Supplier> commandSupplier) {
        return Flux.from(new RedisPublisher<>(commandSupplier, connection, false));
    }

    protected  Mono createMono(CommandType type, CommandOutput output, CommandArgs args) {
        return createMono(() -> new Command<>(type, output, args));
    }

    public  Mono createMono(Supplier> commandSupplier) {
        return Mono.from(new RedisPublisher<>(commandSupplier, connection, false));
    }

    @SuppressWarnings("unchecked")
    public  Flux createDissolvingFlux(Supplier> commandSupplier) {
        return (Flux) Flux.from(new RedisPublisher<>(commandSupplier, connection, true));
    }

    public void setTimeout(long timeout, TimeUnit unit) {
        connection.setTimeout(timeout, unit);
    }

    public void close() {
        connection.close();
    }

    @Override
    public boolean isOpen() {
        return connection.isOpen();
    }

    @Override
    public void reset() {
        getConnection().reset();
    }

    public StatefulConnection getConnection() {
        return connection;
    }

    @Override
    public void setAutoFlushCommands(boolean autoFlush) {
        connection.setAutoFlushCommands(autoFlush);
    }

    @Override
    public void flushCommands() {
        connection.flushCommands();
    }
}
    
    
    
    

    




    
    
    © 2015 - 2025 Weber Informatics LLC | Privacy Policy