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
    `Observable<Long>` | `appendObservable(String key, String value)` Append a value to a key
    `RedisClient` | `auth(String password, Handler<AsyncResult<String>> handler)` Authenticate to the server
    `Observable<String>` | `authObservable(String password)` Authenticate to the server
    `RedisClient` | `bgrewriteaof(Handler<AsyncResult<String>> handler)` Asynchronously rewrite the append-only file
    `Observable<String>` | `bgrewriteaofObservable()` Asynchronously rewrite the append-only file
    `RedisClient` | `bgsave(Handler<AsyncResult<String>> handler)` Asynchronously save the dataset to disk
    `Observable<String>` | `bgsaveObservable()` Asynchronously save the dataset to disk
    `RedisClient` | `bitcount(String key, Handler<AsyncResult<Long>> handler)` Count set bits in a string
    `Observable<Long>` | `bitcountObservable(String key)` Count set bits in a string
    `RedisClient` | `bitcountRange(String key, long start, long end, Handler<AsyncResult<Long>> handler)` Count set bits in a string
    `Observable<Long>` | `bitcountRangeObservable(String key, long start, long end)` Count set bits in a string
    `RedisClient` | `bitop(BitOperation operation, String destkey, List<String> keys, Handler<AsyncResult<Long>> handler)` Perform bitwise operations between strings
    `Observable<Long>` | `bitopObservable(BitOperation operation, String destkey, List<String> keys)` 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.
    `Observable<Long>` | `bitposFromObservable(String key, int bit, int start)` Find first bit set or clear in a string See also bitposRange() method, which takes start, and stop offset.
    `Observable<Long>` | `bitposObservable(String key, int bit)` Find first bit set or clear in a string
    `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
    `Observable<Long>` | `bitposRangeObservable(String key, int bit, int start, int stop)` 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
    `Observable<JsonArray>` | `blpopManyObservable(List<String> keys, int seconds)` Remove and get the first element in any of the lists, or block until one is available
    `Observable<JsonArray>` | `blpopObservable(String key, int seconds)` Remove and get the first element in a list, 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<String>> handler)` Pop a value from a list, push it to another list and return it; or block until one is available
    `Observable<String>` | `brpoplpushObservable(String key, String destkey, int seconds)` 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
    `Observable<JsonArray>` | `brpopManyObservable(List<String> keys, int seconds)` Remove and get the last element in any of the lists, or block until one is available
    `Observable<JsonArray>` | `brpopObservable(String key, int seconds)` Remove and get the last element in a list, or block until one is available
    `RedisClient` | `clientGetname(Handler<AsyncResult<String>> handler)` Get the current connection name
    `Observable<String>` | `clientGetnameObservable()` Get the current connection name
    `RedisClient` | `clientKill(KillFilter filter, Handler<AsyncResult<Long>> handler)` Kill the connection of a client
    `Observable<Long>` | `clientKillObservable(KillFilter filter)` Kill the connection of a client
    `RedisClient` | `clientList(Handler<AsyncResult<String>> handler)` Get the list of client connections
    `Observable<String>` | `clientListObservable()` Get the list of client connections
    `RedisClient` | `clientPause(long millis, Handler<AsyncResult<String>> handler)` Stop processing commands from clients for some time
    `Observable<String>` | `clientPauseObservable(long millis)` Stop processing commands from clients for some time
    `RedisClient` | `clientSetname(String name, Handler<AsyncResult<String>> handler)` Set the current connection name
    `Observable<String>` | `clientSetnameObservable(String name)` Set the current connection name
    `void` | `close(Handler<AsyncResult<Void>> handler)` Close the client - when it is fully closed the handler will be called.
    `Observable<Void>` | `closeObservable()` Close the client - when it is fully closed the handler will be called.
    `RedisClient` | `clusterAddslots(List<Long> slots, Handler<AsyncResult<Void>> handler)` Assign new hash slots to receiving node.
    `Observable<Void>` | `clusterAddslotsObservable(List<Long> slots)` Assign new hash slots to receiving node.
    `RedisClient` | `clusterCountFailureReports(String nodeId, Handler<AsyncResult<Long>> handler)` Return the number of failure reports active for a given node.
    `Observable<Long>` | `clusterCountFailureReportsObservable(String nodeId)` Return the number of failure reports active for a given node.
    `RedisClient` | `clusterCountkeysinslot(long slot, Handler<AsyncResult<Long>> handler)` Return the number of local keys in the specified hash slot.
    `Observable<Long>` | `clusterCountkeysinslotObservable(long slot)` Return the number of local keys in the specified hash slot.
    `RedisClient` | `clusterDelslots(long slot, Handler<AsyncResult<Void>> handler)` Set hash slots as unbound in receiving node.
    `RedisClient` | `clusterDelslotsMany(List<Long> slots, Handler<AsyncResult<Void>> handler)` Set hash slots as unbound in receiving node.
    `Observable<Void>` | `clusterDelslotsManyObservable(List<Long> slots)` Set hash slots as unbound in receiving node.
    `Observable<Void>` | `clusterDelslotsObservable(long slot)` Set hash slots as unbound in receiving node.
    `RedisClient` | `clusterFailover(Handler<AsyncResult<Void>> handler)` Forces a slave to perform a manual failover of its master.
    `Observable<Void>` | `clusterFailoverObservable()` Forces a slave to perform a manual failover of its master.
    `RedisClient` | `clusterFailOverWithOptions(FailoverOptions options, Handler<AsyncResult<Void>> handler)` Forces a slave to perform a manual failover of its master.
    `Observable<Void>` | `clusterFailOverWithOptionsObservable(FailoverOptions options)` Forces a slave to perform a manual failover of its master.
    `RedisClient` | `clusterForget(String nodeId, Handler<AsyncResult<Void>> handler)` Remove a node from the nodes table.
    `Observable<Void>` | `clusterForgetObservable(String nodeId)` Remove a node from the nodes table.
    `RedisClient` | `clusterGetkeysinslot(long slot, long count, Handler<AsyncResult<JsonArray>> handler)` Return local key names in the specified hash slot.
    `Observable<JsonArray>` | `clusterGetkeysinslotObservable(long slot, long count)` Return local key names in the specified hash slot.
    `RedisClient` | `clusterInfo(Handler<AsyncResult<JsonArray>> handler)` Provides info about Redis Cluster node state.
    `Observable<JsonArray>` | `clusterInfoObservable()` Provides info about Redis Cluster node state.
    `RedisClient` | `clusterKeyslot(String key, Handler<AsyncResult<Long>> handler)` Returns the hash slot of the specified key.
    `Observable<Long>` | `clusterKeyslotObservable(String key)` Returns the hash slot of the specified key.
    `RedisClient` | `clusterMeet(String ip, long port, Handler<AsyncResult<Void>> handler)` Force a node cluster to handshake with another node.
    `Observable<Void>` | `clusterMeetObservable(String ip, long port)` Force a node cluster to handshake with another node.
    `RedisClient` | `clusterNodes(Handler<AsyncResult<JsonArray>> handler)` Get Cluster config for the node.
    `Observable<JsonArray>` | `clusterNodesObservable()` Get Cluster config for the node.
    `RedisClient` | `clusterReplicate(String nodeId, Handler<AsyncResult<Void>> handler)` Reconfigure a node as a slave of the specified master node.
    `Observable<Void>` | `clusterReplicateObservable(String nodeId)` Reconfigure a node as a slave of the specified master node.
    `RedisClient` | `clusterReset(Handler<AsyncResult<Void>> handler)` Reset a Redis Cluster node.
    `Observable<Void>` | `clusterResetObservable()` Reset a Redis Cluster node.
    `RedisClient` | `clusterResetWithOptions(ResetOptions options, Handler<AsyncResult<Void>> handler)` Reset a Redis Cluster node.
    `Observable<Void>` | `clusterResetWithOptionsObservable(ResetOptions options)` Reset a Redis Cluster node.
    `RedisClient` | `clusterSaveconfig(Handler<AsyncResult<Void>> handler)` Forces the node to save cluster state on disk.
    `Observable<Void>` | `clusterSaveconfigObservable()` Forces the node to save cluster state on disk.
    `RedisClient` | `clusterSetConfigEpoch(long epoch, Handler<AsyncResult<Void>> handler)` Set the configuration epoch in a new node.
    `Observable<Void>` | `clusterSetConfigEpochObservable(long epoch)` Set the configuration epoch in a new node.
    `RedisClient` | `clusterSetslot(long slot, SlotCmd subcommand, Handler<AsyncResult<Void>> handler)` Bind an hash slot to a specific node.
    `Observable<Void>` | `clusterSetslotObservable(long slot, SlotCmd subcommand)` Bind an hash slot to a specific node.
    `RedisClient` | `clusterSetslotWithNode(long slot, SlotCmd subcommand, String nodeId, Handler<AsyncResult<Void>> handler)` Bind an hash slot to a specific node.
    `Observable<Void>` | `clusterSetslotWithNodeObservable(long slot, SlotCmd subcommand, String nodeId)` Bind an hash slot to a specific node.
    `RedisClient` | `clusterSlaves(String nodeId, Handler<AsyncResult<JsonArray>> handler)` List slave nodes of the specified master node.
    `Observable<JsonArray>` | `clusterSlavesObservable(String nodeId)` List slave nodes of the specified master node.
    `RedisClient` | `clusterSlots(Handler<AsyncResult<JsonArray>> handler)` Get array of Cluster slot to node mappings
    `Observable<JsonArray>` | `clusterSlotsObservable()` 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
    `Observable<Long>` | `commandCountObservable()` Get total number of Redis commands
    `RedisClient` | `commandGetkeys(Handler<AsyncResult<JsonArray>> handler)` Extract keys given a full Redis command
    `Observable<JsonArray>` | `commandGetkeysObservable()` Extract keys given a full Redis command
    `RedisClient` | `commandInfo(List<String> commands, Handler<AsyncResult<JsonArray>> handler)` Get array of specific Redis command details
    `Observable<JsonArray>` | `commandInfoObservable(List<String> commands)` Get array of specific Redis command details
    `Observable<JsonArray>` | `commandObservable()` Get array of Redis command details
    `RedisClient` | `configGet(String parameter, Handler<AsyncResult<JsonArray>> handler)` Get the value of a configuration parameter
    `Observable<JsonArray>` | `configGetObservable(String parameter)` Get the value of a configuration parameter
    `RedisClient` | `configResetstat(Handler<AsyncResult<String>> handler)` Reset the stats returned by INFO
    `Observable<String>` | `configResetstatObservable()` Reset the stats returned by INFO
    `RedisClient` | `configRewrite(Handler<AsyncResult<String>> handler)` Rewrite the configuration file with the in memory configuration
    `Observable<String>` | `configRewriteObservable()` 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
    `Observable<String>` | `configSetObservable(String parameter, String value)` Set a configuration parameter to the given value
    `static RedisClient` | `create(Vertx vertx)`
    `static RedisClient` | `create(Vertx vertx, RedisOptions config)`
    `RedisClient` | `dbsize(Handler<AsyncResult<Long>> handler)` Return the number of keys in the selected database
    `Observable<Long>` | `dbsizeObservable()` Return the number of keys in the selected database
    `RedisClient` | `debugObject(String key, Handler<AsyncResult<String>> handler)` Get debugging information about a key
    `Observable<String>` | `debugObjectObservable(String key)` Get debugging information about a key
    `RedisClient` | `debugSegfault(Handler<AsyncResult<String>> handler)` Make the server crash
    `Observable<String>` | `debugSegfaultObservable()` 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
    `Observable<Long>` | `decrbyObservable(String key, long decrement)` Decrement the integer value of a key by the given number
    `Observable<Long>` | `decrObservable(String key)` Decrement the integer value of a key by one
    `RedisClient` | `del(String key, Handler<AsyncResult<Long>> handler)` Delete a key
    `RedisClient` | `delMany(List<String> keys, Handler<AsyncResult<Long>> handler)` Delete many keys
    `Observable<Long>` | `delManyObservable(List<String> keys)` Delete many keys
    `Observable<Long>` | `delObservable(String key)` Delete a key
    `RedisClient` | `dump(String key, Handler<AsyncResult<String>> handler)` Return a serialized version of the value stored at the specified key.
    `Observable<String>` | `dumpObservable(String key)` Return a serialized version of the value stored at the specified key.
    `RedisClient` | `echo(String message, Handler<AsyncResult<String>> handler)` Echo the given string
    `Observable<String>` | `echoObservable(String message)` Echo the given string
    `RedisClient` | `eval(String script, List<String> keys, List<String> args, Handler<AsyncResult<JsonArray>> handler)` Execute a Lua script server side.
    `Observable<JsonArray>` | `evalObservable(String script, List<String> keys, List<String> args)` Execute a Lua script server side.
    `RedisClient` | `evalsha(String sha1, List<String> keys, List<String> values, Handler<AsyncResult<JsonArray>> handler)` Execute a Lua script server side.
    `Observable<JsonArray>` | `evalshaObservable(String sha1, List<String> keys, List<String> values)` Execute a Lua script server side.
    `RedisClient` | `exists(String key, Handler<AsyncResult<Long>> handler)` Determine if a key exists
    `Observable<Long>` | `existsObservable(String key)` 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
    `Observable<Long>` | `expireatObservable(String key, long seconds)` Set the expiration for a key as a UNIX timestamp
    `Observable<Long>` | `expireObservable(String key, int seconds)` Set a key's time to live in seconds
    `RedisClient` | `flushall(Handler<AsyncResult<String>> handler)` Remove all keys from all databases
    `Observable<String>` | `flushallObservable()` Remove all keys from all databases
    `RedisClient` | `flushdb(Handler<AsyncResult<String>> handler)` Remove all keys from the current database
    `Observable<String>` | `flushdbObservable()` Remove all keys from the current database
    `RedisClient` | `geoadd(String key, double longitude, double latitude, String member, Handler<AsyncResult<Long>> handler)` Add one or more geospatial items in the geospatial index represented using a sorted set.
    `RedisClient` | `geoaddMany(String key, List<GeoMember> members, Handler<AsyncResult<Long>> handler)` Add one or more geospatial items in the geospatial index represented using a sorted set.
    `Observable<Long>` | `geoaddManyObservable(String key, List<GeoMember> members)` Add one or more geospatial items in the geospatial index represented using a sorted set.
    `Observable<Long>` | `geoaddObservable(String key, double longitude, double latitude, String member)` Add one or more geospatial items in the geospatial index represented using a sorted set.
    `RedisClient` | `geodist(String key, String member1, String member2, Handler<AsyncResult<String>> handler)` Return the distance between two members in the geospatial index represented by the sorted set.
    `Observable<String>` | `geodistObservable(String key, String member1, String member2)` Return the distance between two members in the geospatial index represented by the sorted set.
    `RedisClient` | `geodistWithUnit(String key, String member1, String member2, GeoUnit unit, Handler<AsyncResult<String>> handler)` Return the distance between two members in the geospatial index represented by the sorted set.
    `Observable<String>` | `geodistWithUnitObservable(String key, String member1, String member2, GeoUnit unit)` Return the distance between two members in the geospatial index represented by the sorted set.
    `RedisClient` | `geohash(String key, String member, Handler<AsyncResult<JsonArray>> handler)` Return valid Geohash strings representing the position of one or more elements in a sorted set value representing a geospatial index (where elements were added using GEOADD).
    `RedisClient` | `geohashMany(String key, List<String> members, Handler<AsyncResult<JsonArray>> handler)` Return valid Geohash strings representing the position of one or more elements in a sorted set value representing a geospatial index (where elements were added using GEOADD).
    `Observable<JsonArray>` | `geohashManyObservable(String key, List<String> members)` Return valid Geohash strings representing the position of one or more elements in a sorted set value representing a geospatial index (where elements were added using GEOADD).
    `Observable<JsonArray>` | `geohashObservable(String key, String member)` Return valid Geohash strings representing the position of one or more elements in a sorted set value representing a geospatial index (where elements were added using GEOADD).
    `RedisClient` | `geopos(String key, String member, Handler<AsyncResult<JsonArray>> handler)` Return the positions (longitude,latitude) of all the specified members of the geospatial index represented by the sorted set at key.
    `RedisClient` | `geoposMany(String key, List<String> members, Handler<AsyncResult<JsonArray>> handler)` Return the positions (longitude,latitude) of all the specified members of the geospatial index represented by the sorted set at key.
    `Observable<JsonArray>` | `geoposManyObservable(String key, List<String> members)` Return the positions (longitude,latitude) of all the specified members of the geospatial index represented by the sorted set at key.
    `Observable<JsonArray>` | `geoposObservable(String key, String member)` Return the positions (longitude,latitude) of all the specified members of the geospatial index represented by the sorted set at key.
    `RedisClient` | `georadius(String key, double longitude, double latitude, double radius, GeoUnit unit, Handler<AsyncResult<JsonArray>> handler)` Return the members of a sorted set populated with geospatial information using GEOADD, which are within the borders of the area specified with the center location and the maximum distance from the center (the radius).
    `RedisClient` | `georadiusbymember(String key, String member, double radius, GeoUnit unit, Handler<AsyncResult<JsonArray>> handler)` This command is exactly like GEORADIUS with the sole difference that instead of taking, as the center of the area to query, a longitude and latitude value, it takes the name of a member already existing inside the geospatial index represented by the sorted set.
    `Observable<JsonArray>` | `georadiusbymemberObservable(String key, String member, double radius, GeoUnit unit)` This command is exactly like GEORADIUS with the sole difference that instead of taking, as the center of the area to query, a longitude and latitude value, it takes the name of a member already existing inside the geospatial index represented by the sorted set.
    `RedisClient` | `georadiusbymemberWithOptions(String key, String member, double radius, GeoUnit unit, GeoRadiusOptions options, Handler<AsyncResult<JsonArray>> handler)` This command is exactly like GEORADIUS with the sole difference that instead of taking, as the center of the area to query, a longitude and latitude value, it takes the name of a member already existing inside the geospatial index represented by the sorted set.
    `Observable<JsonArray>` | `georadiusbymemberWithOptionsObservable(String key, String member, double radius, GeoUnit unit, GeoRadiusOptions options)` This command is exactly like GEORADIUS with the sole difference that instead of taking, as the center of the area to query, a longitude and latitude value, it takes the name of a member already existing inside the geospatial index represented by the sorted set.
    `Observable<JsonArray>` | `georadiusObservable(String key, double longitude, double latitude, double radius, GeoUnit unit)` Return the members of a sorted set populated with geospatial information using GEOADD, which are within the borders of the area specified with the center location and the maximum distance from the center (the radius).
    `RedisClient` | `georadiusWithOptions(String key, double longitude, double latitude, double radius, GeoUnit unit, GeoRadiusOptions options, Handler<AsyncResult<JsonArray>> handler)` Return the members of a sorted set populated with geospatial information using GEOADD, which are within the borders of the area specified with the center location and the maximum distance from the center (the radius).
    `Observable<JsonArray>` | `georadiusWithOptionsObservable(String key, double longitude, double latitude, double radius, GeoUnit unit, GeoRadiusOptions options)` Return the members of a sorted set populated with geospatial information using GEOADD, which are within the borders of the area specified with the center location and the maximum distance from the center (the radius).
    `RedisClient` | `get(String key, Handler<AsyncResult<String>> handler)` Get the value of a key
    `RedisClient` | `getBinary(String key, Handler<AsyncResult<Buffer>> handler)` Get the value of a key - without decoding as utf-8
    `Observable<Buffer>` | `getBinaryObservable(String key)` 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
    `Observable<Long>` | `getbitObservable(String key, long offset)` Returns the bit value at offset in the string value stored at key
    `Object` | `getDelegate()`
    `Observable<String>` | `getObservable(String key)` Get the value of a key
    `RedisClient` | `getrange(String key, long start, long end, Handler<AsyncResult<String>> handler)` Get a substring of the string stored at a key
    `Observable<String>` | `getrangeObservable(String key, long start, long end)` 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
    `Observable<String>` | `getsetObservable(String key, String value)` 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
    `Observable<Long>` | `hdelManyObservable(String key, List<String> fields)` Delete one or more hash fields
    `Observable<Long>` | `hdelObservable(String key, String field)` Delete one or more hash fields
    `RedisClient` | `hexists(String key, String field, Handler<AsyncResult<Long>> handler)` Determine if a hash field exists
    `Observable<Long>` | `hexistsObservable(String key, String field)` 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
    `Observable<JsonObject>` | `hgetallObservable(String key)` Get all the fields and values in a hash
    `Observable<String>` | `hgetObservable(String key, String field)` Get the value of a hash field
    `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
    `Observable<String>` | `hincrbyfloatObservable(String key, String field, double increment)` Increment the float value of a hash field by the given amount
    `Observable<Long>` | `hincrbyObservable(String key, String field, long increment)` Increment the integer value of a hash field by the given number
    `RedisClient` | `hkeys(String key, Handler<AsyncResult<JsonArray>> handler)` Get all the fields in a hash
    `Observable<JsonArray>` | `hkeysObservable(String key)` Get all the fields in a hash
    `RedisClient` | `hlen(String key, Handler<AsyncResult<Long>> handler)` Get the number of fields in a hash
    `Observable<Long>` | `hlenObservable(String key)` 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
    `Observable<JsonArray>` | `hmgetObservable(String key, List<String> fields)` Get the values of all the given hash fields
    `RedisClient` | `hmset(String key, JsonObject values, Handler<AsyncResult<String>> handler)` Set multiple hash fields to multiple values
    `Observable<String>` | `hmsetObservable(String key, JsonObject values)` 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
    `Observable<JsonArray>` | `hscanObservable(String key, String cursor, ScanOptions options)` 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
    `Observable<Long>` | `hsetnxObservable(String key, String field, String value)` Set the value of a hash field, only if the field does not exist
    `Observable<Long>` | `hsetObservable(String key, String field, String value)` Set the string value of a hash field
    `RedisClient` | `hvals(String key, Handler<AsyncResult<JsonArray>> handler)` Get all the values in a hash
    `Observable<JsonArray>` | `hvalsObservable(String key)` 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
    `Observable<String>` | `incrbyfloatObservable(String key, double increment)` Increment the float value of a key by the given amount
    `Observable<Long>` | `incrbyObservable(String key, long increment)` Increment the integer value of a key by the given amount
    `Observable<Long>` | `incrObservable(String key)` Increment the integer value of a key by one
    `RedisClient` | `info(Handler<AsyncResult<JsonObject>> handler)` Get information and statistics about the server
    `Observable<JsonObject>` | `infoObservable()` Get information and statistics about the server
    `RedisClient` | `infoSection(String section, Handler<AsyncResult<JsonObject>> handler)` Get information and statistics about the server
    `Observable<JsonObject>` | `infoSectionObservable(String section)` Get information and statistics about the server
    `RedisClient` | `keys(String pattern, Handler<AsyncResult<JsonArray>> handler)` Find all keys matching the given pattern
    `Observable<JsonArray>` | `keysObservable(String pattern)` 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
    `Observable<Long>` | `lastsaveObservable()` 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
    `Observable<String>` | `lindexObservable(String key, int index)` 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
    `Observable<Long>` | `linsertObservable(String key, InsertOptions option, String pivot, String value)` 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
    `Observable<Long>` | `llenObservable(String key)` Get the length of a list
    `RedisClient` | `lpop(String key, Handler<AsyncResult<String>> handler)` Remove and get the first element in a list
    `Observable<String>` | `lpopObservable(String key)` 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
    `Observable<Long>` | `lpushManyObservable(String key, List<String> values)` Prepend one or multiple values to a list
    `Observable<Long>` | `lpushObservable(String key, String value)` Prepend one value to a list
    `RedisClient` | `lpushx(String key, String value, Handler<AsyncResult<Long>> handler)` Prepend a value to a list, only if the list exists
    `Observable<Long>` | `lpushxObservable(String key, String value)` 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
    `Observable<JsonArray>` | `lrangeObservable(String key, long from, long to)` 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
    `Observable<Long>` | `lremObservable(String key, long count, String value)` 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
    `Observable<String>` | `lsetObservable(String key, long index, String value)` 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
    `Observable<String>` | `ltrimObservable(String key, long from, long to)` 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
    `Observable<JsonArray>` | `mgetManyObservable(List<String> keys)` Get the values of all the given keys
    `Observable<JsonArray>` | `mgetObservable(String key)` Get the value of the given key
    `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.
    `Observable<String>` | `migrateObservable(String host, int port, String key, int destdb, long timeout, MigrateOptions options)` 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
    `Observable<Void>` | `monitorObservable()` 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
    `Observable<Long>` | `moveObservable(String key, int destdb)` Move a key to another database
    `RedisClient` | `mset(JsonObject keyvals, Handler<AsyncResult<String>> handler)` Set multiple keys to multiple values
    `RedisClient` | `msetnx(JsonObject keyvals, Handler<AsyncResult<Long>> handler)` Set multiple keys to multiple values, only if none of the keys exist
    `Observable<Long>` | `msetnxObservable(JsonObject keyvals)` Set multiple keys to multiple values, only if none of the keys exist
    `Observable<String>` | `msetObservable(JsonObject keyvals)` Set multiple keys to multiple values
    `static RedisClient` | `newInstance(RedisClient arg)`
    `RedisClient` | `object(String key, ObjectCmd cmd, Handler<AsyncResult<Void>> handler)` Inspect the internals of Redis objects
    `Observable<Void>` | `objectObservable(String key, ObjectCmd cmd)` Inspect the internals of Redis objects
    `RedisClient` | `persist(String key, Handler<AsyncResult<Long>> handler)` Remove the expiration from a key
    `Observable<Long>` | `persistObservable(String key)` 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
    `Observable<Long>` | `pexpireatObservable(String key, long millis)` Set the expiration for a key as a UNIX timestamp specified in milliseconds
    `Observable<Long>` | `pexpireObservable(String key, long millis)` Set a key's time to live 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.
    `Observable<Long>` | `pfaddManyObservable(String key, List<String> elements)` Adds the specified elements to the specified HyperLogLog.
    `Observable<Long>` | `pfaddObservable(String key, String element)` Adds the specified element 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).
    `Observable<Long>` | `pfcountManyObservable(List<String> keys)` Return the approximated cardinality of the set(s) observed by the HyperLogLog at key(s).
    `Observable<Long>` | `pfcountObservable(String key)` Return the approximated cardinality of the set observed by the HyperLogLog at key.
    `RedisClient` | `pfmerge(String destkey, List<String> keys, Handler<AsyncResult<String>> handler)` Merge N different HyperLogLogs into a single one.
    `Observable<String>` | `pfmergeObservable(String destkey, List<String> keys)` Merge N different HyperLogLogs into a single one.
    `RedisClient` | `ping(Handler<AsyncResult<String>> handler)` Ping the server
    `Observable<String>` | `pingObservable()` 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
    `Observable<Void>` | `psetexObservable(String key, long millis, String value)` Set the value and expiration in milliseconds of a key
    `RedisClient` | `psubscribe(String pattern, Handler<AsyncResult<JsonArray>> handler)` Listen for messages published to channels matching the given pattern
    `RedisClient` | `psubscribeMany(List<String> patterns, Handler<AsyncResult<JsonArray>> handler)` Listen for messages published to channels matching the given patterns
    `Observable<JsonArray>` | `psubscribeManyObservable(List<String> patterns)` Listen for messages published to channels matching the given patterns
    `Observable<JsonArray>` | `psubscribeObservable(String pattern)` Listen for messages published to channels matching the given pattern
    `RedisClient` | `pttl(String key, Handler<AsyncResult<Long>> handler)` Get the time to live for a key in milliseconds
    `Observable<Long>` | `pttlObservable(String key)` 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
    `Observable<Long>` | `publishObservable(String channel, String message)` Post a message to a channel
    `RedisClient` | `pubsubChannels(String pattern, Handler<AsyncResult<JsonArray>> handler)` Lists the currently active channels - only those matching the pattern
    `Observable<JsonArray>` | `pubsubChannelsObservable(String pattern)` 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)
    `Observable<Long>` | `pubsubNumpatObservable()` 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
    `Observable<JsonArray>` | `pubsubNumsubObservable(List<String> channels)` 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
    `Observable<Void>` | `punsubscribeObservable(List<String> patterns)` Stop listening for messages posted to channels matching the given patterns
    `RedisClient` | `randomkey(Handler<AsyncResult<String>> handler)` Return a random key from the keyspace
    `Observable<String>` | `randomkeyObservable()` 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
    `Observable<Long>` | `renamenxObservable(String key, String newkey)` Rename a key, only if the new key does not exist
    `Observable<String>` | `renameObservable(String key, String newkey)` Rename a key
    `RedisClient` | `restore(String key, long millis, String serialized, Handler<AsyncResult<String>> handler)` Create a key using the provided serialized value, previously obtained using DUMP.
    `Observable<String>` | `restoreObservable(String key, long millis, String serialized)` 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
    `Observable<JsonArray>` | `roleObservable()` 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
    `Observable<String>` | `rpoplpushObservable(String key, String destkey)` Remove the last element in a list, append it to another list and return it
    `Observable<String>` | `rpopObservable(String key)` Remove and get the last element in a list
    `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
    `Observable<Long>` | `rpushManyObservable(String key, List<String> values)` Append one or multiple values to a list
    `Observable<Long>` | `rpushObservable(String key, String value)` 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
    `Observable<Long>` | `rpushxObservable(String key, String value)` 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
    `Observable<Long>` | `saddManyObservable(String key, List<String> members)` Add one or more members to a set
    `Observable<Long>` | `saddObservable(String key, String member)` Add a member to a set
    `RedisClient` | `save(Handler<AsyncResult<String>> handler)` Synchronously save the dataset to disk
    `Observable<String>` | `saveObservable()` Synchronously save the dataset to disk
    `RedisClient` | `scan(String cursor, ScanOptions options, Handler<AsyncResult<JsonArray>> handler)` Incrementally iterate the keys space
    `Observable<JsonArray>` | `scanObservable(String cursor, ScanOptions options)` Incrementally iterate the keys space
    `RedisClient` | `scard(String key, Handler<AsyncResult<Long>> handler)` Get the number of members in a set
    `Observable<Long>` | `scardObservable(String key)` 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.
    `Observable<JsonArray>` | `scriptExistsManyObservable(List<String> scripts)` Check existence of scripts in the script cache.
    `Observable<JsonArray>` | `scriptExistsObservable(String script)` Check existence of script in the script cache.
    `RedisClient` | `scriptFlush(Handler<AsyncResult<String>> handler)` Remove all the scripts from the script cache.
    `Observable<String>` | `scriptFlushObservable()` Remove all the scripts from the script cache.
    `RedisClient` | `scriptKill(Handler<AsyncResult<String>> handler)` Kill the script currently in execution.
    `Observable<String>` | `scriptKillObservable()` Kill the script currently in execution.
    `RedisClient` | `scriptLoad(String script, Handler<AsyncResult<String>> handler)` Load the specified Lua script into the script cache.
    `Observable<String>` | `scriptLoadObservable(String script)` Load the specified Lua script into the script cache.
    `RedisClient` | `sdiff(String key, List<String> cmpkeys, Handler<AsyncResult<JsonArray>> handler)` Subtract multiple sets
    `Observable<JsonArray>` | `sdiffObservable(String key, List<String> cmpkeys)` 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
    `Observable<Long>` | `sdiffstoreObservable(String destkey, String key, List<String> cmpkeys)` 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
    `Observable<String>` | `selectObservable(int dbindex)` 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, Buffer value, Handler<AsyncResult<Void>> handler)` Set the binary string value of a key - without encoding as utf-8
    `Observable<Void>` | `setBinaryObservable(String key, Buffer value)` Set the binary string value of a key - without encoding as utf-8
    `RedisClient` | `setBinaryWithOptions(String key, Buffer value, SetOptions options, Handler<AsyncResult<Void>> handler)` Set the string value of a key
    `Observable<Void>` | `setBinaryWithOptionsObservable(String key, Buffer value, SetOptions options)` Set the string value of a key
    `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
    `Observable<Long>` | `setbitObservable(String key, long offset, int bit)` 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
    `Observable<String>` | `setexObservable(String key, long seconds, String value)` 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
    `Observable<Long>` | `setnxObservable(String key, String value)` Set the value of a key, only if the key does not exist
    `Observable<Void>` | `setObservable(String key, String value)` Set the string value of a key
    `RedisClient` | `setrange(String key, int offset, String value, Handler<AsyncResult<Long>> handler)` Overwrite part of a string at key starting at the specified offset
    `Observable<Long>` | `setrangeObservable(String key, int offset, String value)` Overwrite part of a string at key starting at the specified offset
    `RedisClient` | `setWithOptions(String key, String value, SetOptions options, Handler<AsyncResult<String>> handler)` Set the string value of a key
    `Observable<String>` | `setWithOptionsObservable(String key, String value, SetOptions options)` Set the string value of a key
    `RedisClient` | `sinter(List<String> keys, Handler<AsyncResult<JsonArray>> handler)` Intersect multiple sets
    `Observable<JsonArray>` | `sinterObservable(List<String> keys)` 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
    `Observable<Long>` | `sinterstoreObservable(String destkey, List<String> keys)` 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
    `Observable<Long>` | `sismemberObservable(String key, String member)` 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
    `Observable<String>` | `slaveofNooneObservable()` Make this server a master
    `Observable<String>` | `slaveofObservable(String host, int port)` Make the server a slave of another instance
    `RedisClient` | `slowlogGet(int limit, Handler<AsyncResult<JsonArray>> handler)` Read the Redis slow queries log
    `Observable<JsonArray>` | `slowlogGetObservable(int limit)` Read the Redis slow queries log
    `RedisClient` | `slowlogLen(Handler<AsyncResult<Long>> handler)` Get the length of the Redis slow queries log
    `Observable<Long>` | `slowlogLenObservable()` Get the length of the Redis slow queries log
    `RedisClient` | `slowlogReset(Handler<AsyncResult<Void>> handler)` Reset the Redis slow queries log
    `Observable<Void>` | `slowlogResetObservable()` Reset the Redis slow queries log
    `RedisClient` | `smembers(String key, Handler<AsyncResult<JsonArray>> handler)` Get all the members in a set
    `Observable<JsonArray>` | `smembersObservable(String key)` 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
    `Observable<Long>` | `smoveObservable(String key, String destkey, String member)` 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
    `Observable<JsonArray>` | `sortObservable(String key, SortOptions options)` 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<JsonArray>> handler)` Remove and return random members from a set
    `Observable<JsonArray>` | `spopManyObservable(String key, int count)` Remove and return random members from a set
    `Observable<String>` | `spopObservable(String key)` Remove and return a random member from a set
    `RedisClient` | `srandmember(String key, Handler<AsyncResult<String>> handler)` Get one or multiple random members from a set
    `RedisClient` | `srandmemberCount(String key, int count, Handler<AsyncResult<JsonArray>> handler)` Get one or multiple random members from a set
    `Observable<JsonArray>` | `srandmemberCountObservable(String key, int count)` Get one or multiple random members from a set
    `Observable<String>` | `srandmemberObservable(String key)` 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
    `Observable<Long>` | `sremManyObservable(String key, List<String> members)` Remove one or more members from a set
    `Observable<Long>` | `sremObservable(String key, String member)` Remove one member from a set
    `RedisClient` | `sscan(String key, String cursor, ScanOptions options, Handler<AsyncResult<JsonArray>> handler)` Incrementally iterate Set elements
    `Observable<JsonArray>` | `sscanObservable(String key, String cursor, ScanOptions options)` Incrementally iterate Set elements
    `RedisClient` | `strlen(String key, Handler<AsyncResult<Long>> handler)` Get the length of the value stored in a key
    `Observable<Long>` | `strlenObservable(String key)` Get the length of the value stored in a key
    `RedisClient` | `subscribe(String channel, Handler<AsyncResult<JsonArray>> handler)` Listen for messages published to the given channels
    `RedisClient` | `subscribeMany(List<String> channels, Handler<AsyncResult<JsonArray>> handler)` Listen for messages published to the given channels
    `Observable<JsonArray>` | `subscribeManyObservable(List<String> channels)` Listen for messages published to the given channels
    `Observable<JsonArray>` | `subscribeObservable(String channel)` Listen for messages published to the given channels
    `RedisClient` | `sunion(List<String> keys, Handler<AsyncResult<JsonArray>> handler)` Add multiple sets
    `Observable<JsonArray>` | `sunionObservable(List<String> keys)` 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
    `Observable<Long>` | `sunionstoreObservable(String destkey, List<String> keys)` Add multiple sets and store the resulting set in a key
    `RedisClient` | `sync(Handler<AsyncResult<Void>> handler)` Internal command used for replication
    `Observable<Void>` | `syncObservable()` Internal command used for replication
    `RedisClient` | `time(Handler<AsyncResult<JsonArray>> handler)` Return the current server time
    `Observable<JsonArray>` | `timeObservable()` Return the current server time
    `RedisTransaction` | `transaction()` Return a RedisTransaction instance
    `RedisClient` | `ttl(String key, Handler<AsyncResult<Long>> handler)` Get the time to live for a key
    `Observable<Long>` | `ttlObservable(String key)` Get the time to live for a key
    `RedisClient` | `type(String key, Handler<AsyncResult<String>> handler)` Determine the type stored at key
    `Observable<String>` | `typeObservable(String key)` Determine the type stored at key
    `RedisClient` | `unsubscribe(List<String> channels, Handler<AsyncResult<Void>> handler)` Stop listening for messages posted to the given channels
    `Observable<Void>` | `unsubscribeObservable(List<String> channels)` Stop listening for messages posted to the given channels
    `RedisClient` | `wait(long numSlaves, long timeout, Handler<AsyncResult<String>> handler)` Wait for the synchronous replication of all the write commands sent in the context of the current connection.
    `Observable<String>` | `waitObservable(long numSlaves, long timeout)` Wait for the synchronous replication of all the write commands sent in the context of the current connection.
    `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
    `Observable<Long>` | `zaddManyObservable(String key, Map<String,Double> members)` Add one or more members to a sorted set, or update its score if it already exists
    `Observable<Long>` | `zaddObservable(String key, double score, String member)` 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
    `Observable<Long>` | `zcardObservable(String key)` 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
    `Observable<Long>` | `zcountObservable(String key, double min, double max)` 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
    `Observable<String>` | `zincrbyObservable(String key, double increment, String member)` 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
    `Observable<Long>` | `zinterstoreObservable(String destkey, List<String> sets, AggregateOptions options)` 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
    `Observable<Long>` | `zinterstoreWeighedObservable(String destkey, Map<String,Double> sets, AggregateOptions options)` 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
    `Observable<Long>` | `zlexcountObservable(String key, String min, String max)` 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
    `Observable<JsonArray>` | `zrangebylexObservable(String key, String min, String max, LimitOptions options)` 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
    `Observable<JsonArray>` | `zrangebyscoreObservable(String key, String min, String max, RangeLimitOptions options)` Return a range of members in a sorted set, by score
    `Observable<JsonArray>` | `zrangeObservable(String key, long start, long stop)` Return a range of members in a sorted set, by index
    `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
    `Observable<JsonArray>` | `zrangeWithOptionsObservable(String key, long start, long stop, RangeOptions options)` 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
    `Observable<Long>` | `zrankObservable(String key, String member)` 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
    `Observable<Long>` | `zremManyObservable(String key, List<String> members)` Remove one or more members from a sorted set
    `Observable<Long>` | `zremObservable(String key, String member)` Remove one member 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
    `Observable<Long>` | `zremrangebylexObservable(String key, String min, String max)` 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
    `Observable<Long>` | `zremrangebyrankObservable(String key, long start, long stop)` 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
    `Observable<Long>` | `zremrangebyscoreObservable(String key, String min, String max)` 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
    `Observable<JsonArray>` | `zrevrangebylexObservable(String key, String max, String min, LimitOptions options)` 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
    `Observable<JsonArray>` | `zrevrangebyscoreObservable(String key, String max, String min, RangeLimitOptions options)` Return a range of members in a sorted set, by score, with scores ordered from high to low
    `Observable<JsonArray>` | `zrevrangeObservable(String key, long start, long stop, RangeOptions options)` Return a range of members in a sorted set, by index, 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
    `Observable<Long>` | `zrevrankObservable(String key, String member)` 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<JsonArray>> handler)` Incrementally iterate sorted sets elements and associated scores
    `Observable<JsonArray>` | `zscanObservable(String key, String cursor, ScanOptions options)` 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
    `Observable<String>` | `zscoreObservable(String key, String member)` 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
    `Observable<Long>` | `zunionstoreObservable(String destkey, List<String> sets, AggregateOptions options)` 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
    `Observable<Long>` | `zunionstoreWeighedObservable(String key, Map<String,Double> sets, AggregateOptions options)` 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)

    - #### create

          public static RedisClient create(Vertx vertx,
                                           RedisOptions 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 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:

    - #### appendObservable

          public Observable<Long> appendObservable(String key,
                                                   String value)

      Append a value to a key
      Parameters:
        `key` - Key string
        `value` - Value to append
      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:

    - #### authObservable

          public Observable<String> authObservable(String password)

      Authenticate to the server
      Parameters:
        `password` - Password for authentication
      Returns:

    - #### bgrewriteaof

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

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

    - #### bgrewriteaofObservable

          public Observable<String> bgrewriteaofObservable()

      Asynchronously rewrite the append-only file
      Returns:

    - #### bgsave

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

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

    - #### bgsaveObservable

          public Observable<String> bgsaveObservable()

      Asynchronously save the dataset to disk
      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:

    - #### bitcountObservable

          public Observable<Long> bitcountObservable(String key)

      Count set bits in a string
      Parameters:
        `key` - Key string
      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:

    - #### bitcountRangeObservable

          public Observable<Long> bitcountRangeObservable(String key,
                                                          long start,
                                                          long end)

      Count set bits in a string
      Parameters:
        `key` - Key string
        `start` - Start index
        `end` - End index
      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:

    - #### bitopObservable

          public Observable<Long> bitopObservable(BitOperation operation,
                                                  String destkey,
                                                  List<String> keys)

      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
      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:

    - #### bitposObservable

          public Observable<Long> bitposObservable(String key,
                                                   int bit)

      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
      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:

    - #### bitposFromObservable

          public Observable<Long> bitposFromObservable(String key,
                                                       int bit,
                                                       int start)

      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
      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:

    - #### bitposRangeObservable

          public Observable<Long> bitposRangeObservable(String key,
                                                        int bit,
                                                        int start,
                                                        int stop)

      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
      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:

    - #### blpopObservable

          public Observable<JsonArray> blpopObservable(String key,
                                                       int seconds)

      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
      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:

    - #### blpopManyObservable

          public Observable<JsonArray> blpopManyObservable(List<String> keys,
                                                           int seconds)

      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
      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:

    - #### brpopObservable

          public Observable<JsonArray> brpopObservable(String key,
                                                       int seconds)

      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
      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:

    - #### brpopManyObservable

          public Observable<JsonArray> brpopManyObservable(List<String> keys,
                                                           int seconds)

      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
      Returns:

    - #### brpoplpush

          public RedisClient brpoplpush(String key,
                                        String destkey,
                                        int seconds,
                                        Handler<AsyncResult<String>> 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:

    - #### brpoplpushObservable

          public Observable<String> brpoplpushObservable(String key,
                                                         String destkey,
                                                         int seconds)

      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
      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:

    - #### clientKillObservable

          public Observable<Long> clientKillObservable(KillFilter filter)

      Kill the connection of a client
      Parameters:
        `filter` - Filter options
      Returns:

    - #### clientList

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

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

    - #### clientListObservable

          public Observable<String> clientListObservable()

      Get the list of client connections
      Returns:

    - #### clientGetname

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

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

    - #### clientGetnameObservable

          public Observable<String> clientGetnameObservable()

      Get the current connection name
      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:

    - #### clientPauseObservable

          public Observable<String> clientPauseObservable(long millis)

      Stop processing commands from clients for some time
      Parameters:
        `millis` - Pause time in milliseconds
      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:

    - #### clientSetnameObservable

          public Observable<String> clientSetnameObservable(String name)

      Set the current connection name
      Parameters:
        `name` - New name for current connection
      Returns:

    - #### clusterAddslots

          public RedisClient clusterAddslots(List<Long> slots,
                                             Handler<AsyncResult<Void>> handler)

      Assign new hash slots to receiving node.
      Parameters:
        `slots` -
        `handler` - Handler for the result of this call.
      Returns:

    - #### clusterAddslotsObservable

          public Observable<Void> clusterAddslotsObservable(List<Long> slots)

      Assign new hash slots to receiving node.
      Parameters:
        `slots` -
      Returns:

    - #### clusterCountFailureReports

          public RedisClient clusterCountFailureReports(String nodeId,
                                                        Handler<AsyncResult<Long>> handler)

      Return the number of failure reports active for a given node.
      Parameters:
        `nodeId` -
        `handler` - Handler for the result of this call.
      Returns:

    - #### clusterCountFailureReportsObservable

          public Observable<Long> clusterCountFailureReportsObservable(String nodeId)

      Return the number of failure reports active for a given node.
      Parameters:
        `nodeId` -
      Returns:

    - #### clusterCountkeysinslot

          public RedisClient clusterCountkeysinslot(long slot,
                                                    Handler<AsyncResult<Long>> handler)

      Return the number of local keys in the specified hash slot.
      Parameters:
        `slot` -
        `handler` - Handler for the result of this call.
      Returns:

    - #### clusterCountkeysinslotObservable

          public Observable<Long> clusterCountkeysinslotObservable(long slot)

      Return the number of local keys in the specified hash slot.
      Parameters:
        `slot` -
      Returns:

    - #### clusterDelslots

          public RedisClient clusterDelslots(long slot,
                                             Handler<AsyncResult<Void>> handler)

      Set hash slots as unbound in receiving node.
      Parameters:
        `slot` -
        `handler` - Handler for the result of this call.
      Returns:

    - #### clusterDelslotsObservable

          public Observable<Void> clusterDelslotsObservable(long slot)

      Set hash slots as unbound in receiving node.
      Parameters:
        `slot` -
      Returns:

    - #### clusterDelslotsMany

          public RedisClient clusterDelslotsMany(List<Long> slots,
                                                 Handler<AsyncResult<Void>> handler)

      Set hash slots as unbound in receiving node.
      Parameters:
        `slots` -
        `handler` - Handler for the result of this call.
      Returns:

    - #### clusterDelslotsManyObservable

          public Observable<Void> clusterDelslotsManyObservable(List<Long> slots)

      Set hash slots as unbound in receiving node.
      Parameters:
        `slots` -
      Returns:

    - #### clusterFailover

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

      Forces a slave to perform a manual failover of its master.
      Parameters:
        `handler` - Handler for the result of this call.
      Returns:

    - #### clusterFailoverObservable

          public Observable<Void> clusterFailoverObservable()

      Forces a slave to perform a manual failover of its master.
      Returns:

    - #### clusterFailOverWithOptions

          public RedisClient clusterFailOverWithOptions(FailoverOptions options,
                                                        Handler<AsyncResult<Void>> handler)

      Forces a slave to perform a manual failover of its master.
      Parameters:
        `options` -
        `handler` - Handler for the result of this call.
      Returns:

    - #### clusterFailOverWithOptionsObservable

          public Observable<Void> clusterFailOverWithOptionsObservable(FailoverOptions options)

      Forces a slave to perform a manual failover of its master.
      Parameters:
        `options` -
      Returns:

    - #### clusterForget

          public RedisClient clusterForget(String nodeId,
                                           Handler<AsyncResult<Void>> handler)

      Remove a node from the nodes table.
      Parameters:
        `nodeId` -
        `handler` - Handler for the result of this call.
      Returns:

    - #### clusterForgetObservable

          public Observable<Void> clusterForgetObservable(String nodeId)

      Remove a node from the nodes table.
      Parameters:
        `nodeId` -
      Returns:

    - #### clusterGetkeysinslot

          public RedisClient clusterGetkeysinslot(long slot,
                                                  long count,
                                                  Handler<AsyncResult<JsonArray>> handler)

      Return local key names in the specified hash slot.
      Parameters:
        `slot` -
        `count` -
        `handler` - Handler for the result of this call.
      Returns:

    - #### clusterGetkeysinslotObservable

          public Observable<JsonArray> clusterGetkeysinslotObservable(long slot,
                                                                      long count)

      Return local key names in the specified hash slot.
      Parameters:
        `slot` -
        `count` -
      Returns:

    - #### clusterInfo

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

      Provides info about Redis Cluster node state.
      Parameters:
        `handler` - Handler for the result of this call.
      Returns:

    - #### clusterInfoObservable

          public Observable<JsonArray> clusterInfoObservable()

      Provides info about Redis Cluster node state.
      Returns:

    - #### clusterKeyslot

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

      Returns the hash slot of the specified key.
      Parameters:
        `key` -
        `handler` - Handler for the result of this call.
      Returns:

    - #### clusterKeyslotObservable

          public Observable<Long> clusterKeyslotObservable(String key)

      Returns the hash slot of the specified key.
      Parameters:
        `key` -
      Returns:

    - #### clusterMeet

          public RedisClient clusterMeet(String ip,
                                         long port,
                                         Handler<AsyncResult<Void>> handler)

      Force a node cluster to handshake with another node.
      Parameters:
        `ip` -
        `port` -
        `handler` - Handler for the result of this call.
      Returns:

    - #### clusterMeetObservable

          public Observable<Void> clusterMeetObservable(String ip,
                                                        long port)

      Force a node cluster to handshake with another node.
      Parameters:
        `ip` -
        `port` -
      Returns:

    - #### clusterNodes

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

      Get Cluster config for the node.
      Parameters:
        `handler` - Handler for the result of this call.
      Returns:

    - #### clusterNodesObservable

          public Observable<JsonArray> clusterNodesObservable()

      Get Cluster config for the node.
      Returns:

    - #### clusterReplicate

          public RedisClient clusterReplicate(String nodeId,
                                              Handler<AsyncResult<Void>> handler)

      Reconfigure a node as a slave of the specified master node.
      Parameters:
        `nodeId` -
        `handler` - Handler for the result of this call.
      Returns:

    - #### clusterReplicateObservable

          public Observable<Void> clusterReplicateObservable(String nodeId)

      Reconfigure a node as a slave of the specified master node.
      Parameters:
        `nodeId` -
      Returns:

    - #### clusterReset

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

      Reset a Redis Cluster node.
      Parameters:
        `handler` - Handler for the result of this call.
      Returns:

    - #### clusterResetObservable

          public Observable<Void> clusterResetObservable()

      Reset a Redis Cluster node.
      Returns:

    - #### clusterResetWithOptions

          public RedisClient clusterResetWithOptions(ResetOptions options,
                                                     Handler<AsyncResult<Void>> handler)

      Reset a Redis Cluster node.
      Parameters:
        `options` -
        `handler` - Handler for the result of this call.
      Returns:

    - #### clusterResetWithOptionsObservable

          public Observable<Void> clusterResetWithOptionsObservable(ResetOptions options)

      Reset a Redis Cluster node.
      Parameters:
        `options` -
      Returns:

    - #### clusterSaveconfig

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

      Forces the node to save cluster state on disk.
      Parameters:
        `handler` - Handler for the result of this call.
      Returns:

    - #### clusterSaveconfigObservable

          public Observable<Void> clusterSaveconfigObservable()

      Forces the node to save cluster state on disk.
      Returns:

    - #### clusterSetConfigEpoch

          public RedisClient clusterSetConfigEpoch(long epoch,
                                                   Handler<AsyncResult<Void>> handler)

      Set the configuration epoch in a new node.
      Parameters:
        `epoch` -
        `handler` - Handler for the result of this call.
      Returns:

    - #### clusterSetConfigEpochObservable

          public Observable<Void> clusterSetConfigEpochObservable(long epoch)

      Set the configuration epoch in a new node.
      Parameters:
        `epoch` -
      Returns:

    - #### clusterSetslot

          public RedisClient clusterSetslot(long slot,
                                            SlotCmd subcommand,
                                            Handler<AsyncResult<Void>> handler)

      Bind an hash slot to a specific node.
      Parameters:
        `slot` -
        `subcommand` -
        `handler` - Handler for the result of this call.
      Returns:

    - #### clusterSetslotObservable

          public Observable<Void> clusterSetslotObservable(long slot,
                                                           SlotCmd subcommand)

      Bind an hash slot to a specific node.
      Parameters:
        `slot` -
        `subcommand` -
      Returns:

    - #### clusterSetslotWithNode

          public RedisClient clusterSetslotWithNode(long slot,
                                                    SlotCmd subcommand,
                                                    String nodeId,
                                                    Handler<AsyncResult<Void>> handler)

      Bind an hash slot to a specific node.
      Parameters:
        `slot` -
        `subcommand` -
        `nodeId` -
        `handler` - Handler for the result of this call.
      Returns:

    - #### clusterSetslotWithNodeObservable

          public Observable<Void> clusterSetslotWithNodeObservable(long slot,
                                                                   SlotCmd subcommand,
                                                                   String nodeId)

      Bind an hash slot to a specific node.
      Parameters:
        `slot` -
        `subcommand` -
        `nodeId` -
      Returns:

    - #### clusterSlaves

          public RedisClient clusterSlaves(String nodeId,
                                           Handler<AsyncResult<JsonArray>> handler)

      List slave nodes of the specified master node.
      Parameters:
        `nodeId` -
        `handler` - Handler for the result of this call.
      Returns:

    - #### clusterSlavesObservable

          public Observable<JsonArray> clusterSlavesObservable(String nodeId)

      List slave nodes of the specified master node.
      Parameters:
        `nodeId` -
      Returns:

    - #### clusterSlots

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

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

    - #### clusterSlotsObservable

          public Observable<JsonArray> clusterSlotsObservable()

      Get array of Cluster slot to node mappings
      Returns:

    - #### command

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

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

    - #### commandObservable

          public Observable<JsonArray> commandObservable()

      Get array of Redis command details
      Returns:

    - #### commandCount

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

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

    - #### commandCountObservable

          public Observable<Long> commandCountObservable()

      Get total number of Redis commands
      Returns:

    - #### commandGetkeys

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

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

    - #### commandGetkeysObservable

          public Observable<JsonArray> commandGetkeysObservable()

      Extract keys given a full Redis command
      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:

    - #### commandInfoObservable

          public Observable<JsonArray> commandInfoObservable(List<String> commands)

      Get array of specific Redis command details
      Parameters:
        `commands` - List of commands to get info for
      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:

    - #### configGetObservable

          public Observable<JsonArray> configGetObservable(String parameter)

      Get the value of a configuration parameter
      Parameters:
        `parameter` - Configuration parameter
      Returns:

    - #### configRewrite

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

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

    - #### configRewriteObservable

          public Observable<String> configRewriteObservable()

      Rewrite the configuration file with the in memory configuration
      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:

    - #### configSetObservable

          public Observable<String> configSetObservable(String parameter,
                                                        String value)

      Set a configuration parameter to the given value
      Parameters:
        `parameter` - Configuration parameter
        `value` - New value
      Returns:

    - #### configResetstat

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

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

    - #### configResetstatObservable

          public Observable<String> configResetstatObservable()

      Reset the stats returned by INFO
      Returns:

    - #### dbsize

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

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

    - #### dbsizeObservable

          public Observable<Long> dbsizeObservable()

      Return the number of keys in the selected database
      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:

    - #### debugObjectObservable

          public Observable<String> debugObjectObservable(String key)

      Get debugging information about a key
      Parameters:
        `key` - Key string
      Returns:

    - #### debugSegfault

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

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

    - #### debugSegfaultObservable

          public Observable<String> debugSegfaultObservable()

      Make the server crash
      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:

    - #### decrObservable

          public Observable<Long> decrObservable(String key)

      Decrement the integer value of a key by one
      Parameters:
        `key` - Key string
      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:

    - #### decrbyObservable

          public Observable<Long> decrbyObservable(String key,
                                                   long decrement)

      Decrement the integer value of a key by the given number
      Parameters:
        `key` - Key string
        `decrement` - Value by which to decrement
      Returns:

    - #### del

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

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

    - #### delObservable

          public Observable<Long> delObservable(String key)

      Delete a key
      Parameters:
        `key` - Keys to delete
      Returns:

    - #### delMany

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

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

    - #### delManyObservable

          public Observable<Long> delManyObservable(List<String> keys)

      Delete many keys
      Parameters:
        `keys` - List of keys to delete
      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:

    - #### dumpObservable

          public Observable<String> dumpObservable(String key)

      Return a serialized version of the value stored at the specified key.
      Parameters:
        `key` - Key string
      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:

    - #### echoObservable

          public Observable<String> echoObservable(String message)

      Echo the given string
      Parameters:
        `message` - String to echo
      Returns:

    - #### eval

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

      Execute a Lua script server side. Due to the dynamic nature of this command any response type could be returned for This reason and to ensure type safety the reply is always guaranteed to be a JsonArray. When a reply if for example a String the handler will be called with a JsonArray with a single element containing the String.
      Parameters:
        `script` - Lua script to evaluate
        `keys` - List of keys
        `args` - List of argument values
        `handler` - Handler for the result of this call.
      Returns:

    - #### evalObservable

          public Observable<JsonArray> evalObservable(String script,
                                                      List<String> keys,
                                                      List<String> args)

      Execute a Lua script server side. Due to the dynamic nature of this command any response type could be returned for This reason and to ensure type safety the reply is always guaranteed to be a JsonArray. When a reply if for example a String the handler will be called with a JsonArray with a single element containing the String.
      Parameters:
        `script` - Lua script to evaluate
        `keys` - List of keys
        `args` - List of argument values
      Returns:

    - #### evalsha

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

      Execute a Lua script server side. Due to the dynamic nature of this command any response type could be returned for This reason and to ensure type safety the reply is always guaranteed to be a JsonArray. When a reply if for example a String the handler will be called with a JsonArray with a single element containing the String.
      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:

    - #### evalshaObservable

          public Observable<JsonArray> evalshaObservable(String sha1,
                                                         List<String> keys,
                                                         List<String> values)

      Execute a Lua script server side. Due to the dynamic nature of this command any response type could be returned for This reason and to ensure type safety the reply is always guaranteed to be a JsonArray. When a reply if for example a String the handler will be called with a JsonArray with a single element containing the String.
      Parameters:
        `sha1` - SHA1 digest of the script cached on the server
        `keys` - List of keys
        `values` - List of values
      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:

    - #### existsObservable

          public Observable<Long> existsObservable(String key)

      Determine if a key exists
      Parameters:
        `key` - Key string
      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:

    - #### expireObservable

          public Observable<Long> expireObservable(String key,
                                                   int seconds)

      Set a key's time to live in seconds
      Parameters:
        `key` - Key string
        `seconds` - Time to live in seconds
      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:

    - #### expireatObservable

          public Observable<Long> expireatObservable(String key,
                                                     long seconds)

      Set the expiration for a key as a UNIX timestamp
      Parameters:
        `key` - Key string
        `seconds` - Expiry time as Unix timestamp in seconds
      Returns:

    - #### flushall

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

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

    - #### flushallObservable

          public Observable<String> flushallObservable()

      Remove all keys from all databases
      Returns:

    - #### flushdb

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

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

    - #### flushdbObservable

          public Observable<String> flushdbObservable()

      Remove all keys from the current database
      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:

    - #### getObservable

          public Observable<String> getObservable(String key)

      Get the value of a key
      Parameters:
        `key` - Key string
      Returns:

    - #### getBinary

          public RedisClient getBinary(String key,
                                       Handler<AsyncResult<Buffer>> 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:

    - #### getBinaryObservable

          public Observable<Buffer> getBinaryObservable(String key)

      Get the value of a key - without decoding as utf-8
      Parameters:
        `key` - Key string
      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:

    - #### getbitObservable

          public Observable<Long> getbitObservable(String key,
                                                   long offset)

      Returns the bit value at offset in the string value stored at key
      Parameters:
        `key` - Key string
        `offset` - Offset in bits
      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:

    - #### getrangeObservable

          public Observable<String> getrangeObservable(String key,
                                                       long start,
                                                       long end)

      Get a substring of the string stored at a key
      Parameters:
        `key` - Key string
        `start` - Start offset
        `end` - End offset - inclusive
      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:

    - #### getsetObservable

          public Observable<String> getsetObservable(String key,
                                                     String value)

      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
      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:

    - #### hdelObservable

          public Observable<Long> hdelObservable(String key,
                                                 String field)

      Delete one or more hash fields
      Parameters:
        `key` - Key string
        `field` - Field name
      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:

    - #### hdelManyObservable

          public Observable<Long> hdelManyObservable(String key,
                                                     List<String> fields)

      Delete one or more hash fields
      Parameters:
        `key` - Key string
        `fields` - Field names
      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:

    - #### hexistsObservable

          public Observable<Long> hexistsObservable(String key,
                                                    String field)

      Determine if a hash field exists
      Parameters:
        `key` - Key string
        `field` - Field name
      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:

    - #### hgetObservable

          public Observable<String> hgetObservable(String key,
                                                   String field)

      Get the value of a hash field
      Parameters:
        `key` - Key string
        `field` - Field name
      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:

    - #### hgetallObservable

          public Observable<JsonObject> hgetallObservable(String key)

      Get all the fields and values in a hash
      Parameters:
        `key` - Key string
      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:

    - #### hincrbyObservable

          public Observable<Long> hincrbyObservable(String key,
                                                    String field,
                                                    long increment)

      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
      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:

    - #### hincrbyfloatObservable

          public Observable<String> hincrbyfloatObservable(String key,
                                                           String field,
                                                           double increment)

      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
      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:

    - #### hkeysObservable

          public Observable<JsonArray> hkeysObservable(String key)

      Get all the fields in a hash
      Parameters:
        `key` - Key string
      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:

    - #### hlenObservable

          public Observable<Long> hlenObservable(String key)

      Get the number of fields in a hash
      Parameters:
        `key` - Key string
      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:

    - #### hmgetObservable

          public Observable<JsonArray> hmgetObservable(String key,
                                                       List<String> fields)

      Get the values of all the given hash fields
      Parameters:
        `key` - Key string
        `fields` - Field names
      Returns:

    - #### hmset

          public RedisClient hmset(String key,
                                   JsonObject 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:

    - #### hmsetObservable

          public Observable<String> hmsetObservable(String key,
                                                    JsonObject values)

      Set multiple hash fields to multiple values
      Parameters:
        `key` - Key string
        `values` - Map of field:value pairs
      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:

    - #### hsetObservable

          public Observable<Long> hsetObservable(String key,
                                                 String field,
                                                 String value)

      Set the string value of a hash field
      Parameters:
        `key` - Key string
        `field` - Field name
        `value` - New value
      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:

    - #### hsetnxObservable

          public Observable<Long> hsetnxObservable(String key,
                                                   String field,
                                                   String value)

      Set the value of a hash field, only if the field does not exist
      Parameters:
        `key` - Key string
        `field` - Field name
        `value` - New value
      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:

    - #### hvalsObservable

          public Observable<JsonArray> hvalsObservable(String key)

      Get all the values in a hash
      Parameters:
        `key` - Key string
      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:

    - #### incrObservable

          public Observable<Long> incrObservable(String key)

      Increment the integer value of a key by one
      Parameters:
        `key` - Key string
      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:

    - #### incrbyObservable

          public Observable<Long> incrbyObservable(String key,
                                                   long increment)

      Increment the integer value of a key by the given amount
      Parameters:
        `key` - Key string
        `increment` - Value by which to increment
      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:

    - #### incrbyfloatObservable

          public Observable<String> incrbyfloatObservable(String key,
                                                          double increment)

      Increment the float value of a key by the given amount
      Parameters:
        `key` - Key string
        `increment` - Value by which to increment
      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:

    - #### infoObservable

          public Observable<JsonObject> infoObservable()

      Get information and statistics about the server
      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:

    - #### infoSectionObservable

          public Observable<JsonObject> infoSectionObservable(String section)

      Get information and statistics about the server
      Parameters:
        `section` - Specific section of information to return
      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:

    - #### keysObservable

          public Observable<JsonArray> keysObservable(String pattern)

      Find all keys matching the given pattern
      Parameters:
        `pattern` - Pattern to limit the keys returned
      Returns:

    - #### lastsave

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

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

    - #### lastsaveObservable

          public Observable<Long> lastsaveObservable()

      Get the UNIX time stamp of the last successful save to disk
      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:

    - #### lindexObservable

          public Observable<String> lindexObservable(String key,
                                                     int index)

      Get an element from a list by its index
      Parameters:
        `key` - Key string
        `index` - Index of list element to get
      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:

    - #### linsertObservable

          public Observable<Long> linsertObservable(String key,
                                                    InsertOptions option,
                                                    String pivot,
                                                    String value)

      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
      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:

    - #### llenObservable

          public Observable<Long> llenObservable(String key)

      Get the length of a list
      Parameters:
        `key` - String key
      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:

    - #### lpopObservable

          public Observable<String> lpopObservable(String key)

      Remove and get the first element in a list
      Parameters:
        `key` - String key
      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:

    - #### lpushManyObservable

          public Observable<Long> lpushManyObservable(String key,
                                                      List<String> values)

      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
      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:

    - #### lpushObservable

          public Observable<Long> lpushObservable(String key,
                                                  String value)

      Prepend one value to a list
      Parameters:
        `key` - Key string
        `value` - Value to be added at the beginning of the list
      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:

    - #### lpushxObservable

          public Observable<Long> lpushxObservable(String key,
                                                   String value)

      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
      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:

    - #### lrangeObservable

          public Observable<JsonArray> lrangeObservable(String key,
                                                        long from,
                                                        long to)

      Get a range of elements from a list
      Parameters:
        `key` - Key string
        `from` - Start index
        `to` - Stop index
      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:

    - #### lremObservable

          public Observable<Long> lremObservable(String key,
                                                 long count,
                                                 String value)

      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
      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:

    - #### lsetObservable

          public Observable<String> lsetObservable(String key,
                                                   long index,
                                                   String value)

      Set the value of an element in a list by its index
      Parameters:
        `key` - Key string
        `index` - Position within list
        `value` - New value
      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:

    - #### ltrimObservable

          public Observable<String> ltrimObservable(String key,
                                                    long from,
                                                    long to)

      Trim a list to the specified range
      Parameters:
        `key` - Key string
        `from` - Start index
        `to` - Stop index
      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:

    - #### mgetObservable

          public Observable<JsonArray> mgetObservable(String key)

      Get the value of the given key
      Parameters:
        `key` - Key string
      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:

    - #### mgetManyObservable

          public Observable<JsonArray> mgetManyObservable(List<String> keys)

      Get the values of all the given keys
      Parameters:
        `keys` - List of keys to get
      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:

    - #### migrateObservable

          public Observable<String> migrateObservable(String host,
                                                      int port,
                                                      String key,
                                                      int destdb,
                                                      long timeout,
                                                      MigrateOptions options)

      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
      Returns:

    - #### monitor

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

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

    - #### monitorObservable

          public Observable<Void> monitorObservable()

      Listen for all requests received by the server in real time
      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:

    - #### moveObservable

          public Observable<Long> moveObservable(String key,
                                                 int destdb)

      Move a key to another database
      Parameters:
        `key` - Key to migrate
        `destdb` - Destination database index
      Returns:

    - #### mset

          public RedisClient mset(JsonObject 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:

    - #### msetObservable

          public Observable<String> msetObservable(JsonObject keyvals)

      Set multiple keys to multiple values
      Parameters:
        `keyvals` - Key value pairs to set
      Returns:

    - #### msetnx

          public RedisClient msetnx(JsonObject 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:

    - #### msetnxObservable

          public Observable<Long> msetnxObservable(JsonObject keyvals)

      Set multiple keys to multiple values, only if none of the keys exist
      Parameters:
        `keyvals` - Key value pairs to set
      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:

    - #### objectObservable

          public Observable<Void> objectObservable(String key,
                                                   ObjectCmd cmd)

      Inspect the internals of Redis objects
      Parameters:
        `key` - Key string
        `cmd` - Object sub command
      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:

    - #### persistObservable

          public Observable<Long> persistObservable(String key)

      Remove the expiration from a key
      Parameters:
        `key` - Key string
      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:

    - #### pexpireObservable

          public Observable<Long> pexpireObservable(String key,
                                                    long millis)

      Set a key's time to live in milliseconds
      Parameters:
        `key` - String key
        `millis` - Time to live in milliseconds
      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:

    - #### pexpireatObservable

          public Observable<Long> pexpireatObservable(String key,
                                                      long millis)

      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
      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:

    - #### pfaddObservable

          public Observable<Long> pfaddObservable(String key,
                                                  String element)

      Adds the specified element to the specified HyperLogLog.
      Parameters:
        `key` - Key string
        `element` - Element to add
      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:

    - #### pfaddManyObservable

          public Observable<Long> pfaddManyObservable(String key,
                                                      List<String> elements)

      Adds the specified elements to the specified HyperLogLog.
      Parameters:
        `key` - Key string
        `elements` - Elementa to add
      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:

    - #### pfcountObservable

          public Observable<Long> pfcountObservable(String key)

      Return the approximated cardinality of the set observed by the HyperLogLog at key.
      Parameters:
        `key` - Key string
      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:

    - #### pfcountManyObservable

          public Observable<Long> pfcountManyObservable(List<String> keys)

      Return the approximated cardinality of the set(s) observed by the HyperLogLog at key(s).
      Parameters:
        `keys` - List of keys
      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:

    - #### pfmergeObservable

          public Observable<String> pfmergeObservable(String destkey,
                                                      List<String> keys)

      Merge N different HyperLogLogs into a single one.
      Parameters:
        `destkey` - Destination key
        `keys` - List of source keys
      Returns:

    - #### ping

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

      Ping the server
      Parameters:
        `handler` -
      Returns:

    - #### pingObservable

          public Observable<String> pingObservable()

      Ping the server
      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:

    - #### psetexObservable

          public Observable<Void> psetexObservable(String key,
                                                   long millis,
                                                   String value)

      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
      Returns:

    - #### psubscribe

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

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

    - #### psubscribeObservable

          public Observable<JsonArray> psubscribeObservable(String pattern)

      Listen for messages published to channels matching the given pattern
      Parameters:
        `pattern` - Pattern string
      Returns:

    - #### psubscribeMany

          public RedisClient psubscribeMany(List<String> patterns,
                                            Handler<AsyncResult<JsonArray>> 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:

    - #### psubscribeManyObservable

          public Observable<JsonArray> psubscribeManyObservable(List<String> patterns)

      Listen for messages published to channels matching the given patterns
      Parameters:
        `patterns` - List of patterns
      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:

    - #### pubsubChannelsObservable

          public Observable<JsonArray> pubsubChannelsObservable(String pattern)

      Lists the currently active channels - only those matching the pattern
      Parameters:
        `pattern` - A glob-style pattern - an empty string means no pattern
      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:

    - #### pubsubNumsubObservable

          public Observable<JsonArray> pubsubNumsubObservable(List<String> channels)

      Returns the number of subscribers (not counting clients subscribed to patterns) for the specified channels
      Parameters:
        `channels` - List of channels
      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:

    - #### pubsubNumpatObservable

          public Observable<Long> pubsubNumpatObservable()

      Returns the number of subscriptions to patterns (that are performed using the PSUBSCRIBE command)
      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:

    - #### pttlObservable

          public Observable<Long> pttlObservable(String key)

      Get the time to live for a key in milliseconds
      Parameters:
        `key` - Key string
      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:

    - #### publishObservable

          public Observable<Long> publishObservable(String channel,
                                                    String message)

      Post a message to a channel
      Parameters:
        `channel` - Channel key
        `message` - Message to send to channel
      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:

    - #### punsubscribeObservable

          public Observable<Void> punsubscribeObservable(List<String> patterns)

      Stop listening for messages posted to channels matching the given patterns
      Parameters:
        `patterns` - List of patterns to match against
      Returns:

    - #### randomkey

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

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

    - #### randomkeyObservable

          public Observable<String> randomkeyObservable()

      Return a random key from the keyspace
      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:

    - #### renameObservable

          public Observable<String> renameObservable(String key,
                                                     String newkey)

      Rename a key
      Parameters:
        `key` - Key string to be renamed
        `newkey` - New key string
      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:

    - #### renamenxObservable

          public Observable<Long> renamenxObservable(String key,
                                                     String newkey)

      Rename a key, only if the new key does not exist
      Parameters:
        `key` - Key string to be renamed
        `newkey` - New key string
      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:

    - #### restoreObservable

          public Observable<String> restoreObservable(String key,
                                                      long millis,
                                                      String serialized)

      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
      Returns:

    - #### role

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

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

    - #### roleObservable

          public Observable<JsonArray> roleObservable()

      Return the role of the instance in the context of replication
      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:

    - #### rpopObservable

          public Observable<String> rpopObservable(String key)

      Remove and get the last element in a list
      Parameters:
        `key` - Key string
      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:

    - #### rpoplpushObservable

          public Observable<String> rpoplpushObservable(String key,
                                                        String destkey)

      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
      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:

    - #### rpushManyObservable

          public Observable<Long> rpushManyObservable(String key,
                                                      List<String> values)

      Append one or multiple values to a list
      Parameters:
        `key` - Key string
        `values` - List of values to add to the end of the list
      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:

    - #### rpushObservable

          public Observable<Long> rpushObservable(String key,
                                                  String value)

      Append one or multiple values to a list
      Parameters:
        `key` - Key string
        `value` - Value to be added to the end of the list
      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:

    - #### rpushxObservable

          public Observable<Long> rpushxObservable(String key,
                                                   String value)

      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
      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:

    - #### saddObservable

          public Observable<Long> saddObservable(String key,
                                                 String member)

      Add a member to a set
      Parameters:
        `key` - Key string
        `member` - Value to be added to the set
      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:

    - #### saddManyObservable

          public Observable<Long> saddManyObservable(String key,
                                                     List<String> members)

      Add one or more members to a set
      Parameters:
        `key` - Key string
        `members` - Values to be added to the set
      Returns:

    - #### save

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

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

    - #### saveObservable

          public Observable<String> saveObservable()

      Synchronously save the dataset to disk
      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:

    - #### scardObservable

          public Observable<Long> scardObservable(String key)

      Get the number of members in a set
      Parameters:
        `key` - Key string
      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:

    - #### scriptExistsObservable

          public Observable<JsonArray> scriptExistsObservable(String script)

      Check existence of script in the script cache.
      Parameters:
        `script` - SHA1 digest identifying a script in the script cache
      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:

    - #### scriptExistsManyObservable

          public Observable<JsonArray> scriptExistsManyObservable(List<String> scripts)

      Check existence of scripts in the script cache.
      Parameters:
        `scripts` - List of SHA1 digests identifying scripts in the script cache
      Returns:

    - #### scriptFlush

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

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

    - #### scriptFlushObservable

          public Observable<String> scriptFlushObservable()

      Remove all the scripts from the script cache.
      Returns:

    - #### scriptKill

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

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

    - #### scriptKillObservable

          public Observable<String> scriptKillObservable()

      Kill the script currently in execution.
      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:

    - #### scriptLoadObservable

          public Observable<String> scriptLoadObservable(String script)

      Load the specified Lua script into the script cache.
      Parameters:
        `script` - Lua script
      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:

    - #### sdiffObservable

          public Observable<JsonArray> sdiffObservable(String key,
                                                       List<String> cmpkeys)

      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
      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:

    - #### sdiffstoreObservable

          public Observable<Long> sdiffstoreObservable(String destkey,
                                                       String key,
                                                       List<String> cmpkeys)

      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
      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:

    - #### selectObservable

          public Observable<String> selectObservable(int dbindex)

      Change the selected database for the current connection
      Parameters:
        `dbindex` - Index identifying the new active database
      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:

    - #### setObservable

          public Observable<Void> setObservable(String key,
                                                String value)

      Set the string value of a key
      Parameters:
        `key` - Key of which value to set
        `value` - New value for the key
      Returns:

    - #### setWithOptions

          public RedisClient setWithOptions(String key,
                                            String value,
                                            SetOptions options,
                                            Handler<AsyncResult<String>> 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:

    - #### setWithOptionsObservable

          public Observable<String> setWithOptionsObservable(String key,
                                                             String value,
                                                             SetOptions options)

      Set the string value of a key
      Parameters:
        `key` - Key of which value to set
        `value` - New value for the key
        `options` - Set options
      Returns:

    - #### setBinary

          public RedisClient setBinary(String key,
                                       Buffer 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:

    - #### setBinaryObservable

          public Observable<Void> setBinaryObservable(String key,
                                                      Buffer value)

      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
      Returns:

    - #### setBinaryWithOptions

          public RedisClient setBinaryWithOptions(String key,
                                                  Buffer 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:

    - #### setBinaryWithOptionsObservable

          public Observable<Void> setBinaryWithOptionsObservable(String key,
                                                                 Buffer value,
                                                                 SetOptions options)

      Set the string value of a key
      Parameters:
        `key` - Key of which value to set
        `value` - New value for the key
        `options` - Set options
      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:

    - #### setbitObservable

          public Observable<Long> setbitObservable(String key,
                                                   long offset,
                                                   int bit)

      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
      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:

    - #### setexObservable

          public Observable<String> setexObservable(String key,
                                                    long seconds,
                                                    String value)

      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
      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:

    - #### setnxObservable

          public Observable<Long> setnxObservable(String key,
                                                  String value)

      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
      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:

    - #### setrangeObservable

          public Observable<Long> setrangeObservable(String key,
                                                     int offset,
                                                     String value)

      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
      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:

    - #### sinterObservable

          public Observable<JsonArray> sinterObservable(List<String> keys)

      Intersect multiple sets
      Parameters:
        `keys` - List of keys to perform intersection on
      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:

    - #### sinterstoreObservable

          public Observable<Long> sinterstoreObservable(String destkey,
                                                        List<String> keys)

      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
      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:

    - #### sismemberObservable

          public Observable<Long> sismemberObservable(String key,
                                                      String member)

      Determine if a given value is a member of a set
      Parameters:
        `key` - Key string
        `member` - Member to look for
      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:

    - #### slaveofObservable

          public Observable<String> slaveofObservable(String host,
                                                      int port)

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

    - #### slaveofNoone

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

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

    - #### slaveofNooneObservable

          public Observable<String> slaveofNooneObservable()

      Make this server a master
      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:

    - #### slowlogGetObservable

          public Observable<JsonArray> slowlogGetObservable(int limit)

      Read the Redis slow queries log
      Parameters:
        `limit` - Number of log entries to return. If value is less than zero all entries are returned
      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:

    - #### slowlogLenObservable

          public Observable<Long> slowlogLenObservable()

      Get the length of the Redis slow queries log
      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:

    - #### slowlogResetObservable

          public Observable<Void> slowlogResetObservable()

      Reset the Redis slow queries log
      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:

    - #### smembersObservable

          public Observable<JsonArray> smembersObservable(String key)

      Get all the members in a set
      Parameters:
        `key` - Key string
      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:

    - #### smoveObservable

          public Observable<Long> smoveObservable(String key,
                                                  String destkey,
                                                  String member)

      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
      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:

    - #### sortObservable

          public Observable<JsonArray> sortObservable(String key,
                                                      SortOptions options)

      Sort the elements in a list, set or sorted set
      Parameters:
        `key` - Key string
        `options` - Sort options
      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:

    - #### spopObservable

          public Observable<String> spopObservable(String key)

      Remove and return a random member from a set
      Parameters:
        `key` - Key string
      Returns:

    - #### spopMany

          public RedisClient spopMany(String key,
                                      int count,
                                      Handler<AsyncResult<JsonArray>> 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:

    - #### spopManyObservable

          public Observable<JsonArray> spopManyObservable(String key,
                                                          int count)

      Remove and return random members from a set
      Parameters:
        `key` - Key string
        `count` - Number of members to remove
      Returns:

    - #### srandmember

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

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

    - #### srandmemberObservable

          public Observable<String> srandmemberObservable(String key)

      Get one or multiple random members from a set
      Parameters:
        `key` - Key string
      Returns:

    - #### srandmemberCount

          public RedisClient srandmemberCount(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:

    - #### srandmemberCountObservable

          public Observable<JsonArray> srandmemberCountObservable(String key,
                                                                  int count)

      Get one or multiple random members from a set
      Parameters:
        `key` - Key string
        `count` - Number of members to get
      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:

    - #### sremObservable

          public Observable<Long> sremObservable(String key,
                                                 String member)

      Remove one member from a set
      Parameters:
        `key` - Key string
        `member` - Member to remove
      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:

    - #### sremManyObservable

          public Observable<Long> sremManyObservable(String key,
                                                     List<String> members)

      Remove one or more members from a set
      Parameters:
        `key` - Key string
        `members` - Members to remove
      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:

    - #### strlenObservable

          public Observable<Long> strlenObservable(String key)

      Get the length of the value stored in a key
      Parameters:
        `key` - Key string
      Returns:

    - #### subscribe

          public RedisClient subscribe(String channel,
                                       Handler<AsyncResult<JsonArray>> handler)

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

    - #### subscribeObservable

          public Observable<JsonArray> subscribeObservable(String channel)

      Listen for messages published to the given channels
      Parameters:
        `channel` - Channel to subscribe to
      Returns:

    - #### subscribeMany

          public RedisClient subscribeMany(List<String> channels,
                                           Handler<AsyncResult<JsonArray>> 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:

    - #### subscribeManyObservable

          public Observable<JsonArray> subscribeManyObservable(List<String> channels)

      Listen for messages published to the given channels
      Parameters:
        `channels` - List of channels to subscribe to
      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:

    - #### sunionObservable

          public Observable<JsonArray> sunionObservable(List<String> keys)

      Add multiple sets
      Parameters:
        `keys` - List of keys identifying sets to add up
      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:

    - #### sunionstoreObservable

          public Observable<Long> sunionstoreObservable(String destkey,
                                                        List<String> keys)

      Add multiple sets and store the resulting set in a key
      Parameters:
        `destkey` - Destination key
        `keys` - List of keys identifying sets to add up
      Returns:

    - #### sync

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

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

    - #### syncObservable

          public Observable<Void> syncObservable()

      Internal command used for replication
      Returns:

    - #### time

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

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

    - #### timeObservable

          public Observable<JsonArray> timeObservable()

      Return the current server time
      Returns:

    - #### transaction

          public RedisTransaction transaction()

      Return a RedisTransaction instance
      Returns:
        transaction instance

    - #### 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:

    - #### ttlObservable

          public Observable<Long> ttlObservable(String key)

      Get the time to live for a key
      Parameters:
        `key` - Key string
      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:

    - #### typeObservable

          public Observable<String> typeObservable(String key)

      Determine the type stored at key
      Parameters:
        `key` - Key string
      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:

    - #### unsubscribeObservable

          public Observable<Void> unsubscribeObservable(List<String> channels)

      Stop listening for messages posted to the given channels
      Parameters:
        `channels` - List of channels to subscribe to
      Returns:

    - #### wait

          public RedisClient wait(long numSlaves,
                                  long timeout,
                                  Handler<AsyncResult<String>> handler)

      Wait for the synchronous replication of all the write commands sent in the context of the current connection.
      Parameters:
        `numSlaves` -
        `timeout` -
        `handler` - Handler for the result of this call.
      Returns:

    - #### waitObservable

          public Observable<String> waitObservable(long numSlaves,
                                                   long timeout)

      Wait for the synchronous replication of all the write commands sent in the context of the current connection.
      Parameters:
        `numSlaves` -
        `timeout` -
      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:

    - #### zaddObservable

          public Observable<Long> zaddObservable(String key,
                                                 double score,
                                                 String member)

      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
      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:

    - #### zaddManyObservable

          public Observable<Long> zaddManyObservable(String key,
                                                     Map<String,Double> members)

      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
      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:

    - #### zcardObservable

          public Observable<Long> zcardObservable(String key)

      Get the number of members in a sorted set
      Parameters:
        `key` - Key string
      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:

    - #### zcountObservable

          public Observable<Long> zcountObservable(String key,
                                                   double min,
                                                   double max)

      Count the members in a sorted set with scores within the given values
      Parameters:
        `key` - Key string
        `min` - Minimum score
        `max` - Maximum score
      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:

    - #### zincrbyObservable

          public Observable<String> zincrbyObservable(String key,
                                                      double increment,
                                                      String member)

      Increment the score of a member in a sorted set
      Parameters:
        `key` - Key string
        `increment` - Increment amount
        `member` - Member key
      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:

    - #### zinterstoreObservable

          public Observable<Long> zinterstoreObservable(String destkey,
                                                        List<String> sets,
                                                        AggregateOptions options)

      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
      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:

    - #### zinterstoreWeighedObservable

          public Observable<Long> zinterstoreWeighedObservable(String destkey,
                                                               Map<String,Double> sets,
                                                               AggregateOptions options)

      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
      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:

    - #### zlexcountObservable

          public Observable<Long> zlexcountObservable(String key,
                                                      String min,
                                                      String max)

      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
      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:

    - #### zrangeObservable

          public Observable<JsonArray> zrangeObservable(String key,
                                                        long start,
                                                        long stop)

      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
      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:

    - #### zrangeWithOptionsObservable

          public Observable<JsonArray> zrangeWithOptionsObservable(String key,
                                                                   long start,
                                                                   long stop,
                                                                   RangeOptions options)

      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
      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:

    - #### zrangebylexObservable

          public Observable<JsonArray> zrangebylexObservable(String key,
                                                             String min,
                                                             String max,
                                                             LimitOptions options)

      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
      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:

    - #### zrangebyscoreObservable

          public Observable<JsonArray> zrangebyscoreObservable(String key,
                                                               String min,
                                                               String max,
                                                               RangeLimitOptions options)

      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
      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:

    - #### zrankObservable

          public Observable<Long> zrankObservable(String key,
                                                  String member)

      Determine the index of a member in a sorted set
      Parameters:
        `key` - Key string
        `member` - Member in the sorted set identified by key
      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:

    - #### zremObservable

          public Observable<Long> zremObservable(String key,
                                                 String member)

      Remove one member from a sorted set
      Parameters:
        `key` - Key string
        `member` - Member in the sorted set identified by key
      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:

    - #### zremManyObservable

          public Observable<Long> zremManyObservable(String key,
                                                     List<String> members)

      Remove one or more members from a sorted set
      Parameters:
        `key` - Key string
        `members` - Members in the sorted set identified by key
      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:

    - #### zremrangebylexObservable

          public Observable<Long> zremrangebylexObservable(String key,
                                                           String min,
                                                           String max)

      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
      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:

    - #### zremrangebyrankObservable

          public Observable<Long> zremrangebyrankObservable(String key,
                                                            long start,
                                                            long stop)

      Remove all members in a sorted set within the given indexes
      Parameters:
        `key` - Key string
        `start` - Start index
        `stop` - Stop index
      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:

    - #### zremrangebyscoreObservable

          public Observable<Long> zremrangebyscoreObservable(String key,
                                                             String min,
                                                             String max)

      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
      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:

    - #### zrevrangeObservable

          public Observable<JsonArray> zrevrangeObservable(String key,
                                                           long start,
                                                           long stop,
                                                           RangeOptions options)

      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
      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:

    - #### zrevrangebylexObservable

          public Observable<JsonArray> zrevrangebylexObservable(String key,
                                                                String max,
                                                                String min,
                                                                LimitOptions options)

      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
      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:

    - #### zrevrangebyscoreObservable

          public Observable<JsonArray> zrevrangebyscoreObservable(String key,
                                                                  String max,
                                                                  String min,
                                                                  RangeLimitOptions options)

      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
      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:

    - #### zrevrankObservable

          public Observable<Long> zrevrankObservable(String key,
                                                     String member)

      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
      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:

    - #### zscoreObservable

          public Observable<String> zscoreObservable(String key,
                                                     String member)

      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
      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:

    - #### zunionstoreObservable

          public Observable<Long> zunionstoreObservable(String destkey,
                                                        List<String> sets,
                                                        AggregateOptions options)

      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
      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:

    - #### zunionstoreWeighedObservable

          public Observable<Long> zunionstoreWeighedObservable(String key,
                                                               Map<String,Double> sets,
                                                               AggregateOptions options)

      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
      Returns:

    - #### scan

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

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

    - #### scanObservable

          public Observable<JsonArray> scanObservable(String cursor,
                                                      ScanOptions options)

      Incrementally iterate the keys space
      Parameters:
        `cursor` - Cursor id
        `options` - Scan options
      Returns:

    - #### sscan

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

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

    - #### sscanObservable

          public Observable<JsonArray> sscanObservable(String key,
                                                       String cursor,
                                                       ScanOptions options)

      Incrementally iterate Set elements
      Parameters:
        `key` - Key string
        `cursor` - Cursor id
        `options` - Scan options
      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:

    - #### hscanObservable

          public Observable<JsonArray> hscanObservable(String key,
                                                       String cursor,
                                                       ScanOptions options)

      Incrementally iterate hash fields and associated values
      Parameters:
        `key` - Key string
        `cursor` - Cursor id
        `options` - Scan options
      Returns:

    - #### zscan

          public RedisClient zscan(String key,
                                   String cursor,
                                   ScanOptions options,
                                   Handler<AsyncResult<JsonArray>> 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:

    - #### zscanObservable

          public Observable<JsonArray> zscanObservable(String key,
                                                       String cursor,
                                                       ScanOptions options)

      Incrementally iterate sorted sets elements and associated scores
      Parameters:
        `key` - Key string
        `cursor` - Cursor id
        `options` - Scan options
      Returns:

    - #### geoadd

          public RedisClient geoadd(String key,
                                    double longitude,
                                    double latitude,
                                    String member,
                                    Handler<AsyncResult<Long>> handler)

      Add one or more geospatial items in the geospatial index represented using a sorted set.
      Parameters:
        `key` - Key string
        `longitude` - longitude
        `latitude` - latitude
        `member` - member
        `handler` - Handler for the result of this call.
      Returns:

    - #### geoaddObservable

          public Observable<Long> geoaddObservable(String key,
                                                   double longitude,
                                                   double latitude,
                                                   String member)

      Add one or more geospatial items in the geospatial index represented using a sorted set.
      Parameters:
        `key` - Key string
        `longitude` - longitude
        `latitude` - latitude
        `member` - member
      Returns:

    - #### geoaddMany

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

      Add one or more geospatial items in the geospatial index represented using a sorted set.
      Parameters:
        `key` - Key string
        `members` - list of <lon, lat, member>
        `handler` - Handler for the result of this call.
      Returns:

    - #### geoaddManyObservable

          public Observable<Long> geoaddManyObservable(String key,
                                                       List<GeoMember> members)

      Add one or more geospatial items in the geospatial index represented using a sorted set.
      Parameters:
        `key` - Key string
        `members` - list of <lon, lat, member>
      Returns:

    - #### geohash

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

      Return valid Geohash strings representing the position of one or more elements in a sorted set value representing a geospatial index (where elements were added using GEOADD).
      Parameters:
        `key` - Key string
        `member` - member
        `handler` - Handler for the result of this call.
      Returns:

    - #### geohashObservable

          public Observable<JsonArray> geohashObservable(String key,
                                                         String member)

      Return valid Geohash strings representing the position of one or more elements in a sorted set value representing a geospatial index (where elements were added using GEOADD).
      Parameters:
        `key` - Key string
        `member` - member
      Returns:

    - #### geohashMany

          public RedisClient geohashMany(String key,
                                         List<String> members,
                                         Handler<AsyncResult<JsonArray>> handler)

      Return valid Geohash strings representing the position of one or more elements in a sorted set value representing a geospatial index (where elements were added using GEOADD).
      Parameters:
        `key` - Key string
        `members` - list of members
        `handler` - Handler for the result of this call.
      Returns:

    - #### geohashManyObservable

          public Observable<JsonArray> geohashManyObservable(String key,
                                                             List<String> members)

      Return valid Geohash strings representing the position of one or more elements in a sorted set value representing a geospatial index (where elements were added using GEOADD).
      Parameters:
        `key` - Key string
        `members` - list of members
      Returns:

    - #### geopos

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

      Return the positions (longitude,latitude) of all the specified members of the geospatial index represented by the sorted set at key.
      Parameters:
        `key` - Key string
        `member` - member
        `handler` - Handler for the result of this call.
      Returns:

    - #### geoposObservable

          public Observable<JsonArray> geoposObservable(String key,
                                                        String member)

      Return the positions (longitude,latitude) of all the specified members of the geospatial index represented by the sorted set at key.
      Parameters:
        `key` - Key string
        `member` - member
      Returns:

    - #### geoposMany

          public RedisClient geoposMany(String key,
                                        List<String> members,
                                        Handler<AsyncResult<JsonArray>> handler)

      Return the positions (longitude,latitude) of all the specified members of the geospatial index represented by the sorted set at key.
      Parameters:
        `key` - Key string
        `members` - list of members
        `handler` - Handler for the result of this call.
      Returns:

    - #### geoposManyObservable

          public Observable<JsonArray> geoposManyObservable(String key,
                                                            List<String> members)

      Return the positions (longitude,latitude) of all the specified members of the geospatial index represented by the sorted set at key.
      Parameters:
        `key` - Key string
        `members` - list of members
      Returns:

    - #### geodist

          public RedisClient geodist(String key,
                                     String member1,
                                     String member2,
                                     Handler<AsyncResult<String>> handler)

      Return the distance between two members in the geospatial index represented by the sorted set.
      Parameters:
        `key` - Key string
        `member1` - member 1
        `member2` - member 2
        `handler` - Handler for the result of this call.
      Returns:

    - #### geodistObservable

          public Observable<String> geodistObservable(String key,
                                                      String member1,
                                                      String member2)

      Return the distance between two members in the geospatial index represented by the sorted set.
      Parameters:
        `key` - Key string
        `member1` - member 1
        `member2` - member 2
      Returns:

    - #### geodistWithUnit

          public RedisClient geodistWithUnit(String key,
                                             String member1,
                                             String member2,
                                             GeoUnit unit,
                                             Handler<AsyncResult<String>> handler)

      Return the distance between two members in the geospatial index represented by the sorted set.
      Parameters:
        `key` - Key string
        `member1` - member 1
        `member2` - member 2
        `unit` - geo unit
        `handler` - Handler for the result of this call.
      Returns:

    - #### geodistWithUnitObservable

          public Observable<String> geodistWithUnitObservable(String key,
                                                              String member1,
                                                              String member2,
                                                              GeoUnit unit)

      Return the distance between two members in the geospatial index represented by the sorted set.
      Parameters:
        `key` - Key string
        `member1` - member 1
        `member2` - member 2
        `unit` - geo unit
      Returns:

    - #### georadius

          public RedisClient georadius(String key,
                                       double longitude,
                                       double latitude,
                                       double radius,
                                       GeoUnit unit,
                                       Handler<AsyncResult<JsonArray>> handler)

      Return the members of a sorted set populated with geospatial information using GEOADD, which are within the borders of the area specified with the center location and the maximum distance from the center (the radius).
      Parameters:
        `key` - Key string
        `longitude` - longitude
        `latitude` - latitude
        `radius` - radius
        `unit` - geo unit
        `handler` - Handler for the result of this call.
      Returns:

    - #### georadiusObservable

          public Observable<JsonArray> georadiusObservable(String key,
                                                           double longitude,
                                                           double latitude,
                                                           double radius,
                                                           GeoUnit unit)

      Return the members of a sorted set populated with geospatial information using GEOADD, which are within the borders of the area specified with the center location and the maximum distance from the center (the radius).
      Parameters:
        `key` - Key string
        `longitude` - longitude
        `latitude` - latitude
        `radius` - radius
        `unit` - geo unit
      Returns:

    - #### georadiusWithOptions

          public RedisClient georadiusWithOptions(String key,
                                                  double longitude,
                                                  double latitude,
                                                  double radius,
                                                  GeoUnit unit,
                                                  GeoRadiusOptions options,
                                                  Handler<AsyncResult<JsonArray>> handler)

      Return the members of a sorted set populated with geospatial information using GEOADD, which are within the borders of the area specified with the center location and the maximum distance from the center (the radius).
      Parameters:
        `key` - Key string
        `longitude` - longitude
        `latitude` - latitude
        `radius` - radius
        `unit` - geo unit
        `options` - geo radius options
        `handler` - Handler for the result of this call.
      Returns:

    - #### georadiusWithOptionsObservable

          public Observable<JsonArray> georadiusWithOptionsObservable(String key,
                                                                      double longitude,
                                                                      double latitude,
                                                                      double radius,
                                                                      GeoUnit unit,
                                                                      GeoRadiusOptions options)

      Return the members of a sorted set populated with geospatial information using GEOADD, which are within the borders of the area specified with the center location and the maximum distance from the center (the radius).
      Parameters:
        `key` - Key string
        `longitude` - longitude
        `latitude` - latitude
        `radius` - radius
        `unit` - geo unit
        `options` - geo radius options
      Returns:

    - #### georadiusbymember

          public RedisClient georadiusbymember(String key,
                                               String member,
                                               double radius,
                                               GeoUnit unit,
                                               Handler<AsyncResult<JsonArray>> handler)

      This command is exactly like GEORADIUS with the sole difference that instead of taking, as the center of the area to query, a longitude and latitude value, it takes the name of a member already existing inside the geospatial index represented by the sorted set.
      Parameters:
        `key` - Key string
        `member` - member
        `radius` - radius
        `unit` - geo unit
        `handler` - Handler for the result of this call.
      Returns:

    - #### georadiusbymemberObservable

          public Observable<JsonArray> georadiusbymemberObservable(String key,
                                                                   String member,
                                                                   double radius,
                                                                   GeoUnit unit)

      This command is exactly like GEORADIUS with the sole difference that instead of taking, as the center of the area to query, a longitude and latitude value, it takes the name of a member already existing inside the geospatial index represented by the sorted set.
      Parameters:
        `key` - Key string
        `member` - member
        `radius` - radius
        `unit` - geo unit
      Returns:

    - #### georadiusbymemberWithOptions

          public RedisClient georadiusbymemberWithOptions(String key,
                                                          String member,
                                                          double radius,
                                                          GeoUnit unit,
                                                          GeoRadiusOptions options,
                                                          Handler<AsyncResult<JsonArray>> handler)

      This command is exactly like GEORADIUS with the sole difference that instead of taking, as the center of the area to query, a longitude and latitude value, it takes the name of a member already existing inside the geospatial index represented by the sorted set.
      Parameters:
        `key` - Key string
        `member` - member
        `radius` - radius
        `unit` - geo unit
        `options` - geo radius options
        `handler` - Handler for the result of this call.
      Returns:

    - #### georadiusbymemberWithOptionsObservable

          public Observable<JsonArray> georadiusbymemberWithOptionsObservable(String key,
                                                                              String member,
                                                                              double radius,
                                                                              GeoUnit unit,
                                                                              GeoRadiusOptions options)

      This command is exactly like GEORADIUS with the sole difference that instead of taking, as the center of the area to query, a longitude and latitude value, it takes the name of a member already existing inside the geospatial index represented by the sorted set.
      Parameters:
        `key` - Key string
        `member` - member
        `radius` - radius
        `unit` - geo unit
        `options` - geo radius options
      Returns:

    - #### newInstance

          public static RedisClient newInstance(RedisClient arg)

Copyright © 2016. All rights reserved.