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

    /**
 * Copyright 2018 Nikita Koksharov
 *
 * 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.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;

import org.redisson.api.RType;
import org.redisson.api.StreamMessageId;
import org.redisson.client.codec.StringCodec;
import org.redisson.client.protocol.RedisCommand.ValueType;
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.BooleanNullSafeReplayConvertor;
import org.redisson.client.protocol.convertor.BooleanNumberReplayConvertor;
import org.redisson.client.protocol.convertor.BooleanReplayConvertor;
import org.redisson.client.protocol.convertor.DoubleNullSafeReplayConvertor;
import org.redisson.client.protocol.convertor.DoubleReplayConvertor;
import org.redisson.client.protocol.convertor.IntegerReplayConvertor;
import org.redisson.client.protocol.convertor.LongReplayConvertor;
import org.redisson.client.protocol.convertor.StreamIdConvertor;
import org.redisson.client.protocol.convertor.StringToListConvertor;
import org.redisson.client.protocol.convertor.TimeObjectDecoder;
import org.redisson.client.protocol.convertor.TrueReplayConvertor;
import org.redisson.client.protocol.convertor.TypeConvertor;
import org.redisson.client.protocol.convertor.VoidReplayConvertor;
import org.redisson.client.protocol.decoder.ClusterNodesDecoder;
import org.redisson.client.protocol.decoder.ListFirstObjectDecoder;
import org.redisson.client.protocol.decoder.ListMultiDecoder;
import org.redisson.client.protocol.decoder.ListObjectDecoder;
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.Long2MultiDecoder;
import org.redisson.client.protocol.decoder.LongMultiDecoder;
import org.redisson.client.protocol.decoder.MapScanResult;
import org.redisson.client.protocol.decoder.MapScanResultReplayDecoder;
import org.redisson.client.protocol.decoder.ObjectDecoder;
import org.redisson.client.protocol.decoder.ObjectFirstScoreReplayDecoder;
import org.redisson.client.protocol.decoder.ObjectListReplayDecoder;
import org.redisson.client.protocol.decoder.ObjectMapEntryReplayDecoder;
import org.redisson.client.protocol.decoder.ObjectMapJoinDecoder;
import org.redisson.client.protocol.decoder.ObjectMapReplayDecoder;
import org.redisson.client.protocol.decoder.ObjectSetReplayDecoder;
import org.redisson.client.protocol.decoder.PendingEntryDecoder;
import org.redisson.client.protocol.decoder.PendingResultDecoder;
import org.redisson.client.protocol.decoder.ScoredSortedSetPolledObjectDecoder;
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.SlotsDecoder;
import org.redisson.client.protocol.decoder.StreamIdDecoder;
import org.redisson.client.protocol.decoder.StreamIdListDecoder;
import org.redisson.client.protocol.decoder.StreamObjectMapReplayDecoder;
import org.redisson.client.protocol.decoder.StreamResultDecoder;
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.decoder.TimeLongObjectDecoder;
import org.redisson.client.protocol.pubsub.PubSubStatusDecoder;
import org.redisson.cluster.ClusterNodeInfo;

/**
 * 
 * @author Nikita Koksharov
 *
 */
public interface RedisCommands {

    RedisStrictCommand DEBUG = new RedisStrictCommand("DEBUG");
    
    RedisStrictCommand GEOADD = new RedisStrictCommand("GEOADD");
    RedisCommand GEODIST = new RedisCommand("GEODIST", new DoubleReplayConvertor());
    RedisCommand> GEORADIUS_RO = new RedisCommand>("GEORADIUS_RO", new ObjectListReplayDecoder());
    RedisCommand> GEORADIUSBYMEMBER_RO = new RedisCommand>("GEORADIUSBYMEMBER_RO", new ObjectListReplayDecoder());
    RedisCommand GEORADIUS_STORE = new RedisCommand("GEORADIUS", new Long2MultiDecoder());
    RedisCommand GEORADIUSBYMEMBER_STORE = new RedisCommand("GEORADIUSBYMEMBER", new Long2MultiDecoder());
    
    RedisStrictCommand KEYSLOT = new RedisStrictCommand("CLUSTER", "KEYSLOT", new IntegerReplayConvertor());
    RedisStrictCommand TYPE = new RedisStrictCommand("TYPE", new TypeConvertor());

    RedisStrictCommand GETBIT = new RedisStrictCommand("GETBIT", new BooleanReplayConvertor());
    RedisStrictCommand BITS_SIZE = new RedisStrictCommand("STRLEN", new BitsSizeReplayConvertor());
    RedisStrictCommand STRLEN = new RedisStrictCommand("STRLEN");
    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 BooleanReplayConvertor());
    RedisStrictCommand BITOP = new RedisStrictCommand("BITOP", new VoidReplayConvertor());

    RedisStrictCommand WAIT = new RedisStrictCommand("WAIT", new IntegerReplayConvertor());
    RedisStrictCommand CLIENT_REPLY = new RedisStrictCommand("CLIENT", "REPLY", new VoidReplayConvertor());
    RedisStrictCommand ASKING = new RedisStrictCommand("ASKING", new VoidReplayConvertor());
    RedisStrictCommand READONLY = new RedisStrictCommand("READONLY", new VoidReplayConvertor());

    RedisStrictCommand ZUNIONSTORE_INT = new RedisStrictCommand("ZUNIONSTORE", new IntegerReplayConvertor());
    RedisStrictCommand ZINTERSTORE_INT = new RedisStrictCommand("ZINTERSTORE", new IntegerReplayConvertor());
    RedisCommand ZADD_BOOL = new RedisCommand("ZADD", new BooleanAmountReplayConvertor());
    RedisCommand ZADD_NX_BOOL = new RedisCommand("ZADD", new BooleanAmountReplayConvertor());
    RedisCommand ZADD_BOOL_RAW = new RedisCommand("ZADD", new BooleanAmountReplayConvertor());
    RedisCommand ZADD_RAW = new RedisCommand("ZADD");
    RedisStrictCommand ZADD_INT = new RedisStrictCommand("ZADD", new IntegerReplayConvertor());
    RedisCommand ZADD = new RedisCommand("ZADD");
    RedisStrictCommand ZREM_LONG = new RedisStrictCommand("ZREM");
    RedisCommand ZREM = new RedisCommand("ZREM", new BooleanAmountReplayConvertor());
    RedisStrictCommand ZCARD_INT = new RedisStrictCommand("ZCARD", new IntegerReplayConvertor());
    RedisStrictCommand ZCARD = new RedisStrictCommand("ZCARD");
    RedisStrictCommand ZCOUNT = new RedisStrictCommand("ZCOUNT", new IntegerReplayConvertor());
    RedisStrictCommand ZLEXCOUNT = new RedisStrictCommand("ZLEXCOUNT", new IntegerReplayConvertor());
    RedisCommand ZSCORE_CONTAINS = new RedisCommand("ZSCORE", new BooleanNotNullReplayConvertor());
    RedisStrictCommand ZSCORE = new RedisStrictCommand("ZSCORE", new DoubleReplayConvertor());
    RedisStrictCommand ZRANK = new RedisStrictCommand("ZRANK");
    RedisCommand ZRANK_INT = new RedisCommand("ZRANK", new IntegerReplayConvertor());
    RedisStrictCommand ZREVRANK = new RedisStrictCommand("ZREVRANK");
    RedisCommand ZREVRANK_INT = new RedisCommand("ZREVRANK", new IntegerReplayConvertor());
    RedisCommand ZRANGE_SINGLE = new RedisCommand("ZRANGE", new ListFirstObjectDecoder());
    RedisStrictCommand ZRANGE_SINGLE_SCORE = new RedisStrictCommand("ZRANGE", new ObjectFirstScoreReplayDecoder());
    RedisCommand> ZRANGE = new RedisCommand>("ZRANGE", new ObjectListReplayDecoder());
    RedisCommand> ZPOPMIN = new RedisCommand>("ZPOPMIN", new ObjectListReplayDecoder());
    RedisCommand> ZPOPMAX = new RedisCommand>("ZPOPMAX", 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> ZREVRANGEBYLEX = new RedisCommand>("ZREVRANGEBYLEX", new ObjectListReplayDecoder());
    RedisCommand> ZRANGEBYSCORE = new RedisCommand>("ZRANGEBYSCORE", new ObjectSetReplayDecoder());
    RedisCommand> ZRANGEBYSCORE_LIST = new RedisCommand>("ZRANGEBYSCORE", new ObjectListReplayDecoder());
    RedisCommand> ZREVRANGE = new RedisCommand>("ZREVRANGE", new ObjectListReplayDecoder());
    RedisCommand> ZREVRANGEBYSCORE = new RedisCommand>("ZREVRANGEBYSCORE", new ObjectSetReplayDecoder());
    RedisCommand>> ZREVRANGE_ENTRY = new RedisCommand>>("ZREVRANGE", new ScoredSortedSetReplayDecoder());
    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 ListMultiDecoder(new LongMultiDecoder(), new ScoredSortedSetScanDecoder(), new ScoredSortedSetScanReplayDecoder()));
    RedisStrictCommand ZINCRBY = new RedisStrictCommand("ZINCRBY", new DoubleNullSafeReplayConvertor());

    RedisCommand> SCAN = new RedisCommand>("SCAN", new ListMultiDecoder(new LongMultiDecoder(), new ObjectListReplayDecoder(), new ListScanResultReplayDecoder()));
    RedisStrictCommand RANDOM_KEY = new RedisStrictCommand("RANDOMKEY");
    RedisCommand PING = new RedisCommand("PING");
    RedisStrictCommand PING_BOOL = new RedisStrictCommand("PING", new BooleanNotNullReplayConvertor());

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

    RedisCommand SADD_BOOL = new RedisCommand("SADD", new BooleanAmountReplayConvertor());
    RedisCommand SADD = new RedisCommand("SADD", new IntegerReplayConvertor());
    RedisCommand> SPOP = new RedisCommand>("SPOP", new ObjectSetReplayDecoder());
    RedisCommand SPOP_SINGLE = new RedisCommand("SPOP");
    RedisCommand SADD_SINGLE = new RedisCommand("SADD", new BooleanReplayConvertor());
    RedisCommand SREM_SINGLE = new RedisCommand("SREM", new BooleanAmountReplayConvertor());
    RedisCommand SMOVE = new RedisCommand("SMOVE", new BooleanReplayConvertor());
    RedisCommand> SMEMBERS = new RedisCommand>("SMEMBERS", new ObjectSetReplayDecoder());
    RedisCommand> SRANDMEMBER = new RedisCommand>("SRANDMEMBER", new ObjectSetReplayDecoder());
    RedisCommand SRANDMEMBER_SINGLE = new RedisCommand("SRANDMEMBER");
    RedisCommand> SSCAN = new RedisCommand>("SSCAN", new ListMultiDecoder(new LongMultiDecoder(), new ObjectListReplayDecoder(), new ListScanResultReplayDecoder()));
    RedisCommand> EVAL_SSCAN = new RedisCommand>("EVAL", new ListMultiDecoder(new LongMultiDecoder(), new ObjectListReplayDecoder(), new ListScanResultReplayDecoder()));
    RedisCommand> EVAL_ZSCAN = new RedisCommand>("EVAL", new ListMultiDecoder(new LongMultiDecoder(), new ObjectListReplayDecoder(), new ListScanResultReplayDecoder()));
    RedisCommand SISMEMBER = new RedisCommand("SISMEMBER", new BooleanReplayConvertor());
    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");
    RedisStrictCommand SINTERSTORE = new RedisStrictCommand("SINTERSTORE");
    RedisStrictCommand SDIFFSTORE = new RedisStrictCommand("SDIFFSTORE");
    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());
    RedisCommand LPOP = new RedisCommand("LPOP");
    RedisCommand LREM_SINGLE = new RedisCommand("LREM", new BooleanReplayConvertor());
    RedisCommand LINDEX = new RedisCommand("LINDEX");
    RedisCommand LINSERT_INT = new RedisCommand("LINSERT", new IntegerReplayConvertor());
    RedisStrictCommand LLEN_INT = new RedisStrictCommand("LLEN", new IntegerReplayConvertor());
    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 = new RedisCommand>("BLPOP", new ObjectListReplayDecoder());
    RedisCommand> BRPOP = new RedisCommand>("BRPOP", new ObjectListReplayDecoder());
    RedisCommand BLPOP_VALUE = new RedisCommand("BLPOP", new ListObjectDecoder(1));
    RedisCommand BRPOP_VALUE = new RedisCommand("BRPOP", new ListObjectDecoder(1));
    RedisCommand BZPOPMIN_VALUE = new RedisCommand("BZPOPMIN", new ScoredSortedSetPolledObjectDecoder());
    RedisCommand BZPOPMAX_VALUE = new RedisCommand("BZPOPMAX", new ScoredSortedSetPolledObjectDecoder());

    Set BLOCKING_COMMAND_NAMES = new HashSet(
            Arrays.asList(BLPOP_VALUE.getName(), BRPOP_VALUE.getName(), BRPOPLPUSH.getName(), BZPOPMIN_VALUE.getName(), BZPOPMAX_VALUE.getName(), 
                    BLPOP.getName(), BRPOP.getName()));

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

    RedisCommand> SORT_LIST = new RedisCommand>("SORT", new ObjectListReplayDecoder());
    RedisCommand> SORT_SET = new RedisCommand>("SORT", new ObjectSetReplayDecoder());
    RedisCommand SORT_TO = new RedisCommand("SORT", new IntegerReplayConvertor());
    
    RedisCommand RPOP = new RedisCommand("RPOP");
    RedisCommand LPUSH = new RedisCommand("LPUSH", new IntegerReplayConvertor());
    RedisCommand LPUSH_BOOLEAN = new RedisCommand("LPUSH", new TrueReplayConvertor());
    RedisStrictCommand LPUSH_VOID = new RedisStrictCommand("LPUSH", new VoidReplayConvertor());
    RedisCommand> LRANGE = new RedisCommand>("LRANGE", new ObjectListReplayDecoder());
    RedisCommand> LRANGE_SET = new RedisCommand>("LRANGE", new ObjectSetReplayDecoder());
    RedisCommand RPUSH = new RedisCommand("RPUSH", new IntegerReplayConvertor());
    RedisCommand RPUSH_BOOLEAN = new RedisCommand("RPUSH", new TrueReplayConvertor());
    RedisCommand RPUSH_VOID = new RedisCommand("RPUSH", new VoidReplayConvertor());

    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_BOOLEAN_SAFE = new RedisStrictCommand("EVAL", new BooleanNullSafeReplayConvertor());
    RedisStrictCommand EVAL_NULL_BOOLEAN = new RedisStrictCommand("EVAL", new BooleanNullReplayConvertor());
    RedisStrictCommand EVAL_STRING = new RedisStrictCommand("EVAL", new StringReplayDecoder());
    RedisStrictCommand EVAL_STRING_DATA = new RedisStrictCommand("EVAL", new StringDataDecoder());
    RedisStrictCommand EVAL_INTEGER = new RedisStrictCommand("EVAL", new IntegerReplayConvertor());
    RedisStrictCommand EVAL_DOUBLE = new RedisStrictCommand("EVAL", new DoubleNullSafeReplayConvertor());
    RedisStrictCommand EVAL_LONG = new RedisStrictCommand("EVAL");
    RedisStrictCommand EVAL_LONG_SAFE = new RedisStrictCommand("EVAL", new LongReplayConvertor());
    RedisStrictCommand EVAL_VOID = new RedisStrictCommand("EVAL", new VoidReplayConvertor());
    RedisCommand EVAL_FIRST_LIST = new RedisCommand("EVAL", new ListFirstObjectDecoder());
    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 = new RedisCommand>("EVAL", new ObjectMapReplayDecoder(), ValueType.MAP);
    RedisCommand> EVAL_MAP_VALUE_LIST = new RedisCommand>("EVAL", new ObjectListReplayDecoder(), ValueType.MAP_VALUE);
    RedisCommand> EVAL_MAP_VALUE_SET = new RedisCommand>("EVAL", new ObjectSetReplayDecoder(), ValueType.MAP_VALUE);
    RedisCommand> EVAL_MAP_KEY_SET = new RedisCommand>("EVAL", new ObjectSetReplayDecoder(), ValueType.MAP_KEY);

    RedisStrictCommand INCR = new RedisStrictCommand("INCR");
    RedisStrictCommand INCRBY = new RedisStrictCommand("INCRBY");
    RedisStrictCommand INCRBYFLOAT = new RedisStrictCommand("INCRBYFLOAT", new DoubleNullSafeReplayConvertor());
    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 VoidReplayConvertor());
    RedisStrictCommand CLIENT_GETNAME = new RedisStrictCommand("CLIENT", "GETNAME", new StringDataDecoder());
    RedisStrictCommand FLUSHDB = new RedisStrictCommand("FLUSHDB", new VoidReplayConvertor());
    RedisStrictCommand FLUSHALL = new RedisStrictCommand("FLUSHALL", new VoidReplayConvertor());

    RedisStrictCommand SAVE = new RedisStrictCommand("SAVE", new VoidReplayConvertor());
    RedisStrictCommand LASTSAVE = new RedisStrictCommand("LASTSAVE");
    RedisStrictCommand BGSAVE = new RedisStrictCommand("BGSAVE", new VoidReplayConvertor());
    RedisStrictCommand BGREWRITEAOF = new RedisStrictCommand("BGREWRITEAOF", new VoidReplayConvertor());
    
    RedisStrictCommand FLUSHDB_ASYNC = new RedisStrictCommand("FLUSHDB", "ASYNC", new VoidReplayConvertor());
    RedisStrictCommand FLUSHALL_ASYNC = new RedisStrictCommand("FLUSHALL", "ASYNC", 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());

    RedisStrictCommand HSETNX = new RedisStrictCommand("HSETNX", new BooleanReplayConvertor());
    RedisStrictCommand HSET = new RedisStrictCommand("HSET", new BooleanReplayConvertor());
    RedisStrictCommand HSET_VOID = new RedisStrictCommand("HSET", new VoidReplayConvertor());
    RedisCommand> HSCAN = new RedisCommand>("HSCAN", new ListMultiDecoder(new LongMultiDecoder(), 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());
    RedisStrictCommand HLEN = new RedisStrictCommand("HLEN", new IntegerReplayConvertor());
    RedisCommand HSTRLEN = new RedisCommand("HSTRLEN", 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());
    RedisCommand HGET = new RedisCommand("HGET", ValueType.MAP_VALUE);
    RedisCommand HDEL = new RedisStrictCommand("HDEL");

    RedisStrictCommand DEL = new RedisStrictCommand("DEL");
    RedisStrictCommand DBSIZE = new RedisStrictCommand("DBSIZE");
    RedisStrictCommand DEL_BOOL = new RedisStrictCommand("DEL", new BooleanNullSafeReplayConvertor());
    RedisStrictCommand DEL_OBJECTS = new RedisStrictCommand("DEL", new BooleanNullSafeReplayConvertor());
    RedisStrictCommand DEL_VOID = new RedisStrictCommand("DEL", new VoidReplayConvertor());
    
    RedisStrictCommand UNLINK = new RedisStrictCommand("UNLINK");
    RedisStrictCommand UNLINK_BOOL = new RedisStrictCommand("UNLINK", new BooleanNullSafeReplayConvertor());

    RedisCommand DUMP = new RedisCommand("DUMP");
    RedisStrictCommand RESTORE = new RedisStrictCommand("RESTORE", new VoidReplayConvertor());
    
    RedisCommand GET = new RedisCommand("GET");
    RedisStrictCommand GET_LONG = new RedisStrictCommand("GET", new LongReplayConvertor());
    RedisStrictCommand GET_INTEGER = new RedisStrictCommand("GET", new IntegerReplayConvertor());
    RedisStrictCommand GET_DOUBLE = new RedisStrictCommand("GET", new DoubleNullSafeReplayConvertor());
    RedisCommand GETSET = new RedisCommand("GETSET");
    RedisCommand SET = new RedisCommand("SET", new VoidReplayConvertor());
    RedisCommand SETPXNX = new RedisCommand("SET", new BooleanNotNullReplayConvertor());
    RedisCommand SETNX = new RedisCommand("SETNX", new BooleanReplayConvertor());
    RedisCommand PSETEX = new RedisCommand("PSETEX", new VoidReplayConvertor());

    RedisCommand>>> XRANGE = new RedisCommand>>>("XRANGE",
            new ListMultiDecoder(
                    new ObjectDecoder(new StreamIdDecoder()),
                    new StreamObjectMapReplayDecoder(),
                    new StreamObjectMapReplayDecoder(ListMultiDecoder.RESET),
                    new ObjectMapJoinDecoder()));

    RedisCommand>>> XREVRANGE = 
                new RedisCommand>>>("XREVRANGE", XRANGE.getReplayMultiDecoder());
    
    RedisCommand>>> XREAD = new RedisCommand>>>("XREAD",
            new ListMultiDecoder(
                    new ObjectDecoder(StringCodec.INSTANCE.getValueDecoder()),
                    new ObjectDecoder(new StreamIdDecoder()),
                    new StreamObjectMapReplayDecoder(),
                    new StreamObjectMapReplayDecoder(ListMultiDecoder.RESET_1),
                    new ObjectMapJoinDecoder(), 
                    new StreamObjectMapReplayDecoder(ListMultiDecoder.RESET_INDEX),
                    new StreamResultDecoder()));
            
    RedisCommand>>> XREAD_BLOCKING = new RedisCommand>>>("XREAD", XREAD.getReplayMultiDecoder());

    RedisCommand>> XREAD_SINGLE = new RedisCommand>>("XREAD",
            new ListMultiDecoder(
                    new ObjectDecoder(StringCodec.INSTANCE.getValueDecoder()),
                    new ObjectDecoder(new StreamIdDecoder()),
                    new StreamObjectMapReplayDecoder(),
                    new StreamObjectMapReplayDecoder(ListMultiDecoder.RESET_1),
                    new ObjectMapJoinDecoder(), 
                    new StreamObjectMapReplayDecoder(),
                    new StreamResultDecoder()));
    
    RedisCommand>> XREAD_BLOCKING_SINGLE = 
                new RedisCommand>>("XREAD", XREAD_SINGLE.getReplayMultiDecoder());

    RedisCommand>>> XREADGROUP = new RedisCommand>>>("XREADGROUP",
            new ListMultiDecoder(
                    new ObjectDecoder(StringCodec.INSTANCE.getValueDecoder()),
                    new ObjectDecoder(new StreamIdDecoder()),
                    new StreamObjectMapReplayDecoder(),
                    new StreamObjectMapReplayDecoder(ListMultiDecoder.RESET_1),
                    new ObjectMapJoinDecoder(), 
                    new StreamObjectMapReplayDecoder(ListMultiDecoder.RESET_INDEX),
                    new StreamResultDecoder()));

    RedisCommand>>> XREADGROUP_BLOCKING = 
                new RedisCommand>>>("XREADGROUP", XREADGROUP.getReplayMultiDecoder());
            
    RedisCommand>> XREADGROUP_SINGLE = new RedisCommand>>("XREADGROUP",
            new ListMultiDecoder(
                    new ObjectDecoder(StringCodec.INSTANCE.getValueDecoder()),
                    new ObjectDecoder(new StreamIdDecoder()),
                    new StreamObjectMapReplayDecoder(),
                    new StreamObjectMapReplayDecoder(ListMultiDecoder.RESET_1),
                    new ObjectMapJoinDecoder(), 
                    new StreamObjectMapReplayDecoder(),
                    new StreamResultDecoder()));

    RedisCommand> XCLAIM_IDS = new RedisCommand>("XCLAIM", new StreamIdListDecoder());
    
    RedisCommand>> XCLAIM = new RedisCommand>>("XCLAIM",
            new ListMultiDecoder(
                    new ObjectDecoder(new StreamIdDecoder()),
                    new StreamObjectMapReplayDecoder(),
                    new StreamObjectMapReplayDecoder(ListMultiDecoder.RESET),
                    new ObjectMapJoinDecoder()));
            
    RedisCommand>> XREADGROUP_BLOCKING_SINGLE = new RedisCommand>>("XREADGROUP",
            XREADGROUP_SINGLE.getReplayMultiDecoder());

    Set BLOCKING_COMMANDS = new HashSet(Arrays.asList(
            XREAD_BLOCKING_SINGLE, XREAD_BLOCKING, XREADGROUP_BLOCKING_SINGLE, XREADGROUP_BLOCKING));
    
    RedisStrictCommand XADD = new RedisStrictCommand("XADD", new StreamIdConvertor());
    RedisStrictCommand XGROUP = new RedisStrictCommand("XGROUP", new VoidReplayConvertor());
    RedisStrictCommand XGROUP_LONG = new RedisStrictCommand("XGROUP");
    RedisStrictCommand XADD_VOID = new RedisStrictCommand("XADD", new VoidReplayConvertor());
    RedisStrictCommand XLEN = new RedisStrictCommand("XLEN");
    RedisStrictCommand XACK = new RedisStrictCommand("XACK");
    RedisStrictCommand XDEL = new RedisStrictCommand("XDEL");
    RedisStrictCommand XTRIM = new RedisStrictCommand("XTRIM");
    RedisCommand XPENDING = new RedisCommand("XPENDING", 
            new ListMultiDecoder(new ObjectListReplayDecoder(), new ObjectListReplayDecoder(ListMultiDecoder.RESET), new PendingResultDecoder()));
    RedisCommand XPENDING_ENTRIES = new RedisCommand("XPENDING", 
            new PendingEntryDecoder());
    
    RedisStrictCommand TOUCH_LONG = new RedisStrictCommand("TOUCH", new LongReplayConvertor());
    RedisStrictCommand TOUCH = new RedisStrictCommand("TOUCH", new BooleanReplayConvertor());
    RedisStrictCommand EXISTS_LONG = new RedisStrictCommand("EXISTS", new LongReplayConvertor());
    RedisStrictCommand EXISTS = new RedisStrictCommand("EXISTS", new BooleanReplayConvertor());
    RedisStrictCommand NOT_EXISTS = new RedisStrictCommand("EXISTS", new BooleanNumberReplayConvertor(1L));

    RedisStrictCommand MEMORY_USAGE = new RedisStrictCommand("MEMORY", "USAGE", new LongReplayConvertor());
    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 QUIT = new RedisStrictCommand("QUIT", new VoidReplayConvertor());

    RedisStrictCommand PUBLISH = new RedisStrictCommand("PUBLISH");
    RedisCommand PUBSUB_NUMSUB = new RedisCommand("PUBSUB", "NUMSUB", new ListObjectDecoder(1));

    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());

    Set PUBSUB_COMMANDS = new HashSet(
            Arrays.asList(PSUBSCRIBE.getName(), SUBSCRIBE.getName(), PUNSUBSCRIBE.getName(), UNSUBSCRIBE.getName()));

    RedisStrictCommand> CLUSTER_NODES = new RedisStrictCommand>("CLUSTER", "NODES", new ClusterNodesDecoder(false));
    RedisStrictCommand> CLUSTER_NODES_SSL = new RedisStrictCommand>("CLUSTER", "NODES", new ClusterNodesDecoder(true));
    RedisStrictCommand TIME_LONG = new RedisStrictCommand("TIME", new TimeLongObjectDecoder());
    RedisStrictCommand