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

    • org.redisson.client.protocol.RedisCommands Maven / Gradle / Ivy

    There is a newer version: 3.43.0
    Show newest version
    /**
 * Copyright 2014 Nikita Koksharov, Nickolay Borbit
 *
 * 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 org.redisson.client.protocol;

import java.util.Arrays;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;

import org.redisson.client.protocol.RedisCommand.ValueType;
import org.redisson.client.protocol.convertor.BitSetReplayConvertor;
import org.redisson.client.protocol.convertor.BitsSizeReplayConvertor;
import org.redisson.client.protocol.convertor.BooleanAmountReplayConvertor;
import org.redisson.client.protocol.convertor.BooleanNotNullReplayConvertor;
import org.redisson.client.protocol.convertor.BooleanNullReplayConvertor;
import org.redisson.client.protocol.convertor.BooleanNumberReplayConvertor;
import org.redisson.client.protocol.convertor.BooleanReplayConvertor;
import org.redisson.client.protocol.convertor.DoubleReplayConvertor;
import org.redisson.client.protocol.convertor.IntegerReplayConvertor;
import org.redisson.client.protocol.convertor.KeyValueConvertor;
import org.redisson.client.protocol.convertor.LongReplayConvertor;
import org.redisson.client.protocol.convertor.TrueReplayConvertor;
import org.redisson.client.protocol.convertor.VoidReplayConvertor;
import org.redisson.client.protocol.decoder.KeyValueObjectDecoder;
import org.redisson.client.protocol.decoder.ListResultReplayDecoder;
import org.redisson.client.protocol.decoder.ListScanResult;
import org.redisson.client.protocol.decoder.ListScanResultReplayDecoder;
import org.redisson.client.protocol.decoder.MapScanResult;
import org.redisson.client.protocol.decoder.MapScanResultReplayDecoder;
import org.redisson.client.protocol.decoder.NestedMultiDecoder;
import org.redisson.client.protocol.decoder.FlatNestedMultiDecoder;
import org.redisson.client.protocol.decoder.ObjectFirstResultReplayDecoder;
import org.redisson.client.protocol.decoder.ObjectListReplayDecoder;
import org.redisson.client.protocol.decoder.ObjectMapEntryReplayDecoder;
import org.redisson.client.protocol.decoder.ObjectMapReplayDecoder;
import org.redisson.client.protocol.decoder.ObjectSetReplayDecoder;
import org.redisson.client.protocol.decoder.ScoredSortedSetReplayDecoder;
import org.redisson.client.protocol.decoder.ScoredSortedSetScanDecoder;
import org.redisson.client.protocol.decoder.ScoredSortedSetScanReplayDecoder;
import org.redisson.client.protocol.decoder.StringDataDecoder;
import org.redisson.client.protocol.decoder.StringListReplayDecoder;
import org.redisson.client.protocol.decoder.StringMapDataDecoder;
import org.redisson.client.protocol.decoder.StringReplayDecoder;
import org.redisson.client.protocol.pubsub.PubSubStatusDecoder;

public interface RedisCommands {

    RedisStrictCommand GEOADD = new RedisStrictCommand("GEOADD", 4);
    RedisStrictCommand GEOADD_ENTRIES = new RedisStrictCommand("GEOADD", 2, ValueType.OBJECTS);
    RedisCommand GEODIST = new RedisCommand("GEODIST", new DoubleReplayConvertor(), 2, Arrays.asList(ValueType.OBJECT, ValueType.OBJECT, ValueType.STRING));
    RedisCommand> GEORADIUS = new RedisCommand>("GEORADIUS", new ObjectListReplayDecoder());
    RedisCommand> GEORADIUSBYMEMBER = new RedisCommand>("GEORADIUSBYMEMBER", new ObjectListReplayDecoder(), 2);
    
    RedisStrictCommand KEYSLOT = new RedisStrictCommand("CLUSTER", "KEYSLOT", new IntegerReplayConvertor());

    RedisStrictCommand GETBIT = new RedisStrictCommand("GETBIT", new BooleanReplayConvertor());
    RedisStrictCommand BITS_SIZE = new RedisStrictCommand("STRLEN", new BitsSizeReplayConvertor());
    RedisStrictCommand STRLEN = new RedisStrictCommand("STRLEN", new IntegerReplayConvertor());
    RedisStrictCommand BITCOUNT = new RedisStrictCommand("BITCOUNT");
    RedisStrictCommand BITPOS = new RedisStrictCommand("BITPOS", new IntegerReplayConvertor());
    RedisStrictCommand SETBIT_VOID = new RedisStrictCommand("SETBIT", new VoidReplayConvertor());
    RedisStrictCommand SETBIT = new RedisStrictCommand("SETBIT", new BitSetReplayConvertor());
    RedisStrictCommand BITOP = new RedisStrictCommand("BITOP", new VoidReplayConvertor());

    RedisStrictCommand ASKING = new RedisStrictCommand("ASKING", new VoidReplayConvertor());
    RedisStrictCommand READONLY = new RedisStrictCommand("READONLY", new VoidReplayConvertor());

    RedisCommand ZADD_BOOL = new RedisCommand("ZADD", new BooleanAmountReplayConvertor(), 3);
    RedisCommand ZADD_NX_BOOL = new RedisCommand("ZADD", new BooleanAmountReplayConvertor(), 4);
    RedisCommand ZADD_BOOL_RAW = new RedisCommand("ZADD", new BooleanAmountReplayConvertor());
    RedisCommand ZADD_RAW = new RedisCommand("ZADD");
    RedisCommand ZADD = new RedisCommand("ZADD");
    RedisCommand ZREM = new RedisCommand("ZREM", new BooleanAmountReplayConvertor(), 2, ValueType.OBJECTS);
    RedisStrictCommand ZCARD_INT = new RedisStrictCommand("ZCARD", new IntegerReplayConvertor());
    RedisStrictCommand ZCARD = new RedisStrictCommand("ZCARD");
    RedisStrictCommand ZCOUNT = new RedisStrictCommand("ZCOUNT");
    RedisStrictCommand ZLEXCOUNT = new RedisStrictCommand("ZLEXCOUNT", new IntegerReplayConvertor());
    RedisCommand ZSCORE_CONTAINS = new RedisCommand("ZSCORE", new BooleanNotNullReplayConvertor(), 2);
    RedisStrictCommand ZSCORE = new RedisStrictCommand("ZSCORE", new DoubleReplayConvertor(), 2);
    RedisCommand ZRANK_INT = new RedisCommand("ZRANK", new IntegerReplayConvertor(), 2);
    RedisCommand ZREVRANK_INT = new RedisCommand("ZREVRANK", new IntegerReplayConvertor(), 2);
    RedisStrictCommand ZRANK = new RedisStrictCommand("ZRANK", 2);
    RedisCommand ZRANGE_SINGLE = new RedisCommand("ZRANGE", new ObjectFirstResultReplayDecoder());
    RedisCommand> ZRANGE = new RedisCommand>("ZRANGE", new ObjectListReplayDecoder());
    RedisStrictCommand ZREMRANGEBYRANK = new RedisStrictCommand("ZREMRANGEBYRANK", new IntegerReplayConvertor());
    RedisStrictCommand ZREMRANGEBYSCORE = new RedisStrictCommand("ZREMRANGEBYSCORE", new IntegerReplayConvertor());
    RedisStrictCommand ZREMRANGEBYLEX = new RedisStrictCommand("ZREMRANGEBYLEX", new IntegerReplayConvertor());
    RedisCommand> ZRANGEBYLEX = new RedisCommand>("ZRANGEBYLEX", new ObjectListReplayDecoder());
    RedisCommand> ZRANGEBYSCORE = new RedisCommand>("ZRANGEBYSCORE", new ObjectSetReplayDecoder());
    RedisCommand> ZRANGEBYSCORE_LIST = new RedisCommand>("ZRANGEBYSCORE", new ObjectListReplayDecoder());
    RedisCommand> ZREVRANGEBYSCORE = new RedisCommand>("ZREVRANGEBYSCORE", new ObjectListReplayDecoder());
    RedisCommand>> ZREVRANGEBYSCORE_ENTRY = new RedisCommand>>("ZREVRANGEBYSCORE", new ScoredSortedSetReplayDecoder());
    RedisCommand>> ZRANGE_ENTRY = new RedisCommand>>("ZRANGE", new ScoredSortedSetReplayDecoder());
    RedisCommand>> ZRANGEBYSCORE_ENTRY = new RedisCommand>>("ZRANGEBYSCORE", new ScoredSortedSetReplayDecoder());
    RedisCommand> ZSCAN = new RedisCommand>("ZSCAN", new NestedMultiDecoder(new ScoredSortedSetScanDecoder(), new ScoredSortedSetScanReplayDecoder()), ValueType.OBJECT);
    RedisStrictCommand ZINCRBY = new RedisStrictCommand("ZINCRBY", new DoubleReplayConvertor(), 4);

    RedisCommand> SCAN = new RedisCommand>("SCAN", new NestedMultiDecoder(new ObjectListReplayDecoder(), new ListScanResultReplayDecoder()), ValueType.OBJECT);
    RedisStrictCommand RANDOM_KEY = new RedisStrictCommand("RANDOMKEY", new StringDataDecoder());
    RedisStrictCommand PING = new RedisStrictCommand("PING");

    RedisStrictCommand UNWATCH = new RedisStrictCommand("UNWATCH", new VoidReplayConvertor());
    RedisStrictCommand WATCH = new RedisStrictCommand("WATCH", new VoidReplayConvertor());
    RedisStrictCommand MULTI = new RedisStrictCommand("MULTI", new VoidReplayConvertor());
    RedisCommand> EXEC = new RedisCommand>("EXEC", new ObjectListReplayDecoder());

    RedisCommand SADD_BOOL = new RedisCommand("SADD", new BooleanAmountReplayConvertor(), 2, ValueType.OBJECTS);
    RedisStrictCommand SADD = new RedisStrictCommand("SADD", 2, ValueType.OBJECTS);
    RedisCommand SPOP_SINGLE = new RedisCommand("SPOP");
    RedisCommand SADD_SINGLE = new RedisCommand("SADD", new BooleanReplayConvertor(), 2);
    RedisCommand SREM_SINGLE = new RedisCommand("SREM", new BooleanAmountReplayConvertor(), 2, ValueType.OBJECTS);
    RedisCommand SMOVE = new RedisCommand("SMOVE", new BooleanReplayConvertor(), 3);
    RedisCommand> SMEMBERS = new RedisCommand>("SMEMBERS", new ObjectSetReplayDecoder());
    RedisCommand> SSCAN = new RedisCommand>("SSCAN", new NestedMultiDecoder(new ObjectListReplayDecoder(), new ListScanResultReplayDecoder()), ValueType.OBJECT);
    RedisCommand> EVAL_SSCAN = new RedisCommand>("EVAL", new NestedMultiDecoder(new ObjectListReplayDecoder(), new ListScanResultReplayDecoder()), ValueType.OBJECT);
    RedisCommand> EVAL_ZSCAN = new RedisCommand>("EVAL", new NestedMultiDecoder(new ObjectListReplayDecoder(), new ListScanResultReplayDecoder()), ValueType.OBJECT);
    RedisCommand SISMEMBER = new RedisCommand("SISMEMBER", new BooleanReplayConvertor(), 2);
    RedisStrictCommand SCARD_INT = new RedisStrictCommand("SCARD", new IntegerReplayConvertor());
    RedisStrictCommand SCARD = new RedisStrictCommand("SCARD");
    RedisStrictCommand SUNIONSTORE_INT = new RedisStrictCommand("SUNIONSTORE", new IntegerReplayConvertor());
    RedisStrictCommand SDIFFSTORE_INT = new RedisStrictCommand("SDIFFSTORE", new IntegerReplayConvertor());
    RedisStrictCommand SINTERSTORE_INT = new RedisStrictCommand("SINTERSTORE", new IntegerReplayConvertor());
    RedisStrictCommand SUNIONSTORE = new RedisStrictCommand("SUNIONSTORE");
    RedisCommand> SUNION = new RedisCommand>("SUNION", new ObjectSetReplayDecoder());
    RedisCommand> SDIFF = new RedisCommand>("SDIFF", new ObjectSetReplayDecoder());
    RedisCommand> SINTER = new RedisCommand>("SINTER", new ObjectSetReplayDecoder());

    RedisCommand LSET = new RedisCommand("LSET", new VoidReplayConvertor(), 3);
    RedisCommand LPOP = new RedisCommand("LPOP");
    RedisCommand LREM_SINGLE = new RedisCommand("LREM", new BooleanReplayConvertor(), 3);
    RedisStrictCommand LREM = new RedisStrictCommand("LREM", 3);
    RedisCommand LINDEX = new RedisCommand("LINDEX");
    RedisCommand LINSERT = new RedisCommand("LINSERT", 3, ValueType.OBJECTS);
    RedisCommand LINSERT_INT = new RedisCommand("LINSERT", new IntegerReplayConvertor(), 3, ValueType.OBJECTS);
    RedisStrictCommand LLEN_INT = new RedisStrictCommand("LLEN", new IntegerReplayConvertor());
    RedisStrictCommand LLEN = new RedisStrictCommand("LLEN");
    RedisStrictCommand LTRIM = new RedisStrictCommand("LTRIM", new VoidReplayConvertor());

    RedisStrictCommand PEXPIRE = new RedisStrictCommand("PEXPIRE", new BooleanReplayConvertor());
    RedisStrictCommand PEXPIREAT = new RedisStrictCommand("PEXPIREAT", new BooleanReplayConvertor());
    RedisStrictCommand PERSIST = new RedisStrictCommand("PERSIST", new BooleanReplayConvertor());
    RedisStrictCommand PTTL = new RedisStrictCommand("PTTL");

    RedisCommand RPOPLPUSH = new RedisCommand("RPOPLPUSH");
    RedisCommand BRPOPLPUSH = new RedisCommand("BRPOPLPUSH");
    RedisCommand BLPOP_VALUE = new RedisCommand("BLPOP", new KeyValueObjectDecoder(), new KeyValueConvertor());
    RedisCommand BRPOP_VALUE = new RedisCommand("BRPOP", new KeyValueObjectDecoder(), new KeyValueConvertor());

    RedisCommand PFADD = new RedisCommand("PFADD", new BooleanReplayConvertor(), 2);
    RedisStrictCommand PFCOUNT = new RedisStrictCommand("PFCOUNT");
    RedisStrictCommand PFMERGE = new RedisStrictCommand("PFMERGE", new VoidReplayConvertor());

    RedisStrictCommand RPOP = new RedisStrictCommand("RPOP");
    RedisStrictCommand LPUSH = new RedisStrictCommand("LPUSH", 2, ValueType.OBJECTS);
    RedisCommand LPUSH_BOOLEAN = new RedisCommand("LPUSH", new TrueReplayConvertor(), 2, ValueType.OBJECTS);
    RedisStrictCommand LPUSH_VOID = new RedisStrictCommand("LPUSH", new VoidReplayConvertor(), 2);
    RedisCommand> LRANGE = new RedisCommand>("LRANGE", new ObjectListReplayDecoder());
    RedisCommand RPUSH = new RedisCommand("RPUSH", 2, ValueType.OBJECTS);
    RedisCommand RPUSH_BOOLEAN = new RedisCommand("RPUSH", new TrueReplayConvertor(), 2, ValueType.OBJECTS);

    RedisStrictCommand SCRIPT_LOAD = new RedisStrictCommand("SCRIPT", "LOAD", new StringDataDecoder());
    RedisStrictCommand SCRIPT_KILL = new RedisStrictCommand("SCRIPT", "KILL", new BooleanReplayConvertor());
    RedisStrictCommand SCRIPT_FLUSH = new RedisStrictCommand("SCRIPT", "FLUSH", new BooleanReplayConvertor());
    RedisStrictCommand> SCRIPT_EXISTS = new RedisStrictCommand>("SCRIPT", "EXISTS", new ObjectListReplayDecoder(), new BooleanReplayConvertor());

    RedisStrictCommand EVAL_BOOLEAN_AMOUNT = new RedisStrictCommand("EVAL", new BooleanAmountReplayConvertor());
    RedisStrictCommand EVAL_BOOLEAN = new RedisStrictCommand("EVAL", new BooleanReplayConvertor());
    RedisStrictCommand EVAL_NULL_BOOLEAN = new RedisStrictCommand("EVAL", new BooleanNullReplayConvertor());
    RedisCommand EVAL_BOOLEAN_WITH_VALUES = new RedisCommand("EVAL", new BooleanReplayConvertor(), 4, ValueType.OBJECTS);
    RedisStrictCommand EVAL_STRING = new RedisStrictCommand("EVAL", new StringReplayDecoder());
    RedisStrictCommand EVAL_INTEGER = new RedisStrictCommand("EVAL", new IntegerReplayConvertor());
    RedisStrictCommand EVAL_LONG = new RedisStrictCommand("EVAL");
    RedisStrictCommand EVAL_VOID = new RedisStrictCommand("EVAL", new VoidReplayConvertor());
    RedisCommand> EVAL_LIST = new RedisCommand>("EVAL", new ObjectListReplayDecoder());
    RedisCommand> EVAL_SET = new RedisCommand>("EVAL", new ObjectSetReplayDecoder());
    RedisCommand EVAL_OBJECT = new RedisCommand("EVAL");
    RedisCommand EVAL_MAP_VALUE = new RedisCommand("EVAL", ValueType.MAP_VALUE);
    RedisCommand>> EVAL_MAP_ENTRY = new RedisCommand>>("EVAL", new ObjectMapEntryReplayDecoder(), ValueType.MAP);
    RedisCommand> EVAL_MAP_VALUE_LIST = new RedisCommand>("EVAL", new ObjectListReplayDecoder(), ValueType.MAP_VALUE);

    RedisStrictCommand INCR = new RedisStrictCommand("INCR");
    RedisStrictCommand INCRBY = new RedisStrictCommand("INCRBY");
    RedisStrictCommand INCRBYFLOAT = new RedisStrictCommand("INCRBYFLOAT", new DoubleReplayConvertor());
    RedisStrictCommand DECR = new RedisStrictCommand("DECR");

    RedisStrictCommand AUTH = new RedisStrictCommand("AUTH", new VoidReplayConvertor());
    RedisStrictCommand SELECT = new RedisStrictCommand("SELECT", new VoidReplayConvertor());
    RedisStrictCommand CLIENT_SETNAME = new RedisStrictCommand("CLIENT", "SETNAME", new BooleanReplayConvertor());
    RedisStrictCommand CLIENT_GETNAME = new RedisStrictCommand("CLIENT", "GETNAME", new StringDataDecoder());
    RedisStrictCommand FLUSHDB = new RedisStrictCommand("FLUSHDB", new VoidReplayConvertor());
    RedisStrictCommand FLUSHALL = new RedisStrictCommand("FLUSHALL", new VoidReplayConvertor());

    RedisStrictCommand> KEYS = new RedisStrictCommand>("KEYS", new StringListReplayDecoder());
    RedisCommand> MGET = new RedisCommand>("MGET", new ObjectListReplayDecoder());
    RedisStrictCommand MSET = new RedisStrictCommand("MSET", new VoidReplayConvertor());
    RedisStrictCommand MSETNX = new RedisStrictCommand("MSETNX", new BooleanReplayConvertor());

    RedisCommand HSETNX = new RedisCommand("HSETNX", new BooleanReplayConvertor(), 2, ValueType.MAP);
    RedisCommand HSET = new RedisCommand("HSET", new BooleanReplayConvertor(), 2, ValueType.MAP);
    RedisCommand> HSCAN = new RedisCommand>("HSCAN", new NestedMultiDecoder(new ObjectMapReplayDecoder(), new MapScanResultReplayDecoder()), ValueType.MAP);
    RedisCommand> HGETALL = new RedisCommand>("HGETALL", new ObjectMapReplayDecoder(), ValueType.MAP);
    RedisCommand>> HGETALL_ENTRY = new RedisCommand>>("HGETALL", new ObjectMapEntryReplayDecoder(), ValueType.MAP);
    RedisCommand> HVALS = new RedisCommand>("HVALS", new ObjectListReplayDecoder(), ValueType.MAP_VALUE);
    RedisCommand HEXISTS = new RedisCommand("HEXISTS", new BooleanReplayConvertor(), 2, ValueType.MAP_KEY);
    RedisStrictCommand HLEN = new RedisStrictCommand("HLEN", new IntegerReplayConvertor());
    RedisStrictCommand HLEN_LONG = new RedisStrictCommand("HLEN");
    RedisCommand> HKEYS = new RedisCommand>("HKEYS", new ObjectSetReplayDecoder(), ValueType.MAP_KEY);
    RedisCommand HMSET = new RedisCommand("HMSET", new VoidReplayConvertor(), 2, ValueType.MAP);
    RedisCommand> HMGET = new RedisCommand>("HMGET", new ObjectListReplayDecoder(), 2, ValueType.MAP_KEY, ValueType.MAP_VALUE);
    RedisCommand HGET = new RedisCommand("HGET", 2, ValueType.MAP_KEY, ValueType.MAP_VALUE);
    RedisCommand HDEL = new RedisStrictCommand("HDEL", 2, ValueType.MAP_KEY);

    RedisStrictCommand DEL = new RedisStrictCommand("DEL");
    RedisStrictCommand DBSIZE = new RedisStrictCommand("DBSIZE");
    RedisStrictCommand DEL_BOOL = new RedisStrictCommand("DEL", new BooleanReplayConvertor());
    RedisStrictCommand DEL_OBJECTS = new RedisStrictCommand("DEL", new BooleanAmountReplayConvertor());
    RedisStrictCommand DEL_VOID = new RedisStrictCommand("DEL", new VoidReplayConvertor());

    RedisCommand GET = new RedisCommand("GET");
    RedisStrictCommand GET_LONG = new RedisStrictCommand("GET", new LongReplayConvertor());
    RedisCommand GETSET = new RedisCommand("GETSET", 2);
    RedisCommand SET = new RedisCommand("SET", new VoidReplayConvertor(), 2);
    RedisCommand SETPXNX = new RedisCommand("SET", new BooleanNotNullReplayConvertor(), 2);
    RedisCommand SETNX = new RedisCommand("SETNX", new BooleanReplayConvertor(), 2);
    RedisCommand SETEX = new RedisCommand("SETEX", new VoidReplayConvertor(), 3);
    RedisStrictCommand EXISTS = new RedisStrictCommand("EXISTS", new BooleanReplayConvertor());
    RedisStrictCommand NOT_EXISTS = new RedisStrictCommand("EXISTS", new BooleanNumberReplayConvertor(1L));

    RedisStrictCommand RENAMENX = new RedisStrictCommand("RENAMENX", new BooleanReplayConvertor());
    RedisStrictCommand RENAME = new RedisStrictCommand("RENAME", new VoidReplayConvertor());
    RedisStrictCommand MOVE = new RedisStrictCommand("MOVE", new BooleanReplayConvertor());
    RedisStrictCommand MIGRATE = new RedisStrictCommand("MIGRATE", new VoidReplayConvertor());

    RedisStrictCommand PUBLISH = new RedisStrictCommand("PUBLISH", 2);

    RedisCommand SUBSCRIBE = new RedisCommand("SUBSCRIBE", new PubSubStatusDecoder());
    RedisCommand UNSUBSCRIBE = new RedisCommand("UNSUBSCRIBE", new PubSubStatusDecoder());
    RedisCommand PSUBSCRIBE = new RedisCommand("PSUBSCRIBE", new PubSubStatusDecoder());
    RedisCommand PUNSUBSCRIBE = new RedisCommand("PUNSUBSCRIBE", new PubSubStatusDecoder());

    RedisStrictCommand CLUSTER_NODES = new RedisStrictCommand("CLUSTER", "NODES", new StringDataDecoder());
    RedisStrictCommand> CLUSTER_INFO = new RedisStrictCommand>("CLUSTER", "INFO", new StringMapDataDecoder());

    RedisStrictCommand> SENTINEL_GET_MASTER_ADDR_BY_NAME = new RedisStrictCommand>("SENTINEL", "GET-MASTER-ADDR-BY-NAME", new StringListReplayDecoder());
    RedisCommand>> SENTINEL_SLAVES = new RedisCommand>>("SENTINEL", "SLAVES",
            new FlatNestedMultiDecoder(new ObjectMapReplayDecoder(), new ListResultReplayDecoder()), ValueType.OBJECT
            );

    RedisStrictCommand INFO_REPLICATION = new RedisStrictCommand("INFO", "replication", new StringDataDecoder());
    RedisStrictCommand> INFO_PERSISTENCE = new RedisStrictCommand>("INFO", "persistence", new StringMapDataDecoder());
    RedisStrictCommand> SERVER_INFO = new RedisStrictCommand>("INFO", "SERVER", new StringMapDataDecoder());
}
    
    
    
    

    




    
    
    © 2015 - 2025 Weber Informatics LLC | Privacy Policy