io.vertx.rxjava.redis

## Class RedisClient

- java.lang.Object
- - io.vertx.rxjava.redis.RedisClient

-     public class RedisClient
      extends Object

- - ### Constructor Summary

    Constructors
    Constructor and Description
    `RedisClient(RedisClient delegate)`

  - ### Method Summary

    All Methods Static Methods Instance Methods Concrete Methods
    Modifier and Type | Method and Description
    --- | ---
    `RedisClient` | `append(String key, String value, Handler<AsyncResult<Long>> handler)` Append a value to a key
    `RedisClient` | `auth(String password, Handler<AsyncResult<String>> handler)` Authenticate to the server
    `RedisClient` | `bgrewriteaof(Handler<AsyncResult<String>> handler)` Asynchronously rewrite the append-only file
    `RedisClient` | `bgsave(Handler<AsyncResult<String>> handler)` Asynchronously save the dataset to disk
    `RedisClient` | `bitcount(String key, Handler<AsyncResult<Long>> handler)` Count set bits in a string
    `RedisClient` | `bitcountRange(String key, long start, long end, Handler<AsyncResult<Long>> handler)` Count set bits in a string
    `RedisClient` | `bitop(BitOperation operation, String destkey, List<String> keys, Handler<AsyncResult<Long>> handler)` Perform bitwise operations between strings
    `RedisClient` | `bitpos(String key, int bit, Handler<AsyncResult<Long>> handler)` Find first bit set or clear in a string
    `RedisClient` | `bitposFrom(String key, int bit, int start, Handler<AsyncResult<Long>> handler)` Find first bit set or clear in a string See also bitposRange() method, which takes start, and stop offset.
    `RedisClient` | `bitposRange(String key, int bit, int start, int stop, Handler<AsyncResult<Long>> handler)` Find first bit set or clear in a string Note: when both start, and stop offsets are specified, behaviour is slightly different than if only start is specified
    `RedisClient` | `blpop(String key, int seconds, Handler<AsyncResult<JsonArray>> handler)` Remove and get the first element in a list, or block until one is available
    `RedisClient` | `blpopMany(List<String> keys, int seconds, Handler<AsyncResult<JsonArray>> handler)` Remove and get the first element in any of the lists, or block until one is available
    `RedisClient` | `brpop(String key, int seconds, Handler<AsyncResult<JsonArray>> handler)` Remove and get the last element in a list, or block until one is available
    `RedisClient` | `brpoplpush(String key, String destkey, int seconds, Handler<AsyncResult<Void>> handler)` Pop a value from a list, push it to another list and return it; or block until one is available
    `RedisClient` | `brpopMany(List<String> keys, int seconds, Handler<AsyncResult<JsonArray>> handler)` Remove and get the last element in any of the lists, or block until one is available
    `RedisClient` | `clientGetname(Handler<AsyncResult<String>> handler)` Get the current connection name
    `RedisClient` | `clientKill(KillFilter filter, Handler<AsyncResult<Long>> handler)` Kill the connection of a client
    `RedisClient` | `clientList(Handler<AsyncResult<String>> handler)` Get the list of client connections
    `RedisClient` | `clientPause(long millis, Handler<AsyncResult<String>> handler)` Stop processing commands from clients for some time
    `RedisClient` | `clientSetname(String name, Handler<AsyncResult<String>> handler)` Set the current connection name
    `void` | `close(Handler<AsyncResult<Void>> handler)` Close the client - when it is fully closed the handler will be called.
    `rx.Observable<Void>` | `closeObservable()` Close the client - when it is fully closed the handler will be called.
    `RedisClient` | `clusterSlots(Handler<AsyncResult<JsonArray>> handler)` Get array of Cluster slot to node mappings
    `RedisClient` | `command(Handler<AsyncResult<JsonArray>> handler)` Get array of Redis command details
    `RedisClient` | `commandCount(Handler<AsyncResult<Long>> handler)` Get total number of Redis commands
    `RedisClient` | `commandGetkeys(Handler<AsyncResult<JsonArray>> handler)` Extract keys given a full Redis command
    `RedisClient` | `commandInfo(List<String> commands, Handler<AsyncResult<JsonArray>> handler)` Get array of specific Redis command details
    `RedisClient` | `configGet(String parameter, Handler<AsyncResult<JsonArray>> handler)` Get the value of a configuration parameter
    `RedisClient` | `configResetstat(Handler<AsyncResult<String>> handler)` Reset the stats returned by INFO
    `RedisClient` | `configRewrite(Handler<AsyncResult<String>> handler)` Rewrite the configuration file with the in memory configuration
    `RedisClient` | `configSet(String parameter, String value, Handler<AsyncResult<String>> handler)` Set a configuration parameter to the given value
    `static RedisClient` | `create(Vertx vertx, JsonObject config)`
    `RedisClient` | `dbsize(Handler<AsyncResult<Long>> handler)` Return the number of keys in the selected database
    `RedisClient` | `debugObject(String key, Handler<AsyncResult<String>> handler)` Get debugging information about a key
    `RedisClient` | `debugSegfault(Handler<AsyncResult<String>> handler)` Make the server crash
    `RedisClient` | `decr(String key, Handler<AsyncResult<Long>> handler)` Decrement the integer value of a key by one
    `RedisClient` | `decrby(String key, long decrement, Handler<AsyncResult<Long>> handler)` Decrement the integer value of a key by the given number
    `RedisClient` | `del(List<String> keys, Handler<AsyncResult<Long>> handler)` Delete a key
    `RedisClient` | `discard(Handler<AsyncResult<String>> handler)` Discard all commands issued after MULTI
    `RedisClient` | `dump(String key, Handler<AsyncResult<String>> handler)` Return a serialized version of the value stored at the specified key.
    `RedisClient` | `echo(String message, Handler<AsyncResult<String>> handler)` Echo the given string
    `RedisClient` | `eval(String script, List<String> keys, List<String> args, Handler<AsyncResult<Void>> handler)` Execute a Lua script server side
    `RedisClient` | `evalsha(String sha1, List<String> keys, List<String> values, Handler<AsyncResult<Void>> handler)` Execute a Lua script server side
    `RedisClient` | `exec(Handler<AsyncResult<Void>> handler)` Execute all commands issued after MULTI
    `RedisClient` | `exists(String key, Handler<AsyncResult<Long>> handler)` Determine if a key exists
    `RedisClient` | `expire(String key, int seconds, Handler<AsyncResult<Long>> handler)` Set a key's time to live in seconds
    `RedisClient` | `expireat(String key, long seconds, Handler<AsyncResult<Long>> handler)` Set the expiration for a key as a UNIX timestamp
    `RedisClient` | `flushall(Handler<AsyncResult<String>> handler)` Remove all keys from all databases
    `RedisClient` | `flushdb(Handler<AsyncResult<String>> handler)` Remove all keys from the current database
    `RedisClient` | `get(String key, Handler<AsyncResult<String>> handler)` Get the value of a key
    `RedisClient` | `getBinary(String key, Handler<AsyncResult<String>> handler)` Get the value of a key - without decoding as utf-8
    `RedisClient` | `getbit(String key, long offset, Handler<AsyncResult<Long>> handler)` Returns the bit value at offset in the string value stored at key
    `Object` | `getDelegate()`
    `RedisClient` | `getrange(String key, long start, long end, Handler<AsyncResult<String>> handler)` Get a substring of the string stored at a key
    `RedisClient` | `getset(String key, String value, Handler<AsyncResult<String>> handler)` Set the string value of a key and return its old value
    `RedisClient` | `hdel(String key, String field, Handler<AsyncResult<Long>> handler)` Delete one or more hash fields
    `RedisClient` | `hdelMany(String key, List<String> fields, Handler<AsyncResult<Long>> handler)` Delete one or more hash fields
    `RedisClient` | `hexists(String key, String field, Handler<AsyncResult<Long>> handler)` Determine if a hash field exists
    `RedisClient` | `hget(String key, String field, Handler<AsyncResult<String>> handler)` Get the value of a hash field
    `RedisClient` | `hgetall(String key, Handler<AsyncResult<JsonObject>> handler)` Get all the fields and values in a hash
    `RedisClient` | `hincrby(String key, String field, long increment, Handler<AsyncResult<Long>> handler)` Increment the integer value of a hash field by the given number
    `RedisClient` | `hincrbyfloat(String key, String field, double increment, Handler<AsyncResult<String>> handler)` Increment the float value of a hash field by the given amount
    `RedisClient` | `hkeys(String key, Handler<AsyncResult<JsonArray>> handler)` Get all the fields in a hash
    `RedisClient` | `hlen(String key, Handler<AsyncResult<Long>> handler)` Get the number of fields in a hash
    `RedisClient` | `hmget(String key, List<String> fields, Handler<AsyncResult<JsonArray>> handler)` Get the values of all the given hash fields
    `RedisClient` | `hmset(String key, Map<String,String> values, Handler<AsyncResult<String>> handler)` Set multiple hash fields to multiple values
    `RedisClient` | `hscan(String key, String cursor, ScanOptions options, Handler<AsyncResult<JsonArray>> handler)` Incrementally iterate hash fields and associated values
    `RedisClient` | `hset(String key, String field, String value, Handler<AsyncResult<Long>> handler)` Set the string value of a hash field
    `RedisClient` | `hsetnx(String key, String field, String value, Handler<AsyncResult<Long>> handler)` Set the value of a hash field, only if the field does not exist
    `RedisClient` | `hvals(String key, Handler<AsyncResult<JsonArray>> handler)` Get all the values in a hash
    `RedisClient` | `incr(String key, Handler<AsyncResult<Long>> handler)` Increment the integer value of a key by one
    `RedisClient` | `incrby(String key, long increment, Handler<AsyncResult<Long>> handler)` Increment the integer value of a key by the given amount
    `RedisClient` | `incrbyfloat(String key, double increment, Handler<AsyncResult<String>> handler)` Increment the float value of a key by the given amount
    `RedisClient` | `info(Handler<AsyncResult<JsonObject>> handler)` Get information and statistics about the server
    `RedisClient` | `infoSection(String section, Handler<AsyncResult<JsonObject>> handler)` Get information and statistics about the server
    `RedisClient` | `keys(String pattern, Handler<AsyncResult<JsonArray>> handler)` Find all keys matching the given pattern
    `RedisClient` | `lastsave(Handler<AsyncResult<Long>> handler)` Get the UNIX time stamp of the last successful save to disk
    `RedisClient` | `lindex(String key, int index, Handler<AsyncResult<String>> handler)` Get an element from a list by its index
    `RedisClient` | `linsert(String key, InsertOptions option, String pivot, String value, Handler<AsyncResult<Long>> handler)` Insert an element before or after another element in a list
    `RedisClient` | `llen(String key, Handler<AsyncResult<Long>> handler)` Get the length of a list
    `RedisClient` | `lpop(String key, Handler<AsyncResult<String>> handler)` Remove and get the first element in a list
    `RedisClient` | `lpush(String key, String value, Handler<AsyncResult<Long>> handler)` Prepend one value to a list
    `RedisClient` | `lpushMany(String key, List<String> values, Handler<AsyncResult<Long>> handler)` Prepend one or multiple values to a list
    `RedisClient` | `lpushx(String key, String value, Handler<AsyncResult<Long>> handler)` Prepend a value to a list, only if the list exists
    `RedisClient` | `lrange(String key, long from, long to, Handler<AsyncResult<JsonArray>> handler)` Get a range of elements from a list
    `RedisClient` | `lrem(String key, long count, String value, Handler<AsyncResult<Long>> handler)` Remove elements from a list
    `RedisClient` | `lset(String key, long index, String value, Handler<AsyncResult<String>> handler)` Set the value of an element in a list by its index
    `RedisClient` | `ltrim(String key, long from, long to, Handler<AsyncResult<String>> handler)` Trim a list to the specified range
    `RedisClient` | `mget(String key, Handler<AsyncResult<JsonArray>> handler)` Get the value of the given key
    `RedisClient` | `mgetMany(List<String> keys, Handler<AsyncResult<JsonArray>> handler)` Get the values of all the given keys
    `RedisClient` | `migrate(String host, int port, String key, int destdb, long timeout, MigrateOptions options, Handler<AsyncResult<String>> handler)` Atomically transfer a key from a Redis instance to another one.
    `RedisClient` | `monitor(Handler<AsyncResult<Void>> handler)` Listen for all requests received by the server in real time
    `RedisClient` | `move(String key, int destdb, Handler<AsyncResult<Long>> handler)` Move a key to another database
    `RedisClient` | `mset(Map<String,String> keyvals, Handler<AsyncResult<String>> handler)` Set multiple keys to multiple values
    `RedisClient` | `msetnx(Map<String,String> keyvals, Handler<AsyncResult<Long>> handler)` Set multiple keys to multiple values, only if none of the keys exist
    `RedisClient` | `multi(Handler<AsyncResult<String>> handler)` Mark the start of a transaction block
    `static RedisClient` | `newInstance(RedisClient arg)`
    `RedisClient` | `object(String key, ObjectCmd cmd, Handler<AsyncResult<Void>> handler)` Inspect the internals of Redis objects
    `RedisClient` | `persist(String key, Handler<AsyncResult<Long>> handler)` Remove the expiration from a key
    `RedisClient` | `pexpire(String key, long millis, Handler<AsyncResult<Long>> handler)` Set a key's time to live in milliseconds
    `RedisClient` | `pexpireat(String key, long millis, Handler<AsyncResult<Long>> handler)` Set the expiration for a key as a UNIX timestamp specified in milliseconds
    `RedisClient` | `pfadd(String key, String element, Handler<AsyncResult<Long>> handler)` Adds the specified element to the specified HyperLogLog.
    `RedisClient` | `pfaddMany(String key, List<String> elements, Handler<AsyncResult<Long>> handler)` Adds the specified elements to the specified HyperLogLog.
    `RedisClient` | `pfcount(String key, Handler<AsyncResult<Long>> handler)` Return the approximated cardinality of the set observed by the HyperLogLog at key.
    `RedisClient` | `pfcountMany(List<String> keys, Handler<AsyncResult<Long>> handler)` Return the approximated cardinality of the set(s) observed by the HyperLogLog at key(s).
    `RedisClient` | `pfmerge(String destkey, List<String> keys, Handler<AsyncResult<String>> handler)` Merge N different HyperLogLogs into a single one.
    `RedisClient` | `ping(Handler<AsyncResult<String>> handler)` Ping the server
    `RedisClient` | `psetex(String key, long millis, String value, Handler<AsyncResult<Void>> handler)` Set the value and expiration in milliseconds of a key
    `RedisClient` | `psubscribe(String pattern, Handler<AsyncResult<Void>> handler)` Listen for messages published to channels matching the given pattern
    `RedisClient` | `psubscribeMany(List<String> patterns, Handler<AsyncResult<Void>> handler)` Listen for messages published to channels matching the given patterns
    `RedisClient` | `pttl(String key, Handler<AsyncResult<Long>> handler)` Get the time to live for a key in milliseconds
    `RedisClient` | `publish(String channel, String message, Handler<AsyncResult<Long>> handler)` Post a message to a channel
    `RedisClient` | `pubsubChannels(String pattern, Handler<AsyncResult<JsonArray>> handler)` Lists the currently active channels - only those matching the pattern
    `RedisClient` | `pubsubNumpat(Handler<AsyncResult<Long>> handler)` Returns the number of subscriptions to patterns (that are performed using the PSUBSCRIBE command)
    `RedisClient` | `pubsubNumsub(List<String> channels, Handler<AsyncResult<JsonArray>> handler)` Returns the number of subscribers (not counting clients subscribed to patterns) for the specified channels
    `RedisClient` | `punsubscribe(List<String> patterns, Handler<AsyncResult<Void>> handler)` Stop listening for messages posted to channels matching the given patterns
    `RedisClient` | `randomkey(Handler<AsyncResult<String>> handler)` Return a random key from the keyspace
    `RedisClient` | `rename(String key, String newkey, Handler<AsyncResult<String>> handler)` Rename a key
    `RedisClient` | `renamenx(String key, String newkey, Handler<AsyncResult<Long>> handler)` Rename a key, only if the new key does not exist
    `RedisClient` | `restore(String key, long millis, String serialized, Handler<AsyncResult<String>> handler)` Create a key using the provided serialized value, previously obtained using DUMP.
    `RedisClient` | `role(Handler<AsyncResult<JsonArray>> handler)` Return the role of the instance in the context of replication
    `RedisClient` | `rpop(String key, Handler<AsyncResult<String>> handler)` Remove and get the last element in a list
    `RedisClient` | `rpoplpush(String key, String destkey, Handler<AsyncResult<String>> handler)` Remove the last element in a list, append it to another list and return it
    `RedisClient` | `rpush(String key, String value, Handler<AsyncResult<Long>> handler)` Append one or multiple values to a list
    `RedisClient` | `rpushMany(String key, List<String> values, Handler<AsyncResult<Long>> handler)` Append one or multiple values to a list
    `RedisClient` | `rpushx(String key, String value, Handler<AsyncResult<Long>> handler)` Append a value to a list, only if the list exists
    `RedisClient` | `sadd(String key, String member, Handler<AsyncResult<Long>> handler)` Add a member to a set
    `RedisClient` | `saddMany(String key, List<String> members, Handler<AsyncResult<Long>> handler)` Add one or more members to a set
    `RedisClient` | `save(Handler<AsyncResult<String>> handler)` Synchronously save the dataset to disk
    `RedisClient` | `scan(String cursor, ScanOptions options, Handler<AsyncResult<Void>> handler)` Incrementally iterate the keys space
    `RedisClient` | `scard(String key, Handler<AsyncResult<Long>> handler)` Get the number of members in a set
    `RedisClient` | `scriptExists(String script, Handler<AsyncResult<JsonArray>> handler)` Check existence of script in the script cache.
    `RedisClient` | `scriptExistsMany(List<String> scripts, Handler<AsyncResult<JsonArray>> handler)` Check existence of scripts in the script cache.
    `RedisClient` | `scriptFlush(Handler<AsyncResult<String>> handler)` Remove all the scripts from the script cache.
    `RedisClient` | `scriptKill(Handler<AsyncResult<String>> handler)` Kill the script currently in execution.
    `RedisClient` | `scriptLoad(String script, Handler<AsyncResult<String>> handler)` Load the specified Lua script into the script cache.
    `RedisClient` | `sdiff(String key, List<String> cmpkeys, Handler<AsyncResult<JsonArray>> handler)` Subtract multiple sets
    `RedisClient` | `sdiffstore(String destkey, String key, List<String> cmpkeys, Handler<AsyncResult<Long>> handler)` Subtract multiple sets and store the resulting set in a key
    `RedisClient` | `select(int dbindex, Handler<AsyncResult<String>> handler)` Change the selected database for the current connection
    `RedisClient` | `set(String key, String value, Handler<AsyncResult<Void>> handler)` Set the string value of a key
    `RedisClient` | `setBinary(String key, String value, Handler<AsyncResult<Void>> handler)` Set the binary string value of a key - without encoding as utf-8
    `RedisClient` | `setbit(String key, long offset, int bit, Handler<AsyncResult<Long>> handler)` Sets or clears the bit at offset in the string value stored at key
    `RedisClient` | `setex(String key, long seconds, String value, Handler<AsyncResult<String>> handler)` Set the value and expiration of a key
    `RedisClient` | `setnx(String key, String value, Handler<AsyncResult<Long>> handler)` Set the value of a key, only if the key does not exist
    `RedisClient` | `setrange(String key, int offset, String value, Handler<AsyncResult<Long>> handler)` Overwrite part of a string at key starting at the specified offset
    `RedisClient` | `setWithOptions(String key, String value, SetOptions options, Handler<AsyncResult<Void>> handler)` Set the string value of a key
    `RedisClient` | `sinter(List<String> keys, Handler<AsyncResult<JsonArray>> handler)` Intersect multiple sets
    `RedisClient` | `sinterstore(String destkey, List<String> keys, Handler<AsyncResult<Long>> handler)` Intersect multiple sets and store the resulting set in a key
    `RedisClient` | `sismember(String key, String member, Handler<AsyncResult<Long>> handler)` Determine if a given value is a member of a set
    `RedisClient` | `slaveof(String host, int port, Handler<AsyncResult<String>> handler)` Make the server a slave of another instance
    `RedisClient` | `slaveofNoone(Handler<AsyncResult<String>> handler)` Make this server a master
    `RedisClient` | `slowlogGet(int limit, Handler<AsyncResult<JsonArray>> handler)` Read the Redis slow queries log
    `RedisClient` | `slowlogLen(Handler<AsyncResult<Long>> handler)` Get the length of the Redis slow queries log
    `RedisClient` | `slowlogReset(Handler<AsyncResult<Void>> handler)` Reset the Redis slow queries log
    `RedisClient` | `smembers(String key, Handler<AsyncResult<JsonArray>> handler)` Get all the members in a set
    `RedisClient` | `smove(String key, String destkey, String member, Handler<AsyncResult<Long>> handler)` Move a member from one set to another
    `RedisClient` | `sort(String key, SortOptions options, Handler<AsyncResult<JsonArray>> handler)` Sort the elements in a list, set or sorted set
    `RedisClient` | `spop(String key, Handler<AsyncResult<String>> handler)` Remove and return a random member from a set
    `RedisClient` | `spopMany(String key, int count, Handler<AsyncResult<String>> handler)` Remove and return random members from a set
    `RedisClient` | `srandmember(String key, int count, Handler<AsyncResult<JsonArray>> handler)` Get one or multiple random members from a set
    `RedisClient` | `srem(String key, String member, Handler<AsyncResult<Long>> handler)` Remove one member from a set
    `RedisClient` | `sremMany(String key, List<String> members, Handler<AsyncResult<Long>> handler)` Remove one or more members from a set
    `RedisClient` | `sscan(String key, String cursor, ScanOptions options, Handler<AsyncResult<Void>> handler)` Incrementally iterate Set elements
    `RedisClient` | `strlen(String key, Handler<AsyncResult<Long>> handler)` Get the length of the value stored in a key
    `RedisClient` | `subscribe(List<String> channels, Handler<AsyncResult<Void>> handler)` Listen for messages published to the given channels
    `RedisClient` | `sunion(List<String> keys, Handler<AsyncResult<JsonArray>> handler)` Add multiple sets
    `RedisClient` | `sunionstore(String destkey, List<String> keys, Handler<AsyncResult<Long>> handler)` Add multiple sets and store the resulting set in a key
    `RedisClient` | `sync(Handler<AsyncResult<Void>> handler)` Internal command used for replication
    `RedisClient` | `time(Handler<AsyncResult<JsonArray>> handler)` Return the current server time
    `RedisClient` | `ttl(String key, Handler<AsyncResult<Long>> handler)` Get the time to live for a key
    `RedisClient` | `type(String key, Handler<AsyncResult<String>> handler)` Determine the type stored at key
    `RedisClient` | `unsubscribe(List<String> channels, Handler<AsyncResult<Void>> handler)` Stop listening for messages posted to the given channels
    `RedisClient` | `unwatch(Handler<AsyncResult<String>> handler)` Forget about all watched keys
    `RedisClient` | `watch(List<String> keys, Handler<AsyncResult<String>> handler)` Watch the given keys to determine execution of the MULTI/EXEC block
    `RedisClient` | `zadd(String key, double score, String member, Handler<AsyncResult<Long>> handler)` Add one or more members to a sorted set, or update its score if it already exists
    `RedisClient` | `zaddMany(String key, Map<String,Double> members, Handler<AsyncResult<Long>> handler)` Add one or more members to a sorted set, or update its score if it already exists
    `RedisClient` | `zcard(String key, Handler<AsyncResult<Long>> handler)` Get the number of members in a sorted set
    `RedisClient` | `zcount(String key, double min, double max, Handler<AsyncResult<Long>> handler)` Count the members in a sorted set with scores within the given values
    `RedisClient` | `zincrby(String key, double increment, String member, Handler<AsyncResult<String>> handler)` Increment the score of a member in a sorted set
    `RedisClient` | `zinterstore(String destkey, List<String> sets, AggregateOptions options, Handler<AsyncResult<Long>> handler)` Intersect multiple sorted sets and store the resulting sorted set in a new key
    `RedisClient` | `zinterstoreWeighed(String destkey, Map<String,Double> sets, AggregateOptions options, Handler<AsyncResult<Long>> handler)` Intersect multiple sorted sets and store the resulting sorted set in a new key using weights for scoring
    `RedisClient` | `zlexcount(String key, String min, String max, Handler<AsyncResult<Long>> handler)` Count the number of members in a sorted set between a given lexicographical range
    `RedisClient` | `zrange(String key, long start, long stop, Handler<AsyncResult<JsonArray>> handler)` Return a range of members in a sorted set, by index
    `RedisClient` | `zrangebylex(String key, String min, String max, LimitOptions options, Handler<AsyncResult<JsonArray>> handler)` Return a range of members in a sorted set, by lexicographical range
    `RedisClient` | `zrangebyscore(String key, String min, String max, RangeLimitOptions options, Handler<AsyncResult<JsonArray>> handler)` Return a range of members in a sorted set, by score
    `RedisClient` | `zrangeWithOptions(String key, long start, long stop, RangeOptions options, Handler<AsyncResult<JsonArray>> handler)` Return a range of members in a sorted set, by index
    `RedisClient` | `zrank(String key, String member, Handler<AsyncResult<Long>> handler)` Determine the index of a member in a sorted set
    `RedisClient` | `zrem(String key, String member, Handler<AsyncResult<Long>> handler)` Remove one member from a sorted set
    `RedisClient` | `zremMany(String key, List<String> members, Handler<AsyncResult<Long>> handler)` Remove one or more members from a sorted set
    `RedisClient` | `zremrangebylex(String key, String min, String max, Handler<AsyncResult<Long>> handler)` Remove all members in a sorted set between the given lexicographical range
    `RedisClient` | `zremrangebyrank(String key, long start, long stop, Handler<AsyncResult<Long>> handler)` Remove all members in a sorted set within the given indexes
    `RedisClient` | `zremrangebyscore(String key, String min, String max, Handler<AsyncResult<Long>> handler)` Remove all members in a sorted set within the given scores
    `RedisClient` | `zrevrange(String key, long start, long stop, RangeOptions options, Handler<AsyncResult<JsonArray>> handler)` Return a range of members in a sorted set, by index, with scores ordered from high to low
    `RedisClient` | `zrevrangebylex(String key, String max, String min, LimitOptions options, Handler<AsyncResult<JsonArray>> handler)` Return a range of members in a sorted set, by score, between the given lexicographical range with scores ordered from high to low
    `RedisClient` | `zrevrangebyscore(String key, String max, String min, RangeLimitOptions options, Handler<AsyncResult<JsonArray>> handler)` Return a range of members in a sorted set, by score, with scores ordered from high to low
    `RedisClient` | `zrevrank(String key, String member, Handler<AsyncResult<Long>> handler)` Determine the index of a member in a sorted set, with scores ordered from high to low
    `RedisClient` | `zscan(String key, String cursor, ScanOptions options, Handler<AsyncResult<Void>> handler)` Incrementally iterate sorted sets elements and associated scores
    `RedisClient` | `zscore(String key, String member, Handler<AsyncResult<String>> handler)` Get the score associated with the given member in a sorted set
    `RedisClient` | `zunionstore(String destkey, List<String> sets, AggregateOptions options, Handler<AsyncResult<Long>> handler)` Add multiple sorted sets and store the resulting sorted set in a new key
    `RedisClient` | `zunionstoreWeighed(String key, Map<String,Double> sets, AggregateOptions options, Handler<AsyncResult<Long>> handler)` Add multiple sorted sets using weights, and store the resulting sorted set in a new key

    - ### Methods inherited from class java.lang.Object

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

- - ### Constructor Detail

    - #### RedisClient

          public RedisClient(RedisClient delegate)

  - ### Method Detail

    - #### getDelegate

          public Object getDelegate()

    - #### create

          public static RedisClient create(Vertx vertx,
                                           JsonObject config)

    - #### close

          public void close(Handler<AsyncResult<Void>> handler)

      Close the client - when it is fully closed the handler will be called.
      Parameters:
        `handler` -

    - #### closeObservable

          public rx.Observable<Void> closeObservable()

      Close the client - when it is fully closed the handler will be called.
      Returns:

    - #### append

          public RedisClient append(String key,
                                    String value,
                                    Handler<AsyncResult<Long>> handler)

      Append a value to a key
      Parameters:
        `key` - Key string
        `value` - Value to append
        `handler` - Handler for the result of this call.
      Returns:

    - #### auth

          public RedisClient auth(String password,
                                  Handler<AsyncResult<String>> handler)

      Authenticate to the server
      Parameters:
        `password` - Password for authentication
        `handler` - Handler for the result of this call.
      Returns:

    - #### bgrewriteaof

          public RedisClient bgrewriteaof(Handler<AsyncResult<String>> handler)

      Asynchronously rewrite the append-only file
      Parameters:
        `handler` -
      Returns:

    - #### bgsave

          public RedisClient bgsave(Handler<AsyncResult<String>> handler)

      Asynchronously save the dataset to disk
      Parameters:
        `handler` -
      Returns:

    - #### bitcount

          public RedisClient bitcount(String key,
                                      Handler<AsyncResult<Long>> handler)

      Count set bits in a string
      Parameters:
        `key` - Key string
        `handler` - Handler for the result of this call.
      Returns:

    - #### bitcountRange

          public RedisClient bitcountRange(String key,
                                           long start,
                                           long end,
                                           Handler<AsyncResult<Long>> handler)

      Count set bits in a string
      Parameters:
        `key` - Key string
        `start` - Start index
        `end` - End index
        `handler` - Handler for the result of this call.
      Returns:

    - #### bitop

          public RedisClient bitop(BitOperation operation,
                                   String destkey,
                                   List<String> keys,
                                   Handler<AsyncResult<Long>> handler)

      Perform bitwise operations between strings
      Parameters:
        `operation` - Bitwise operation to perform
        `destkey` - Destination key where result is stored
        `keys` - List of keys on which to perform the operation
        `handler` - Handler for the result of this call.
      Returns:

    - #### bitpos

          public RedisClient bitpos(String key,
                                    int bit,
                                    Handler<AsyncResult<Long>> handler)

      Find first bit set or clear in a string
      Parameters:
        `key` - Key string
        `bit` - What bit value to look for - must be 1, or 0
        `handler` - Handler for the result of this call.
      Returns:

    - #### bitposFrom

          public RedisClient bitposFrom(String key,
                                        int bit,
                                        int start,
                                        Handler<AsyncResult<Long>> handler)

      Find first bit set or clear in a string See also bitposRange() method, which takes start, and stop offset.
      Parameters:
        `key` - Key string
        `bit` - What bit value to look for - must be 1, or 0
        `start` - Start offset
        `handler` - Handler for the result of this call.
      Returns:

    - #### bitposRange

          public RedisClient bitposRange(String key,
                                         int bit,
                                         int start,
                                         int stop,
                                         Handler<AsyncResult<Long>> handler)

      Find first bit set or clear in a string Note: when both start, and stop offsets are specified, behaviour is slightly different than if only start is specified
      Parameters:
        `key` - Key string
        `bit` - What bit value to look for - must be 1, or 0
        `start` - Start offset
        `stop` - End offset - inclusive
        `handler` - Handler for the result of this call.
      Returns:

    - #### blpop

          public RedisClient blpop(String key,
                                   int seconds,
                                   Handler<AsyncResult<JsonArray>> handler)

      Remove and get the first element in a list, or block until one is available
      Parameters:
        `key` - Key string identifying a list to watch
        `seconds` - Timeout in seconds
        `handler` - Handler for the result of this call.
      Returns:

    - #### blpopMany

          public RedisClient blpopMany(List<String> keys,
                                       int seconds,
                                       Handler<AsyncResult<JsonArray>> handler)

      Remove and get the first element in any of the lists, or block until one is available
      Parameters:
        `keys` - List of key strings identifying lists to watch
        `seconds` - Timeout in seconds
        `handler` - Handler for the result of this call.
      Returns:

    - #### brpop

          public RedisClient brpop(String key,
                                   int seconds,
                                   Handler<AsyncResult<JsonArray>> handler)

      Remove and get the last element in a list, or block until one is available
      Parameters:
        `key` - Key string identifying a list to watch
        `seconds` - Timeout in seconds
        `handler` - Handler for the result of this call.
      Returns:

    - #### brpopMany

          public RedisClient brpopMany(List<String> keys,
                                       int seconds,
                                       Handler<AsyncResult<JsonArray>> handler)

      Remove and get the last element in any of the lists, or block until one is available
      Parameters:
        `keys` - List of key strings identifying lists to watch
        `seconds` - Timeout in seconds
        `handler` - Handler for the result of this call.
      Returns:

    - #### brpoplpush

          public RedisClient brpoplpush(String key,
                                        String destkey,
                                        int seconds,
                                        Handler<AsyncResult<Void>> handler)

      Pop a value from a list, push it to another list and return it; or block until one is available
      Parameters:
        `key` - Key string identifying the source list
        `destkey` - Key string identifying the destination list
        `seconds` - Timeout in seconds
        `handler` - Handler for the result of this call.
      Returns:

    - #### clientKill

          public RedisClient clientKill(KillFilter filter,
                                        Handler<AsyncResult<Long>> handler)

      Kill the connection of a client
      Parameters:
        `filter` - Filter options
        `handler` - Handler for the result of this call.
      Returns:

    - #### clientList

          public RedisClient clientList(Handler<AsyncResult<String>> handler)

      Get the list of client connections
      Parameters:
        `handler` -
      Returns:

    - #### clientGetname

          public RedisClient clientGetname(Handler<AsyncResult<String>> handler)

      Get the current connection name
      Parameters:
        `handler` -
      Returns:

    - #### clientPause

          public RedisClient clientPause(long millis,
                                         Handler<AsyncResult<String>> handler)

      Stop processing commands from clients for some time
      Parameters:
        `millis` - Pause time in milliseconds
        `handler` - Handler for the result of this call.
      Returns:

    - #### clientSetname

          public RedisClient clientSetname(String name,
                                           Handler<AsyncResult<String>> handler)

      Set the current connection name
      Parameters:
        `name` - New name for current connection
        `handler` - Handler for the result of this call.
      Returns:

    - #### clusterSlots

          public RedisClient clusterSlots(Handler<AsyncResult<JsonArray>> handler)

      Get array of Cluster slot to node mappings
      Parameters:
        `handler` -
      Returns:

    - #### command

          public RedisClient command(Handler<AsyncResult<JsonArray>> handler)

      Get array of Redis command details
      Parameters:
        `handler` -
      Returns:

    - #### commandCount

          public RedisClient commandCount(Handler<AsyncResult<Long>> handler)

      Get total number of Redis commands
      Parameters:
        `handler` -
      Returns:

    - #### commandGetkeys

          public RedisClient commandGetkeys(Handler<AsyncResult<JsonArray>> handler)

      Extract keys given a full Redis command
      Parameters:
        `handler` -
      Returns:

    - #### commandInfo

          public RedisClient commandInfo(List<String> commands,
                                         Handler<AsyncResult<JsonArray>> handler)

      Get array of specific Redis command details
      Parameters:
        `commands` - List of commands to get info for
        `handler` - Handler for the result of this call.
      Returns:

    - #### configGet

          public RedisClient configGet(String parameter,
                                       Handler<AsyncResult<JsonArray>> handler)

      Get the value of a configuration parameter
      Parameters:
        `parameter` - Configuration parameter
        `handler` - Handler for the result of this call.
      Returns:

    - #### configRewrite

          public RedisClient configRewrite(Handler<AsyncResult<String>> handler)

      Rewrite the configuration file with the in memory configuration
      Parameters:
        `handler` -
      Returns:

    - #### configSet

          public RedisClient configSet(String parameter,
                                       String value,
                                       Handler<AsyncResult<String>> handler)

      Set a configuration parameter to the given value
      Parameters:
        `parameter` - Configuration parameter
        `value` - New value
        `handler` - Handler for the result of this call.
      Returns:

    - #### configResetstat

          public RedisClient configResetstat(Handler<AsyncResult<String>> handler)

      Reset the stats returned by INFO
      Parameters:
        `handler` -
      Returns:

    - #### dbsize

          public RedisClient dbsize(Handler<AsyncResult<Long>> handler)

      Return the number of keys in the selected database
      Parameters:
        `handler` -
      Returns:

    - #### debugObject

          public RedisClient debugObject(String key,
                                         Handler<AsyncResult<String>> handler)

      Get debugging information about a key
      Parameters:
        `key` - Key string
        `handler` - Handler for the result of this call.
      Returns:

    - #### debugSegfault

          public RedisClient debugSegfault(Handler<AsyncResult<String>> handler)

      Make the server crash
      Parameters:
        `handler` -
      Returns:

    - #### decr

          public RedisClient decr(String key,
                                  Handler<AsyncResult<Long>> handler)

      Decrement the integer value of a key by one
      Parameters:
        `key` - Key string
        `handler` - Handler for the result of this call.
      Returns:

    - #### decrby

          public RedisClient decrby(String key,
                                    long decrement,
                                    Handler<AsyncResult<Long>> handler)

      Decrement the integer value of a key by the given number
      Parameters:
        `key` - Key string
        `decrement` - Value by which to decrement
        `handler` - Handler for the result of this call.
      Returns:

    - #### del

          public RedisClient del(List<String> keys,
                                 Handler<AsyncResult<Long>> handler)

      Delete a key
      Parameters:
        `keys` - List of keys to delete
        `handler` - Handler for the result of this call.
      Returns:

    - #### discard

          public RedisClient discard(Handler<AsyncResult<String>> handler)

      Discard all commands issued after MULTI
      Parameters:
        `handler` -
      Returns:

    - #### dump

          public RedisClient dump(String key,
                                  Handler<AsyncResult<String>> handler)

      Return a serialized version of the value stored at the specified key.
      Parameters:
        `key` - Key string
        `handler` - Handler for the result of this call.
      Returns:

    - #### echo

          public RedisClient echo(String message,
                                  Handler<AsyncResult<String>> handler)

      Echo the given string
      Parameters:
        `message` - String to echo
        `handler` - Handler for the result of this call.
      Returns:

    - #### eval

          public RedisClient eval(String script,
                                  List<String> keys,
                                  List<String> args,
                                  Handler<AsyncResult<Void>> handler)

      Execute a Lua script server side
      Parameters:
        `script` - Lua script to evaluate
        `keys` - List of keys
        `args` - List of argument values
        `handler` - Handler for the result of this call.
      Returns:

    - #### evalsha

          public RedisClient evalsha(String sha1,
                                     List<String> keys,
                                     List<String> values,
                                     Handler<AsyncResult<Void>> handler)

      Execute a Lua script server side
      Parameters:
        `sha1` - SHA1 digest of the script cached on the server
        `keys` - List of keys
        `values` - List of values
        `handler` - Handler for the result of this call.
      Returns:

    - #### exec

          public RedisClient exec(Handler<AsyncResult<Void>> handler)

      Execute all commands issued after MULTI
      Parameters:
        `handler` -
      Returns:

    - #### exists

          public RedisClient exists(String key,
                                    Handler<AsyncResult<Long>> handler)

      Determine if a key exists
      Parameters:
        `key` - Key string
        `handler` - Handler for the result of this call.
      Returns:

    - #### expire

          public RedisClient expire(String key,
                                    int seconds,
                                    Handler<AsyncResult<Long>> handler)

      Set a key's time to live in seconds
      Parameters:
        `key` - Key string
        `seconds` - Time to live in seconds
        `handler` - Handler for the result of this call.
      Returns:

    - #### expireat

          public RedisClient expireat(String key,
                                      long seconds,
                                      Handler<AsyncResult<Long>> handler)

      Set the expiration for a key as a UNIX timestamp
      Parameters:
        `key` - Key string
        `seconds` - Expiry time as Unix timestamp in seconds
        `handler` - Handler for the result of this call.
      Returns:

    - #### flushall

          public RedisClient flushall(Handler<AsyncResult<String>> handler)

      Remove all keys from all databases
      Parameters:
        `handler` -
      Returns:

    - #### flushdb

          public RedisClient flushdb(Handler<AsyncResult<String>> handler)

      Remove all keys from the current database
      Parameters:
        `handler` -
      Returns:

    - #### get

          public RedisClient get(String key,
                                 Handler<AsyncResult<String>> handler)

      Get the value of a key
      Parameters:
        `key` - Key string
        `handler` - Handler for the result of this call.
      Returns:

    - #### getBinary

          public RedisClient getBinary(String key,
                                       Handler<AsyncResult<String>> handler)

      Get the value of a key - without decoding as utf-8
      Parameters:
        `key` - Key string
        `handler` - Handler for the result of this call.
      Returns:

    - #### getbit

          public RedisClient getbit(String key,
                                    long offset,
                                    Handler<AsyncResult<Long>> handler)

      Returns the bit value at offset in the string value stored at key
      Parameters:
        `key` - Key string
        `offset` - Offset in bits
        `handler` - Handler for the result of this call.
      Returns:

    - #### getrange

          public RedisClient getrange(String key,
                                      long start,
                                      long end,
                                      Handler<AsyncResult<String>> handler)

      Get a substring of the string stored at a key
      Parameters:
        `key` - Key string
        `start` - Start offset
        `end` - End offset - inclusive
        `handler` - Handler for the result of this call.
      Returns:

    - #### getset

          public RedisClient getset(String key,
                                    String value,
                                    Handler<AsyncResult<String>> handler)

      Set the string value of a key and return its old value
      Parameters:
        `key` - Key of which value to set
        `value` - New value for the key
        `handler` - Handler for the result of this call.
      Returns:

    - #### hdel

          public RedisClient hdel(String key,
                                  String field,
                                  Handler<AsyncResult<Long>> handler)

      Delete one or more hash fields
      Parameters:
        `key` - Key string
        `field` - Field name
        `handler` - Handler for the result of this call.
      Returns:

    - #### hdelMany

          public RedisClient hdelMany(String key,
                                      List<String> fields,
                                      Handler<AsyncResult<Long>> handler)

      Delete one or more hash fields
      Parameters:
        `key` - Key string
        `fields` - Field names
        `handler` - Handler for the result of this call.
      Returns:

    - #### hexists

          public RedisClient hexists(String key,
                                     String field,
                                     Handler<AsyncResult<Long>> handler)

      Determine if a hash field exists
      Parameters:
        `key` - Key string
        `field` - Field name
        `handler` - Handler for the result of this call.
      Returns:

    - #### hget

          public RedisClient hget(String key,
                                  String field,
                                  Handler<AsyncResult<String>> handler)

      Get the value of a hash field
      Parameters:
        `key` - Key string
        `field` - Field name
        `handler` - Handler for the result of this call.
      Returns:

    - #### hgetall

          public RedisClient hgetall(String key,
                                     Handler<AsyncResult<JsonObject>> handler)

      Get all the fields and values in a hash
      Parameters:
        `key` - Key string
        `handler` - Handler for the result of this call.
      Returns:

    - #### hincrby

          public RedisClient hincrby(String key,
                                     String field,
                                     long increment,
                                     Handler<AsyncResult<Long>> handler)

      Increment the integer value of a hash field by the given number
      Parameters:
        `key` - Key string
        `field` - Field name
        `increment` - Value by which to increment
        `handler` - Handler for the result of this call.
      Returns:

    - #### hincrbyfloat

          public RedisClient hincrbyfloat(String key,
                                          String field,
                                          double increment,
                                          Handler<AsyncResult<String>> handler)

      Increment the float value of a hash field by the given amount
      Parameters:
        `key` - Key string
        `field` - Field name
        `increment` - Value by which to increment
        `handler` - Handler for the result of this call.
      Returns:

    - #### hkeys

          public RedisClient hkeys(String key,
                                   Handler<AsyncResult<JsonArray>> handler)

      Get all the fields in a hash
      Parameters:
        `key` - Key string
        `handler` - Handler for the result of this call.
      Returns:

    - #### hlen

          public RedisClient hlen(String key,
                                  Handler<AsyncResult<Long>> handler)

      Get the number of fields in a hash
      Parameters:
        `key` - Key string
        `handler` - Handler for the result of this call.
      Returns:

    - #### hmget

          public RedisClient hmget(String key,
                                   List<String> fields,
                                   Handler<AsyncResult<JsonArray>> handler)

      Get the values of all the given hash fields
      Parameters:
        `key` - Key string
        `fields` - Field names
        `handler` - Handler for the result of this call.
      Returns:

    - #### hmset

          public RedisClient hmset(String key,
                                   Map<String,String> values,
                                   Handler<AsyncResult<String>> handler)

      Set multiple hash fields to multiple values
      Parameters:
        `key` - Key string
        `values` - Map of field:value pairs
        `handler` - Handler for the result of this call.
      Returns:

    - #### hset

          public RedisClient hset(String key,
                                  String field,
                                  String value,
                                  Handler<AsyncResult<Long>> handler)

      Set the string value of a hash field
      Parameters:
        `key` - Key string
        `field` - Field name
        `value` - New value
        `handler` - Handler for the result of this call.
      Returns:

    - #### hsetnx

          public RedisClient hsetnx(String key,
                                    String field,
                                    String value,
                                    Handler<AsyncResult<Long>> handler)

      Set the value of a hash field, only if the field does not exist
      Parameters:
        `key` - Key string
        `field` - Field name
        `value` - New value
        `handler` - Handler for the result of this call.
      Returns:

    - #### hvals

          public RedisClient hvals(String key,
                                   Handler<AsyncResult<JsonArray>> handler)

      Get all the values in a hash
      Parameters:
        `key` - Key string
        `handler` - Handler for the result of this call.
      Returns:

    - #### incr

          public RedisClient incr(String key,
                                  Handler<AsyncResult<Long>> handler)

      Increment the integer value of a key by one
      Parameters:
        `key` - Key string
        `handler` - Handler for the result of this call.
      Returns:

    - #### incrby

          public RedisClient incrby(String key,
                                    long increment,
                                    Handler<AsyncResult<Long>> handler)

      Increment the integer value of a key by the given amount
      Parameters:
        `key` - Key string
        `increment` - Value by which to increment
        `handler` - Handler for the result of this call.
      Returns:

    - #### incrbyfloat

          public RedisClient incrbyfloat(String key,
                                         double increment,
                                         Handler<AsyncResult<String>> handler)

      Increment the float value of a key by the given amount
      Parameters:
        `key` - Key string
        `increment` - Value by which to increment
        `handler` - Handler for the result of this call.
      Returns:

    - #### info

          public RedisClient info(Handler<AsyncResult<JsonObject>> handler)

      Get information and statistics about the server
      Parameters:
        `handler` - Handler for the result of this call.
      Returns:

    - #### infoSection

          public RedisClient infoSection(String section,
                                         Handler<AsyncResult<JsonObject>> handler)

      Get information and statistics about the server
      Parameters:
        `section` - Specific section of information to return
        `handler` - Handler for the result of this call.
      Returns:

    - #### keys

          public RedisClient keys(String pattern,
                                  Handler<AsyncResult<JsonArray>> handler)

      Find all keys matching the given pattern
      Parameters:
        `pattern` - Pattern to limit the keys returned
        `handler` - Handler for the result of this call.
      Returns:

    - #### lastsave

          public RedisClient lastsave(Handler<AsyncResult<Long>> handler)

      Get the UNIX time stamp of the last successful save to disk
      Parameters:
        `handler` -
      Returns:

    - #### lindex

          public RedisClient lindex(String key,
                                    int index,
                                    Handler<AsyncResult<String>> handler)

      Get an element from a list by its index
      Parameters:
        `key` - Key string
        `index` - Index of list element to get
        `handler` - Handler for the result of this call.
      Returns:

    - #### linsert

          public RedisClient linsert(String key,
                                     InsertOptions option,
                                     String pivot,
                                     String value,
                                     Handler<AsyncResult<Long>> handler)

      Insert an element before or after another element in a list
      Parameters:
        `key` - Key string
        `option` - BEFORE or AFTER
        `pivot` - Key to use as a pivot
        `value` - Value to be inserted before or after the pivot
        `handler` - Handler for the result of this call.
      Returns:

    - #### llen

          public RedisClient llen(String key,
                                  Handler<AsyncResult<Long>> handler)

      Get the length of a list
      Parameters:
        `key` - String key
        `handler` - Handler for the result of this call.
      Returns:

    - #### lpop

          public RedisClient lpop(String key,
                                  Handler<AsyncResult<String>> handler)

      Remove and get the first element in a list
      Parameters:
        `key` - String key
        `handler` - Handler for the result of this call.
      Returns:

    - #### lpushMany

          public RedisClient lpushMany(String key,
                                       List<String> values,
                                       Handler<AsyncResult<Long>> handler)

      Prepend one or multiple values to a list
      Parameters:
        `key` - Key string
        `values` - Values to be added at the beginning of the list, one by one
        `handler` - Handler for the result of this call.
      Returns:

    - #### lpush

          public RedisClient lpush(String key,
                                   String value,
                                   Handler<AsyncResult<Long>> handler)

      Prepend one value to a list
      Parameters:
        `key` - Key string
        `value` - Value to be added at the beginning of the list
        `handler` - Handler for the result of this call.
      Returns:

    - #### lpushx

          public RedisClient lpushx(String key,
                                    String value,
                                    Handler<AsyncResult<Long>> handler)

      Prepend a value to a list, only if the list exists
      Parameters:
        `key` - Key string
        `value` - Value to add at the beginning of the list
        `handler` - Handler for the result of this call.
      Returns:

    - #### lrange

          public RedisClient lrange(String key,
                                    long from,
                                    long to,
                                    Handler<AsyncResult<JsonArray>> handler)

      Get a range of elements from a list
      Parameters:
        `key` - Key string
        `from` - Start index
        `to` - Stop index
        `handler` - Handler for the result of this call.
      Returns:

    - #### lrem

          public RedisClient lrem(String key,
                                  long count,
                                  String value,
                                  Handler<AsyncResult<Long>> handler)

      Remove elements from a list
      Parameters:
        `key` - Key string
        `count` - Number of first found occurrences equal to $value to remove from the list
        `value` - Value to be removed
        `handler` - Handler for the result of this call.
      Returns:

    - #### lset

          public RedisClient lset(String key,
                                  long index,
                                  String value,
                                  Handler<AsyncResult<String>> handler)

      Set the value of an element in a list by its index
      Parameters:
        `key` - Key string
        `index` - Position within list
        `value` - New value
        `handler` - Handler for the result of this call.
      Returns:

    - #### ltrim

          public RedisClient ltrim(String key,
                                   long from,
                                   long to,
                                   Handler<AsyncResult<String>> handler)

      Trim a list to the specified range
      Parameters:
        `key` - Key string
        `from` - Start index
        `to` - Stop index
        `handler` - Handler for the result of this call.
      Returns:

    - #### mget

          public RedisClient mget(String key,
                                  Handler<AsyncResult<JsonArray>> handler)

      Get the value of the given key
      Parameters:
        `key` - Key string
        `handler` - Handler for the result of this call.
      Returns:

    - #### mgetMany

          public RedisClient mgetMany(List<String> keys,
                                      Handler<AsyncResult<JsonArray>> handler)

      Get the values of all the given keys
      Parameters:
        `keys` - List of keys to get
        `handler` - Handler for the result of this call.
      Returns:

    - #### migrate

          public RedisClient migrate(String host,
                                     int port,
                                     String key,
                                     int destdb,
                                     long timeout,
                                     MigrateOptions options,
                                     Handler<AsyncResult<String>> handler)

      Atomically transfer a key from a Redis instance to another one.
      Parameters:
        `host` - Destination host
        `port` - Destination port
        `key` - Key to migrate
        `destdb` - Destination database index
        `timeout` -
        `options` - Migrate options
        `handler` - Handler for the result of this call.
      Returns:

    - #### monitor

          public RedisClient monitor(Handler<AsyncResult<Void>> handler)

      Listen for all requests received by the server in real time
      Parameters:
        `handler` -
      Returns:

    - #### move

          public RedisClient move(String key,
                                  int destdb,
                                  Handler<AsyncResult<Long>> handler)

      Move a key to another database
      Parameters:
        `key` - Key to migrate
        `destdb` - Destination database index
        `handler` - Handler for the result of this call.
      Returns:

    - #### mset

          public RedisClient mset(Map<String,String> keyvals,
                                  Handler<AsyncResult<String>> handler)

      Set multiple keys to multiple values
      Parameters:
        `keyvals` - Key value pairs to set
        `handler` - Handler for the result of this call.
      Returns:

    - #### msetnx

          public RedisClient msetnx(Map<String,String> keyvals,
                                    Handler<AsyncResult<Long>> handler)

      Set multiple keys to multiple values, only if none of the keys exist
      Parameters:
        `keyvals` - Key value pairs to set
        `handler` - Handler for the result of this call.
      Returns:

    - #### multi

          public RedisClient multi(Handler<AsyncResult<String>> handler)

      Mark the start of a transaction block
      Parameters:
        `handler` -
      Returns:

    - #### object

          public RedisClient object(String key,
                                    ObjectCmd cmd,
                                    Handler<AsyncResult<Void>> handler)

      Inspect the internals of Redis objects
      Parameters:
        `key` - Key string
        `cmd` - Object sub command
        `handler` - Handler for the result of this call.
      Returns:

    - #### persist

          public RedisClient persist(String key,
                                     Handler<AsyncResult<Long>> handler)

      Remove the expiration from a key
      Parameters:
        `key` - Key string
        `handler` - Handler for the result of this call.
      Returns:

    - #### pexpire

          public RedisClient pexpire(String key,
                                     long millis,
                                     Handler<AsyncResult<Long>> handler)

      Set a key's time to live in milliseconds
      Parameters:
        `key` - String key
        `millis` - Time to live in milliseconds
        `handler` - Handler for the result of this call.
      Returns:

    - #### pexpireat

          public RedisClient pexpireat(String key,
                                       long millis,
                                       Handler<AsyncResult<Long>> handler)

      Set the expiration for a key as a UNIX timestamp specified in milliseconds
      Parameters:
        `key` - Key string
        `millis` - Expiry time as Unix timestamp in milliseconds
        `handler` - Handler for the result of this call.
      Returns:

    - #### pfadd

          public RedisClient pfadd(String key,
                                   String element,
                                   Handler<AsyncResult<Long>> handler)

      Adds the specified element to the specified HyperLogLog.
      Parameters:
        `key` - Key string
        `element` - Element to add
        `handler` - Handler for the result of this call.
      Returns:

    - #### pfaddMany

          public RedisClient pfaddMany(String key,
                                       List<String> elements,
                                       Handler<AsyncResult<Long>> handler)

      Adds the specified elements to the specified HyperLogLog.
      Parameters:
        `key` - Key string
        `elements` - Elementa to add
        `handler` - Handler for the result of this call.
      Returns:

    - #### pfcount

          public RedisClient pfcount(String key,
                                     Handler<AsyncResult<Long>> handler)

      Return the approximated cardinality of the set observed by the HyperLogLog at key.
      Parameters:
        `key` - Key string
        `handler` - Handler for the result of this call.
      Returns:

    - #### pfcountMany

          public RedisClient pfcountMany(List<String> keys,
                                         Handler<AsyncResult<Long>> handler)

      Return the approximated cardinality of the set(s) observed by the HyperLogLog at key(s).
      Parameters:
        `keys` - List of keys
        `handler` - Handler for the result of this call.
      Returns:

    - #### pfmerge

          public RedisClient pfmerge(String destkey,
                                     List<String> keys,
                                     Handler<AsyncResult<String>> handler)

      Merge N different HyperLogLogs into a single one.
      Parameters:
        `destkey` - Destination key
        `keys` - List of source keys
        `handler` - Handler for the result of this call.
      Returns:

    - #### ping

          public RedisClient ping(Handler<AsyncResult<String>> handler)

      Ping the server
      Parameters:
        `handler` -
      Returns:

    - #### psetex

          public RedisClient psetex(String key,
                                    long millis,
                                    String value,
                                    Handler<AsyncResult<Void>> handler)

      Set the value and expiration in milliseconds of a key
      Parameters:
        `key` - Key string
        `millis` - Number of milliseconds until the key expires
        `value` - New value for key
        `handler` - Handler for the result of this call.
      Returns:

    - #### psubscribe

          public RedisClient psubscribe(String pattern,
                                        Handler<AsyncResult<Void>> handler)

      Listen for messages published to channels matching the given pattern
      Parameters:
        `pattern` - Pattern string
        `handler` - Handler for the result of this call.
      Returns:

    - #### psubscribeMany

          public RedisClient psubscribeMany(List<String> patterns,
                                            Handler<AsyncResult<Void>> handler)

      Listen for messages published to channels matching the given patterns
      Parameters:
        `patterns` - List of patterns
        `handler` - Handler for the result of this call.
      Returns:

    - #### pubsubChannels

          public RedisClient pubsubChannels(String pattern,
                                            Handler<AsyncResult<JsonArray>> handler)

      Lists the currently active channels - only those matching the pattern
      Parameters:
        `pattern` - A glob-style pattern - an empty string means no pattern
        `handler` - Handler for the result of this call.
      Returns:

    - #### pubsubNumsub

          public RedisClient pubsubNumsub(List<String> channels,
                                          Handler<AsyncResult<JsonArray>> handler)

      Returns the number of subscribers (not counting clients subscribed to patterns) for the specified channels
      Parameters:
        `channels` - List of channels
        `handler` - Handler for the result of this call.
      Returns:

    - #### pubsubNumpat

          public RedisClient pubsubNumpat(Handler<AsyncResult<Long>> handler)

      Returns the number of subscriptions to patterns (that are performed using the PSUBSCRIBE command)
      Parameters:
        `handler` - Handler for the result of this call.
      Returns:

    - #### pttl

          public RedisClient pttl(String key,
                                  Handler<AsyncResult<Long>> handler)

      Get the time to live for a key in milliseconds
      Parameters:
        `key` - Key string
        `handler` - Handler for the result of this call.
      Returns:

    - #### publish

          public RedisClient publish(String channel,
                                     String message,
                                     Handler<AsyncResult<Long>> handler)

      Post a message to a channel
      Parameters:
        `channel` - Channel key
        `message` - Message to send to channel
        `handler` - Handler for the result of this call.
      Returns:

    - #### punsubscribe

          public RedisClient punsubscribe(List<String> patterns,
                                          Handler<AsyncResult<Void>> handler)

      Stop listening for messages posted to channels matching the given patterns
      Parameters:
        `patterns` - List of patterns to match against
        `handler` - Handler for the result of this call.
      Returns:

    - #### randomkey

          public RedisClient randomkey(Handler<AsyncResult<String>> handler)

      Return a random key from the keyspace
      Parameters:
        `handler` -
      Returns:

    - #### rename

          public RedisClient rename(String key,
                                    String newkey,
                                    Handler<AsyncResult<String>> handler)

      Rename a key
      Parameters:
        `key` - Key string to be renamed
        `newkey` - New key string
        `handler` - Handler for the result of this call.
      Returns:

    - #### renamenx

          public RedisClient renamenx(String key,
                                      String newkey,
                                      Handler<AsyncResult<Long>> handler)

      Rename a key, only if the new key does not exist
      Parameters:
        `key` - Key string to be renamed
        `newkey` - New key string
        `handler` - Handler for the result of this call.
      Returns:

    - #### restore

          public RedisClient restore(String key,
                                     long millis,
                                     String serialized,
                                     Handler<AsyncResult<String>> handler)

      Create a key using the provided serialized value, previously obtained using DUMP.
      Parameters:
        `key` - Key string
        `millis` - Expiry time in milliseconds to set on the key
        `serialized` - Serialized form of the key value as obtained using DUMP
        `handler` - Handler for the result of this call.
      Returns:

    - #### role

          public RedisClient role(Handler<AsyncResult<JsonArray>> handler)

      Return the role of the instance in the context of replication
      Parameters:
        `handler` -
      Returns:

    - #### rpop

          public RedisClient rpop(String key,
                                  Handler<AsyncResult<String>> handler)

      Remove and get the last element in a list
      Parameters:
        `key` - Key string
        `handler` - Handler for the result of this call.
      Returns:

    - #### rpoplpush

          public RedisClient rpoplpush(String key,
                                       String destkey,
                                       Handler<AsyncResult<String>> handler)

      Remove the last element in a list, append it to another list and return it
      Parameters:
        `key` - Key string identifying source list
        `destkey` - Key string identifying destination list
        `handler` - Handler for the result of this call.
      Returns:

    - #### rpushMany

          public RedisClient rpushMany(String key,
                                       List<String> values,
                                       Handler<AsyncResult<Long>> handler)

      Append one or multiple values to a list
      Parameters:
        `key` - Key string
        `values` - List of values to add to the end of the list
        `handler` - Handler for the result of this call.
      Returns:

    - #### rpush

          public RedisClient rpush(String key,
                                   String value,
                                   Handler<AsyncResult<Long>> handler)

      Append one or multiple values to a list
      Parameters:
        `key` - Key string
        `value` - Value to be added to the end of the list
        `handler` - Handler for the result of this call.
      Returns:

    - #### rpushx

          public RedisClient rpushx(String key,
                                    String value,
                                    Handler<AsyncResult<Long>> handler)

      Append a value to a list, only if the list exists
      Parameters:
        `key` - Key string
        `value` - Value to be added to the end of the list
        `handler` - Handler for the result of this call.
      Returns:

    - #### sadd

          public RedisClient sadd(String key,
                                  String member,
                                  Handler<AsyncResult<Long>> handler)

      Add a member to a set
      Parameters:
        `key` - Key string
        `member` - Value to be added to the set
        `handler` - Handler for the result of this call.
      Returns:

    - #### saddMany

          public RedisClient saddMany(String key,
                                      List<String> members,
                                      Handler<AsyncResult<Long>> handler)

      Add one or more members to a set
      Parameters:
        `key` - Key string
        `members` - Values to be added to the set
        `handler` - Handler for the result of this call.
      Returns:

    - #### save

          public RedisClient save(Handler<AsyncResult<String>> handler)

      Synchronously save the dataset to disk
      Parameters:
        `handler` -
      Returns:

    - #### scard

          public RedisClient scard(String key,
                                   Handler<AsyncResult<Long>> handler)

      Get the number of members in a set
      Parameters:
        `key` - Key string
        `handler` - Handler for the result of this call.
      Returns:

    - #### scriptExists

          public RedisClient scriptExists(String script,
                                          Handler<AsyncResult<JsonArray>> handler)

      Check existence of script in the script cache.
      Parameters:
        `script` - SHA1 digest identifying a script in the script cache
        `handler` - Handler for the result of this call.
      Returns:

    - #### scriptExistsMany

          public RedisClient scriptExistsMany(List<String> scripts,
                                              Handler<AsyncResult<JsonArray>> handler)

      Check existence of scripts in the script cache.
      Parameters:
        `scripts` - List of SHA1 digests identifying scripts in the script cache
        `handler` - Handler for the result of this call.
      Returns:

    - #### scriptFlush

          public RedisClient scriptFlush(Handler<AsyncResult<String>> handler)

      Remove all the scripts from the script cache.
      Parameters:
        `handler` -
      Returns:

    - #### scriptKill

          public RedisClient scriptKill(Handler<AsyncResult<String>> handler)

      Kill the script currently in execution.
      Parameters:
        `handler` -
      Returns:

    - #### scriptLoad

          public RedisClient scriptLoad(String script,
                                        Handler<AsyncResult<String>> handler)

      Load the specified Lua script into the script cache.
      Parameters:
        `script` - Lua script
        `handler` - Handler for the result of this call.
      Returns:

    - #### sdiff

          public RedisClient sdiff(String key,
                                   List<String> cmpkeys,
                                   Handler<AsyncResult<JsonArray>> handler)

      Subtract multiple sets
      Parameters:
        `key` - Key identifying the set to compare with all other sets combined
        `cmpkeys` - List of keys identifying sets to subtract from the key set
        `handler` - Handler for the result of this call.
      Returns:

    - #### sdiffstore

          public RedisClient sdiffstore(String destkey,
                                        String key,
                                        List<String> cmpkeys,
                                        Handler<AsyncResult<Long>> handler)

      Subtract multiple sets and store the resulting set in a key
      Parameters:
        `destkey` - Destination key where the result should be stored
        `key` - Key identifying the set to compare with all other sets combined
        `cmpkeys` - List of keys identifying sets to subtract from the key set
        `handler` - Handler for the result of this call.
      Returns:

    - #### select

          public RedisClient select(int dbindex,
                                    Handler<AsyncResult<String>> handler)

      Change the selected database for the current connection
      Parameters:
        `dbindex` - Index identifying the new active database
        `handler` - Handler for the result of this call.
      Returns:

    - #### set

          public RedisClient set(String key,
                                 String value,
                                 Handler<AsyncResult<Void>> handler)

      Set the string value of a key
      Parameters:
        `key` - Key of which value to set
        `value` - New value for the key
        `handler` - Handler for the result of this call.
      Returns:

    - #### setWithOptions

          public RedisClient setWithOptions(String key,
                                            String value,
                                            SetOptions options,
                                            Handler<AsyncResult<Void>> handler)

      Set the string value of a key
      Parameters:
        `key` - Key of which value to set
        `value` - New value for the key
        `options` - Set options
        `handler` - Handler for the result of this call.
      Returns:

    - #### setBinary

          public RedisClient setBinary(String key,
                                       String value,
                                       Handler<AsyncResult<Void>> handler)

      Set the binary string value of a key - without encoding as utf-8
      Parameters:
        `key` - Key of which value to set
        `value` - New value for the key
        `handler` - Handler for the result of this call.
      Returns:

    - #### setbit

          public RedisClient setbit(String key,
                                    long offset,
                                    int bit,
                                    Handler<AsyncResult<Long>> handler)

      Sets or clears the bit at offset in the string value stored at key
      Parameters:
        `key` - Key string
        `offset` - Bit offset
        `bit` - New value - must be 1 or 0
        `handler` - Handler for the result of this call.
      Returns:

    - #### setex

          public RedisClient setex(String key,
                                   long seconds,
                                   String value,
                                   Handler<AsyncResult<String>> handler)

      Set the value and expiration of a key
      Parameters:
        `key` - Key string
        `seconds` - Number of seconds until the key expires
        `value` - New value for key
        `handler` - Handler for the result of this call.
      Returns:

    - #### setnx

          public RedisClient setnx(String key,
                                   String value,
                                   Handler<AsyncResult<Long>> handler)

      Set the value of a key, only if the key does not exist
      Parameters:
        `key` - Key of which value to set
        `value` - New value for the key
        `handler` - Handler for the result of this call.
      Returns:

    - #### setrange

          public RedisClient setrange(String key,
                                      int offset,
                                      String value,
                                      Handler<AsyncResult<Long>> handler)

      Overwrite part of a string at key starting at the specified offset
      Parameters:
        `key` - Key string
        `offset` - Offset - the maximum offset that you can set is 2^29 -1 (536870911), as Redis Strings are limited to 512 megabytes
        `value` - Value to overwrite with
        `handler` - Handler for the result of this call.
      Returns:

    - #### sinter

          public RedisClient sinter(List<String> keys,
                                    Handler<AsyncResult<JsonArray>> handler)

      Intersect multiple sets
      Parameters:
        `keys` - List of keys to perform intersection on
        `handler` - Handler for the result of this call.
      Returns:

    - #### sinterstore

          public RedisClient sinterstore(String destkey,
                                         List<String> keys,
                                         Handler<AsyncResult<Long>> handler)

      Intersect multiple sets and store the resulting set in a key
      Parameters:
        `destkey` - Key where to store the results
        `keys` - List of keys to perform intersection on
        `handler` - Handler for the result of this call.
      Returns:

    - #### sismember

          public RedisClient sismember(String key,
                                       String member,
                                       Handler<AsyncResult<Long>> handler)

      Determine if a given value is a member of a set
      Parameters:
        `key` - Key string
        `member` - Member to look for
        `handler` - Handler for the result of this call.
      Returns:

    - #### slaveof

          public RedisClient slaveof(String host,
                                     int port,
                                     Handler<AsyncResult<String>> handler)

      Make the server a slave of another instance
      Parameters:
        `host` - Host to become this server's master
        `port` - Port of our new master
        `handler` - Handler for the result of this call.
      Returns:

    - #### slaveofNoone

          public RedisClient slaveofNoone(Handler<AsyncResult<String>> handler)

      Make this server a master
      Parameters:
        `handler` - Handler for the result of this call.
      Returns:

    - #### slowlogGet

          public RedisClient slowlogGet(int limit,
                                        Handler<AsyncResult<JsonArray>> handler)

      Read the Redis slow queries log
      Parameters:
        `limit` - Number of log entries to return. If value is less than zero all entries are returned
        `handler` - Handler for the result of this call.
      Returns:

    - #### slowlogLen

          public RedisClient slowlogLen(Handler<AsyncResult<Long>> handler)

      Get the length of the Redis slow queries log
      Parameters:
        `handler` - Handler for the result of this call.
      Returns:

    - #### slowlogReset

          public RedisClient slowlogReset(Handler<AsyncResult<Void>> handler)

      Reset the Redis slow queries log
      Parameters:
        `handler` - Handler for the result of this call.
      Returns:

    - #### smembers

          public RedisClient smembers(String key,
                                      Handler<AsyncResult<JsonArray>> handler)

      Get all the members in a set
      Parameters:
        `key` - Key string
        `handler` - Handler for the result of this call.
      Returns:

    - #### smove

          public RedisClient smove(String key,
                                   String destkey,
                                   String member,
                                   Handler<AsyncResult<Long>> handler)

      Move a member from one set to another
      Parameters:
        `key` - Key of source set currently containing the member
        `destkey` - Key identifying the destination set
        `member` - Member to move
        `handler` - Handler for the result of this call.
      Returns:

    - #### sort

          public RedisClient sort(String key,
                                  SortOptions options,
                                  Handler<AsyncResult<JsonArray>> handler)

      Sort the elements in a list, set or sorted set
      Parameters:
        `key` - Key string
        `options` - Sort options
        `handler` - Handler for the result of this call.
      Returns:

    - #### spop

          public RedisClient spop(String key,
                                  Handler<AsyncResult<String>> handler)

      Remove and return a random member from a set
      Parameters:
        `key` - Key string
        `handler` - Handler for the result of this call.
      Returns:

    - #### spopMany

          public RedisClient spopMany(String key,
                                      int count,
                                      Handler<AsyncResult<String>> handler)

      Remove and return random members from a set
      Parameters:
        `key` - Key string
        `count` - Number of members to remove
        `handler` - Handler for the result of this call.
      Returns:

    - #### srandmember

          public RedisClient srandmember(String key,
                                         int count,
                                         Handler<AsyncResult<JsonArray>> handler)

      Get one or multiple random members from a set
      Parameters:
        `key` - Key string
        `count` - Number of members to get
        `handler` - Handler for the result of this call.
      Returns:

    - #### srem

          public RedisClient srem(String key,
                                  String member,
                                  Handler<AsyncResult<Long>> handler)

      Remove one member from a set
      Parameters:
        `key` - Key string
        `member` - Member to remove
        `handler` - Handler for the result of this call.
      Returns:

    - #### sremMany

          public RedisClient sremMany(String key,
                                      List<String> members,
                                      Handler<AsyncResult<Long>> handler)

      Remove one or more members from a set
      Parameters:
        `key` - Key string
        `members` - Members to remove
        `handler` - Handler for the result of this call.
      Returns:

    - #### strlen

          public RedisClient strlen(String key,
                                    Handler<AsyncResult<Long>> handler)

      Get the length of the value stored in a key
      Parameters:
        `key` - Key string
        `handler` - Handler for the result of this call.
      Returns:

    - #### subscribe

          public RedisClient subscribe(List<String> channels,
                                       Handler<AsyncResult<Void>> handler)

      Listen for messages published to the given channels
      Parameters:
        `channels` - List of channels to subscribe to
        `handler` - Handler for the result of this call.
      Returns:

    - #### sunion

          public RedisClient sunion(List<String> keys,
                                    Handler<AsyncResult<JsonArray>> handler)

      Add multiple sets
      Parameters:
        `keys` - List of keys identifying sets to add up
        `handler` - Handler for the result of this call.
      Returns:

    - #### sunionstore

          public RedisClient sunionstore(String destkey,
                                         List<String> keys,
                                         Handler<AsyncResult<Long>> handler)

      Add multiple sets and store the resulting set in a key
      Parameters:
        `destkey` - Destination key
        `keys` - List of keys identifying sets to add up
        `handler` - Handler for the result of this call.
      Returns:

    - #### sync

          public RedisClient sync(Handler<AsyncResult<Void>> handler)

      Internal command used for replication
      Parameters:
        `handler` -
      Returns:

    - #### time

          public RedisClient time(Handler<AsyncResult<JsonArray>> handler)

      Return the current server time
      Parameters:
        `handler` -
      Returns:

    - #### ttl

          public RedisClient ttl(String key,
                                 Handler<AsyncResult<Long>> handler)

      Get the time to live for a key
      Parameters:
        `key` - Key string
        `handler` - Handler for the result of this call.
      Returns:

    - #### type

          public RedisClient type(String key,
                                  Handler<AsyncResult<String>> handler)

      Determine the type stored at key
      Parameters:
        `key` - Key string
        `handler` - Handler for the result of this call.
      Returns:

    - #### unsubscribe

          public RedisClient unsubscribe(List<String> channels,
                                         Handler<AsyncResult<Void>> handler)

      Stop listening for messages posted to the given channels
      Parameters:
        `channels` - List of channels to subscribe to
        `handler` - Handler for the result of this call.
      Returns:

    - #### unwatch

          public RedisClient unwatch(Handler<AsyncResult<String>> handler)

      Forget about all watched keys
      Parameters:
        `handler` -
      Returns:

    - #### watch

          public RedisClient watch(List<String> keys,
                                   Handler<AsyncResult<String>> handler)

      Watch the given keys to determine execution of the MULTI/EXEC block
      Parameters:
        `keys` - List of keys to watch
        `handler` - Handler for the result of this call.
      Returns:

    - #### zadd

          public RedisClient zadd(String key,
                                  double score,
                                  String member,
                                  Handler<AsyncResult<Long>> handler)

      Add one or more members to a sorted set, or update its score if it already exists
      Parameters:
        `key` - Key string
        `score` - Score used for sorting
        `member` - New member key
        `handler` - Handler for the result of this call.
      Returns:

    - #### zaddMany

          public RedisClient zaddMany(String key,
                                      Map<String,Double> members,
                                      Handler<AsyncResult<Long>> handler)

      Add one or more members to a sorted set, or update its score if it already exists
      Parameters:
        `key` - Key string
        `members` - New member keys and their scores
        `handler` - Handler for the result of this call.
      Returns:

    - #### zcard

          public RedisClient zcard(String key,
                                   Handler<AsyncResult<Long>> handler)

      Get the number of members in a sorted set
      Parameters:
        `key` - Key string
        `handler` - Handler for the result of this call.
      Returns:

    - #### zcount

          public RedisClient zcount(String key,
                                    double min,
                                    double max,
                                    Handler<AsyncResult<Long>> handler)

      Count the members in a sorted set with scores within the given values
      Parameters:
        `key` - Key string
        `min` - Minimum score
        `max` - Maximum score
        `handler` - Handler for the result of this call.
      Returns:

    - #### zincrby

          public RedisClient zincrby(String key,
                                     double increment,
                                     String member,
                                     Handler<AsyncResult<String>> handler)

      Increment the score of a member in a sorted set
      Parameters:
        `key` - Key string
        `increment` - Increment amount
        `member` - Member key
        `handler` - Handler for the result of this call.
      Returns:

    - #### zinterstore

          public RedisClient zinterstore(String destkey,
                                         List<String> sets,
                                         AggregateOptions options,
                                         Handler<AsyncResult<Long>> handler)

      Intersect multiple sorted sets and store the resulting sorted set in a new key
      Parameters:
        `destkey` - Destination key
        `sets` - List of keys identifying sorted sets to intersect
        `options` - Aggregation options
        `handler` - Handler for the result of this call.
      Returns:

    - #### zinterstoreWeighed

          public RedisClient zinterstoreWeighed(String destkey,
                                                Map<String,Double> sets,
                                                AggregateOptions options,
                                                Handler<AsyncResult<Long>> handler)

      Intersect multiple sorted sets and store the resulting sorted set in a new key using weights for scoring
      Parameters:
        `destkey` - Destination key
        `sets` - List of keys identifying sorted sets to intersect
        `options` - Aggregation options
        `handler` - Handler for the result of this call.
      Returns:

    - #### zlexcount

          public RedisClient zlexcount(String key,
                                       String min,
                                       String max,
                                       Handler<AsyncResult<Long>> handler)

      Count the number of members in a sorted set between a given lexicographical range
      Parameters:
        `key` - Key string
        `min` - Pattern to compare against for minimum value
        `max` - Pattern to compare against for maximum value
        `handler` - Handler for the result of this call.
      Returns:

    - #### zrange

          public RedisClient zrange(String key,
                                    long start,
                                    long stop,
                                    Handler<AsyncResult<JsonArray>> handler)

      Return a range of members in a sorted set, by index
      Parameters:
        `key` - Key string
        `start` - Start index for the range
        `stop` - Stop index for the range - inclusive
        `handler` - Handler for the result of this call.
      Returns:

    - #### zrangeWithOptions

          public RedisClient zrangeWithOptions(String key,
                                               long start,
                                               long stop,
                                               RangeOptions options,
                                               Handler<AsyncResult<JsonArray>> handler)

      Return a range of members in a sorted set, by index
      Parameters:
        `key` - Key string
        `start` - Start index for the range
        `stop` - Stop index for the range - inclusive
        `options` - Range options
        `handler` - Handler for the result of this call.
      Returns:

    - #### zrangebylex

          public RedisClient zrangebylex(String key,
                                         String min,
                                         String max,
                                         LimitOptions options,
                                         Handler<AsyncResult<JsonArray>> handler)

      Return a range of members in a sorted set, by lexicographical range
      Parameters:
        `key` - Key string
        `min` - Pattern representing a minimum allowed value
        `max` - Pattern representing a maximum allowed value
        `options` - Limit options where limit can be specified
        `handler` - Handler for the result of this call.
      Returns:

    - #### zrangebyscore

          public RedisClient zrangebyscore(String key,
                                           String min,
                                           String max,
                                           RangeLimitOptions options,
                                           Handler<AsyncResult<JsonArray>> handler)

      Return a range of members in a sorted set, by score
      Parameters:
        `key` - Key string
        `min` - Pattern defining a minimum value
        `max` - Pattern defining a maximum value
        `options` - Range and limit options
        `handler` - Handler for the result of this call.
      Returns:

    - #### zrank

          public RedisClient zrank(String key,
                                   String member,
                                   Handler<AsyncResult<Long>> handler)

      Determine the index of a member in a sorted set
      Parameters:
        `key` - Key string
        `member` - Member in the sorted set identified by key
        `handler` - Handler for the result of this call.
      Returns:

    - #### zrem

          public RedisClient zrem(String key,
                                  String member,
                                  Handler<AsyncResult<Long>> handler)

      Remove one member from a sorted set
      Parameters:
        `key` - Key string
        `member` - Member in the sorted set identified by key
        `handler` - Handler for the result of this call.
      Returns:

    - #### zremMany

          public RedisClient zremMany(String key,
                                      List<String> members,
                                      Handler<AsyncResult<Long>> handler)

      Remove one or more members from a sorted set
      Parameters:
        `key` - Key string
        `members` - Members in the sorted set identified by key
        `handler` - Handler for the result of this call.
      Returns:

    - #### zremrangebylex

          public RedisClient zremrangebylex(String key,
                                            String min,
                                            String max,
                                            Handler<AsyncResult<Long>> handler)

      Remove all members in a sorted set between the given lexicographical range
      Parameters:
        `key` - Key string
        `min` - Pattern defining a minimum value
        `max` - Pattern defining a maximum value
        `handler` - Handler for the result of this call.
      Returns:

    - #### zremrangebyrank

          public RedisClient zremrangebyrank(String key,
                                             long start,
                                             long stop,
                                             Handler<AsyncResult<Long>> handler)

      Remove all members in a sorted set within the given indexes
      Parameters:
        `key` - Key string
        `start` - Start index
        `stop` - Stop index
        `handler` - Handler for the result of this call.
      Returns:

    - #### zremrangebyscore

          public RedisClient zremrangebyscore(String key,
                                              String min,
                                              String max,
                                              Handler<AsyncResult<Long>> handler)

      Remove all members in a sorted set within the given scores
      Parameters:
        `key` - Key string
        `min` - Pattern defining a minimum value
        `max` - Pattern defining a maximum value
        `handler` -
      Returns:

    - #### zrevrange

          public RedisClient zrevrange(String key,
                                       long start,
                                       long stop,
                                       RangeOptions options,
                                       Handler<AsyncResult<JsonArray>> handler)

      Return a range of members in a sorted set, by index, with scores ordered from high to low
      Parameters:
        `key` - Key string
        `start` - Start index for the range
        `stop` - Stop index for the range - inclusive
        `options` - Range options
        `handler` - Handler for the result of this call.
      Returns:

    - #### zrevrangebylex

          public RedisClient zrevrangebylex(String key,
                                            String max,
                                            String min,
                                            LimitOptions options,
                                            Handler<AsyncResult<JsonArray>> handler)

      Return a range of members in a sorted set, by score, between the given lexicographical range with scores ordered from high to low
      Parameters:
        `key` - Key string
        `max` - Pattern defining a maximum value
        `min` - Pattern defining a minimum value
        `options` - Limit options
        `handler` - Handler for the result of this call.
      Returns:

    - #### zrevrangebyscore

          public RedisClient zrevrangebyscore(String key,
                                              String max,
                                              String min,
                                              RangeLimitOptions options,
                                              Handler<AsyncResult<JsonArray>> handler)

      Return a range of members in a sorted set, by score, with scores ordered from high to low
      Parameters:
        `key` - Key string
        `max` - Pattern defining a maximum value
        `min` - Pattern defining a minimum value
        `options` - Range and limit options
        `handler` - Handler for the result of this call.
      Returns:

    - #### zrevrank

          public RedisClient zrevrank(String key,
                                      String member,
                                      Handler<AsyncResult<Long>> handler)

      Determine the index of a member in a sorted set, with scores ordered from high to low
      Parameters:
        `key` - Key string
        `member` - Member in the sorted set identified by key
        `handler` - Handler for the result of this call.
      Returns:

    - #### zscore

          public RedisClient zscore(String key,
                                    String member,
                                    Handler<AsyncResult<String>> handler)

      Get the score associated with the given member in a sorted set
      Parameters:
        `key` - Key string
        `member` - Member in the sorted set identified by key
        `handler` - Handler for the result of this call.
      Returns:

    - #### zunionstore

          public RedisClient zunionstore(String destkey,
                                         List<String> sets,
                                         AggregateOptions options,
                                         Handler<AsyncResult<Long>> handler)

      Add multiple sorted sets and store the resulting sorted set in a new key
      Parameters:
        `destkey` - Destination key
        `sets` - List of keys identifying sorted sets
        `options` - Aggregation options
        `handler` - Handler for the result of this call.
      Returns:

    - #### zunionstoreWeighed

          public RedisClient zunionstoreWeighed(String key,
                                                Map<String,Double> sets,
                                                AggregateOptions options,
                                                Handler<AsyncResult<Long>> handler)

      Add multiple sorted sets using weights, and store the resulting sorted set in a new key
      Parameters:
        `key` - Destination key
        `sets` - Map containing set-key:weight pairs
        `options` - Aggregation options
        `handler` - Handler for the result of this call.
      Returns:

    - #### scan

          public RedisClient scan(String cursor,
                                  ScanOptions options,
                                  Handler<AsyncResult<Void>> handler)

      Incrementally iterate the keys space
      Parameters:
        `cursor` - Cursor id
        `options` - Scan options
        `handler` - Handler for the result of this call.
      Returns:

    - #### sscan

          public RedisClient sscan(String key,
                                   String cursor,
                                   ScanOptions options,
                                   Handler<AsyncResult<Void>> handler)

      Incrementally iterate Set elements
      Parameters:
        `key` - Key string
        `cursor` - Cursor id
        `options` - Scan options
        `handler` - Handler for the result of this call.
      Returns:

    - #### hscan

          public RedisClient hscan(String key,
                                   String cursor,
                                   ScanOptions options,
                                   Handler<AsyncResult<JsonArray>> handler)

      Incrementally iterate hash fields and associated values
      Parameters:
        `key` - Key string
        `cursor` - Cursor id
        `options` - Scan options
        `handler` - Handler for the result of this call.
      Returns:

    - #### zscan

          public RedisClient zscan(String key,
                                   String cursor,
                                   ScanOptions options,
                                   Handler<AsyncResult<Void>> handler)

      Incrementally iterate sorted sets elements and associated scores
      Parameters:
        `key` - Key string
        `cursor` - Cursor id
        `options` - Scan options
        `handler` - Handler for the result of this call.
      Returns:

    - #### newInstance

          public static RedisClient newInstance(RedisClient arg)

Copyright © 2015. All Rights Reserved.