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.9.1
    Show newest version
    /**
 * 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.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.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.KeyValueConvertor;
import org.redisson.client.protocol.convertor.LongListObjectDecoder;
import org.redisson.client.protocol.convertor.LongReplayConvertor;
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.KeyValueObjectDecoder;
import org.redisson.client.protocol.decoder.ListMultiDecoder;
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.ObjectFirstResultReplayDecoder;
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.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.SlotsDecoder;
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;
import org.redisson.cluster.ClusterNodeInfo;

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

    RedisStrictCommand GEOADD = new RedisStrictCommand("GEOADD");
    RedisStrictCommand GEOADD_ENTRIES = new RedisStrictCommand("GEOADD");
    RedisCommand GEODIST = new RedisCommand("GEODIST", new DoubleReplayConvertor());
    RedisCommand> GEORADIUS = new RedisCommand>("GEORADIUS", new ObjectListReplayDecoder());
    RedisCommand> GEORADIUSBYMEMBER = new RedisCommand>("GEORADIUSBYMEMBER", 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_TRUE = new RedisStrictCommand("SETBIT", new BitSetReplayConvertor(0));
    RedisStrictCommand SETBIT_FALSE = new RedisStrictCommand("SETBIT", new BitSetReplayConvertor(1));
    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");
    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");
    RedisStrictCommand ZLEXCOUNT = new RedisStrictCommand("ZLEXCOUNT", new IntegerReplayConvertor());
    RedisCommand ZSCORE_CONTAINS = new RedisCommand("ZSCORE", new BooleanNotNullReplayConvertor());
    RedisStrictCommand ZSCORE = new RedisStrictCommand("ZSCORE", new DoubleReplayConvertor());
    RedisCommand ZRANK_INT = new RedisCommand("ZRANK", new IntegerReplayConvertor());
    RedisCommand ZREVRANK_INT = new RedisCommand("ZREVRANK", new IntegerReplayConvertor());
    RedisCommand ZRANGE_SINGLE = new RedisCommand("ZRANGE", new ObjectFirstResultReplayDecoder());
    RedisStrictCommand ZRANGE_SINGLE_SCORE = new RedisStrictCommand("ZRANGE", new ObjectFirstScoreReplayDecoder());
    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> 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 ObjectListReplayDecoder());
    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", new StringDataDecoder());
    RedisStrictCommand PING = new RedisStrictCommand("PING");
    RedisStrictCommand PING_BOOL = new RedisStrictCommand("PING", new BooleanNotNullReplayConvertor());

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

    Set BLOCKING_COMMANDS = new HashSet(
            Arrays.asList(BLPOP_VALUE.getName(), BRPOP_VALUE.getName(), BRPOPLPUSH.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());
    
    RedisStrictCommand RPOP = new RedisStrictCommand("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_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_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 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 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 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 GETRANGE = new RedisCommand("GETRANGE");
    RedisCommand APPEND = new RedisCommand("APPEND");
    RedisCommand SETRANGE = new RedisCommand("SETRANGE");
    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());
    
    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 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");

    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));
    RedisCommand TIME = new RedisCommand("TIME", new LongListObjectDecoder());
    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 ListMultiDecoder(new ObjectMapReplayDecoder(), new ObjectListReplayDecoder(ListMultiDecoder.RESET), new ListResultReplayDecoder()));
    RedisCommand>> SENTINEL_SENTINELS = new RedisCommand>>("SENTINEL", "SENTINELS",
            new ListMultiDecoder(new ObjectMapReplayDecoder(), new ObjectListReplayDecoder(ListMultiDecoder.RESET), new ListResultReplayDecoder()));

    RedisStrictCommand CLUSTER_ADDSLOTS = new RedisStrictCommand("CLUSTER", "ADDSLOTS");
    RedisStrictCommand CLUSTER_REPLICATE = new RedisStrictCommand("CLUSTER", "REPLICATE");
    RedisStrictCommand CLUSTER_FORGET = new RedisStrictCommand("CLUSTER", "FORGET");
    RedisCommand CLUSTER_SLOTS = new RedisCommand("CLUSTER", "SLOTS", new SlotsDecoder());
    RedisStrictCommand CLUSTER_RESET = new RedisStrictCommand("CLUSTER", "RESET");
    RedisStrictCommand> CLUSTER_GETKEYSINSLOT = new RedisStrictCommand>("CLUSTER", "GETKEYSINSLOT", new StringListReplayDecoder());
    RedisStrictCommand CLUSTER_SETSLOT = new RedisStrictCommand("CLUSTER", "SETSLOT");
    RedisStrictCommand CLUSTER_MEET = new RedisStrictCommand("CLUSTER", "MEET");
    
    RedisStrictCommand> INFO_ALL = new RedisStrictCommand>("INFO", "ALL", new StringMapDataDecoder());
    RedisStrictCommand> INFO_DEFAULT = new RedisStrictCommand>("INFO", "DEFAULT", new StringMapDataDecoder());
    RedisStrictCommand> INFO_SERVER = new RedisStrictCommand>("INFO", "SERVER", new StringMapDataDecoder());
    RedisStrictCommand> INFO_CLIENTS = new RedisStrictCommand>("INFO", "CLIENTS", new StringMapDataDecoder());
    RedisStrictCommand> INFO_MEMORY = new RedisStrictCommand>("INFO", "MEMORY", new StringMapDataDecoder());
    RedisStrictCommand> INFO_PERSISTENCE = new RedisStrictCommand>("INFO", "PERSISTENCE", new StringMapDataDecoder());
    RedisStrictCommand> INFO_STATS = new RedisStrictCommand>("INFO", "STATS", new StringMapDataDecoder());
    RedisStrictCommand> INFO_REPLICATION = new RedisStrictCommand>("INFO", "REPLICATION", new StringMapDataDecoder());
    RedisStrictCommand> INFO_CPU = new RedisStrictCommand>("INFO", "CPU", new StringMapDataDecoder());
    RedisStrictCommand> INFO_COMMANDSTATS = new RedisStrictCommand>("INFO", "COMMANDSTATS", new StringMapDataDecoder());
    RedisStrictCommand> INFO_CLUSTER = new RedisStrictCommand>("INFO", "CLUSTER", new StringMapDataDecoder());
    RedisStrictCommand> INFO_KEYSPACE = new RedisStrictCommand>("INFO", "KEYSPACE", new StringMapDataDecoder());
}
    
    
    
    

    




    
    
    © 2015 - 2025 Weber Informatics LLC | Privacy Policy