Class List Method List File List

# Class: VertxRedis::RedisClient

Inherits:
  Object
  - Object
  - VertxRedis::RedisClient
  show all
Defined in:
  /Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx-redis/redis_client.rb

## Overview

This factory is deprecated use Redis instead, or for a typed API RedisAPI.

## Constant Summary

@@j_api_type =

      Object.new

## Class Method Summary (collapse)

- + (Boolean) accept?(obj)
- + (::VertxRedis::RedisClient) create(vertx = nil, config = nil)
- + (Object) j_api_type
- + (Object) j_class
- + (Object) unwrap(obj)
- + (Object) wrap(obj)

## Instance Method Summary (collapse)

- - (self) append(key = nil, value = nil) { ... }
  Append a value to a key.
- - (self) auth(password = nil) { ... }
  Authenticate to the server.
- - (self) bgrewriteaof { ... }
  Asynchronously rewrite the append-only file.
- - (self) bgsave { ... }
  Asynchronously save the dataset to disk.
- - (self) bitcount(key = nil) { ... }
  Count set bits in a string.
- - (self) bitcount_range(key = nil, start = nil, _end = nil) { ... }
  Count set bits in a string.
- - (self) bitfield(key = nil, bitFieldOptions = nil) { ... }
  Perform arbitrary bitfield integer operations on strings.
- - (self) bitfield_with_overflow(key = nil, commands = nil, overflow = nil) { ... }
  Perform arbitrary bitfield integer operations on strings.
- - (self) bitop(operation = nil, destkey = nil, keys = nil) { ... }
  Perform bitwise operations between strings.
- - (self) bitpos(key = nil, bit = nil) { ... }
  Find first bit set or clear in a string.
- - (self) bitpos_from(key = nil, bit = nil, start = nil) { ... }
  Find first bit set or clear in a string.
- - (self) bitpos_range(key = nil, bit = nil, start = nil, stop = nil) { ... }
  Find first bit set or clear in a string.
- - (self) blpop(key = nil, seconds = nil) { ... }
  Remove and get the first element in a list, or block until one is available.
- - (self) blpop_many(keys = nil, seconds = nil) { ... }
  Remove and get the first element in any of the lists, or block until one is available.
- - (self) brpop(key = nil, seconds = nil) { ... }
  Remove and get the last element in a list, or block until one is available.
- - (self) brpop_many(keys = nil, seconds = nil) { ... }
  Remove and get the last element in any of the lists, or block until one is available.
- - (self) brpoplpush(key = nil, destkey = nil, seconds = nil) { ... }
  Pop a value from a list, push it to another list and return it; or block until one is available.
- - (self) client_getname { ... }
  Get the current connection name.
- - (self) client_kill(filter = nil) { ... }
  Kill the connection of a client.
- - (self) client_list { ... }
  Get the list of client connections.
- - (self) client_pause(millis = nil) { ... }
  Stop processing commands from clients for some time.
- - (self) client_reply(options = nil) { ... }
  Instruct the server whether to reply to commands.
- - (self) client_setname(name = nil) { ... }
  Set the current connection name.
- - (void) close { ... }
  Close the client - when it is fully closed the handler will be called.
- - (self) cluster_addslots(slots = nil) { ... }
  Assign new hash slots to receiving node.
- - (self) cluster_count_failure_reports(nodeId = nil) { ... }
  Return the number of failure reports active for a given node.
- - (self) cluster_countkeysinslot(slot = nil) { ... }
  Return the number of local keys in the specified hash slot.
- - (self) cluster_delslots(slot = nil) { ... }
  Set hash slots as unbound in receiving node.
- - (self) cluster_delslots_many(slots = nil) { ... }
  Set hash slots as unbound in receiving node.
- - (self) cluster_fail_over_with_options(options = nil) { ... }
  Forces a slave to perform a manual failover of its master.
- - (self) cluster_failover { ... }
  Forces a slave to perform a manual failover of its master.
- - (self) cluster_forget(nodeId = nil) { ... }
  Remove a node from the nodes table.
- - (self) cluster_getkeysinslot(slot = nil, count = nil) { ... }
  Return local key names in the specified hash slot.
- - (self) cluster_info { ... }
  Provides info about Redis Cluster node state.
- - (self) cluster_keyslot(key = nil) { ... }
  Returns the hash slot of the specified key.
- - (self) cluster_meet(ip = nil, port = nil) { ... }
  Force a node cluster to handshake with another node.
- - (self) cluster_nodes { ... }
  Get Cluster config for the node.
- - (self) cluster_replicate(nodeId = nil) { ... }
  Reconfigure a node as a slave of the specified master node.
- - (self) cluster_reset { ... }
  Reset a Redis Cluster node.
- - (self) cluster_reset_with_options(options = nil) { ... }
  Reset a Redis Cluster node.
- - (self) cluster_saveconfig { ... }
  Forces the node to save cluster state on disk.
- - (self) cluster_set_config_epoch(epoch = nil) { ... }
  Set the configuration epoch in a new node.
- - (self) cluster_setslot(slot = nil, subcommand = nil) { ... }
  Bind an hash slot to a specific node.
- - (self) cluster_setslot_with_node(slot = nil, subcommand = nil, nodeId = nil) { ... }
  Bind an hash slot to a specific node.
- - (self) cluster_slaves(nodeId = nil) { ... }
  List slave nodes of the specified master node.
- - (self) cluster_slots { ... }
  Get array of Cluster slot to node mappings.
- - (self) command { ... }
  Get array of Redis command details.
- - (self) command_count { ... }
  Get total number of Redis commands.
- - (self) command_getkeys { ... }
  Extract keys given a full Redis command.
- - (self) command_info(commands = nil) { ... }
  Get array of specific Redis command details.
- - (self) config_get(parameter = nil) { ... }
  Get the value of a configuration parameter.
- - (self) config_resetstat { ... }
  Reset the stats returned by INFO.
- - (self) config_rewrite { ... }
  Rewrite the configuration file with the in memory configuration.
- - (self) config_set(parameter = nil, value = nil) { ... }
  Set a configuration parameter to the given value.
- - (self) dbsize { ... }
  Return the number of keys in the selected database.
- - (self) debug_object(key = nil) { ... }
  Get debugging information about a key.
- - (self) debug_segfault { ... }
  Make the server crash.
- - (self) decr(key = nil) { ... }
  Decrement the integer value of a key by one.
- - (self) decrby(key = nil, decrement = nil) { ... }
  Decrement the integer value of a key by the given number.
- - (self) del(key = nil) { ... }
  Delete a key.
- - (self) del_many(keys = nil) { ... }
  Delete many keys.
- - (self) dump(key = nil) { ... }
  Return a serialized version of the value stored at the specified key.
- - (self) echo(message = nil) { ... }
  Echo the given string.
- - (self) eval(script = nil, keys = nil, args = nil) { ... }
  Execute a Lua script server side.
- - (self) eval_script(script = nil, keys = nil, args = nil) { ... }
  Execute a Lua script server side.
- - (self) evalsha(sha1 = nil, keys = nil, values = nil) { ... }
  Execute a Lua script server side.
- - (self) exists(key = nil) { ... }
  Determine if a key exists.
- - (self) exists_many(keys = nil) { ... }
  Determine if one or many keys exist.
- - (self) expire(key = nil, seconds = nil) { ... }
  Set a key's time to live in seconds.
- - (self) expireat(key = nil, seconds = nil) { ... }
  Set the expiration for a key as a UNIX timestamp.
- - (self) flushall { ... }
  Remove all keys from all databases.
- - (self) flushdb { ... }
  Remove all keys from the current database.
- - (self) geoadd(key = nil, longitude = nil, latitude = nil, member = nil) { ... }
  Add one or more geospatial items in the geospatial index represented using a sorted set.
- - (self) geoadd_many(key = nil, members = nil) { ... }
  Add one or more geospatial items in the geospatial index represented using a sorted set.
- - (self) geodist(key = nil, member1 = nil, member2 = nil) { ... }
  Return the distance between two members in the geospatial index represented by the sorted set.
- - (self) geodist_with_unit(key = nil, member1 = nil, member2 = nil, unit = nil) { ... }
  Return the distance between two members in the geospatial index represented by the sorted set.
- - (self) geohash(key = nil, member = nil) { ... }
  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).
- - (self) geohash_many(key = nil, members = nil) { ... }
  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).
- - (self) geopos(key = nil, member = nil) { ... }
  Return the positions (longitude,latitude) of all the specified members of the geospatial index represented by the sorted set at key.
- - (self) geopos_many(key = nil, members = nil) { ... }
  Return the positions (longitude,latitude) of all the specified members of the geospatial index represented by the sorted set at key.
- - (self) georadius(key = nil, longitude = nil, latitude = nil, radius = nil, unit = nil) { ... }
  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).
- - (self) georadius_with_options(key = nil, longitude = nil, latitude = nil, radius = nil, unit = nil, options = nil) { ... }
  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).
- - (self) georadiusbymember(key = nil, member = nil, radius = nil, unit = nil) { ... }
  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.
- - (self) georadiusbymember_with_options(key = nil, member = nil, radius = nil, unit = nil, options = nil) { ... }
  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.
- - (self) get(key = nil) { ... }
  Get the value of a key.
- - (self) get_binary(key = nil) { ... }
  Get the value of a key - without decoding as utf-8.
- - (self) getbit(key = nil, offset = nil) { ... }
  Returns the bit value at offset in the string value stored at key.
- - (self) getrange(key = nil, start = nil, _end = nil) { ... }
  Get a substring of the string stored at a key.
- - (self) getset(key = nil, value = nil) { ... }
  Set the string value of a key and return its old value.
- - (self) hdel(key = nil, field = nil) { ... }
  Delete one or more hash fields.
- - (self) hdel_many(key = nil, fields = nil) { ... }
  Delete one or more hash fields.
- - (self) hexists(key = nil, field = nil) { ... }
  Determine if a hash field exists.
- - (self) hget(key = nil, field = nil) { ... }
  Get the value of a hash field.
- - (self) hgetall(key = nil) { ... }
  Get all the fields and values in a hash.
- - (self) hincrby(key = nil, field = nil, increment = nil) { ... }
  Increment the integer value of a hash field by the given number.
- - (self) hincrbyfloat(key = nil, field = nil, increment = nil) { ... }
  Increment the float value of a hash field by the given amount.
- - (self) hkeys(key = nil) { ... }
  Get all the fields in a hash.
- - (self) hlen(key = nil) { ... }
  Get the number of fields in a hash.
- - (self) hmget(key = nil, fields = nil) { ... }
  Get the values of all the given hash fields.
- - (self) hmset(key = nil, values = nil) { ... }
  Set multiple hash fields to multiple values.
- - (self) hscan(key = nil, cursor = nil, options = nil) { ... }
  Incrementally iterate hash fields and associated values.
- - (self) hset(key = nil, field = nil, value = nil) { ... }
  Set the string value of a hash field.
- - (self) hsetnx(key = nil, field = nil, value = nil) { ... }
  Set the value of a hash field, only if the field does not exist.
- - (self) hstrlen(key = nil, field = nil) { ... }
  Get the length of the value of a hash field.
- - (self) hvals(key = nil) { ... }
  Get all the values in a hash.
- - (self) incr(key = nil) { ... }
  Increment the integer value of a key by one.
- - (self) incrby(key = nil, increment = nil) { ... }
  Increment the integer value of a key by the given amount.
- - (self) incrbyfloat(key = nil, increment = nil) { ... }
  Increment the float value of a key by the given amount.
- - (self) info { ... }
  Get information and statistics about the server.
- - (self) info_section(section = nil) { ... }
  Get information and statistics about the server.
- - (self) keys(pattern = nil) { ... }
  Find all keys matching the given pattern.
- - (self) lastsave { ... }
  Get the UNIX time stamp of the last successful save to disk.
- - (self) lindex(key = nil, index = nil) { ... }
  Get an element from a list by its index.
- - (self) linsert(key = nil, option = nil, pivot = nil, value = nil) { ... }
  Insert an element before or after another element in a list.
- - (self) llen(key = nil) { ... }
  Get the length of a list.
- - (self) lpop(key = nil) { ... }
  Remove and get the first element in a list.
- - (self) lpush(key = nil, value = nil) { ... }
  Prepend one value to a list.
- - (self) lpush_many(key = nil, values = nil) { ... }
  Prepend one or multiple values to a list.
- - (self) lpushx(key = nil, value = nil) { ... }
  Prepend a value to a list, only if the list exists.
- - (self) lrange(key = nil, from = nil, to = nil) { ... }
  Get a range of elements from a list.
- - (self) lrem(key = nil, count = nil, value = nil) { ... }
  Remove elements from a list.
- - (self) lset(key = nil, index = nil, value = nil) { ... }
  Set the value of an element in a list by its index.
- - (self) ltrim(key = nil, from = nil, to = nil) { ... }
  Trim a list to the specified range.
- - (self) mget(key = nil) { ... }
  Get the value of the given key.
- - (self) mget_many(keys = nil) { ... }
  Get the values of all the given keys.
- - (self) migrate(host = nil, port = nil, key = nil, destdb = nil, timeout = nil, options = nil) { ... }
  Atomically transfer a key from a Redis instance to another one.
- - (self) monitor { ... }
  Listen for all requests received by the server in real time.
- - (self) move(key = nil, destdb = nil) { ... }
  Move a key to another database.
- - (self) mset(keyvals = nil) { ... }
  Set multiple keys to multiple values.
- - (self) msetnx(keyvals = nil) { ... }
  Set multiple keys to multiple values, only if none of the keys exist.
- - (self) object(key = nil, cmd = nil) { ... }
  Inspect the internals of Redis objects.
- - (self) persist(key = nil) { ... }
  Remove the expiration from a key.
- - (self) pexpire(key = nil, millis = nil) { ... }
  Set a key's time to live in milliseconds.
- - (self) pexpireat(key = nil, millis = nil) { ... }
  Set the expiration for a key as a UNIX timestamp specified in milliseconds.
- - (self) pfadd(key = nil, element = nil) { ... }
  Adds the specified element to the specified HyperLogLog.
- - (self) pfadd_many(key = nil, elements = nil) { ... }
  Adds the specified elements to the specified HyperLogLog.
- - (self) pfcount(key = nil) { ... }
  Return the approximated cardinality of the set observed by the HyperLogLog at key.
- - (self) pfcount_many(keys = nil) { ... }
  Return the approximated cardinality of the set(s) observed by the HyperLogLog at key(s).
- - (self) pfmerge(destkey = nil, keys = nil) { ... }
  Merge N different HyperLogLogs into a single one.
- - (self) ping { ... }
  Ping the server.
- - (self) psetex(key = nil, millis = nil, value = nil) { ... }
  Set the value and expiration in milliseconds of a key.
- - (self) psubscribe(pattern = nil) { ... }
  Listen for messages published to channels matching the given pattern.
- - (self) psubscribe_many(patterns = nil) { ... }
  Listen for messages published to channels matching the given patterns.
- - (self) pttl(key = nil) { ... }
  Get the time to live for a key in milliseconds.
- - (self) publish(channel = nil, message = nil) { ... }
  Post a message to a channel.
- - (self) pubsub_channels(pattern = nil) { ... }
  Lists the currently active channels - only those matching the pattern.
- - (self) pubsub_numpat { ... }
  Returns the number of subscriptions to patterns (that are performed using the PSUBSCRIBE command).
- - (self) pubsub_numsub(channels = nil) { ... }
  Returns the number of subscribers (not counting clients subscribed to patterns) for the specified channels.
- - (self) punsubscribe(patterns = nil) { ... }
  Stop listening for messages posted to channels matching the given patterns.
- - (self) randomkey { ... }
  Return a random key from the keyspace.
- - (self) rename(key = nil, newkey = nil) { ... }
  Rename a key.
- - (self) renamenx(key = nil, newkey = nil) { ... }
  Rename a key, only if the new key does not exist.
- - (self) restore(key = nil, millis = nil, serialized = nil) { ... }
  Create a key using the provided serialized value, previously obtained using DUMP.
- - (self) role { ... }
  Return the role of the instance in the context of replication.
- - (self) rpop(key = nil) { ... }
  Remove and get the last element in a list.
- - (self) rpoplpush(key = nil, destkey = nil) { ... }
  Remove the last element in a list, append it to another list and return it.
- - (self) rpush(key = nil, value = nil) { ... }
  Append one or multiple values to a list.
- - (self) rpush_many(key = nil, values = nil) { ... }
  Append one or multiple values to a list.
- - (self) rpushx(key = nil, value = nil) { ... }
  Append a value to a list, only if the list exists.
- - (self) sadd(key = nil, member = nil) { ... }
  Add a member to a set.
- - (self) sadd_many(key = nil, members = nil) { ... }
  Add one or more members to a set.
- - (self) save { ... }
  Synchronously save the dataset to disk.
- - (self) scan(cursor = nil, options = nil) { ... }
  Incrementally iterate the keys space.
- - (self) scard(key = nil) { ... }
  Get the number of members in a set.
- - (self) script_debug(scriptDebugOptions = nil) { ... }
  Set the debug mode for executed scripts.
- - (self) script_exists(script = nil) { ... }
  Check existence of script in the script cache.
- - (self) script_exists_many(scripts = nil) { ... }
  Check existence of scripts in the script cache.
- - (self) script_flush { ... }
  Remove all the scripts from the script cache.
- - (self) script_kill { ... }
  Kill the script currently in execution.
- - (self) script_load(script = nil) { ... }
  Load the specified Lua script into the script cache.
- - (self) sdiff(key = nil, cmpkeys = nil) { ... }
  Subtract multiple sets.
- - (self) sdiffstore(destkey = nil, key = nil, cmpkeys = nil) { ... }
  Subtract multiple sets and store the resulting set in a key.
- - (self) select(dbindex = nil) { ... }
  Change the selected database for the current connection.
- - (self) set(key = nil, value = nil) { ... }
  Set the string value of a key.
- - (self) set_binary(key = nil, value = nil) { ... }
  Set the binary string value of a key - without encoding as utf-8.
- - (self) set_binary_with_options(key = nil, value = nil, options = nil) { ... }
  Set the string value of a key.
- - (self) set_with_options(key = nil, value = nil, options = nil) { ... }
  Set the string value of a key.
- - (self) setbit(key = nil, offset = nil, bit = nil) { ... }
  Sets or clears the bit at offset in the string value stored at key.
- - (self) setex(key = nil, seconds = nil, value = nil) { ... }
  Set the value and expiration of a key.
- - (self) setnx(key = nil, value = nil) { ... }
  Set the value of a key, only if the key does not exist.
- - (self) setrange(key = nil, offset = nil, value = nil) { ... }
  Overwrite part of a string at key starting at the specified offset.
- - (self) sinter(keys = nil) { ... }
  Intersect multiple sets.
- - (self) sinterstore(destkey = nil, keys = nil) { ... }
  Intersect multiple sets and store the resulting set in a key.
- - (self) sismember(key = nil, member = nil) { ... }
  Determine if a given value is a member of a set.
- - (self) slaveof(host = nil, port = nil) { ... }
  Make the server a slave of another instance.
- - (self) slaveof_noone { ... }
  Make this server a master.
- - (self) slowlog_get(limit = nil) { ... }
  Read the Redis slow queries log.
- - (self) slowlog_len { ... }
  Get the length of the Redis slow queries log.
- - (self) slowlog_reset { ... }
  Reset the Redis slow queries log.
- - (self) smembers(key = nil) { ... }
  Get all the members in a set.
- - (self) smove(key = nil, destkey = nil, member = nil) { ... }
  Move a member from one set to another.
- - (self) sort(key = nil, options = nil) { ... }
  Sort the elements in a list, set or sorted set.
- - (self) spop(key = nil) { ... }
  Remove and return a random member from a set.
- - (self) spop_many(key = nil, count = nil) { ... }
  Remove and return random members from a set.
- - (self) srandmember(key = nil) { ... }
  Get one or multiple random members from a set.
- - (self) srandmember_count(key = nil, count = nil) { ... }
  Get one or multiple random members from a set.
- - (self) srem(key = nil, member = nil) { ... }
  Remove one member from a set.
- - (self) srem_many(key = nil, members = nil) { ... }
  Remove one or more members from a set.
- - (self) sscan(key = nil, cursor = nil, options = nil) { ... }
  Incrementally iterate Set elements.
- - (self) strlen(key = nil) { ... }
  Get the length of the value stored in a key.
- - (self) subscribe(channel = nil) { ... }
  Listen for messages published to the given channels.
- - (self) subscribe_many(channels = nil) { ... }
  Listen for messages published to the given channels.
- - (self) sunion(keys = nil) { ... }
  Add multiple sets.
- - (self) sunionstore(destkey = nil, keys = nil) { ... }
  Add multiple sets and store the resulting set in a key.
- - (self) swapdb(index1 = nil, index2 = nil) { ... }
  Swaps two Redis databases.
- - (self) sync { ... }
  Internal command used for replication.
- - (self) time { ... }
  Return the current server time.
- - (self) touch(key = nil) { ... }
  Alters the last access time of a key(s).
- - (self) touch_many(keys = nil) { ... }
  Alters the last access time of a key(s).
- - (::VertxRedis::RedisTransaction) transaction
  Return a RedisTransaction instance.
- - (self) ttl(key = nil) { ... }
  Get the time to live for a key.
- - (self) type(key = nil) { ... }
  Determine the type stored at key.
- - (self) unlink(key = nil) { ... }
  Delete a key asynchronously in another thread.
- - (self) unlink_many(keys = nil) { ... }
  Delete multiple keys asynchronously in another thread.
- - (self) unsubscribe(channels = nil) { ... }
  Stop listening for messages posted to the given channels.
- - (self) wait(numSlaves = nil, timeout = nil) { ... }
  Wait for the synchronous replication of all the write commands sent in the context of the current connection.
- - (self) zadd(key = nil, score = nil, member = nil) { ... }
  Add one or more members to a sorted set, or update its score if it already exists.
- - (self) zadd_many(key = nil, members = nil) { ... }
  Add one or more members to a sorted set, or update its score if it already exists.
- - (self) zcard(key = nil) { ... }
  Get the number of members in a sorted set.
- - (self) zcount(key = nil, min = nil, max = nil) { ... }
  Count the members in a sorted set with scores within the given values.
- - (self) zincrby(key = nil, increment = nil, member = nil) { ... }
  Increment the score of a member in a sorted set.
- - (self) zinterstore(destkey = nil, sets = nil, options = nil) { ... }
  Intersect multiple sorted sets and store the resulting sorted set in a new key.
- - (self) zinterstore_weighed(destkey = nil, sets = nil, options = nil) { ... }
  Intersect multiple sorted sets and store the resulting sorted set in a new key using weights for scoring.
- - (self) zlexcount(key = nil, min = nil, max = nil) { ... }
  Count the number of members in a sorted set between a given lexicographical range.
- - (self) zrange(key = nil, start = nil, stop = nil) { ... }
  Return a range of members in a sorted set, by index.
- - (self) zrange_with_options(key = nil, start = nil, stop = nil, options = nil) { ... }
  Return a range of members in a sorted set, by index.
- - (self) zrangebylex(key = nil, min = nil, max = nil, options = nil) { ... }
  Return a range of members in a sorted set, by lexicographical range.
- - (self) zrangebyscore(key = nil, min = nil, max = nil, options = nil) { ... }
  Return a range of members in a sorted set, by score.
- - (self) zrank(key = nil, member = nil) { ... }
  Determine the index of a member in a sorted set.
- - (self) zrem(key = nil, member = nil) { ... }
  Remove one member from a sorted set.
- - (self) zrem_many(key = nil, members = nil) { ... }
  Remove one or more members from a sorted set.
- - (self) zremrangebylex(key = nil, min = nil, max = nil) { ... }
  Remove all members in a sorted set between the given lexicographical range.
- - (self) zremrangebyrank(key = nil, start = nil, stop = nil) { ... }
  Remove all members in a sorted set within the given indexes.
- - (self) zremrangebyscore(key = nil, min = nil, max = nil) { ... }
  Remove all members in a sorted set within the given scores.
- - (self) zrevrange(key = nil, start = nil, stop = nil, options = nil) { ... }
  Return a range of members in a sorted set, by index, with scores ordered from high to low.
- - (self) zrevrangebylex(key = nil, max = nil, min = nil, options = nil) { ... }
  Return a range of members in a sorted set, by score, between the given lexicographical range with scores ordered from high to low.
- - (self) zrevrangebyscore(key = nil, max = nil, min = nil, options = nil) { ... }
  Return a range of members in a sorted set, by score, with scores ordered from high to low.
- - (self) zrevrank(key = nil, member = nil) { ... }
  Determine the index of a member in a sorted set, with scores ordered from high to low.
- - (self) zscan(key = nil, cursor = nil, options = nil) { ... }
  Incrementally iterate sorted sets elements and associated scores.
- - (self) zscore(key = nil, member = nil) { ... }
  Get the score associated with the given member in a sorted set.
- - (self) zunionstore(destkey = nil, sets = nil, options = nil) { ... }
  Add multiple sorted sets and store the resulting sorted set in a new key.
- - (self) zunionstore_weighed(key = nil, sets = nil, options = nil) { ... }
  Add multiple sorted sets using weights, and store the resulting sorted set in a new key.

## Class Method Details

### + (`Boolean`) accept?(obj)

Returns:

- (`Boolean`)

    22
    23
    24
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx-redis/redis_client.rb', line 22

    def @@j_api_type.accept?(obj)
      obj.class == RedisClient
    end

### + (`::VertxRedis::RedisClient`) create(vertx = nil, config = nil)

Parameters:

- vertx (`::Vertx::Vertx`) (defaults to: `nil`)
- config (`Hash{String => Object}`) (defaults to: `nil`)

Returns:

- (`::VertxRedis::RedisClient`)

Raises:

- (`ArgumentError`)

    40
    41
    42
    43
    44
    45
    46
    47
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx-redis/redis_client.rb', line 40

    def self.create(vertx=nil,config=nil)
      if vertx.class.method_defined?(:j_del) && !block_given? && config == nil
        return ::Vertx::Util::Utils.safe_create(Java::IoVertxRedis::RedisClient.java_method(:create, [Java::IoVertxCore::Vertx.java_class]).call(vertx.j_del),::VertxRedis::RedisClient)
      elsif vertx.class.method_defined?(:j_del) && config.class == Hash && !block_given?
        return ::Vertx::Util::Utils.safe_create(Java::IoVertxRedis::RedisClient.java_method(:create, [Java::IoVertxCore::Vertx.java_class,Java::IoVertxCoreJson::JsonObject.java_class]).call(vertx.j_del,::Vertx::Util::Utils.to_json_object(config)),::VertxRedis::RedisClient)
      end
      raise ArgumentError, "Invalid arguments when calling create(#{vertx},#{config})"
    end

### + (`Object`) j_api_type

    31
    32
    33
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx-redis/redis_client.rb', line 31

    def self.j_api_type
      @@j_api_type
    end

### + (`Object`) j_class

    34
    35
    36
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx-redis/redis_client.rb', line 34

    def self.j_class
      Java::IoVertxRedis::RedisClient.java_class
    end

### + (`Object`) unwrap(obj)

    28
    29
    30
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx-redis/redis_client.rb', line 28

    def @@j_api_type.unwrap(obj)
      obj.j_del
    end

### + (`Object`) wrap(obj)

    25
    26
    27
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx-redis/redis_client.rb', line 25

    def @@j_api_type.wrap(obj)
      RedisClient.new(obj)
    end

## Instance Method Details

### - (`self`) append(key = nil, value = nil) { ... }

Append a value to a key

Parameters:

- key (`String`) (defaults to: `nil`) —
  Key string
- value (`String`) (defaults to: `nil`) —
  Value to append

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    62
    63
    64
    65
    66
    67
    68
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx-redis/redis_client.rb', line 62

    def append(key=nil,value=nil)
      if key.class == String && value.class == String && block_given?
        @j_del.java_method(:append, [Java::java.lang.String.java_class,Java::java.lang.String.java_class,Java::IoVertxCore::Handler.java_class]).call(key,value,(Proc.new { |ar| yield(ar.failed ? ar.cause : nil, ar.succeeded ? ar.result : nil) }))
        return self
      end
      raise ArgumentError, "Invalid arguments when calling append(#{key},#{value})"
    end

### - (`self`) auth(password = nil) { ... }

Authenticate to the server

Parameters:

- password (`String`) (defaults to: `nil`) —
  Password for authentication

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    73
    74
    75
    76
    77
    78
    79
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx-redis/redis_client.rb', line 73

    def auth(password=nil)
      if password.class == String && block_given?
        @j_del.java_method(:auth, [Java::java.lang.String.java_class,Java::IoVertxCore::Handler.java_class]).call(password,(Proc.new { |ar| yield(ar.failed ? ar.cause : nil, ar.succeeded ? ar.result : nil) }))
        return self
      end
      raise ArgumentError, "Invalid arguments when calling auth(#{password})"
    end

### - (`self`) bgrewriteaof { ... }

Asynchronously rewrite the append-only file

Yields:

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    83
    84
    85
    86
    87
    88
    89
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx-redis/redis_client.rb', line 83

    def bgrewriteaof
      if block_given?
        @j_del.java_method(:bgrewriteaof, [Java::IoVertxCore::Handler.java_class]).call((Proc.new { |ar| yield(ar.failed ? ar.cause : nil, ar.succeeded ? ar.result : nil) }))
        return self
      end
      raise ArgumentError, "Invalid arguments when calling bgrewriteaof()"
    end

### - (`self`) bgsave { ... }

Asynchronously save the dataset to disk

Yields:

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    93
    94
    95
    96
    97
    98
    99
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx-redis/redis_client.rb', line 93

    def bgsave
      if block_given?
        @j_del.java_method(:bgsave, [Java::IoVertxCore::Handler.java_class]).call((Proc.new { |ar| yield(ar.failed ? ar.cause : nil, ar.succeeded ? ar.result : nil) }))
        return self
      end
      raise ArgumentError, "Invalid arguments when calling bgsave()"
    end

### - (`self`) bitcount(key = nil) { ... }

Count set bits in a string

Parameters:

- key (`String`) (defaults to: `nil`) —
  Key string

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    104
    105
    106
    107
    108
    109
    110
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx-redis/redis_client.rb', line 104

    def bitcount(key=nil)
      if key.class == String && block_given?
        @j_del.java_method(:bitcount, [Java::java.lang.String.java_class,Java::IoVertxCore::Handler.java_class]).call(key,(Proc.new { |ar| yield(ar.failed ? ar.cause : nil, ar.succeeded ? ar.result : nil) }))
        return self
      end
      raise ArgumentError, "Invalid arguments when calling bitcount(#{key})"
    end

### - (`self`) bitcount_range(key = nil, start = nil, _end = nil) { ... }

Count set bits in a string

Parameters:

- key (`String`) (defaults to: `nil`) —
  Key string
- start (`Fixnum`) (defaults to: `nil`) —
  Start index
- _end (`Fixnum`) (defaults to: `nil`) —
  End index

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    117
    118
    119
    120
    121
    122
    123
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx-redis/redis_client.rb', line 117

    def bitcount_range(key=nil,start=nil,_end=nil)
      if key.class == String && start.class == Fixnum && _end.class == Fixnum && block_given?
        @j_del.java_method(:bitcountRange, [Java::java.lang.String.java_class,Java::long.java_class,Java::long.java_class,Java::IoVertxCore::Handler.java_class]).call(key,start,_end,(Proc.new { |ar| yield(ar.failed ? ar.cause : nil, ar.succeeded ? ar.result : nil) }))
        return self
      end
      raise ArgumentError, "Invalid arguments when calling bitcount_range(#{key},#{start},#{_end})"
    end

### - (`self`) bitfield(key = nil, bitFieldOptions = nil) { ... }

Perform arbitrary bitfield integer operations on strings.

Parameters:

- key (`String`) (defaults to: `nil`) —
  Key string
- bitFieldOptions (`Hash`) (defaults to: `nil`)

Yields:

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    2854
    2855
    2856
    2857
    2858
    2859
    2860
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx-redis/redis_client.rb', line 2854

    def bitfield(key=nil,bitFieldOptions=nil)
      if key.class == String && bitFieldOptions.class == Hash && block_given?
        @j_del.java_method(:bitfield, [Java::java.lang.String.java_class,Java::IoVertxRedisOp::BitFieldOptions.java_class,Java::IoVertxCore::Handler.java_class]).call(key,Java::IoVertxRedisOp::BitFieldOptions.new(::Vertx::Util::Utils.to_json_object(bitFieldOptions)),(Proc.new { |ar| yield(ar.failed ? ar.cause : nil, ar.succeeded ? ar.result != nil ? JSON.parse(ar.result.encode) : nil : nil) }))
        return self
      end
      raise ArgumentError, "Invalid arguments when calling bitfield(#{key},#{bitFieldOptions})"
    end

### - (`self`) bitfield_with_overflow(key = nil, commands = nil, overflow = nil) { ... }

Perform arbitrary bitfield integer operations on strings.

Parameters:

- key (`String`) (defaults to: `nil`) —
  Key string
- commands (`Hash`) (defaults to: `nil`)
- overflow (`:WRAP`, `:SAT`, `:FAIL`) (defaults to: `nil`)

Yields:

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    2867
    2868
    2869
    2870
    2871
    2872
    2873
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx-redis/redis_client.rb', line 2867

    def bitfield_with_overflow(key=nil,commands=nil,overflow=nil)
      if key.class == String && commands.class == Hash && overflow.class == Symbol && block_given?
        @j_del.java_method(:bitfieldWithOverflow, [Java::java.lang.String.java_class,Java::IoVertxRedisOp::BitFieldOptions.java_class,Java::IoVertxRedisOp::BitFieldOverflowOptions.java_class,Java::IoVertxCore::Handler.java_class]).call(key,Java::IoVertxRedisOp::BitFieldOptions.new(::Vertx::Util::Utils.to_json_object(commands)),Java::IoVertxRedisOp::BitFieldOverflowOptions.valueOf(overflow.to_s),(Proc.new { |ar| yield(ar.failed ? ar.cause : nil, ar.succeeded ? ar.result != nil ? JSON.parse(ar.result.encode) : nil : nil) }))
        return self
      end
      raise ArgumentError, "Invalid arguments when calling bitfield_with_overflow(#{key},#{commands},#{overflow})"
    end

### - (`self`) bitop(operation = nil, destkey = nil, keys = nil) { ... }

Perform bitwise operations between strings

Parameters:

- operation (`:AND`, `:OR`, `:XOR`, `:NOT`) (defaults to: `nil`) —
  Bitwise operation to perform
- destkey (`String`) (defaults to: `nil`) —
  Destination key where result is stored
- keys (`Array<String>`) (defaults to: `nil`) —
  List of keys on which to perform the operation

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    130
    131
    132
    133
    134
    135
    136
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx-redis/redis_client.rb', line 130

    def bitop(operation=nil,destkey=nil,keys=nil)
      if operation.class == Symbol && destkey.class == String && keys.class == Array && block_given?
        @j_del.java_method(:bitop, [Java::IoVertxRedisOp::BitOperation.java_class,Java::java.lang.String.java_class,Java::JavaUtil::List.java_class,Java::IoVertxCore::Handler.java_class]).call(Java::IoVertxRedisOp::BitOperation.valueOf(operation.to_s),destkey,keys.map { |element| element },(Proc.new { |ar| yield(ar.failed ? ar.cause : nil, ar.succeeded ? ar.result : nil) }))
        return self
      end
      raise ArgumentError, "Invalid arguments when calling bitop(#{operation},#{destkey},#{keys})"
    end

### - (`self`) bitpos(key = nil, bit = nil) { ... }

Find first bit set or clear in a string

Parameters:

- key (`String`) (defaults to: `nil`) —
  Key string
- bit (`Fixnum`) (defaults to: `nil`) —
  What bit value to look for - must be 1, or 0

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    142
    143
    144
    145
    146
    147
    148
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx-redis/redis_client.rb', line 142

    def bitpos(key=nil,bit=nil)
      if key.class == String && bit.class == Fixnum && block_given?
        @j_del.java_method(:bitpos, [Java::java.lang.String.java_class,Java::int.java_class,Java::IoVertxCore::Handler.java_class]).call(key,bit,(Proc.new { |ar| yield(ar.failed ? ar.cause : nil, ar.succeeded ? ar.result : nil) }))
        return self
      end
      raise ArgumentError, "Invalid arguments when calling bitpos(#{key},#{bit})"
    end

### - (`self`) bitpos_from(key = nil, bit = nil, start = nil) { ... }

Find first bit set or clear in a string See also bitposRange() method, which takes start, and stop offset.

Parameters:

- key (`String`) (defaults to: `nil`) —
  Key string
- bit (`Fixnum`) (defaults to: `nil`) —
  What bit value to look for - must be 1, or 0
- start (`Fixnum`) (defaults to: `nil`) —
  Start offset

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    157
    158
    159
    160
    161
    162
    163
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx-redis/redis_client.rb', line 157

    def bitpos_from(key=nil,bit=nil,start=nil)
      if key.class == String && bit.class == Fixnum && start.class == Fixnum && block_given?
        @j_del.java_method(:bitposFrom, [Java::java.lang.String.java_class,Java::int.java_class,Java::int.java_class,Java::IoVertxCore::Handler.java_class]).call(key,bit,start,(Proc.new { |ar| yield(ar.failed ? ar.cause : nil, ar.succeeded ? ar.result : nil) }))
        return self
      end
      raise ArgumentError, "Invalid arguments when calling bitpos_from(#{key},#{bit},#{start})"
    end

### - (`self`) bitpos_range(key = nil, bit = nil, start = nil, stop = nil) { ... }

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 (`String`) (defaults to: `nil`) —
  Key string
- bit (`Fixnum`) (defaults to: `nil`) —
  What bit value to look for - must be 1, or 0
- start (`Fixnum`) (defaults to: `nil`) —
  Start offset
- stop (`Fixnum`) (defaults to: `nil`) —
  End offset - inclusive

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    174
    175
    176
    177
    178
    179
    180
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx-redis/redis_client.rb', line 174

    def bitpos_range(key=nil,bit=nil,start=nil,stop=nil)
      if key.class == String && bit.class == Fixnum && start.class == Fixnum && stop.class == Fixnum && block_given?
        @j_del.java_method(:bitposRange, [Java::java.lang.String.java_class,Java::int.java_class,Java::int.java_class,Java::int.java_class,Java::IoVertxCore::Handler.java_class]).call(key,bit,start,stop,(Proc.new { |ar| yield(ar.failed ? ar.cause : nil, ar.succeeded ? ar.result : nil) }))
        return self
      end
      raise ArgumentError, "Invalid arguments when calling bitpos_range(#{key},#{bit},#{start},#{stop})"
    end

### - (`self`) blpop(key = nil, seconds = nil) { ... }

Remove and get the first element in a list, or block until one is available

Parameters:

- key (`String`) (defaults to: `nil`) —
  Key string identifying a list to watch
- seconds (`Fixnum`) (defaults to: `nil`) —
  Timeout in seconds

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    186
    187
    188
    189
    190
    191
    192
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx-redis/redis_client.rb', line 186

    def blpop(key=nil,seconds=nil)
      if key.class == String && seconds.class == Fixnum && block_given?
        @j_del.java_method(:blpop, [Java::java.lang.String.java_class,Java::int.java_class,Java::IoVertxCore::Handler.java_class]).call(key,seconds,(Proc.new { |ar| yield(ar.failed ? ar.cause : nil, ar.succeeded ? ar.result != nil ? JSON.parse(ar.result.encode) : nil : nil) }))
        return self
      end
      raise ArgumentError, "Invalid arguments when calling blpop(#{key},#{seconds})"
    end

### - (`self`) blpop_many(keys = nil, seconds = nil) { ... }

Remove and get the first element in any of the lists, or block until one is available

Parameters:

- keys (`Array<String>`) (defaults to: `nil`) —
  List of key strings identifying lists to watch
- seconds (`Fixnum`) (defaults to: `nil`) —
  Timeout in seconds

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    198
    199
    200
    201
    202
    203
    204
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx-redis/redis_client.rb', line 198

    def blpop_many(keys=nil,seconds=nil)
      if keys.class == Array && seconds.class == Fixnum && block_given?
        @j_del.java_method(:blpopMany, [Java::JavaUtil::List.java_class,Java::int.java_class,Java::IoVertxCore::Handler.java_class]).call(keys.map { |element| element },seconds,(Proc.new { |ar| yield(ar.failed ? ar.cause : nil, ar.succeeded ? ar.result != nil ? JSON.parse(ar.result.encode) : nil : nil) }))
        return self
      end
      raise ArgumentError, "Invalid arguments when calling blpop_many(#{keys},#{seconds})"
    end

### - (`self`) brpop(key = nil, seconds = nil) { ... }

Remove and get the last element in a list, or block until one is available

Parameters:

- key (`String`) (defaults to: `nil`) —
  Key string identifying a list to watch
- seconds (`Fixnum`) (defaults to: `nil`) —
  Timeout in seconds

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    210
    211
    212
    213
    214
    215
    216
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx-redis/redis_client.rb', line 210

    def brpop(key=nil,seconds=nil)
      if key.class == String && seconds.class == Fixnum && block_given?
        @j_del.java_method(:brpop, [Java::java.lang.String.java_class,Java::int.java_class,Java::IoVertxCore::Handler.java_class]).call(key,seconds,(Proc.new { |ar| yield(ar.failed ? ar.cause : nil, ar.succeeded ? ar.result != nil ? JSON.parse(ar.result.encode) : nil : nil) }))
        return self
      end
      raise ArgumentError, "Invalid arguments when calling brpop(#{key},#{seconds})"
    end

### - (`self`) brpop_many(keys = nil, seconds = nil) { ... }

Remove and get the last element in any of the lists, or block until one is available

Parameters:

- keys (`Array<String>`) (defaults to: `nil`) —
  List of key strings identifying lists to watch
- seconds (`Fixnum`) (defaults to: `nil`) —
  Timeout in seconds

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    222
    223
    224
    225
    226
    227
    228
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx-redis/redis_client.rb', line 222

    def brpop_many(keys=nil,seconds=nil)
      if keys.class == Array && seconds.class == Fixnum && block_given?
        @j_del.java_method(:brpopMany, [Java::JavaUtil::List.java_class,Java::int.java_class,Java::IoVertxCore::Handler.java_class]).call(keys.map { |element| element },seconds,(Proc.new { |ar| yield(ar.failed ? ar.cause : nil, ar.succeeded ? ar.result != nil ? JSON.parse(ar.result.encode) : nil : nil) }))
        return self
      end
      raise ArgumentError, "Invalid arguments when calling brpop_many(#{keys},#{seconds})"
    end

### - (`self`) brpoplpush(key = nil, destkey = nil, seconds = nil) { ... }

Pop a value from a list, push it to another list and return it; or block until one is available

Parameters:

- key (`String`) (defaults to: `nil`) —
  Key string identifying the source list
- destkey (`String`) (defaults to: `nil`) —
  Key string identifying the destination list
- seconds (`Fixnum`) (defaults to: `nil`) —
  Timeout in seconds

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    235
    236
    237
    238
    239
    240
    241
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx-redis/redis_client.rb', line 235

    def brpoplpush(key=nil,destkey=nil,seconds=nil)
      if key.class == String && destkey.class == String && seconds.class == Fixnum && block_given?
        @j_del.java_method(:brpoplpush, [Java::java.lang.String.java_class,Java::java.lang.String.java_class,Java::int.java_class,Java::IoVertxCore::Handler.java_class]).call(key,destkey,seconds,(Proc.new { |ar| yield(ar.failed ? ar.cause : nil, ar.succeeded ? ar.result : nil) }))
        return self
      end
      raise ArgumentError, "Invalid arguments when calling brpoplpush(#{key},#{destkey},#{seconds})"
    end

### - (`self`) client_getname { ... }

Get the current connection name

Yields:

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    266
    267
    268
    269
    270
    271
    272
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx-redis/redis_client.rb', line 266

    def client_getname
      if block_given?
        @j_del.java_method(:clientGetname, [Java::IoVertxCore::Handler.java_class]).call((Proc.new { |ar| yield(ar.failed ? ar.cause : nil, ar.succeeded ? ar.result : nil) }))
        return self
      end
      raise ArgumentError, "Invalid arguments when calling client_getname()"
    end

### - (`self`) client_kill(filter = nil) { ... }

Kill the connection of a client

Parameters:

- filter (`Hash`) (defaults to: `nil`) —
  Filter options

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    246
    247
    248
    249
    250
    251
    252
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx-redis/redis_client.rb', line 246

    def client_kill(filter=nil)
      if filter.class == Hash && block_given?
        @j_del.java_method(:clientKill, [Java::IoVertxRedisOp::KillFilter.java_class,Java::IoVertxCore::Handler.java_class]).call(Java::IoVertxRedisOp::KillFilter.new(::Vertx::Util::Utils.to_json_object(filter)),(Proc.new { |ar| yield(ar.failed ? ar.cause : nil, ar.succeeded ? ar.result : nil) }))
        return self
      end
      raise ArgumentError, "Invalid arguments when calling client_kill(#{filter})"
    end

### - (`self`) client_list { ... }

Get the list of client connections

Yields:

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    256
    257
    258
    259
    260
    261
    262
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx-redis/redis_client.rb', line 256

    def client_list
      if block_given?
        @j_del.java_method(:clientList, [Java::IoVertxCore::Handler.java_class]).call((Proc.new { |ar| yield(ar.failed ? ar.cause : nil, ar.succeeded ? ar.result : nil) }))
        return self
      end
      raise ArgumentError, "Invalid arguments when calling client_list()"
    end

### - (`self`) client_pause(millis = nil) { ... }

Stop processing commands from clients for some time

Parameters:

- millis (`Fixnum`) (defaults to: `nil`) —
  Pause time in milliseconds

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    277
    278
    279
    280
    281
    282
    283
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx-redis/redis_client.rb', line 277

    def client_pause(millis=nil)
      if millis.class == Fixnum && block_given?
        @j_del.java_method(:clientPause, [Java::long.java_class,Java::IoVertxCore::Handler.java_class]).call(millis,(Proc.new { |ar| yield(ar.failed ? ar.cause : nil, ar.succeeded ? ar.result : nil) }))
        return self
      end
      raise ArgumentError, "Invalid arguments when calling client_pause(#{millis})"
    end

### - (`self`) client_reply(options = nil) { ... }

Instruct the server whether to reply to commands.

Parameters:

- options (`:ON`, `:OFF`, `:SKIP`) (defaults to: `nil`)

Yields:

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    2797
    2798
    2799
    2800
    2801
    2802
    2803
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx-redis/redis_client.rb', line 2797

    def client_reply(options=nil)
      if options.class == Symbol && block_given?
        @j_del.java_method(:clientReply, [Java::IoVertxRedisOp::ClientReplyOptions.java_class,Java::IoVertxCore::Handler.java_class]).call(Java::IoVertxRedisOp::ClientReplyOptions.valueOf(options.to_s),(Proc.new { |ar| yield(ar.failed ? ar.cause : nil, ar.succeeded ? ar.result : nil) }))
        return self
      end
      raise ArgumentError, "Invalid arguments when calling client_reply(#{options})"
    end

### - (`self`) client_setname(name = nil) { ... }

Set the current connection name

Parameters:

- name (`String`) (defaults to: `nil`) —
  New name for current connection

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    288
    289
    290
    291
    292
    293
    294
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx-redis/redis_client.rb', line 288

    def client_setname(name=nil)
      if name.class == String && block_given?
        @j_del.java_method(:clientSetname, [Java::java.lang.String.java_class,Java::IoVertxCore::Handler.java_class]).call(name,(Proc.new { |ar| yield(ar.failed ? ar.cause : nil, ar.succeeded ? ar.result : nil) }))
        return self
      end
      raise ArgumentError, "Invalid arguments when calling client_setname(#{name})"
    end

### - (`void`) close { ... }

This method returns an undefined value.

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

Yields:

Raises:

- (`ArgumentError`)

    51
    52
    53
    54
    55
    56
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx-redis/redis_client.rb', line 51

    def close
      if block_given?
        return @j_del.java_method(:close, [Java::IoVertxCore::Handler.java_class]).call((Proc.new { |ar| yield(ar.failed ? ar.cause : nil) }))
      end
      raise ArgumentError, "Invalid arguments when calling close()"
    end

### - (`self`) cluster_addslots(slots = nil) { ... }

Assign new hash slots to receiving node.

Parameters:

- slots (`Array<Fixnum>`) (defaults to: `nil`)

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    299
    300
    301
    302
    303
    304
    305
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx-redis/redis_client.rb', line 299

    def cluster_addslots(slots=nil)
      if slots.class == Array && block_given?
        @j_del.java_method(:clusterAddslots, [Java::JavaUtil::List.java_class,Java::IoVertxCore::Handler.java_class]).call(slots.map { |element| element },(Proc.new { |ar| yield(ar.failed ? ar.cause : nil) }))
        return self
      end
      raise ArgumentError, "Invalid arguments when calling cluster_addslots(#{slots})"
    end

### - (`self`) cluster_count_failure_reports(nodeId = nil) { ... }

Return the number of failure reports active for a given node.

Parameters:

- nodeId (`String`) (defaults to: `nil`)

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    310
    311
    312
    313
    314
    315
    316
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx-redis/redis_client.rb', line 310

    def cluster_count_failure_reports(nodeId=nil)
      if nodeId.class == String && block_given?
        @j_del.java_method(:clusterCountFailureReports, [Java::java.lang.String.java_class,Java::IoVertxCore::Handler.java_class]).call(nodeId,(Proc.new { |ar| yield(ar.failed ? ar.cause : nil, ar.succeeded ? ar.result : nil) }))
        return self
      end
      raise ArgumentError, "Invalid arguments when calling cluster_count_failure_reports(#{nodeId})"
    end

### - (`self`) cluster_countkeysinslot(slot = nil) { ... }

Return the number of local keys in the specified hash slot.

Parameters:

- slot (`Fixnum`) (defaults to: `nil`)

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    321
    322
    323
    324
    325
    326
    327
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx-redis/redis_client.rb', line 321

    def cluster_countkeysinslot(slot=nil)
      if slot.class == Fixnum && block_given?
        @j_del.java_method(:clusterCountkeysinslot, [Java::long.java_class,Java::IoVertxCore::Handler.java_class]).call(slot,(Proc.new { |ar| yield(ar.failed ? ar.cause : nil, ar.succeeded ? ar.result : nil) }))
        return self
      end
      raise ArgumentError, "Invalid arguments when calling cluster_countkeysinslot(#{slot})"
    end

### - (`self`) cluster_delslots(slot = nil) { ... }

Set hash slots as unbound in receiving node.

Parameters:

- slot (`Fixnum`) (defaults to: `nil`)

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    332
    333
    334
    335
    336
    337
    338
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx-redis/redis_client.rb', line 332

    def cluster_delslots(slot=nil)
      if slot.class == Fixnum && block_given?
        @j_del.java_method(:clusterDelslots, [Java::long.java_class,Java::IoVertxCore::Handler.java_class]).call(slot,(Proc.new { |ar| yield(ar.failed ? ar.cause : nil) }))
        return self
      end
      raise ArgumentError, "Invalid arguments when calling cluster_delslots(#{slot})"
    end

### - (`self`) cluster_delslots_many(slots = nil) { ... }

Set hash slots as unbound in receiving node.

Parameters:

- slots (`Array<Fixnum>`) (defaults to: `nil`)

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    343
    344
    345
    346
    347
    348
    349
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx-redis/redis_client.rb', line 343

    def cluster_delslots_many(slots=nil)
      if slots.class == Array && block_given?
        @j_del.java_method(:clusterDelslotsMany, [Java::JavaUtil::List.java_class,Java::IoVertxCore::Handler.java_class]).call(slots.map { |element| element },(Proc.new { |ar| yield(ar.failed ? ar.cause : nil) }))
        return self
      end
      raise ArgumentError, "Invalid arguments when calling cluster_delslots_many(#{slots})"
    end

### - (`self`) cluster_fail_over_with_options(options = nil) { ... }

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

Parameters:

- options (`:FORCE`, `:TAKEOVER`) (defaults to: `nil`)

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    364
    365
    366
    367
    368
    369
    370
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx-redis/redis_client.rb', line 364

    def cluster_fail_over_with_options(options=nil)
      if options.class == Symbol && block_given?
        @j_del.java_method(:clusterFailOverWithOptions, [Java::IoVertxRedisOp::FailoverOptions.java_class,Java::IoVertxCore::Handler.java_class]).call(Java::IoVertxRedisOp::FailoverOptions.valueOf(options.to_s),(Proc.new { |ar| yield(ar.failed ? ar.cause : nil) }))
        return self
      end
      raise ArgumentError, "Invalid arguments when calling cluster_fail_over_with_options(#{options})"
    end

### - (`self`) cluster_failover { ... }

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

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    353
    354
    355
    356
    357
    358
    359
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx-redis/redis_client.rb', line 353

    def cluster_failover
      if block_given?
        @j_del.java_method(:clusterFailover, [Java::IoVertxCore::Handler.java_class]).call((Proc.new { |ar| yield(ar.failed ? ar.cause : nil) }))
        return self
      end
      raise ArgumentError, "Invalid arguments when calling cluster_failover()"
    end

### - (`self`) cluster_forget(nodeId = nil) { ... }

Remove a node from the nodes table.

Parameters:

- nodeId (`String`) (defaults to: `nil`)

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    375
    376
    377
    378
    379
    380
    381
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx-redis/redis_client.rb', line 375

    def cluster_forget(nodeId=nil)
      if nodeId.class == String && block_given?
        @j_del.java_method(:clusterForget, [Java::java.lang.String.java_class,Java::IoVertxCore::Handler.java_class]).call(nodeId,(Proc.new { |ar| yield(ar.failed ? ar.cause : nil) }))
        return self
      end
      raise ArgumentError, "Invalid arguments when calling cluster_forget(#{nodeId})"
    end

### - (`self`) cluster_getkeysinslot(slot = nil, count = nil) { ... }

Return local key names in the specified hash slot.

Parameters:

- slot (`Fixnum`) (defaults to: `nil`)
- count (`Fixnum`) (defaults to: `nil`)

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    387
    388
    389
    390
    391
    392
    393
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx-redis/redis_client.rb', line 387

    def cluster_getkeysinslot(slot=nil,count=nil)
      if slot.class == Fixnum && count.class == Fixnum && block_given?
        @j_del.java_method(:clusterGetkeysinslot, [Java::long.java_class,Java::long.java_class,Java::IoVertxCore::Handler.java_class]).call(slot,count,(Proc.new { |ar| yield(ar.failed ? ar.cause : nil, ar.succeeded ? ar.result != nil ? JSON.parse(ar.result.encode) : nil : nil) }))
        return self
      end
      raise ArgumentError, "Invalid arguments when calling cluster_getkeysinslot(#{slot},#{count})"
    end

### - (`self`) cluster_info { ... }

Provides info about Redis Cluster node state.

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    397
    398
    399
    400
    401
    402
    403
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx-redis/redis_client.rb', line 397

    def cluster_info
      if block_given?
        @j_del.java_method(:clusterInfo, [Java::IoVertxCore::Handler.java_class]).call((Proc.new { |ar| yield(ar.failed ? ar.cause : nil, ar.succeeded ? ar.result != nil ? JSON.parse(ar.result.encode) : nil : nil) }))
        return self
      end
      raise ArgumentError, "Invalid arguments when calling cluster_info()"
    end

### - (`self`) cluster_keyslot(key = nil) { ... }

Returns the hash slot of the specified key.

Parameters:

- key (`String`) (defaults to: `nil`)

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    408
    409
    410
    411
    412
    413
    414
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx-redis/redis_client.rb', line 408

    def cluster_keyslot(key=nil)
      if key.class == String && block_given?
        @j_del.java_method(:clusterKeyslot, [Java::java.lang.String.java_class,Java::IoVertxCore::Handler.java_class]).call(key,(Proc.new { |ar| yield(ar.failed ? ar.cause : nil, ar.succeeded ? ar.result : nil) }))
        return self
      end
      raise ArgumentError, "Invalid arguments when calling cluster_keyslot(#{key})"
    end

### - (`self`) cluster_meet(ip = nil, port = nil) { ... }

Force a node cluster to handshake with another node.

Parameters:

- ip (`String`) (defaults to: `nil`)
- port (`Fixnum`) (defaults to: `nil`)

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    420
    421
    422
    423
    424
    425
    426
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx-redis/redis_client.rb', line 420

    def cluster_meet(ip=nil,port=nil)
      if ip.class == String && port.class == Fixnum && block_given?
        @j_del.java_method(:clusterMeet, [Java::java.lang.String.java_class,Java::long.java_class,Java::IoVertxCore::Handler.java_class]).call(ip,port,(Proc.new { |ar| yield(ar.failed ? ar.cause : nil) }))
        return self
      end
      raise ArgumentError, "Invalid arguments when calling cluster_meet(#{ip},#{port})"
    end

### - (`self`) cluster_nodes { ... }

Get Cluster config for the node.

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    430
    431
    432
    433
    434
    435
    436
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx-redis/redis_client.rb', line 430

    def cluster_nodes
      if block_given?
        @j_del.java_method(:clusterNodes, [Java::IoVertxCore::Handler.java_class]).call((Proc.new { |ar| yield(ar.failed ? ar.cause : nil, ar.succeeded ? ar.result != nil ? JSON.parse(ar.result.encode) : nil : nil) }))
        return self
      end
      raise ArgumentError, "Invalid arguments when calling cluster_nodes()"
    end

### - (`self`) cluster_replicate(nodeId = nil) { ... }

Reconfigure a node as a slave of the specified master node.

Parameters:

- nodeId (`String`) (defaults to: `nil`)

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    441
    442
    443
    444
    445
    446
    447
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx-redis/redis_client.rb', line 441

    def cluster_replicate(nodeId=nil)
      if nodeId.class == String && block_given?
        @j_del.java_method(:clusterReplicate, [Java::java.lang.String.java_class,Java::IoVertxCore::Handler.java_class]).call(nodeId,(Proc.new { |ar| yield(ar.failed ? ar.cause : nil) }))
        return self
      end
      raise ArgumentError, "Invalid arguments when calling cluster_replicate(#{nodeId})"
    end

### - (`self`) cluster_reset { ... }

Reset a Redis Cluster node.

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    451
    452
    453
    454
    455
    456
    457
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx-redis/redis_client.rb', line 451

    def cluster_reset
      if block_given?
        @j_del.java_method(:clusterReset, [Java::IoVertxCore::Handler.java_class]).call((Proc.new { |ar| yield(ar.failed ? ar.cause : nil) }))
        return self
      end
      raise ArgumentError, "Invalid arguments when calling cluster_reset()"
    end

### - (`self`) cluster_reset_with_options(options = nil) { ... }

Reset a Redis Cluster node.

Parameters:

- options (`:HARD`, `:SOFT`) (defaults to: `nil`)

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    462
    463
    464
    465
    466
    467
    468
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx-redis/redis_client.rb', line 462

    def cluster_reset_with_options(options=nil)
      if options.class == Symbol && block_given?
        @j_del.java_method(:clusterResetWithOptions, [Java::IoVertxRedisOp::ResetOptions.java_class,Java::IoVertxCore::Handler.java_class]).call(Java::IoVertxRedisOp::ResetOptions.valueOf(options.to_s),(Proc.new { |ar| yield(ar.failed ? ar.cause : nil) }))
        return self
      end
      raise ArgumentError, "Invalid arguments when calling cluster_reset_with_options(#{options})"
    end

### - (`self`) cluster_saveconfig { ... }

Forces the node to save cluster state on disk.

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    472
    473
    474
    475
    476
    477
    478
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx-redis/redis_client.rb', line 472

    def cluster_saveconfig
      if block_given?
        @j_del.java_method(:clusterSaveconfig, [Java::IoVertxCore::Handler.java_class]).call((Proc.new { |ar| yield(ar.failed ? ar.cause : nil) }))
        return self
      end
      raise ArgumentError, "Invalid arguments when calling cluster_saveconfig()"
    end

### - (`self`) cluster_set_config_epoch(epoch = nil) { ... }

Set the configuration epoch in a new node.

Parameters:

- epoch (`Fixnum`) (defaults to: `nil`)

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    483
    484
    485
    486
    487
    488
    489
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx-redis/redis_client.rb', line 483

    def cluster_set_config_epoch(epoch=nil)
      if epoch.class == Fixnum && block_given?
        @j_del.java_method(:clusterSetConfigEpoch, [Java::long.java_class,Java::IoVertxCore::Handler.java_class]).call(epoch,(Proc.new { |ar| yield(ar.failed ? ar.cause : nil) }))
        return self
      end
      raise ArgumentError, "Invalid arguments when calling cluster_set_config_epoch(#{epoch})"
    end

### - (`self`) cluster_setslot(slot = nil, subcommand = nil) { ... }

Bind an hash slot to a specific node.

Parameters:

- slot (`Fixnum`) (defaults to: `nil`)
- subcommand (`:IMPORTING`, `:MIGRATING`, `:STABLE`, `:NODE`) (defaults to: `nil`)

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    495
    496
    497
    498
    499
    500
    501
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx-redis/redis_client.rb', line 495

    def cluster_setslot(slot=nil,subcommand=nil)
      if slot.class == Fixnum && subcommand.class == Symbol && block_given?
        @j_del.java_method(:clusterSetslot, [Java::long.java_class,Java::IoVertxRedisOp::SlotCmd.java_class,Java::IoVertxCore::Handler.java_class]).call(slot,Java::IoVertxRedisOp::SlotCmd.valueOf(subcommand.to_s),(Proc.new { |ar| yield(ar.failed ? ar.cause : nil) }))
        return self
      end
      raise ArgumentError, "Invalid arguments when calling cluster_setslot(#{slot},#{subcommand})"
    end

### - (`self`) cluster_setslot_with_node(slot = nil, subcommand = nil, nodeId = nil) { ... }

Bind an hash slot to a specific node.

Parameters:

- slot (`Fixnum`) (defaults to: `nil`)
- subcommand (`:IMPORTING`, `:MIGRATING`, `:STABLE`, `:NODE`) (defaults to: `nil`)
- nodeId (`String`) (defaults to: `nil`)

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    508
    509
    510
    511
    512
    513
    514
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx-redis/redis_client.rb', line 508

    def cluster_setslot_with_node(slot=nil,subcommand=nil,nodeId=nil)
      if slot.class == Fixnum && subcommand.class == Symbol && nodeId.class == String && block_given?
        @j_del.java_method(:clusterSetslotWithNode, [Java::long.java_class,Java::IoVertxRedisOp::SlotCmd.java_class,Java::java.lang.String.java_class,Java::IoVertxCore::Handler.java_class]).call(slot,Java::IoVertxRedisOp::SlotCmd.valueOf(subcommand.to_s),nodeId,(Proc.new { |ar| yield(ar.failed ? ar.cause : nil) }))
        return self
      end
      raise ArgumentError, "Invalid arguments when calling cluster_setslot_with_node(#{slot},#{subcommand},#{nodeId})"
    end

### - (`self`) cluster_slaves(nodeId = nil) { ... }

List slave nodes of the specified master node.

Parameters:

- nodeId (`String`) (defaults to: `nil`)

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    519
    520
    521
    522
    523
    524
    525
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx-redis/redis_client.rb', line 519

    def cluster_slaves(nodeId=nil)
      if nodeId.class == String && block_given?
        @j_del.java_method(:clusterSlaves, [Java::java.lang.String.java_class,Java::IoVertxCore::Handler.java_class]).call(nodeId,(Proc.new { |ar| yield(ar.failed ? ar.cause : nil, ar.succeeded ? ar.result != nil ? JSON.parse(ar.result.encode) : nil : nil) }))
        return self
      end
      raise ArgumentError, "Invalid arguments when calling cluster_slaves(#{nodeId})"
    end

### - (`self`) cluster_slots { ... }

Get array of Cluster slot to node mappings

Yields:

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    529
    530
    531
    532
    533
    534
    535
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx-redis/redis_client.rb', line 529

    def cluster_slots
      if block_given?
        @j_del.java_method(:clusterSlots, [Java::IoVertxCore::Handler.java_class]).call((Proc.new { |ar| yield(ar.failed ? ar.cause : nil, ar.succeeded ? ar.result != nil ? JSON.parse(ar.result.encode) : nil : nil) }))
        return self
      end
      raise ArgumentError, "Invalid arguments when calling cluster_slots()"
    end

### - (`self`) command { ... }

Get array of Redis command details

Yields:

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    539
    540
    541
    542
    543
    544
    545
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx-redis/redis_client.rb', line 539

    def command
      if block_given?
        @j_del.java_method(:command, [Java::IoVertxCore::Handler.java_class]).call((Proc.new { |ar| yield(ar.failed ? ar.cause : nil, ar.succeeded ? ar.result != nil ? JSON.parse(ar.result.encode) : nil : nil) }))
        return self
      end
      raise ArgumentError, "Invalid arguments when calling command()"
    end

### - (`self`) command_count { ... }

Get total number of Redis commands

Yields:

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    549
    550
    551
    552
    553
    554
    555
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx-redis/redis_client.rb', line 549

    def command_count
      if block_given?
        @j_del.java_method(:commandCount, [Java::IoVertxCore::Handler.java_class]).call((Proc.new { |ar| yield(ar.failed ? ar.cause : nil, ar.succeeded ? ar.result : nil) }))
        return self
      end
      raise ArgumentError, "Invalid arguments when calling command_count()"
    end

### - (`self`) command_getkeys { ... }

Extract keys given a full Redis command

Yields:

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    559
    560
    561
    562
    563
    564
    565
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx-redis/redis_client.rb', line 559

    def command_getkeys
      if block_given?
        @j_del.java_method(:commandGetkeys, [Java::IoVertxCore::Handler.java_class]).call((Proc.new { |ar| yield(ar.failed ? ar.cause : nil, ar.succeeded ? ar.result != nil ? JSON.parse(ar.result.encode) : nil : nil) }))
        return self
      end
      raise ArgumentError, "Invalid arguments when calling command_getkeys()"
    end

### - (`self`) command_info(commands = nil) { ... }

Get array of specific Redis command details

Parameters:

- commands (`Array<String>`) (defaults to: `nil`) —
  List of commands to get info for

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    570
    571
    572
    573
    574
    575
    576
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx-redis/redis_client.rb', line 570

    def command_info(commands=nil)
      if commands.class == Array && block_given?
        @j_del.java_method(:commandInfo, [Java::JavaUtil::List.java_class,Java::IoVertxCore::Handler.java_class]).call(commands.map { |element| element },(Proc.new { |ar| yield(ar.failed ? ar.cause : nil, ar.succeeded ? ar.result != nil ? JSON.parse(ar.result.encode) : nil : nil) }))
        return self
      end
      raise ArgumentError, "Invalid arguments when calling command_info(#{commands})"
    end

### - (`self`) config_get(parameter = nil) { ... }

Get the value of a configuration parameter

Parameters:

- parameter (`String`) (defaults to: `nil`) —
  Configuration parameter

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    581
    582
    583
    584
    585
    586
    587
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx-redis/redis_client.rb', line 581

    def config_get(parameter=nil)
      if parameter.class == String && block_given?
        @j_del.java_method(:configGet, [Java::java.lang.String.java_class,Java::IoVertxCore::Handler.java_class]).call(parameter,(Proc.new { |ar| yield(ar.failed ? ar.cause : nil, ar.succeeded ? ar.result != nil ? JSON.parse(ar.result.encode) : nil : nil) }))
        return self
      end
      raise ArgumentError, "Invalid arguments when calling config_get(#{parameter})"
    end

### - (`self`) config_resetstat { ... }

Reset the stats returned by INFO

Yields:

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    613
    614
    615
    616
    617
    618
    619
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx-redis/redis_client.rb', line 613

    def config_resetstat
      if block_given?
        @j_del.java_method(:configResetstat, [Java::IoVertxCore::Handler.java_class]).call((Proc.new { |ar| yield(ar.failed ? ar.cause : nil, ar.succeeded ? ar.result : nil) }))
        return self
      end
      raise ArgumentError, "Invalid arguments when calling config_resetstat()"
    end

### - (`self`) config_rewrite { ... }

Rewrite the configuration file with the in memory configuration

Yields:

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    591
    592
    593
    594
    595
    596
    597
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx-redis/redis_client.rb', line 591

    def config_rewrite
      if block_given?
        @j_del.java_method(:configRewrite, [Java::IoVertxCore::Handler.java_class]).call((Proc.new { |ar| yield(ar.failed ? ar.cause : nil, ar.succeeded ? ar.result : nil) }))
        return self
      end
      raise ArgumentError, "Invalid arguments when calling config_rewrite()"
    end

### - (`self`) config_set(parameter = nil, value = nil) { ... }

Set a configuration parameter to the given value

Parameters:

- parameter (`String`) (defaults to: `nil`) —
  Configuration parameter
- value (`String`) (defaults to: `nil`) —
  New value

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    603
    604
    605
    606
    607
    608
    609
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx-redis/redis_client.rb', line 603

    def config_set(parameter=nil,value=nil)
      if parameter.class == String && value.class == String && block_given?
        @j_del.java_method(:configSet, [Java::java.lang.String.java_class,Java::java.lang.String.java_class,Java::IoVertxCore::Handler.java_class]).call(parameter,value,(Proc.new { |ar| yield(ar.failed ? ar.cause : nil, ar.succeeded ? ar.result : nil) }))
        return self
      end
      raise ArgumentError, "Invalid arguments when calling config_set(#{parameter},#{value})"
    end

### - (`self`) dbsize { ... }

Return the number of keys in the selected database

Yields:

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    623
    624
    625
    626
    627
    628
    629
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx-redis/redis_client.rb', line 623

    def dbsize
      if block_given?
        @j_del.java_method(:dbsize, [Java::IoVertxCore::Handler.java_class]).call((Proc.new { |ar| yield(ar.failed ? ar.cause : nil, ar.succeeded ? ar.result : nil) }))
        return self
      end
      raise ArgumentError, "Invalid arguments when calling dbsize()"
    end

### - (`self`) debug_object(key = nil) { ... }

Get debugging information about a key

Parameters:

- key (`String`) (defaults to: `nil`) —
  Key string

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    634
    635
    636
    637
    638
    639
    640
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx-redis/redis_client.rb', line 634

    def debug_object(key=nil)
      if key.class == String && block_given?
        @j_del.java_method(:debugObject, [Java::java.lang.String.java_class,Java::IoVertxCore::Handler.java_class]).call(key,(Proc.new { |ar| yield(ar.failed ? ar.cause : nil, ar.succeeded ? ar.result : nil) }))
        return self
      end
      raise ArgumentError, "Invalid arguments when calling debug_object(#{key})"
    end

### - (`self`) debug_segfault { ... }

Make the server crash

Yields:

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    644
    645
    646
    647
    648
    649
    650
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx-redis/redis_client.rb', line 644

    def debug_segfault
      if block_given?
        @j_del.java_method(:debugSegfault, [Java::IoVertxCore::Handler.java_class]).call((Proc.new { |ar| yield(ar.failed ? ar.cause : nil, ar.succeeded ? ar.result : nil) }))
        return self
      end
      raise ArgumentError, "Invalid arguments when calling debug_segfault()"
    end

### - (`self`) decr(key = nil) { ... }

Decrement the integer value of a key by one

Parameters:

- key (`String`) (defaults to: `nil`) —
  Key string

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    655
    656
    657
    658
    659
    660
    661
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx-redis/redis_client.rb', line 655

    def decr(key=nil)
      if key.class == String && block_given?
        @j_del.java_method(:decr, [Java::java.lang.String.java_class,Java::IoVertxCore::Handler.java_class]).call(key,(Proc.new { |ar| yield(ar.failed ? ar.cause : nil, ar.succeeded ? ar.result : nil) }))
        return self
      end
      raise ArgumentError, "Invalid arguments when calling decr(#{key})"
    end

### - (`self`) decrby(key = nil, decrement = nil) { ... }

Decrement the integer value of a key by the given number

Parameters:

- key (`String`) (defaults to: `nil`) —
  Key string
- decrement (`Fixnum`) (defaults to: `nil`) —
  Value by which to decrement

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    667
    668
    669
    670
    671
    672
    673
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx-redis/redis_client.rb', line 667

    def decrby(key=nil,decrement=nil)
      if key.class == String && decrement.class == Fixnum && block_given?
        @j_del.java_method(:decrby, [Java::java.lang.String.java_class,Java::long.java_class,Java::IoVertxCore::Handler.java_class]).call(key,decrement,(Proc.new { |ar| yield(ar.failed ? ar.cause : nil, ar.succeeded ? ar.result : nil) }))
        return self
      end
      raise ArgumentError, "Invalid arguments when calling decrby(#{key},#{decrement})"
    end

### - (`self`) del(key = nil) { ... }

Delete a key

Parameters:

- key (`String`) (defaults to: `nil`) —
  Keys to delete

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    678
    679
    680
    681
    682
    683
    684
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx-redis/redis_client.rb', line 678

    def del(key=nil)
      if key.class == String && block_given?
        @j_del.java_method(:del, [Java::java.lang.String.java_class,Java::IoVertxCore::Handler.java_class]).call(key,(Proc.new { |ar| yield(ar.failed ? ar.cause : nil, ar.succeeded ? ar.result : nil) }))
        return self
      end
      raise ArgumentError, "Invalid arguments when calling del(#{key})"
    end

### - (`self`) del_many(keys = nil) { ... }

Delete many keys

Parameters:

- keys (`Array<String>`) (defaults to: `nil`) —
  List of keys to delete

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    689
    690
    691
    692
    693
    694
    695
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx-redis/redis_client.rb', line 689

    def del_many(keys=nil)
      if keys.class == Array && block_given?
        @j_del.java_method(:delMany, [Java::JavaUtil::List.java_class,Java::IoVertxCore::Handler.java_class]).call(keys.map { |element| element },(Proc.new { |ar| yield(ar.failed ? ar.cause : nil, ar.succeeded ? ar.result : nil) }))
        return self
      end
      raise ArgumentError, "Invalid arguments when calling del_many(#{keys})"
    end

### - (`self`) dump(key = nil) { ... }

Return a serialized version of the value stored at the specified key.

Parameters:

- key (`String`) (defaults to: `nil`) —
  Key string

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    700
    701
    702
    703
    704
    705
    706
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx-redis/redis_client.rb', line 700

    def dump(key=nil)
      if key.class == String && block_given?
        @j_del.java_method(:dump, [Java::java.lang.String.java_class,Java::IoVertxCore::Handler.java_class]).call(key,(Proc.new { |ar| yield(ar.failed ? ar.cause : nil, ar.succeeded ? ar.result : nil) }))
        return self
      end
      raise ArgumentError, "Invalid arguments when calling dump(#{key})"
    end

### - (`self`) echo(message = nil) { ... }

Echo the given string

Parameters:

- message (`String`) (defaults to: `nil`) —
  String to echo

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    711
    712
    713
    714
    715
    716
    717
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx-redis/redis_client.rb', line 711

    def echo(message=nil)
      if message.class == String && block_given?
        @j_del.java_method(:echo, [Java::java.lang.String.java_class,Java::IoVertxCore::Handler.java_class]).call(message,(Proc.new { |ar| yield(ar.failed ? ar.cause : nil, ar.succeeded ? ar.result : nil) }))
        return self
      end
      raise ArgumentError, "Invalid arguments when calling echo(#{message})"
    end

### - (`self`) eval(script = nil, keys = nil, args = nil) { ... }

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 (`String`) (defaults to: `nil`) —
  Lua script to evaluate
- keys (`Array<String>`) (defaults to: `nil`) —
  List of keys
- args (`Array<String>`) (defaults to: `nil`) —
  List of argument values

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    728
    729
    730
    731
    732
    733
    734
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx-redis/redis_client.rb', line 728

    def eval(script=nil,keys=nil,args=nil)
      if script.class == String && keys.class == Array && args.class == Array && block_given?
        @j_del.java_method(:eval, [Java::java.lang.String.java_class,Java::JavaUtil::List.java_class,Java::JavaUtil::List.java_class,Java::IoVertxCore::Handler.java_class]).call(script,keys.map { |element| element },args.map { |element| element },(Proc.new { |ar| yield(ar.failed ? ar.cause : nil, ar.succeeded ? ar.result != nil ? JSON.parse(ar.result.encode) : nil : nil) }))
        return self
      end
      raise ArgumentError, "Invalid arguments when calling eval(#{script},#{keys},#{args})"
    end

### - (`self`) eval_script(script = nil, keys = nil, args = nil) { ... }

Execute a Lua script server side. This method is a high level wrapper around EVAL and EVALSHA using the latter if possible, falling back to EVAL if the script is not cached by the server yet. According to Redis documentation, executed scripts are guaranteed to be in the script cache of a given execution of a Redis instance forever, which means typically the overhead incurred by optimistically sending EVALSHA is minimal, while improving performance and saving bandwidth compared to using EVAL every time.

Parameters:

- script (`::VertxRedis::Script`) (defaults to: `nil`) —
  Lua script and its SHA1 digest
- keys (`Array<String>`) (defaults to: `nil`) —
  List of keys
- args (`Array<String>`) (defaults to: `nil`) —
  List of argument values

Yields:

- Handler for the result of this call. group: scripting

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    763
    764
    765
    766
    767
    768
    769
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx-redis/redis_client.rb', line 763

    def eval_script(script=nil,keys=nil,args=nil)
      if script.class.method_defined?(:j_del) && keys.class == Array && args.class == Array && block_given?
        @j_del.java_method(:evalScript, [Java::IoVertxRedis::Script.java_class,Java::JavaUtil::List.java_class,Java::JavaUtil::List.java_class,Java::IoVertxCore::Handler.java_class]).call(script.j_del,keys.map { |element| element },args.map { |element| element },(Proc.new { |ar| yield(ar.failed ? ar.cause : nil, ar.succeeded ? ar.result != nil ? JSON.parse(ar.result.encode) : nil : nil) }))
        return self
      end
      raise ArgumentError, "Invalid arguments when calling eval_script(#{script},#{keys},#{args})"
    end

### - (`self`) evalsha(sha1 = nil, keys = nil, values = nil) { ... }

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 (`String`) (defaults to: `nil`) —
  SHA1 digest of the script cached on the server
- keys (`Array<String>`) (defaults to: `nil`) —
  List of keys
- values (`Array<String>`) (defaults to: `nil`) —
  List of values

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    745
    746
    747
    748
    749
    750
    751
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx-redis/redis_client.rb', line 745

    def evalsha(sha1=nil,keys=nil,values=nil)
      if sha1.class == String && keys.class == Array && values.class == Array && block_given?
        @j_del.java_method(:evalsha, [Java::java.lang.String.java_class,Java::JavaUtil::List.java_class,Java::JavaUtil::List.java_class,Java::IoVertxCore::Handler.java_class]).call(sha1,keys.map { |element| element },values.map { |element| element },(Proc.new { |ar| yield(ar.failed ? ar.cause : nil, ar.succeeded ? ar.result != nil ? JSON.parse(ar.result.encode) : nil : nil) }))
        return self
      end
      raise ArgumentError, "Invalid arguments when calling evalsha(#{sha1},#{keys},#{values})"
    end

### - (`self`) exists(key = nil) { ... }

Determine if a key exists

Parameters:

- key (`String`) (defaults to: `nil`) —
  Key string

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    774
    775
    776
    777
    778
    779
    780
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx-redis/redis_client.rb', line 774

    def exists(key=nil)
      if key.class == String && block_given?
        @j_del.java_method(:exists, [Java::java.lang.String.java_class,Java::IoVertxCore::Handler.java_class]).call(key,(Proc.new { |ar| yield(ar.failed ? ar.cause : nil, ar.succeeded ? ar.result : nil) }))
        return self
      end
      raise ArgumentError, "Invalid arguments when calling exists(#{key})"
    end

### - (`self`) exists_many(keys = nil) { ... }

Determine if one or many keys exist

Parameters:

- keys (`Array<String>`) (defaults to: `nil`) —
  List of key strings

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    785
    786
    787
    788
    789
    790
    791
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx-redis/redis_client.rb', line 785

    def exists_many(keys=nil)
      if keys.class == Array && block_given?
        @j_del.java_method(:existsMany, [Java::JavaUtil::List.java_class,Java::IoVertxCore::Handler.java_class]).call(keys.map { |element| element },(Proc.new { |ar| yield(ar.failed ? ar.cause : nil, ar.succeeded ? ar.result : nil) }))
        return self
      end
      raise ArgumentError, "Invalid arguments when calling exists_many(#{keys})"
    end

### - (`self`) expire(key = nil, seconds = nil) { ... }

Set a key's time to live in seconds

Parameters:

- key (`String`) (defaults to: `nil`) —
  Key string
- seconds (`Fixnum`) (defaults to: `nil`) —
  Time to live in seconds

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    797
    798
    799
    800
    801
    802
    803
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx-redis/redis_client.rb', line 797

    def expire(key=nil,seconds=nil)
      if key.class == String && seconds.class == Fixnum && block_given?
        @j_del.java_method(:expire, [Java::java.lang.String.java_class,Java::long.java_class,Java::IoVertxCore::Handler.java_class]).call(key,seconds,(Proc.new { |ar| yield(ar.failed ? ar.cause : nil, ar.succeeded ? ar.result : nil) }))
        return self
      end
      raise ArgumentError, "Invalid arguments when calling expire(#{key},#{seconds})"
    end

### - (`self`) expireat(key = nil, seconds = nil) { ... }

Set the expiration for a key as a UNIX timestamp

Parameters:

- key (`String`) (defaults to: `nil`) —
  Key string
- seconds (`Fixnum`) (defaults to: `nil`) —
  Expiry time as Unix timestamp in seconds

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    809
    810
    811
    812
    813
    814
    815
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx-redis/redis_client.rb', line 809

    def expireat(key=nil,seconds=nil)
      if key.class == String && seconds.class == Fixnum && block_given?
        @j_del.java_method(:expireat, [Java::java.lang.String.java_class,Java::long.java_class,Java::IoVertxCore::Handler.java_class]).call(key,seconds,(Proc.new { |ar| yield(ar.failed ? ar.cause : nil, ar.succeeded ? ar.result : nil) }))
        return self
      end
      raise ArgumentError, "Invalid arguments when calling expireat(#{key},#{seconds})"
    end

### - (`self`) flushall { ... }

Remove all keys from all databases

Yields:

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    819
    820
    821
    822
    823
    824
    825
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx-redis/redis_client.rb', line 819

    def flushall
      if block_given?
        @j_del.java_method(:flushall, [Java::IoVertxCore::Handler.java_class]).call((Proc.new { |ar| yield(ar.failed ? ar.cause : nil, ar.succeeded ? ar.result : nil) }))
        return self
      end
      raise ArgumentError, "Invalid arguments when calling flushall()"
    end

### - (`self`) flushdb { ... }

Remove all keys from the current database

Yields:

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    829
    830
    831
    832
    833
    834
    835
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx-redis/redis_client.rb', line 829

    def flushdb
      if block_given?
        @j_del.java_method(:flushdb, [Java::IoVertxCore::Handler.java_class]).call((Proc.new { |ar| yield(ar.failed ? ar.cause : nil, ar.succeeded ? ar.result : nil) }))
        return self
      end
      raise ArgumentError, "Invalid arguments when calling flushdb()"
    end

### - (`self`) geoadd(key = nil, longitude = nil, latitude = nil, member = nil) { ... }

Add one or more geospatial items in the geospatial index represented using a sorted set.

Parameters:

- key (`String`) (defaults to: `nil`) —
  Key string
- longitude (`Float`) (defaults to: `nil`) —
  longitude
- latitude (`Float`) (defaults to: `nil`) —
  latitude
- member (`String`) (defaults to: `nil`) —
  member

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    2629
    2630
    2631
    2632
    2633
    2634
    2635
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx-redis/redis_client.rb', line 2629

    def geoadd(key=nil,longitude=nil,latitude=nil,member=nil)
      if key.class == String && longitude.class == Float && latitude.class == Float && member.class == String && block_given?
        @j_del.java_method(:geoadd, [Java::java.lang.String.java_class,Java::double.java_class,Java::double.java_class,Java::java.lang.String.java_class,Java::IoVertxCore::Handler.java_class]).call(key,::Vertx::Util::Utils.to_double(longitude),::Vertx::Util::Utils.to_double(latitude),member,(Proc.new { |ar| yield(ar.failed ? ar.cause : nil, ar.succeeded ? ar.result : nil) }))
        return self
      end
      raise ArgumentError, "Invalid arguments when calling geoadd(#{key},#{longitude},#{latitude},#{member})"
    end

### - (`self`) geoadd_many(key = nil, members = nil) { ... }

Add one or more geospatial items in the geospatial index represented using a sorted set.

Parameters:

- key (`String`) (defaults to: `nil`) —
  Key string
- members (`Array<Hash>`) (defaults to: `nil`) —
  list of <lon, lat, member>

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    2641
    2642
    2643
    2644
    2645
    2646
    2647
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx-redis/redis_client.rb', line 2641

    def geoadd_many(key=nil,members=nil)
      if key.class == String && members.class == Array && block_given?
        @j_del.java_method(:geoaddMany, [Java::java.lang.String.java_class,Java::JavaUtil::List.java_class,Java::IoVertxCore::Handler.java_class]).call(key,members.map { |element| Java::IoVertxRedisOp::GeoMember.new(::Vertx::Util::Utils.to_json_object(element)) },(Proc.new { |ar| yield(ar.failed ? ar.cause : nil, ar.succeeded ? ar.result : nil) }))
        return self
      end
      raise ArgumentError, "Invalid arguments when calling geoadd_many(#{key},#{members})"
    end

### - (`self`) geodist(key = nil, member1 = nil, member2 = nil) { ... }

Return the distance between two members in the geospatial index represented by the sorted set.

Parameters:

- key (`String`) (defaults to: `nil`) —
  Key string
- member1 (`String`) (defaults to: `nil`) —
  member 1
- member2 (`String`) (defaults to: `nil`) —
  member 2

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    2706
    2707
    2708
    2709
    2710
    2711
    2712
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx-redis/redis_client.rb', line 2706

    def geodist(key=nil,member1=nil,member2=nil)
      if key.class == String && member1.class == String && member2.class == String && block_given?
        @j_del.java_method(:geodist, [Java::java.lang.String.java_class,Java::java.lang.String.java_class,Java::java.lang.String.java_class,Java::IoVertxCore::Handler.java_class]).call(key,member1,member2,(Proc.new { |ar| yield(ar.failed ? ar.cause : nil, ar.succeeded ? ar.result : nil) }))
        return self
      end
      raise ArgumentError, "Invalid arguments when calling geodist(#{key},#{member1},#{member2})"
    end

### - (`self`) geodist_with_unit(key = nil, member1 = nil, member2 = nil, unit = nil) { ... }

Return the distance between two members in the geospatial index represented by the sorted set.

Parameters:

- key (`String`) (defaults to: `nil`) —
  Key string
- member1 (`String`) (defaults to: `nil`) —
  member 1
- member2 (`String`) (defaults to: `nil`) —
  member 2
- unit (`:m`, `:km`, `:mi`, `:ft`) (defaults to: `nil`) —
  geo unit

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    2720
    2721
    2722
    2723
    2724
    2725
    2726
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx-redis/redis_client.rb', line 2720

    def geodist_with_unit(key=nil,member1=nil,member2=nil,unit=nil)
      if key.class == String && member1.class == String && member2.class == String && unit.class == Symbol && block_given?
        @j_del.java_method(:geodistWithUnit, [Java::java.lang.String.java_class,Java::java.lang.String.java_class,Java::java.lang.String.java_class,Java::IoVertxRedisOp::GeoUnit.java_class,Java::IoVertxCore::Handler.java_class]).call(key,member1,member2,Java::IoVertxRedisOp::GeoUnit.valueOf(unit.to_s),(Proc.new { |ar| yield(ar.failed ? ar.cause : nil, ar.succeeded ? ar.result : nil) }))
        return self
      end
      raise ArgumentError, "Invalid arguments when calling geodist_with_unit(#{key},#{member1},#{member2},#{unit})"
    end

### - (`self`) geohash(key = nil, member = nil) { ... }

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 (`String`) (defaults to: `nil`) —
  Key string
- member (`String`) (defaults to: `nil`) —
  member

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    2654
    2655
    2656
    2657
    2658
    2659
    2660
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx-redis/redis_client.rb', line 2654

    def geohash(key=nil,member=nil)
      if key.class == String && member.class == String && block_given?
        @j_del.java_method(:geohash, [Java::java.lang.String.java_class,Java::java.lang.String.java_class,Java::IoVertxCore::Handler.java_class]).call(key,member,(Proc.new { |ar| yield(ar.failed ? ar.cause : nil, ar.succeeded ? ar.result != nil ? JSON.parse(ar.result.encode) : nil : nil) }))
        return self
      end
      raise ArgumentError, "Invalid arguments when calling geohash(#{key},#{member})"
    end

### - (`self`) geohash_many(key = nil, members = nil) { ... }

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 (`String`) (defaults to: `nil`) —
  Key string
- members (`Array<String>`) (defaults to: `nil`) —
  list of members

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    2667
    2668
    2669
    2670
    2671
    2672
    2673
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx-redis/redis_client.rb', line 2667

    def geohash_many(key=nil,members=nil)
      if key.class == String && members.class == Array && block_given?
        @j_del.java_method(:geohashMany, [Java::java.lang.String.java_class,Java::JavaUtil::List.java_class,Java::IoVertxCore::Handler.java_class]).call(key,members.map { |element| element },(Proc.new { |ar| yield(ar.failed ? ar.cause : nil, ar.succeeded ? ar.result != nil ? JSON.parse(ar.result.encode) : nil : nil) }))
        return self
      end
      raise ArgumentError, "Invalid arguments when calling geohash_many(#{key},#{members})"
    end

### - (`self`) geopos(key = nil, member = nil) { ... }

Return the positions (longitude,latitude) of all the specified members of the geospatial index represented by the sorted set at key.

Parameters:

- key (`String`) (defaults to: `nil`) —
  Key string
- member (`String`) (defaults to: `nil`) —
  member

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    2680
    2681
    2682
    2683
    2684
    2685
    2686
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx-redis/redis_client.rb', line 2680

    def geopos(key=nil,member=nil)
      if key.class == String && member.class == String && block_given?
        @j_del.java_method(:geopos, [Java::java.lang.String.java_class,Java::java.lang.String.java_class,Java::IoVertxCore::Handler.java_class]).call(key,member,(Proc.new { |ar| yield(ar.failed ? ar.cause : nil, ar.succeeded ? ar.result != nil ? JSON.parse(ar.result.encode) : nil : nil) }))
        return self
      end
      raise ArgumentError, "Invalid arguments when calling geopos(#{key},#{member})"
    end

### - (`self`) geopos_many(key = nil, members = nil) { ... }

Return the positions (longitude,latitude) of all the specified members of the geospatial index represented by the sorted set at key.

Parameters:

- key (`String`) (defaults to: `nil`) —
  Key string
- members (`Array<String>`) (defaults to: `nil`) —
  list of members

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    2693
    2694
    2695
    2696
    2697
    2698
    2699
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx-redis/redis_client.rb', line 2693

    def geopos_many(key=nil,members=nil)
      if key.class == String && members.class == Array && block_given?
        @j_del.java_method(:geoposMany, [Java::java.lang.String.java_class,Java::JavaUtil::List.java_class,Java::IoVertxCore::Handler.java_class]).call(key,members.map { |element| element },(Proc.new { |ar| yield(ar.failed ? ar.cause : nil, ar.succeeded ? ar.result != nil ? JSON.parse(ar.result.encode) : nil : nil) }))
        return self
      end
      raise ArgumentError, "Invalid arguments when calling geopos_many(#{key},#{members})"
    end

### - (`self`) georadius(key = nil, longitude = nil, latitude = nil, radius = nil, unit = nil) { ... }

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 (`String`) (defaults to: `nil`) —
  Key string
- longitude (`Float`) (defaults to: `nil`) —
  longitude
- latitude (`Float`) (defaults to: `nil`) —
  latitude
- radius (`Float`) (defaults to: `nil`) —
  radius
- unit (`:m`, `:km`, `:mi`, `:ft`) (defaults to: `nil`) —
  geo unit

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    2736
    2737
    2738
    2739
    2740
    2741
    2742
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx-redis/redis_client.rb', line 2736

    def georadius(key=nil,longitude=nil,latitude=nil,radius=nil,unit=nil)
      if key.class == String && longitude.class == Float && latitude.class == Float && radius.class == Float && unit.class == Symbol && block_given?
        @j_del.java_method(:georadius, [Java::java.lang.String.java_class,Java::double.java_class,Java::double.java_class,Java::double.java_class,Java::IoVertxRedisOp::GeoUnit.java_class,Java::IoVertxCore::Handler.java_class]).call(key,::Vertx::Util::Utils.to_double(longitude),::Vertx::Util::Utils.to_double(latitude),::Vertx::Util::Utils.to_double(radius),Java::IoVertxRedisOp::GeoUnit.valueOf(unit.to_s),(Proc.new { |ar| yield(ar.failed ? ar.cause : nil, ar.succeeded ? ar.result != nil ? JSON.parse(ar.result.encode) : nil : nil) }))
        return self
      end
      raise ArgumentError, "Invalid arguments when calling georadius(#{key},#{longitude},#{latitude},#{radius},#{unit})"
    end

### - (`self`) georadius_with_options(key = nil, longitude = nil, latitude = nil, radius = nil, unit = nil, options = nil) { ... }

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 (`String`) (defaults to: `nil`) —
  Key string
- longitude (`Float`) (defaults to: `nil`) —
  longitude
- latitude (`Float`) (defaults to: `nil`) —
  latitude
- radius (`Float`) (defaults to: `nil`) —
  radius
- unit (`:m`, `:km`, `:mi`, `:ft`) (defaults to: `nil`) —
  geo unit
- options (`Hash`) (defaults to: `nil`) —
  geo radius options

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    2753
    2754
    2755
    2756
    2757
    2758
    2759
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx-redis/redis_client.rb', line 2753

    def georadius_with_options(key=nil,longitude=nil,latitude=nil,radius=nil,unit=nil,options=nil)
      if key.class == String && longitude.class == Float && latitude.class == Float && radius.class == Float && unit.class == Symbol && options.class == Hash && block_given?
        @j_del.java_method(:georadiusWithOptions, [Java::java.lang.String.java_class,Java::double.java_class,Java::double.java_class,Java::double.java_class,Java::IoVertxRedisOp::GeoUnit.java_class,Java::IoVertxRedisOp::GeoRadiusOptions.java_class,Java::IoVertxCore::Handler.java_class]).call(key,::Vertx::Util::Utils.to_double(longitude),::Vertx::Util::Utils.to_double(latitude),::Vertx::Util::Utils.to_double(radius),Java::IoVertxRedisOp::GeoUnit.valueOf(unit.to_s),Java::IoVertxRedisOp::GeoRadiusOptions.new(::Vertx::Util::Utils.to_json_object(options)),(Proc.new { |ar| yield(ar.failed ? ar.cause : nil, ar.succeeded ? ar.result != nil ? JSON.parse(ar.result.encode) : nil : nil) }))
        return self
      end
      raise ArgumentError, "Invalid arguments when calling georadius_with_options(#{key},#{longitude},#{latitude},#{radius},#{unit},#{options})"
    end

### - (`self`) georadiusbymember(key = nil, member = nil, radius = nil, unit = nil) { ... }

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 (`String`) (defaults to: `nil`) —
  Key string
- member (`String`) (defaults to: `nil`) —
  member
- radius (`Float`) (defaults to: `nil`) —
  radius
- unit (`:m`, `:km`, `:mi`, `:ft`) (defaults to: `nil`) —
  geo unit

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    2769
    2770
    2771
    2772
    2773
    2774
    2775
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx-redis/redis_client.rb', line 2769

    def georadiusbymember(key=nil,member=nil,radius=nil,unit=nil)
      if key.class == String && member.class == String && radius.class == Float && unit.class == Symbol && block_given?
        @j_del.java_method(:georadiusbymember, [Java::java.lang.String.java_class,Java::java.lang.String.java_class,Java::double.java_class,Java::IoVertxRedisOp::GeoUnit.java_class,Java::IoVertxCore::Handler.java_class]).call(key,member,::Vertx::Util::Utils.to_double(radius),Java::IoVertxRedisOp::GeoUnit.valueOf(unit.to_s),(Proc.new { |ar| yield(ar.failed ? ar.cause : nil, ar.succeeded ? ar.result != nil ? JSON.parse(ar.result.encode) : nil : nil) }))
        return self
      end
      raise ArgumentError, "Invalid arguments when calling georadiusbymember(#{key},#{member},#{radius},#{unit})"
    end

### - (`self`) georadiusbymember_with_options(key = nil, member = nil, radius = nil, unit = nil, options = nil) { ... }

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 (`String`) (defaults to: `nil`) —
  Key string
- member (`String`) (defaults to: `nil`) —
  member
- radius (`Float`) (defaults to: `nil`) —
  radius
- unit (`:m`, `:km`, `:mi`, `:ft`) (defaults to: `nil`) —
  geo unit
- options (`Hash`) (defaults to: `nil`) —
  geo radius options

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    2786
    2787
    2788
    2789
    2790
    2791
    2792
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx-redis/redis_client.rb', line 2786

    def georadiusbymember_with_options(key=nil,member=nil,radius=nil,unit=nil,options=nil)
      if key.class == String && member.class == String && radius.class == Float && unit.class == Symbol && options.class == Hash && block_given?
        @j_del.java_method(:georadiusbymemberWithOptions, [Java::java.lang.String.java_class,Java::java.lang.String.java_class,Java::double.java_class,Java::IoVertxRedisOp::GeoUnit.java_class,Java::IoVertxRedisOp::GeoRadiusOptions.java_class,Java::IoVertxCore::Handler.java_class]).call(key,member,::Vertx::Util::Utils.to_double(radius),Java::IoVertxRedisOp::GeoUnit.valueOf(unit.to_s),Java::IoVertxRedisOp::GeoRadiusOptions.new(::Vertx::Util::Utils.to_json_object(options)),(Proc.new { |ar| yield(ar.failed ? ar.cause : nil, ar.succeeded ? ar.result != nil ? JSON.parse(ar.result.encode) : nil : nil) }))
        return self
      end
      raise ArgumentError, "Invalid arguments when calling georadiusbymember_with_options(#{key},#{member},#{radius},#{unit},#{options})"
    end

### - (`self`) get(key = nil) { ... }

Get the value of a key

Parameters:

- key (`String`) (defaults to: `nil`) —
  Key string

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    840
    841
    842
    843
    844
    845
    846
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx-redis/redis_client.rb', line 840

    def get(key=nil)
      if key.class == String && block_given?
        @j_del.java_method(:get, [Java::java.lang.String.java_class,Java::IoVertxCore::Handler.java_class]).call(key,(Proc.new { |ar| yield(ar.failed ? ar.cause : nil, ar.succeeded ? ar.result : nil) }))
        return self
      end
      raise ArgumentError, "Invalid arguments when calling get(#{key})"
    end

### - (`self`) get_binary(key = nil) { ... }

Get the value of a key - without decoding as utf-8

Parameters:

- key (`String`) (defaults to: `nil`) —
  Key string

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    851
    852
    853
    854
    855
    856
    857
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx-redis/redis_client.rb', line 851

    def get_binary(key=nil)
      if key.class == String && block_given?
        @j_del.java_method(:getBinary, [Java::java.lang.String.java_class,Java::IoVertxCore::Handler.java_class]).call(key,(Proc.new { |ar| yield(ar.failed ? ar.cause : nil, ar.succeeded ? ::Vertx::Util::Utils.safe_create(ar.result,::Vertx::Buffer) : nil) }))
        return self
      end
      raise ArgumentError, "Invalid arguments when calling get_binary(#{key})"
    end

### - (`self`) getbit(key = nil, offset = nil) { ... }

Returns the bit value at offset in the string value stored at key

Parameters:

- key (`String`) (defaults to: `nil`) —
  Key string
- offset (`Fixnum`) (defaults to: `nil`) —
  Offset in bits

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    863
    864
    865
    866
    867
    868
    869
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx-redis/redis_client.rb', line 863

    def getbit(key=nil,offset=nil)
      if key.class == String && offset.class == Fixnum && block_given?
        @j_del.java_method(:getbit, [Java::java.lang.String.java_class,Java::long.java_class,Java::IoVertxCore::Handler.java_class]).call(key,offset,(Proc.new { |ar| yield(ar.failed ? ar.cause : nil, ar.succeeded ? ar.result : nil) }))
        return self
      end
      raise ArgumentError, "Invalid arguments when calling getbit(#{key},#{offset})"
    end

### - (`self`) getrange(key = nil, start = nil, _end = nil) { ... }

Get a substring of the string stored at a key

Parameters:

- key (`String`) (defaults to: `nil`) —
  Key string
- start (`Fixnum`) (defaults to: `nil`) —
  Start offset
- _end (`Fixnum`) (defaults to: `nil`) —
  End offset - inclusive

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    876
    877
    878
    879
    880
    881
    882
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx-redis/redis_client.rb', line 876

    def getrange(key=nil,start=nil,_end=nil)
      if key.class == String && start.class == Fixnum && _end.class == Fixnum && block_given?
        @j_del.java_method(:getrange, [Java::java.lang.String.java_class,Java::long.java_class,Java::long.java_class,Java::IoVertxCore::Handler.java_class]).call(key,start,_end,(Proc.new { |ar| yield(ar.failed ? ar.cause : nil, ar.succeeded ? ar.result : nil) }))
        return self
      end
      raise ArgumentError, "Invalid arguments when calling getrange(#{key},#{start},#{_end})"
    end

### - (`self`) getset(key = nil, value = nil) { ... }

Set the string value of a key and return its old value

Parameters:

- key (`String`) (defaults to: `nil`) —
  Key of which value to set
- value (`String`) (defaults to: `nil`) —
  New value for the key

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    888
    889
    890
    891
    892
    893
    894
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx-redis/redis_client.rb', line 888

    def getset(key=nil,value=nil)
      if key.class == String && value.class == String && block_given?
        @j_del.java_method(:getset, [Java::java.lang.String.java_class,Java::java.lang.String.java_class,Java::IoVertxCore::Handler.java_class]).call(key,value,(Proc.new { |ar| yield(ar.failed ? ar.cause : nil, ar.succeeded ? ar.result : nil) }))
        return self
      end
      raise ArgumentError, "Invalid arguments when calling getset(#{key},#{value})"
    end

### - (`self`) hdel(key = nil, field = nil) { ... }

Delete one or more hash fields

Parameters:

- key (`String`) (defaults to: `nil`) —
  Key string
- field (`String`) (defaults to: `nil`) —
  Field name

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    900
    901
    902
    903
    904
    905
    906
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx-redis/redis_client.rb', line 900

    def hdel(key=nil,field=nil)
      if key.class == String && field.class == String && block_given?
        @j_del.java_method(:hdel, [Java::java.lang.String.java_class,Java::java.lang.String.java_class,Java::IoVertxCore::Handler.java_class]).call(key,field,(Proc.new { |ar| yield(ar.failed ? ar.cause : nil, ar.succeeded ? ar.result : nil) }))
        return self
      end
      raise ArgumentError, "Invalid arguments when calling hdel(#{key},#{field})"
    end

### - (`self`) hdel_many(key = nil, fields = nil) { ... }

Delete one or more hash fields

Parameters:

- key (`String`) (defaults to: `nil`) —
  Key string
- fields (`Array<String>`) (defaults to: `nil`) —
  Field names

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    912
    913
    914
    915
    916
    917
    918
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx-redis/redis_client.rb', line 912

    def hdel_many(key=nil,fields=nil)
      if key.class == String && fields.class == Array && block_given?
        @j_del.java_method(:hdelMany, [Java::java.lang.String.java_class,Java::JavaUtil::List.java_class,Java::IoVertxCore::Handler.java_class]).call(key,fields.map { |element| element },(Proc.new { |ar| yield(ar.failed ? ar.cause : nil, ar.succeeded ? ar.result : nil) }))
        return self
      end
      raise ArgumentError, "Invalid arguments when calling hdel_many(#{key},#{fields})"
    end

### - (`self`) hexists(key = nil, field = nil) { ... }

Determine if a hash field exists

Parameters:

- key (`String`) (defaults to: `nil`) —
  Key string
- field (`String`) (defaults to: `nil`) —
  Field name

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    924
    925
    926
    927
    928
    929
    930
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx-redis/redis_client.rb', line 924

    def hexists(key=nil,field=nil)
      if key.class == String && field.class == String && block_given?
        @j_del.java_method(:hexists, [Java::java.lang.String.java_class,Java::java.lang.String.java_class,Java::IoVertxCore::Handler.java_class]).call(key,field,(Proc.new { |ar| yield(ar.failed ? ar.cause : nil, ar.succeeded ? ar.result : nil) }))
        return self
      end
      raise ArgumentError, "Invalid arguments when calling hexists(#{key},#{field})"
    end

### - (`self`) hget(key = nil, field = nil) { ... }

Get the value of a hash field

Parameters:

- key (`String`) (defaults to: `nil`) —
  Key string
- field (`String`) (defaults to: `nil`) —
  Field name

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    936
    937
    938
    939
    940
    941
    942
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx-redis/redis_client.rb', line 936

    def hget(key=nil,field=nil)
      if key.class == String && field.class == String && block_given?
        @j_del.java_method(:hget, [Java::java.lang.String.java_class,Java::java.lang.String.java_class,Java::IoVertxCore::Handler.java_class]).call(key,field,(Proc.new { |ar| yield(ar.failed ? ar.cause : nil, ar.succeeded ? ar.result : nil) }))
        return self
      end
      raise ArgumentError, "Invalid arguments when calling hget(#{key},#{field})"
    end

### - (`self`) hgetall(key = nil) { ... }

Get all the fields and values in a hash

Parameters:

- key (`String`) (defaults to: `nil`) —
  Key string

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    947
    948
    949
    950
    951
    952
    953
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx-redis/redis_client.rb', line 947

    def hgetall(key=nil)
      if key.class == String && block_given?
        @j_del.java_method(:hgetall, [Java::java.lang.String.java_class,Java::IoVertxCore::Handler.java_class]).call(key,(Proc.new { |ar| yield(ar.failed ? ar.cause : nil, ar.succeeded ? ar.result != nil ? JSON.parse(ar.result.encode) : nil : nil) }))
        return self
      end
      raise ArgumentError, "Invalid arguments when calling hgetall(#{key})"
    end

### - (`self`) hincrby(key = nil, field = nil, increment = nil) { ... }

Increment the integer value of a hash field by the given number

Parameters:

- key (`String`) (defaults to: `nil`) —
  Key string
- field (`String`) (defaults to: `nil`) —
  Field name
- increment (`Fixnum`) (defaults to: `nil`) —
  Value by which to increment

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    960
    961
    962
    963
    964
    965
    966
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx-redis/redis_client.rb', line 960

    def hincrby(key=nil,field=nil,increment=nil)
      if key.class == String && field.class == String && increment.class == Fixnum && block_given?
        @j_del.java_method(:hincrby, [Java::java.lang.String.java_class,Java::java.lang.String.java_class,Java::long.java_class,Java::IoVertxCore::Handler.java_class]).call(key,field,increment,(Proc.new { |ar| yield(ar.failed ? ar.cause : nil, ar.succeeded ? ar.result : nil) }))
        return self
      end
      raise ArgumentError, "Invalid arguments when calling hincrby(#{key},#{field},#{increment})"
    end

### - (`self`) hincrbyfloat(key = nil, field = nil, increment = nil) { ... }

Increment the float value of a hash field by the given amount

Parameters:

- key (`String`) (defaults to: `nil`) —
  Key string
- field (`String`) (defaults to: `nil`) —
  Field name
- increment (`Float`) (defaults to: `nil`) —
  Value by which to increment

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    973
    974
    975
    976
    977
    978
    979
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx-redis/redis_client.rb', line 973

    def hincrbyfloat(key=nil,field=nil,increment=nil)
      if key.class == String && field.class == String && increment.class == Float && block_given?
        @j_del.java_method(:hincrbyfloat, [Java::java.lang.String.java_class,Java::java.lang.String.java_class,Java::double.java_class,Java::IoVertxCore::Handler.java_class]).call(key,field,::Vertx::Util::Utils.to_double(increment),(Proc.new { |ar| yield(ar.failed ? ar.cause : nil, ar.succeeded ? ar.result : nil) }))
        return self
      end
      raise ArgumentError, "Invalid arguments when calling hincrbyfloat(#{key},#{field},#{increment})"
    end

### - (`self`) hkeys(key = nil) { ... }

Get all the fields in a hash

Parameters:

- key (`String`) (defaults to: `nil`) —
  Key string

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    984
    985
    986
    987
    988
    989
    990
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx-redis/redis_client.rb', line 984

    def hkeys(key=nil)
      if key.class == String && block_given?
        @j_del.java_method(:hkeys, [Java::java.lang.String.java_class,Java::IoVertxCore::Handler.java_class]).call(key,(Proc.new { |ar| yield(ar.failed ? ar.cause : nil, ar.succeeded ? ar.result != nil ? JSON.parse(ar.result.encode) : nil : nil) }))
        return self
      end
      raise ArgumentError, "Invalid arguments when calling hkeys(#{key})"
    end

### - (`self`) hlen(key = nil) { ... }

Get the number of fields in a hash

Parameters:

- key (`String`) (defaults to: `nil`) —
  Key string

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    995
    996
    997
    998
    999
    1000
    1001
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx-redis/redis_client.rb', line 995

    def hlen(key=nil)
      if key.class == String && block_given?
        @j_del.java_method(:hlen, [Java::java.lang.String.java_class,Java::IoVertxCore::Handler.java_class]).call(key,(Proc.new { |ar| yield(ar.failed ? ar.cause : nil, ar.succeeded ? ar.result : nil) }))
        return self
      end
      raise ArgumentError, "Invalid arguments when calling hlen(#{key})"
    end

### - (`self`) hmget(key = nil, fields = nil) { ... }

Get the values of all the given hash fields

Parameters:

- key (`String`) (defaults to: `nil`) —
  Key string
- fields (`Array<String>`) (defaults to: `nil`) —
  Field names

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    1007
    1008
    1009
    1010
    1011
    1012
    1013
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx-redis/redis_client.rb', line 1007

    def hmget(key=nil,fields=nil)
      if key.class == String && fields.class == Array && block_given?
        @j_del.java_method(:hmget, [Java::java.lang.String.java_class,Java::JavaUtil::List.java_class,Java::IoVertxCore::Handler.java_class]).call(key,fields.map { |element| element },(Proc.new { |ar| yield(ar.failed ? ar.cause : nil, ar.succeeded ? ar.result != nil ? JSON.parse(ar.result.encode) : nil : nil) }))
        return self
      end
      raise ArgumentError, "Invalid arguments when calling hmget(#{key},#{fields})"
    end

### - (`self`) hmset(key = nil, values = nil) { ... }

Set multiple hash fields to multiple values

Parameters:

- key (`String`) (defaults to: `nil`) —
  Key string
- values (`Hash{String => Object}`) (defaults to: `nil`) —
  Map of field:value pairs

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    1019
    1020
    1021
    1022
    1023
    1024
    1025
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx-redis/redis_client.rb', line 1019

    def hmset(key=nil,values=nil)
      if key.class == String && values.class == Hash && block_given?
        @j_del.java_method(:hmset, [Java::java.lang.String.java_class,Java::IoVertxCoreJson::JsonObject.java_class,Java::IoVertxCore::Handler.java_class]).call(key,::Vertx::Util::Utils.to_json_object(values),(Proc.new { |ar| yield(ar.failed ? ar.cause : nil, ar.succeeded ? ar.result : nil) }))
        return self
      end
      raise ArgumentError, "Invalid arguments when calling hmset(#{key},#{values})"
    end

### - (`self`) hscan(key = nil, cursor = nil, options = nil) { ... }

Incrementally iterate hash fields and associated values

Parameters:

- key (`String`) (defaults to: `nil`) —
  Key string
- cursor (`String`) (defaults to: `nil`) —
  Cursor id
- options (`Hash`) (defaults to: `nil`) —
  Scan options

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    2602
    2603
    2604
    2605
    2606
    2607
    2608
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx-redis/redis_client.rb', line 2602

    def hscan(key=nil,cursor=nil,options=nil)
      if key.class == String && cursor.class == String && options.class == Hash && block_given?
        @j_del.java_method(:hscan, [Java::java.lang.String.java_class,Java::java.lang.String.java_class,Java::IoVertxRedisOp::ScanOptions.java_class,Java::IoVertxCore::Handler.java_class]).call(key,cursor,Java::IoVertxRedisOp::ScanOptions.new(::Vertx::Util::Utils.to_json_object(options)),(Proc.new { |ar| yield(ar.failed ? ar.cause : nil, ar.succeeded ? ar.result != nil ? JSON.parse(ar.result.encode) : nil : nil) }))
        return self
      end
      raise ArgumentError, "Invalid arguments when calling hscan(#{key},#{cursor},#{options})"
    end

### - (`self`) hset(key = nil, field = nil, value = nil) { ... }

Set the string value of a hash field

Parameters:

- key (`String`) (defaults to: `nil`) —
  Key string
- field (`String`) (defaults to: `nil`) —
  Field name
- value (`String`) (defaults to: `nil`) —
  New value

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    1032
    1033
    1034
    1035
    1036
    1037
    1038
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx-redis/redis_client.rb', line 1032

    def hset(key=nil,field=nil,value=nil)
      if key.class == String && field.class == String && value.class == String && block_given?
        @j_del.java_method(:hset, [Java::java.lang.String.java_class,Java::java.lang.String.java_class,Java::java.lang.String.java_class,Java::IoVertxCore::Handler.java_class]).call(key,field,value,(Proc.new { |ar| yield(ar.failed ? ar.cause : nil, ar.succeeded ? ar.result : nil) }))
        return self
      end
      raise ArgumentError, "Invalid arguments when calling hset(#{key},#{field},#{value})"
    end

### - (`self`) hsetnx(key = nil, field = nil, value = nil) { ... }

Set the value of a hash field, only if the field does not exist

Parameters:

- key (`String`) (defaults to: `nil`) —
  Key string
- field (`String`) (defaults to: `nil`) —
  Field name
- value (`String`) (defaults to: `nil`) —
  New value

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    1045
    1046
    1047
    1048
    1049
    1050
    1051
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx-redis/redis_client.rb', line 1045

    def hsetnx(key=nil,field=nil,value=nil)
      if key.class == String && field.class == String && value.class == String && block_given?
        @j_del.java_method(:hsetnx, [Java::java.lang.String.java_class,Java::java.lang.String.java_class,Java::java.lang.String.java_class,Java::IoVertxCore::Handler.java_class]).call(key,field,value,(Proc.new { |ar| yield(ar.failed ? ar.cause : nil, ar.succeeded ? ar.result : nil) }))
        return self
      end
      raise ArgumentError, "Invalid arguments when calling hsetnx(#{key},#{field},#{value})"
    end

### - (`self`) hstrlen(key = nil, field = nil) { ... }

Get the length of the value of a hash field.

Parameters:

- key (`String`) (defaults to: `nil`) —
  Key String
- field (`String`) (defaults to: `nil`) —
  field

Yields:

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    2809
    2810
    2811
    2812
    2813
    2814
    2815
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx-redis/redis_client.rb', line 2809

    def hstrlen(key=nil,field=nil)
      if key.class == String && field.class == String && block_given?
        @j_del.java_method(:hstrlen, [Java::java.lang.String.java_class,Java::java.lang.String.java_class,Java::IoVertxCore::Handler.java_class]).call(key,field,(Proc.new { |ar| yield(ar.failed ? ar.cause : nil, ar.succeeded ? ar.result : nil) }))
        return self
      end
      raise ArgumentError, "Invalid arguments when calling hstrlen(#{key},#{field})"
    end

### - (`self`) hvals(key = nil) { ... }

Get all the values in a hash

Parameters:

- key (`String`) (defaults to: `nil`) —
  Key string

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    1056
    1057
    1058
    1059
    1060
    1061
    1062
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx-redis/redis_client.rb', line 1056

    def hvals(key=nil)
      if key.class == String && block_given?
        @j_del.java_method(:hvals, [Java::java.lang.String.java_class,Java::IoVertxCore::Handler.java_class]).call(key,(Proc.new { |ar| yield(ar.failed ? ar.cause : nil, ar.succeeded ? ar.result != nil ? JSON.parse(ar.result.encode) : nil : nil) }))
        return self
      end
      raise ArgumentError, "Invalid arguments when calling hvals(#{key})"
    end

### - (`self`) incr(key = nil) { ... }

Increment the integer value of a key by one

Parameters:

- key (`String`) (defaults to: `nil`) —
  Key string

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    1067
    1068
    1069
    1070
    1071
    1072
    1073
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx-redis/redis_client.rb', line 1067

    def incr(key=nil)
      if key.class == String && block_given?
        @j_del.java_method(:incr, [Java::java.lang.String.java_class,Java::IoVertxCore::Handler.java_class]).call(key,(Proc.new { |ar| yield(ar.failed ? ar.cause : nil, ar.succeeded ? ar.result : nil) }))
        return self
      end
      raise ArgumentError, "Invalid arguments when calling incr(#{key})"
    end

### - (`self`) incrby(key = nil, increment = nil) { ... }

Increment the integer value of a key by the given amount

Parameters:

- key (`String`) (defaults to: `nil`) —
  Key string
- increment (`Fixnum`) (defaults to: `nil`) —
  Value by which to increment

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    1079
    1080
    1081
    1082
    1083
    1084
    1085
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx-redis/redis_client.rb', line 1079

    def incrby(key=nil,increment=nil)
      if key.class == String && increment.class == Fixnum && block_given?
        @j_del.java_method(:incrby, [Java::java.lang.String.java_class,Java::long.java_class,Java::IoVertxCore::Handler.java_class]).call(key,increment,(Proc.new { |ar| yield(ar.failed ? ar.cause : nil, ar.succeeded ? ar.result : nil) }))
        return self
      end
      raise ArgumentError, "Invalid arguments when calling incrby(#{key},#{increment})"
    end

### - (`self`) incrbyfloat(key = nil, increment = nil) { ... }

Increment the float value of a key by the given amount

Parameters:

- key (`String`) (defaults to: `nil`) —
  Key string
- increment (`Float`) (defaults to: `nil`) —
  Value by which to increment

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    1091
    1092
    1093
    1094
    1095
    1096
    1097
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx-redis/redis_client.rb', line 1091

    def incrbyfloat(key=nil,increment=nil)
      if key.class == String && increment.class == Float && block_given?
        @j_del.java_method(:incrbyfloat, [Java::java.lang.String.java_class,Java::double.java_class,Java::IoVertxCore::Handler.java_class]).call(key,::Vertx::Util::Utils.to_double(increment),(Proc.new { |ar| yield(ar.failed ? ar.cause : nil, ar.succeeded ? ar.result : nil) }))
        return self
      end
      raise ArgumentError, "Invalid arguments when calling incrbyfloat(#{key},#{increment})"
    end

### - (`self`) info { ... }

Get information and statistics about the server

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    1101
    1102
    1103
    1104
    1105
    1106
    1107
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx-redis/redis_client.rb', line 1101

    def info
      if block_given?
        @j_del.java_method(:info, [Java::IoVertxCore::Handler.java_class]).call((Proc.new { |ar| yield(ar.failed ? ar.cause : nil, ar.succeeded ? ar.result != nil ? JSON.parse(ar.result.encode) : nil : nil) }))
        return self
      end
      raise ArgumentError, "Invalid arguments when calling info()"
    end

### - (`self`) info_section(section = nil) { ... }

Get information and statistics about the server

Parameters:

- section (`String`) (defaults to: `nil`) —
  Specific section of information to return

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    1112
    1113
    1114
    1115
    1116
    1117
    1118
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx-redis/redis_client.rb', line 1112

    def info_section(section=nil)
      if section.class == String && block_given?
        @j_del.java_method(:infoSection, [Java::java.lang.String.java_class,Java::IoVertxCore::Handler.java_class]).call(section,(Proc.new { |ar| yield(ar.failed ? ar.cause : nil, ar.succeeded ? ar.result != nil ? JSON.parse(ar.result.encode) : nil : nil) }))
        return self
      end
      raise ArgumentError, "Invalid arguments when calling info_section(#{section})"
    end

### - (`self`) keys(pattern = nil) { ... }

Find all keys matching the given pattern

Parameters:

- pattern (`String`) (defaults to: `nil`) —
  Pattern to limit the keys returned

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    1123
    1124
    1125
    1126
    1127
    1128
    1129
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx-redis/redis_client.rb', line 1123

    def keys(pattern=nil)
      if pattern.class == String && block_given?
        @j_del.java_method(:keys, [Java::java.lang.String.java_class,Java::IoVertxCore::Handler.java_class]).call(pattern,(Proc.new { |ar| yield(ar.failed ? ar.cause : nil, ar.succeeded ? ar.result != nil ? JSON.parse(ar.result.encode) : nil : nil) }))
        return self
      end
      raise ArgumentError, "Invalid arguments when calling keys(#{pattern})"
    end

### - (`self`) lastsave { ... }

Get the UNIX time stamp of the last successful save to disk

Yields:

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    1133
    1134
    1135
    1136
    1137
    1138
    1139
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx-redis/redis_client.rb', line 1133

    def lastsave
      if block_given?
        @j_del.java_method(:lastsave, [Java::IoVertxCore::Handler.java_class]).call((Proc.new { |ar| yield(ar.failed ? ar.cause : nil, ar.succeeded ? ar.result : nil) }))
        return self
      end
      raise ArgumentError, "Invalid arguments when calling lastsave()"
    end

### - (`self`) lindex(key = nil, index = nil) { ... }

Get an element from a list by its index

Parameters:

- key (`String`) (defaults to: `nil`) —
  Key string
- index (`Fixnum`) (defaults to: `nil`) —
  Index of list element to get

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    1145
    1146
    1147
    1148
    1149
    1150
    1151
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx-redis/redis_client.rb', line 1145

    def lindex(key=nil,index=nil)
      if key.class == String && index.class == Fixnum && block_given?
        @j_del.java_method(:lindex, [Java::java.lang.String.java_class,Java::int.java_class,Java::IoVertxCore::Handler.java_class]).call(key,index,(Proc.new { |ar| yield(ar.failed ? ar.cause : nil, ar.succeeded ? ar.result : nil) }))
        return self
      end
      raise ArgumentError, "Invalid arguments when calling lindex(#{key},#{index})"
    end

### - (`self`) linsert(key = nil, option = nil, pivot = nil, value = nil) { ... }

Insert an element before or after another element in a list

Parameters:

- key (`String`) (defaults to: `nil`) —
  Key string
- option (`:BEFORE`, `:AFTER`) (defaults to: `nil`) —
  BEFORE or AFTER
- pivot (`String`) (defaults to: `nil`) —
  Key to use as a pivot
- value (`String`) (defaults to: `nil`) —
  Value to be inserted before or after the pivot

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    1159
    1160
    1161
    1162
    1163
    1164
    1165
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx-redis/redis_client.rb', line 1159

    def linsert(key=nil,option=nil,pivot=nil,value=nil)
      if key.class == String && option.class == Symbol && pivot.class == String && value.class == String && block_given?
        @j_del.java_method(:linsert, [Java::java.lang.String.java_class,Java::IoVertxRedisOp::InsertOptions.java_class,Java::java.lang.String.java_class,Java::java.lang.String.java_class,Java::IoVertxCore::Handler.java_class]).call(key,Java::IoVertxRedisOp::InsertOptions.valueOf(option.to_s),pivot,value,(Proc.new { |ar| yield(ar.failed ? ar.cause : nil, ar.succeeded ? ar.result : nil) }))
        return self
      end
      raise ArgumentError, "Invalid arguments when calling linsert(#{key},#{option},#{pivot},#{value})"
    end

### - (`self`) llen(key = nil) { ... }

Get the length of a list

Parameters:

- key (`String`) (defaults to: `nil`) —
  String key

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    1170
    1171
    1172
    1173
    1174
    1175
    1176
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx-redis/redis_client.rb', line 1170

    def llen(key=nil)
      if key.class == String && block_given?
        @j_del.java_method(:llen, [Java::java.lang.String.java_class,Java::IoVertxCore::Handler.java_class]).call(key,(Proc.new { |ar| yield(ar.failed ? ar.cause : nil, ar.succeeded ? ar.result : nil) }))
        return self
      end
      raise ArgumentError, "Invalid arguments when calling llen(#{key})"
    end

### - (`self`) lpop(key = nil) { ... }

Remove and get the first element in a list

Parameters:

- key (`String`) (defaults to: `nil`) —
  String key

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    1181
    1182
    1183
    1184
    1185
    1186
    1187
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx-redis/redis_client.rb', line 1181

    def lpop(key=nil)
      if key.class == String && block_given?
        @j_del.java_method(:lpop, [Java::java.lang.String.java_class,Java::IoVertxCore::Handler.java_class]).call(key,(Proc.new { |ar| yield(ar.failed ? ar.cause : nil, ar.succeeded ? ar.result : nil) }))
        return self
      end
      raise ArgumentError, "Invalid arguments when calling lpop(#{key})"
    end

### - (`self`) lpush(key = nil, value = nil) { ... }

Prepend one value to a list

Parameters:

- key (`String`) (defaults to: `nil`) —
  Key string
- value (`String`) (defaults to: `nil`) —
  Value to be added at the beginning of the list

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    1205
    1206
    1207
    1208
    1209
    1210
    1211
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx-redis/redis_client.rb', line 1205

    def lpush(key=nil,value=nil)
      if key.class == String && value.class == String && block_given?
        @j_del.java_method(:lpush, [Java::java.lang.String.java_class,Java::java.lang.String.java_class,Java::IoVertxCore::Handler.java_class]).call(key,value,(Proc.new { |ar| yield(ar.failed ? ar.cause : nil, ar.succeeded ? ar.result : nil) }))
        return self
      end
      raise ArgumentError, "Invalid arguments when calling lpush(#{key},#{value})"
    end

### - (`self`) lpush_many(key = nil, values = nil) { ... }

Prepend one or multiple values to a list

Parameters:

- key (`String`) (defaults to: `nil`) —
  Key string
- values (`Array<String>`) (defaults to: `nil`) —
  Values to be added at the beginning of the list, one by one

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    1193
    1194
    1195
    1196
    1197
    1198
    1199
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx-redis/redis_client.rb', line 1193

    def lpush_many(key=nil,values=nil)
      if key.class == String && values.class == Array && block_given?
        @j_del.java_method(:lpushMany, [Java::java.lang.String.java_class,Java::JavaUtil::List.java_class,Java::IoVertxCore::Handler.java_class]).call(key,values.map { |element| element },(Proc.new { |ar| yield(ar.failed ? ar.cause : nil, ar.succeeded ? ar.result : nil) }))
        return self
      end
      raise ArgumentError, "Invalid arguments when calling lpush_many(#{key},#{values})"
    end

### - (`self`) lpushx(key = nil, value = nil) { ... }

Prepend a value to a list, only if the list exists

Parameters:

- key (`String`) (defaults to: `nil`) —
  Key string
- value (`String`) (defaults to: `nil`) —
  Value to add at the beginning of the list

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    1217
    1218
    1219
    1220
    1221
    1222
    1223
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx-redis/redis_client.rb', line 1217

    def lpushx(key=nil,value=nil)
      if key.class == String && value.class == String && block_given?
        @j_del.java_method(:lpushx, [Java::java.lang.String.java_class,Java::java.lang.String.java_class,Java::IoVertxCore::Handler.java_class]).call(key,value,(Proc.new { |ar| yield(ar.failed ? ar.cause : nil, ar.succeeded ? ar.result : nil) }))
        return self
      end
      raise ArgumentError, "Invalid arguments when calling lpushx(#{key},#{value})"
    end

### - (`self`) lrange(key = nil, from = nil, to = nil) { ... }

Get a range of elements from a list

Parameters:

- key (`String`) (defaults to: `nil`) —
  Key string
- from (`Fixnum`) (defaults to: `nil`) —
  Start index
- to (`Fixnum`) (defaults to: `nil`) —
  Stop index

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    1230
    1231
    1232
    1233
    1234
    1235
    1236
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx-redis/redis_client.rb', line 1230

    def lrange(key=nil,from=nil,to=nil)
      if key.class == String && from.class == Fixnum && to.class == Fixnum && block_given?
        @j_del.java_method(:lrange, [Java::java.lang.String.java_class,Java::long.java_class,Java::long.java_class,Java::IoVertxCore::Handler.java_class]).call(key,from,to,(Proc.new { |ar| yield(ar.failed ? ar.cause : nil, ar.succeeded ? ar.result != nil ? JSON.parse(ar.result.encode) : nil : nil) }))
        return self
      end
      raise ArgumentError, "Invalid arguments when calling lrange(#{key},#{from},#{to})"
    end

### - (`self`) lrem(key = nil, count = nil, value = nil) { ... }

Remove elements from a list

Parameters:

- key (`String`) (defaults to: `nil`) —
  Key string
- count (`Fixnum`) (defaults to: `nil`) —
  Number of first found occurrences equal to $value to remove from the list
- value (`String`) (defaults to: `nil`) —
  Value to be removed

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    1243
    1244
    1245
    1246
    1247
    1248
    1249
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx-redis/redis_client.rb', line 1243

    def lrem(key=nil,count=nil,value=nil)
      if key.class == String && count.class == Fixnum && value.class == String && block_given?
        @j_del.java_method(:lrem, [Java::java.lang.String.java_class,Java::long.java_class,Java::java.lang.String.java_class,Java::IoVertxCore::Handler.java_class]).call(key,count,value,(Proc.new { |ar| yield(ar.failed ? ar.cause : nil, ar.succeeded ? ar.result : nil) }))
        return self
      end
      raise ArgumentError, "Invalid arguments when calling lrem(#{key},#{count},#{value})"
    end

### - (`self`) lset(key = nil, index = nil, value = nil) { ... }

Set the value of an element in a list by its index

Parameters:

- key (`String`) (defaults to: `nil`) —
  Key string
- index (`Fixnum`) (defaults to: `nil`) —
  Position within list
- value (`String`) (defaults to: `nil`) —
  New value

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    1256
    1257
    1258
    1259
    1260
    1261
    1262
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx-redis/redis_client.rb', line 1256

    def lset(key=nil,index=nil,value=nil)
      if key.class == String && index.class == Fixnum && value.class == String && block_given?
        @j_del.java_method(:lset, [Java::java.lang.String.java_class,Java::long.java_class,Java::java.lang.String.java_class,Java::IoVertxCore::Handler.java_class]).call(key,index,value,(Proc.new { |ar| yield(ar.failed ? ar.cause : nil, ar.succeeded ? ar.result : nil) }))
        return self
      end
      raise ArgumentError, "Invalid arguments when calling lset(#{key},#{index},#{value})"
    end

### - (`self`) ltrim(key = nil, from = nil, to = nil) { ... }

Trim a list to the specified range

Parameters:

- key (`String`) (defaults to: `nil`) —
  Key string
- from (`Fixnum`) (defaults to: `nil`) —
  Start index
- to (`Fixnum`) (defaults to: `nil`) —
  Stop index

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    1269
    1270
    1271
    1272
    1273
    1274
    1275
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx-redis/redis_client.rb', line 1269

    def ltrim(key=nil,from=nil,to=nil)
      if key.class == String && from.class == Fixnum && to.class == Fixnum && block_given?
        @j_del.java_method(:ltrim, [Java::java.lang.String.java_class,Java::long.java_class,Java::long.java_class,Java::IoVertxCore::Handler.java_class]).call(key,from,to,(Proc.new { |ar| yield(ar.failed ? ar.cause : nil, ar.succeeded ? ar.result : nil) }))
        return self
      end
      raise ArgumentError, "Invalid arguments when calling ltrim(#{key},#{from},#{to})"
    end

### - (`self`) mget(key = nil) { ... }

Get the value of the given key

Parameters:

- key (`String`) (defaults to: `nil`) —
  Key string

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    1280
    1281
    1282
    1283
    1284
    1285
    1286
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx-redis/redis_client.rb', line 1280

    def mget(key=nil)
      if key.class == String && block_given?
        @j_del.java_method(:mget, [Java::java.lang.String.java_class,Java::IoVertxCore::Handler.java_class]).call(key,(Proc.new { |ar| yield(ar.failed ? ar.cause : nil, ar.succeeded ? ar.result != nil ? JSON.parse(ar.result.encode) : nil : nil) }))
        return self
      end
      raise ArgumentError, "Invalid arguments when calling mget(#{key})"
    end

### - (`self`) mget_many(keys = nil) { ... }

Get the values of all the given keys

Parameters:

- keys (`Array<String>`) (defaults to: `nil`) —
  List of keys to get

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    1291
    1292
    1293
    1294
    1295
    1296
    1297
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx-redis/redis_client.rb', line 1291

    def mget_many(keys=nil)
      if keys.class == Array && block_given?
        @j_del.java_method(:mgetMany, [Java::JavaUtil::List.java_class,Java::IoVertxCore::Handler.java_class]).call(keys.map { |element| element },(Proc.new { |ar| yield(ar.failed ? ar.cause : nil, ar.succeeded ? ar.result != nil ? JSON.parse(ar.result.encode) : nil : nil) }))
        return self
      end
      raise ArgumentError, "Invalid arguments when calling mget_many(#{keys})"
    end

### - (`self`) migrate(host = nil, port = nil, key = nil, destdb = nil, timeout = nil, options = nil) { ... }

Atomically transfer a key from a Redis instance to another one.

Parameters:

- host (`String`) (defaults to: `nil`) —
  Destination host
- port (`Fixnum`) (defaults to: `nil`) —
  Destination port
- key (`String`) (defaults to: `nil`) —
  Key to migrate
- destdb (`Fixnum`) (defaults to: `nil`) —
  Destination database index
- timeout (`Fixnum`) (defaults to: `nil`)
- options (`Hash`) (defaults to: `nil`) —
  Migrate options

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    1307
    1308
    1309
    1310
    1311
    1312
    1313
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx-redis/redis_client.rb', line 1307

    def migrate(host=nil,port=nil,key=nil,destdb=nil,timeout=nil,options=nil)
      if host.class == String && port.class == Fixnum && key.class == String && destdb.class == Fixnum && timeout.class == Fixnum && options.class == Hash && block_given?
        @j_del.java_method(:migrate, [Java::java.lang.String.java_class,Java::int.java_class,Java::java.lang.String.java_class,Java::int.java_class,Java::long.java_class,Java::IoVertxRedisOp::MigrateOptions.java_class,Java::IoVertxCore::Handler.java_class]).call(host,port,key,destdb,timeout,Java::IoVertxRedisOp::MigrateOptions.new(::Vertx::Util::Utils.to_json_object(options)),(Proc.new { |ar| yield(ar.failed ? ar.cause : nil, ar.succeeded ? ar.result : nil) }))
        return self
      end
      raise ArgumentError, "Invalid arguments when calling migrate(#{host},#{port},#{key},#{destdb},#{timeout},#{options})"
    end

### - (`self`) monitor { ... }

Listen for all requests received by the server in real time

Yields:

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    1317
    1318
    1319
    1320
    1321
    1322
    1323
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx-redis/redis_client.rb', line 1317

    def monitor
      if block_given?
        @j_del.java_method(:monitor, [Java::IoVertxCore::Handler.java_class]).call((Proc.new { |ar| yield(ar.failed ? ar.cause : nil) }))
        return self
      end
      raise ArgumentError, "Invalid arguments when calling monitor()"
    end

### - (`self`) move(key = nil, destdb = nil) { ... }

Move a key to another database

Parameters:

- key (`String`) (defaults to: `nil`) —
  Key to migrate
- destdb (`Fixnum`) (defaults to: `nil`) —
  Destination database index

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    1329
    1330
    1331
    1332
    1333
    1334
    1335
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx-redis/redis_client.rb', line 1329

    def move(key=nil,destdb=nil)
      if key.class == String && destdb.class == Fixnum && block_given?
        @j_del.java_method(:move, [Java::java.lang.String.java_class,Java::int.java_class,Java::IoVertxCore::Handler.java_class]).call(key,destdb,(Proc.new { |ar| yield(ar.failed ? ar.cause : nil, ar.succeeded ? ar.result : nil) }))
        return self
      end
      raise ArgumentError, "Invalid arguments when calling move(#{key},#{destdb})"
    end

### - (`self`) mset(keyvals = nil) { ... }

Set multiple keys to multiple values

Parameters:

- keyvals (`Hash{String => Object}`) (defaults to: `nil`) —
  Key value pairs to set

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    1340
    1341
    1342
    1343
    1344
    1345
    1346
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx-redis/redis_client.rb', line 1340

    def mset(keyvals=nil)
      if keyvals.class == Hash && block_given?
        @j_del.java_method(:mset, [Java::IoVertxCoreJson::JsonObject.java_class,Java::IoVertxCore::Handler.java_class]).call(::Vertx::Util::Utils.to_json_object(keyvals),(Proc.new { |ar| yield(ar.failed ? ar.cause : nil, ar.succeeded ? ar.result : nil) }))
        return self
      end
      raise ArgumentError, "Invalid arguments when calling mset(#{keyvals})"
    end

### - (`self`) msetnx(keyvals = nil) { ... }

Set multiple keys to multiple values, only if none of the keys exist

Parameters:

- keyvals (`Hash{String => Object}`) (defaults to: `nil`) —
  Key value pairs to set

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    1351
    1352
    1353
    1354
    1355
    1356
    1357
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx-redis/redis_client.rb', line 1351

    def msetnx(keyvals=nil)
      if keyvals.class == Hash && block_given?
        @j_del.java_method(:msetnx, [Java::IoVertxCoreJson::JsonObject.java_class,Java::IoVertxCore::Handler.java_class]).call(::Vertx::Util::Utils.to_json_object(keyvals),(Proc.new { |ar| yield(ar.failed ? ar.cause : nil, ar.succeeded ? ar.result : nil) }))
        return self
      end
      raise ArgumentError, "Invalid arguments when calling msetnx(#{keyvals})"
    end

### - (`self`) object(key = nil, cmd = nil) { ... }

Inspect the internals of Redis objects

Parameters:

- key (`String`) (defaults to: `nil`) —
  Key string
- cmd (`:REFCOUNT`, `:ENCODING`, `:IDLETIME`) (defaults to: `nil`) —
  Object sub command

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    1363
    1364
    1365
    1366
    1367
    1368
    1369
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx-redis/redis_client.rb', line 1363

    def object(key=nil,cmd=nil)
      if key.class == String && cmd.class == Symbol && block_given?
        @j_del.java_method(:object, [Java::java.lang.String.java_class,Java::IoVertxRedisOp::ObjectCmd.java_class,Java::IoVertxCore::Handler.java_class]).call(key,Java::IoVertxRedisOp::ObjectCmd.valueOf(cmd.to_s),(Proc.new { |ar| yield(ar.failed ? ar.cause : nil) }))
        return self
      end
      raise ArgumentError, "Invalid arguments when calling object(#{key},#{cmd})"
    end

### - (`self`) persist(key = nil) { ... }

Remove the expiration from a key

Parameters:

- key (`String`) (defaults to: `nil`) —
  Key string

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    1374
    1375
    1376
    1377
    1378
    1379
    1380
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx-redis/redis_client.rb', line 1374

    def persist(key=nil)
      if key.class == String && block_given?
        @j_del.java_method(:persist, [Java::java.lang.String.java_class,Java::IoVertxCore::Handler.java_class]).call(key,(Proc.new { |ar| yield(ar.failed ? ar.cause : nil, ar.succeeded ? ar.result : nil) }))
        return self
      end
      raise ArgumentError, "Invalid arguments when calling persist(#{key})"
    end

### - (`self`) pexpire(key = nil, millis = nil) { ... }

Set a key's time to live in milliseconds

Parameters:

- key (`String`) (defaults to: `nil`) —
  String key
- millis (`Fixnum`) (defaults to: `nil`) —
  Time to live in milliseconds

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    1386
    1387
    1388
    1389
    1390
    1391
    1392
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx-redis/redis_client.rb', line 1386

    def pexpire(key=nil,millis=nil)
      if key.class == String && millis.class == Fixnum && block_given?
        @j_del.java_method(:pexpire, [Java::java.lang.String.java_class,Java::long.java_class,Java::IoVertxCore::Handler.java_class]).call(key,millis,(Proc.new { |ar| yield(ar.failed ? ar.cause : nil, ar.succeeded ? ar.result : nil) }))
        return self
      end
      raise ArgumentError, "Invalid arguments when calling pexpire(#{key},#{millis})"
    end

### - (`self`) pexpireat(key = nil, millis = nil) { ... }

Set the expiration for a key as a UNIX timestamp specified in milliseconds

Parameters:

- key (`String`) (defaults to: `nil`) —
  Key string
- millis (`Fixnum`) (defaults to: `nil`) —
  Expiry time as Unix timestamp in milliseconds

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    1398
    1399
    1400
    1401
    1402
    1403
    1404
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx-redis/redis_client.rb', line 1398

    def pexpireat(key=nil,millis=nil)
      if key.class == String && millis.class == Fixnum && block_given?
        @j_del.java_method(:pexpireat, [Java::java.lang.String.java_class,Java::long.java_class,Java::IoVertxCore::Handler.java_class]).call(key,millis,(Proc.new { |ar| yield(ar.failed ? ar.cause : nil, ar.succeeded ? ar.result : nil) }))
        return self
      end
      raise ArgumentError, "Invalid arguments when calling pexpireat(#{key},#{millis})"
    end

### - (`self`) pfadd(key = nil, element = nil) { ... }

Adds the specified element to the specified HyperLogLog.

Parameters:

- key (`String`) (defaults to: `nil`) —
  Key string
- element (`String`) (defaults to: `nil`) —
  Element to add

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    1410
    1411
    1412
    1413
    1414
    1415
    1416
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx-redis/redis_client.rb', line 1410

    def pfadd(key=nil,element=nil)
      if key.class == String && element.class == String && block_given?
        @j_del.java_method(:pfadd, [Java::java.lang.String.java_class,Java::java.lang.String.java_class,Java::IoVertxCore::Handler.java_class]).call(key,element,(Proc.new { |ar| yield(ar.failed ? ar.cause : nil, ar.succeeded ? ar.result : nil) }))
        return self
      end
      raise ArgumentError, "Invalid arguments when calling pfadd(#{key},#{element})"
    end

### - (`self`) pfadd_many(key = nil, elements = nil) { ... }

Adds the specified elements to the specified HyperLogLog.

Parameters:

- key (`String`) (defaults to: `nil`) —
  Key string
- elements (`Array<String>`) (defaults to: `nil`) —
  Elementa to add

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    1422
    1423
    1424
    1425
    1426
    1427
    1428
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx-redis/redis_client.rb', line 1422

    def pfadd_many(key=nil,elements=nil)
      if key.class == String && elements.class == Array && block_given?
        @j_del.java_method(:pfaddMany, [Java::java.lang.String.java_class,Java::JavaUtil::List.java_class,Java::IoVertxCore::Handler.java_class]).call(key,elements.map { |element| element },(Proc.new { |ar| yield(ar.failed ? ar.cause : nil, ar.succeeded ? ar.result : nil) }))
        return self
      end
      raise ArgumentError, "Invalid arguments when calling pfadd_many(#{key},#{elements})"
    end

### - (`self`) pfcount(key = nil) { ... }

Return the approximated cardinality of the set observed by the HyperLogLog at key.

Parameters:

- key (`String`) (defaults to: `nil`) —
  Key string

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    1433
    1434
    1435
    1436
    1437
    1438
    1439
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx-redis/redis_client.rb', line 1433

    def pfcount(key=nil)
      if key.class == String && block_given?
        @j_del.java_method(:pfcount, [Java::java.lang.String.java_class,Java::IoVertxCore::Handler.java_class]).call(key,(Proc.new { |ar| yield(ar.failed ? ar.cause : nil, ar.succeeded ? ar.result : nil) }))
        return self
      end
      raise ArgumentError, "Invalid arguments when calling pfcount(#{key})"
    end

### - (`self`) pfcount_many(keys = nil) { ... }

Return the approximated cardinality of the set(s) observed by the HyperLogLog at key(s).

Parameters:

- keys (`Array<String>`) (defaults to: `nil`) —
  List of keys

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    1444
    1445
    1446
    1447
    1448
    1449
    1450
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx-redis/redis_client.rb', line 1444

    def pfcount_many(keys=nil)
      if keys.class == Array && block_given?
        @j_del.java_method(:pfcountMany, [Java::JavaUtil::List.java_class,Java::IoVertxCore::Handler.java_class]).call(keys.map { |element| element },(Proc.new { |ar| yield(ar.failed ? ar.cause : nil, ar.succeeded ? ar.result : nil) }))
        return self
      end
      raise ArgumentError, "Invalid arguments when calling pfcount_many(#{keys})"
    end

### - (`self`) pfmerge(destkey = nil, keys = nil) { ... }

Merge N different HyperLogLogs into a single one.

Parameters:

- destkey (`String`) (defaults to: `nil`) —
  Destination key
- keys (`Array<String>`) (defaults to: `nil`) —
  List of source keys

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    1456
    1457
    1458
    1459
    1460
    1461
    1462
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx-redis/redis_client.rb', line 1456

    def pfmerge(destkey=nil,keys=nil)
      if destkey.class == String && keys.class == Array && block_given?
        @j_del.java_method(:pfmerge, [Java::java.lang.String.java_class,Java::JavaUtil::List.java_class,Java::IoVertxCore::Handler.java_class]).call(destkey,keys.map { |element| element },(Proc.new { |ar| yield(ar.failed ? ar.cause : nil, ar.succeeded ? ar.result : nil) }))
        return self
      end
      raise ArgumentError, "Invalid arguments when calling pfmerge(#{destkey},#{keys})"
    end

### - (`self`) ping { ... }

Ping the server

Yields:

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    1466
    1467
    1468
    1469
    1470
    1471
    1472
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx-redis/redis_client.rb', line 1466

    def ping
      if block_given?
        @j_del.java_method(:ping, [Java::IoVertxCore::Handler.java_class]).call((Proc.new { |ar| yield(ar.failed ? ar.cause : nil, ar.succeeded ? ar.result : nil) }))
        return self
      end
      raise ArgumentError, "Invalid arguments when calling ping()"
    end

### - (`self`) psetex(key = nil, millis = nil, value = nil) { ... }

Set the value and expiration in milliseconds of a key

Parameters:

- key (`String`) (defaults to: `nil`) —
  Key string
- millis (`Fixnum`) (defaults to: `nil`) —
  Number of milliseconds until the key expires
- value (`String`) (defaults to: `nil`) —
  New value for key

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    1479
    1480
    1481
    1482
    1483
    1484
    1485
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx-redis/redis_client.rb', line 1479

    def psetex(key=nil,millis=nil,value=nil)
      if key.class == String && millis.class == Fixnum && value.class == String && block_given?
        @j_del.java_method(:psetex, [Java::java.lang.String.java_class,Java::long.java_class,Java::java.lang.String.java_class,Java::IoVertxCore::Handler.java_class]).call(key,millis,value,(Proc.new { |ar| yield(ar.failed ? ar.cause : nil) }))
        return self
      end
      raise ArgumentError, "Invalid arguments when calling psetex(#{key},#{millis},#{value})"
    end

### - (`self`) psubscribe(pattern = nil) { ... }

Listen for messages published to channels matching the given pattern

Parameters:

- pattern (`String`) (defaults to: `nil`) —
  Pattern string

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    1490
    1491
    1492
    1493
    1494
    1495
    1496
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx-redis/redis_client.rb', line 1490

    def psubscribe(pattern=nil)
      if pattern.class == String && block_given?
        @j_del.java_method(:psubscribe, [Java::java.lang.String.java_class,Java::IoVertxCore::Handler.java_class]).call(pattern,(Proc.new { |ar| yield(ar.failed ? ar.cause : nil, ar.succeeded ? ar.result != nil ? JSON.parse(ar.result.encode) : nil : nil) }))
        return self
      end
      raise ArgumentError, "Invalid arguments when calling psubscribe(#{pattern})"
    end

### - (`self`) psubscribe_many(patterns = nil) { ... }

Listen for messages published to channels matching the given patterns

Parameters:

- patterns (`Array<String>`) (defaults to: `nil`) —
  List of patterns

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    1501
    1502
    1503
    1504
    1505
    1506
    1507
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx-redis/redis_client.rb', line 1501

    def psubscribe_many(patterns=nil)
      if patterns.class == Array && block_given?
        @j_del.java_method(:psubscribeMany, [Java::JavaUtil::List.java_class,Java::IoVertxCore::Handler.java_class]).call(patterns.map { |element| element },(Proc.new { |ar| yield(ar.failed ? ar.cause : nil, ar.succeeded ? ar.result != nil ? JSON.parse(ar.result.encode) : nil : nil) }))
        return self
      end
      raise ArgumentError, "Invalid arguments when calling psubscribe_many(#{patterns})"
    end

### - (`self`) pttl(key = nil) { ... }

Get the time to live for a key in milliseconds

Parameters:

- key (`String`) (defaults to: `nil`) —
  Key string

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    1544
    1545
    1546
    1547
    1548
    1549
    1550
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx-redis/redis_client.rb', line 1544

    def pttl(key=nil)
      if key.class == String && block_given?
        @j_del.java_method(:pttl, [Java::java.lang.String.java_class,Java::IoVertxCore::Handler.java_class]).call(key,(Proc.new { |ar| yield(ar.failed ? ar.cause : nil, ar.succeeded ? ar.result : nil) }))
        return self
      end
      raise ArgumentError, "Invalid arguments when calling pttl(#{key})"
    end

### - (`self`) publish(channel = nil, message = nil) { ... }

Post a message to a channel

Parameters:

- channel (`String`) (defaults to: `nil`) —
  Channel key
- message (`String`) (defaults to: `nil`) —
  Message to send to channel

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    1556
    1557
    1558
    1559
    1560
    1561
    1562
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx-redis/redis_client.rb', line 1556

    def publish(channel=nil,message=nil)
      if channel.class == String && message.class == String && block_given?
        @j_del.java_method(:publish, [Java::java.lang.String.java_class,Java::java.lang.String.java_class,Java::IoVertxCore::Handler.java_class]).call(channel,message,(Proc.new { |ar| yield(ar.failed ? ar.cause : nil, ar.succeeded ? ar.result : nil) }))
        return self
      end
      raise ArgumentError, "Invalid arguments when calling publish(#{channel},#{message})"
    end

### - (`self`) pubsub_channels(pattern = nil) { ... }

Lists the currently active channels - only those matching the pattern

Parameters:

- pattern (`String`) (defaults to: `nil`) —
  A glob-style pattern - an empty string means no pattern

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    1512
    1513
    1514
    1515
    1516
    1517
    1518
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx-redis/redis_client.rb', line 1512

    def pubsub_channels(pattern=nil)
      if pattern.class == String && block_given?
        @j_del.java_method(:pubsubChannels, [Java::java.lang.String.java_class,Java::IoVertxCore::Handler.java_class]).call(pattern,(Proc.new { |ar| yield(ar.failed ? ar.cause : nil, ar.succeeded ? ar.result != nil ? JSON.parse(ar.result.encode) : nil : nil) }))
        return self
      end
      raise ArgumentError, "Invalid arguments when calling pubsub_channels(#{pattern})"
    end

### - (`self`) pubsub_numpat { ... }

Returns the number of subscriptions to patterns (that are performed using the PSUBSCRIBE command)

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    1533
    1534
    1535
    1536
    1537
    1538
    1539
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx-redis/redis_client.rb', line 1533

    def pubsub_numpat
      if block_given?
        @j_del.java_method(:pubsubNumpat, [Java::IoVertxCore::Handler.java_class]).call((Proc.new { |ar| yield(ar.failed ? ar.cause : nil, ar.succeeded ? ar.result : nil) }))
        return self
      end
      raise ArgumentError, "Invalid arguments when calling pubsub_numpat()"
    end

### - (`self`) pubsub_numsub(channels = nil) { ... }

Returns the number of subscribers (not counting clients subscribed to patterns) for the specified channels

Parameters:

- channels (`Array<String>`) (defaults to: `nil`) —
  List of channels

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    1523
    1524
    1525
    1526
    1527
    1528
    1529
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx-redis/redis_client.rb', line 1523

    def pubsub_numsub(channels=nil)
      if channels.class == Array && block_given?
        @j_del.java_method(:pubsubNumsub, [Java::JavaUtil::List.java_class,Java::IoVertxCore::Handler.java_class]).call(channels.map { |element| element },(Proc.new { |ar| yield(ar.failed ? ar.cause : nil, ar.succeeded ? ar.result != nil ? JSON.parse(ar.result.encode) : nil : nil) }))
        return self
      end
      raise ArgumentError, "Invalid arguments when calling pubsub_numsub(#{channels})"
    end

### - (`self`) punsubscribe(patterns = nil) { ... }

Stop listening for messages posted to channels matching the given patterns

Parameters:

- patterns (`Array<String>`) (defaults to: `nil`) —
  List of patterns to match against

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    1567
    1568
    1569
    1570
    1571
    1572
    1573
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx-redis/redis_client.rb', line 1567

    def punsubscribe(patterns=nil)
      if patterns.class == Array && block_given?
        @j_del.java_method(:punsubscribe, [Java::JavaUtil::List.java_class,Java::IoVertxCore::Handler.java_class]).call(patterns.map { |element| element },(Proc.new { |ar| yield(ar.failed ? ar.cause : nil) }))
        return self
      end
      raise ArgumentError, "Invalid arguments when calling punsubscribe(#{patterns})"
    end

### - (`self`) randomkey { ... }

Return a random key from the keyspace

Yields:

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    1577
    1578
    1579
    1580
    1581
    1582
    1583
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx-redis/redis_client.rb', line 1577

    def randomkey
      if block_given?
        @j_del.java_method(:randomkey, [Java::IoVertxCore::Handler.java_class]).call((Proc.new { |ar| yield(ar.failed ? ar.cause : nil, ar.succeeded ? ar.result : nil) }))
        return self
      end
      raise ArgumentError, "Invalid arguments when calling randomkey()"
    end

### - (`self`) rename(key = nil, newkey = nil) { ... }

Rename a key

Parameters:

- key (`String`) (defaults to: `nil`) —
  Key string to be renamed
- newkey (`String`) (defaults to: `nil`) —
  New key string

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    1589
    1590
    1591
    1592
    1593
    1594
    1595
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx-redis/redis_client.rb', line 1589

    def rename(key=nil,newkey=nil)
      if key.class == String && newkey.class == String && block_given?
        @j_del.java_method(:rename, [Java::java.lang.String.java_class,Java::java.lang.String.java_class,Java::IoVertxCore::Handler.java_class]).call(key,newkey,(Proc.new { |ar| yield(ar.failed ? ar.cause : nil, ar.succeeded ? ar.result : nil) }))
        return self
      end
      raise ArgumentError, "Invalid arguments when calling rename(#{key},#{newkey})"
    end

### - (`self`) renamenx(key = nil, newkey = nil) { ... }

Rename a key, only if the new key does not exist

Parameters:

- key (`String`) (defaults to: `nil`) —
  Key string to be renamed
- newkey (`String`) (defaults to: `nil`) —
  New key string

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    1601
    1602
    1603
    1604
    1605
    1606
    1607
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx-redis/redis_client.rb', line 1601

    def renamenx(key=nil,newkey=nil)
      if key.class == String && newkey.class == String && block_given?
        @j_del.java_method(:renamenx, [Java::java.lang.String.java_class,Java::java.lang.String.java_class,Java::IoVertxCore::Handler.java_class]).call(key,newkey,(Proc.new { |ar| yield(ar.failed ? ar.cause : nil, ar.succeeded ? ar.result : nil) }))
        return self
      end
      raise ArgumentError, "Invalid arguments when calling renamenx(#{key},#{newkey})"
    end

### - (`self`) restore(key = nil, millis = nil, serialized = nil) { ... }

Create a key using the provided serialized value, previously obtained using DUMP.

Parameters:

- key (`String`) (defaults to: `nil`) —
  Key string
- millis (`Fixnum`) (defaults to: `nil`) —
  Expiry time in milliseconds to set on the key
- serialized (`String`) (defaults to: `nil`) —
  Serialized form of the key value as obtained using DUMP

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    1614
    1615
    1616
    1617
    1618
    1619
    1620
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx-redis/redis_client.rb', line 1614

    def restore(key=nil,millis=nil,serialized=nil)
      if key.class == String && millis.class == Fixnum && serialized.class == String && block_given?
        @j_del.java_method(:restore, [Java::java.lang.String.java_class,Java::long.java_class,Java::java.lang.String.java_class,Java::IoVertxCore::Handler.java_class]).call(key,millis,serialized,(Proc.new { |ar| yield(ar.failed ? ar.cause : nil, ar.succeeded ? ar.result : nil) }))
        return self
      end
      raise ArgumentError, "Invalid arguments when calling restore(#{key},#{millis},#{serialized})"
    end

### - (`self`) role { ... }

Return the role of the instance in the context of replication

Yields:

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    1624
    1625
    1626
    1627
    1628
    1629
    1630
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx-redis/redis_client.rb', line 1624

    def role
      if block_given?
        @j_del.java_method(:role, [Java::IoVertxCore::Handler.java_class]).call((Proc.new { |ar| yield(ar.failed ? ar.cause : nil, ar.succeeded ? ar.result != nil ? JSON.parse(ar.result.encode) : nil : nil) }))
        return self
      end
      raise ArgumentError, "Invalid arguments when calling role()"
    end

### - (`self`) rpop(key = nil) { ... }

Remove and get the last element in a list

Parameters:

- key (`String`) (defaults to: `nil`) —
  Key string

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    1635
    1636
    1637
    1638
    1639
    1640
    1641
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx-redis/redis_client.rb', line 1635

    def rpop(key=nil)
      if key.class == String && block_given?
        @j_del.java_method(:rpop, [Java::java.lang.String.java_class,Java::IoVertxCore::Handler.java_class]).call(key,(Proc.new { |ar| yield(ar.failed ? ar.cause : nil, ar.succeeded ? ar.result : nil) }))
        return self
      end
      raise ArgumentError, "Invalid arguments when calling rpop(#{key})"
    end

### - (`self`) rpoplpush(key = nil, destkey = nil) { ... }

Remove the last element in a list, append it to another list and return it

Parameters:

- key (`String`) (defaults to: `nil`) —
  Key string identifying source list
- destkey (`String`) (defaults to: `nil`) —
  Key string identifying destination list

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    1647
    1648
    1649
    1650
    1651
    1652
    1653
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx-redis/redis_client.rb', line 1647

    def rpoplpush(key=nil,destkey=nil)
      if key.class == String && destkey.class == String && block_given?
        @j_del.java_method(:rpoplpush, [Java::java.lang.String.java_class,Java::java.lang.String.java_class,Java::IoVertxCore::Handler.java_class]).call(key,destkey,(Proc.new { |ar| yield(ar.failed ? ar.cause : nil, ar.succeeded ? ar.result : nil) }))
        return self
      end
      raise ArgumentError, "Invalid arguments when calling rpoplpush(#{key},#{destkey})"
    end

### - (`self`) rpush(key = nil, value = nil) { ... }

Append one or multiple values to a list

Parameters:

- key (`String`) (defaults to: `nil`) —
  Key string
- value (`String`) (defaults to: `nil`) —
  Value to be added to the end of the list

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    1671
    1672
    1673
    1674
    1675
    1676
    1677
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx-redis/redis_client.rb', line 1671

    def rpush(key=nil,value=nil)
      if key.class == String && value.class == String && block_given?
        @j_del.java_method(:rpush, [Java::java.lang.String.java_class,Java::java.lang.String.java_class,Java::IoVertxCore::Handler.java_class]).call(key,value,(Proc.new { |ar| yield(ar.failed ? ar.cause : nil, ar.succeeded ? ar.result : nil) }))
        return self
      end
      raise ArgumentError, "Invalid arguments when calling rpush(#{key},#{value})"
    end

### - (`self`) rpush_many(key = nil, values = nil) { ... }

Append one or multiple values to a list

Parameters:

- key (`String`) (defaults to: `nil`) —
  Key string
- values (`Array<String>`) (defaults to: `nil`) —
  List of values to add to the end of the list

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    1659
    1660
    1661
    1662
    1663
    1664
    1665
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx-redis/redis_client.rb', line 1659

    def rpush_many(key=nil,values=nil)
      if key.class == String && values.class == Array && block_given?
        @j_del.java_method(:rpushMany, [Java::java.lang.String.java_class,Java::JavaUtil::List.java_class,Java::IoVertxCore::Handler.java_class]).call(key,values.map { |element| element },(Proc.new { |ar| yield(ar.failed ? ar.cause : nil, ar.succeeded ? ar.result : nil) }))
        return self
      end
      raise ArgumentError, "Invalid arguments when calling rpush_many(#{key},#{values})"
    end

### - (`self`) rpushx(key = nil, value = nil) { ... }

Append a value to a list, only if the list exists

Parameters:

- key (`String`) (defaults to: `nil`) —
  Key string
- value (`String`) (defaults to: `nil`) —
  Value to be added to the end of the list

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    1683
    1684
    1685
    1686
    1687
    1688
    1689
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx-redis/redis_client.rb', line 1683

    def rpushx(key=nil,value=nil)
      if key.class == String && value.class == String && block_given?
        @j_del.java_method(:rpushx, [Java::java.lang.String.java_class,Java::java.lang.String.java_class,Java::IoVertxCore::Handler.java_class]).call(key,value,(Proc.new { |ar| yield(ar.failed ? ar.cause : nil, ar.succeeded ? ar.result : nil) }))
        return self
      end
      raise ArgumentError, "Invalid arguments when calling rpushx(#{key},#{value})"
    end

### - (`self`) sadd(key = nil, member = nil) { ... }

Add a member to a set

Parameters:

- key (`String`) (defaults to: `nil`) —
  Key string
- member (`String`) (defaults to: `nil`) —
  Value to be added to the set

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    1695
    1696
    1697
    1698
    1699
    1700
    1701
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx-redis/redis_client.rb', line 1695

    def sadd(key=nil,member=nil)
      if key.class == String && member.class == String && block_given?
        @j_del.java_method(:sadd, [Java::java.lang.String.java_class,Java::java.lang.String.java_class,Java::IoVertxCore::Handler.java_class]).call(key,member,(Proc.new { |ar| yield(ar.failed ? ar.cause : nil, ar.succeeded ? ar.result : nil) }))
        return self
      end
      raise ArgumentError, "Invalid arguments when calling sadd(#{key},#{member})"
    end

### - (`self`) sadd_many(key = nil, members = nil) { ... }

Add one or more members to a set

Parameters:

- key (`String`) (defaults to: `nil`) —
  Key string
- members (`Array<String>`) (defaults to: `nil`) —
  Values to be added to the set

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    1707
    1708
    1709
    1710
    1711
    1712
    1713
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx-redis/redis_client.rb', line 1707

    def sadd_many(key=nil,members=nil)
      if key.class == String && members.class == Array && block_given?
        @j_del.java_method(:saddMany, [Java::java.lang.String.java_class,Java::JavaUtil::List.java_class,Java::IoVertxCore::Handler.java_class]).call(key,members.map { |element| element },(Proc.new { |ar| yield(ar.failed ? ar.cause : nil, ar.succeeded ? ar.result : nil) }))
        return self
      end
      raise ArgumentError, "Invalid arguments when calling sadd_many(#{key},#{members})"
    end

### - (`self`) save { ... }

Synchronously save the dataset to disk

Yields:

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    1717
    1718
    1719
    1720
    1721
    1722
    1723
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx-redis/redis_client.rb', line 1717

    def save
      if block_given?
        @j_del.java_method(:save, [Java::IoVertxCore::Handler.java_class]).call((Proc.new { |ar| yield(ar.failed ? ar.cause : nil, ar.succeeded ? ar.result : nil) }))
        return self
      end
      raise ArgumentError, "Invalid arguments when calling save()"
    end

### - (`self`) scan(cursor = nil, options = nil) { ... }

Incrementally iterate the keys space

Parameters:

- cursor (`String`) (defaults to: `nil`) —
  Cursor id
- options (`Hash`) (defaults to: `nil`) —
  Scan options

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    2576
    2577
    2578
    2579
    2580
    2581
    2582
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx-redis/redis_client.rb', line 2576

    def scan(cursor=nil,options=nil)
      if cursor.class == String && options.class == Hash && block_given?
        @j_del.java_method(:scan, [Java::java.lang.String.java_class,Java::IoVertxRedisOp::ScanOptions.java_class,Java::IoVertxCore::Handler.java_class]).call(cursor,Java::IoVertxRedisOp::ScanOptions.new(::Vertx::Util::Utils.to_json_object(options)),(Proc.new { |ar| yield(ar.failed ? ar.cause : nil, ar.succeeded ? ar.result != nil ? JSON.parse(ar.result.encode) : nil : nil) }))
        return self
      end
      raise ArgumentError, "Invalid arguments when calling scan(#{cursor},#{options})"
    end

### - (`self`) scard(key = nil) { ... }

Get the number of members in a set

Parameters:

- key (`String`) (defaults to: `nil`) —
  Key string

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    1728
    1729
    1730
    1731
    1732
    1733
    1734
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx-redis/redis_client.rb', line 1728

    def scard(key=nil)
      if key.class == String && block_given?
        @j_del.java_method(:scard, [Java::java.lang.String.java_class,Java::IoVertxCore::Handler.java_class]).call(key,(Proc.new { |ar| yield(ar.failed ? ar.cause : nil, ar.succeeded ? ar.result : nil) }))
        return self
      end
      raise ArgumentError, "Invalid arguments when calling scard(#{key})"
    end

### - (`self`) script_debug(scriptDebugOptions = nil) { ... }

Set the debug mode for executed scripts.

Parameters:

- scriptDebugOptions (`:YES`, `:SYNC`, `:NO`) (defaults to: `nil`) —
  the option

Yields:

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    2842
    2843
    2844
    2845
    2846
    2847
    2848
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx-redis/redis_client.rb', line 2842

    def script_debug(scriptDebugOptions=nil)
      if scriptDebugOptions.class == Symbol && block_given?
        @j_del.java_method(:scriptDebug, [Java::IoVertxRedisOp::ScriptDebugOptions.java_class,Java::IoVertxCore::Handler.java_class]).call(Java::IoVertxRedisOp::ScriptDebugOptions.valueOf(scriptDebugOptions.to_s),(Proc.new { |ar| yield(ar.failed ? ar.cause : nil, ar.succeeded ? ar.result : nil) }))
        return self
      end
      raise ArgumentError, "Invalid arguments when calling script_debug(#{scriptDebugOptions})"
    end

### - (`self`) script_exists(script = nil) { ... }

Check existence of script in the script cache.

Parameters:

- script (`String`) (defaults to: `nil`) —
  SHA1 digest identifying a script in the script cache

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    1739
    1740
    1741
    1742
    1743
    1744
    1745
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx-redis/redis_client.rb', line 1739

    def script_exists(script=nil)
      if script.class == String && block_given?
        @j_del.java_method(:scriptExists, [Java::java.lang.String.java_class,Java::IoVertxCore::Handler.java_class]).call(script,(Proc.new { |ar| yield(ar.failed ? ar.cause : nil, ar.succeeded ? ar.result != nil ? JSON.parse(ar.result.encode) : nil : nil) }))
        return self
      end
      raise ArgumentError, "Invalid arguments when calling script_exists(#{script})"
    end

### - (`self`) script_exists_many(scripts = nil) { ... }

Check existence of scripts in the script cache.

Parameters:

- scripts (`Array<String>`) (defaults to: `nil`) —
  List of SHA1 digests identifying scripts in the script cache

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    1750
    1751
    1752
    1753
    1754
    1755
    1756
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx-redis/redis_client.rb', line 1750

    def script_exists_many(scripts=nil)
      if scripts.class == Array && block_given?
        @j_del.java_method(:scriptExistsMany, [Java::JavaUtil::List.java_class,Java::IoVertxCore::Handler.java_class]).call(scripts.map { |element| element },(Proc.new { |ar| yield(ar.failed ? ar.cause : nil, ar.succeeded ? ar.result != nil ? JSON.parse(ar.result.encode) : nil : nil) }))
        return self
      end
      raise ArgumentError, "Invalid arguments when calling script_exists_many(#{scripts})"
    end

### - (`self`) script_flush { ... }

Remove all the scripts from the script cache.

Yields:

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    1760
    1761
    1762
    1763
    1764
    1765
    1766
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx-redis/redis_client.rb', line 1760

    def script_flush
      if block_given?
        @j_del.java_method(:scriptFlush, [Java::IoVertxCore::Handler.java_class]).call((Proc.new { |ar| yield(ar.failed ? ar.cause : nil, ar.succeeded ? ar.result : nil) }))
        return self
      end
      raise ArgumentError, "Invalid arguments when calling script_flush()"
    end

### - (`self`) script_kill { ... }

Kill the script currently in execution.

Yields:

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    1770
    1771
    1772
    1773
    1774
    1775
    1776
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx-redis/redis_client.rb', line 1770

    def script_kill
      if block_given?
        @j_del.java_method(:scriptKill, [Java::IoVertxCore::Handler.java_class]).call((Proc.new { |ar| yield(ar.failed ? ar.cause : nil, ar.succeeded ? ar.result : nil) }))
        return self
      end
      raise ArgumentError, "Invalid arguments when calling script_kill()"
    end

### - (`self`) script_load(script = nil) { ... }

Load the specified Lua script into the script cache.

Parameters:

- script (`String`) (defaults to: `nil`) —
  Lua script

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    1781
    1782
    1783
    1784
    1785
    1786
    1787
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx-redis/redis_client.rb', line 1781

    def script_load(script=nil)
      if script.class == String && block_given?
        @j_del.java_method(:scriptLoad, [Java::java.lang.String.java_class,Java::IoVertxCore::Handler.java_class]).call(script,(Proc.new { |ar| yield(ar.failed ? ar.cause : nil, ar.succeeded ? ar.result : nil) }))
        return self
      end
      raise ArgumentError, "Invalid arguments when calling script_load(#{script})"
    end

### - (`self`) sdiff(key = nil, cmpkeys = nil) { ... }

Subtract multiple sets

Parameters:

- key (`String`) (defaults to: `nil`) —
  Key identifying the set to compare with all other sets combined
- cmpkeys (`Array<String>`) (defaults to: `nil`) —
  List of keys identifying sets to subtract from the key set

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    1793
    1794
    1795
    1796
    1797
    1798
    1799
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx-redis/redis_client.rb', line 1793

    def sdiff(key=nil,cmpkeys=nil)
      if key.class == String && cmpkeys.class == Array && block_given?
        @j_del.java_method(:sdiff, [Java::java.lang.String.java_class,Java::JavaUtil::List.java_class,Java::IoVertxCore::Handler.java_class]).call(key,cmpkeys.map { |element| element },(Proc.new { |ar| yield(ar.failed ? ar.cause : nil, ar.succeeded ? ar.result != nil ? JSON.parse(ar.result.encode) : nil : nil) }))
        return self
      end
      raise ArgumentError, "Invalid arguments when calling sdiff(#{key},#{cmpkeys})"
    end

### - (`self`) sdiffstore(destkey = nil, key = nil, cmpkeys = nil) { ... }

Subtract multiple sets and store the resulting set in a key

Parameters:

- destkey (`String`) (defaults to: `nil`) —
  Destination key where the result should be stored
- key (`String`) (defaults to: `nil`) —
  Key identifying the set to compare with all other sets combined
- cmpkeys (`Array<String>`) (defaults to: `nil`) —
  List of keys identifying sets to subtract from the key set

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    1806
    1807
    1808
    1809
    1810
    1811
    1812
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx-redis/redis_client.rb', line 1806

    def sdiffstore(destkey=nil,key=nil,cmpkeys=nil)
      if destkey.class == String && key.class == String && cmpkeys.class == Array && block_given?
        @j_del.java_method(:sdiffstore, [Java::java.lang.String.java_class,Java::java.lang.String.java_class,Java::JavaUtil::List.java_class,Java::IoVertxCore::Handler.java_class]).call(destkey,key,cmpkeys.map { |element| element },(Proc.new { |ar| yield(ar.failed ? ar.cause : nil, ar.succeeded ? ar.result : nil) }))
        return self
      end
      raise ArgumentError, "Invalid arguments when calling sdiffstore(#{destkey},#{key},#{cmpkeys})"
    end

### - (`self`) select(dbindex = nil) { ... }

Change the selected database for the current connection

Parameters:

- dbindex (`Fixnum`) (defaults to: `nil`) —
  Index identifying the new active database

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    1817
    1818
    1819
    1820
    1821
    1822
    1823
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx-redis/redis_client.rb', line 1817

    def select(dbindex=nil)
      if dbindex.class == Fixnum && block_given?
        @j_del.java_method(:select, [Java::int.java_class,Java::IoVertxCore::Handler.java_class]).call(dbindex,(Proc.new { |ar| yield(ar.failed ? ar.cause : nil, ar.succeeded ? ar.result : nil) }))
        return self
      end
      raise ArgumentError, "Invalid arguments when calling select(#{dbindex})"
    end

### - (`self`) set(key = nil, value = nil) { ... }

Set the string value of a key

Parameters:

- key (`String`) (defaults to: `nil`) —
  Key of which value to set
- value (`String`) (defaults to: `nil`) —
  New value for the key

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    1829
    1830
    1831
    1832
    1833
    1834
    1835
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx-redis/redis_client.rb', line 1829

    def set(key=nil,value=nil)
      if key.class == String && value.class == String && block_given?
        @j_del.java_method(:set, [Java::java.lang.String.java_class,Java::java.lang.String.java_class,Java::IoVertxCore::Handler.java_class]).call(key,value,(Proc.new { |ar| yield(ar.failed ? ar.cause : nil) }))
        return self
      end
      raise ArgumentError, "Invalid arguments when calling set(#{key},#{value})"
    end

### - (`self`) set_binary(key = nil, value = nil) { ... }

Set the binary string value of a key - without encoding as utf-8

Parameters:

- key (`String`) (defaults to: `nil`) —
  Key of which value to set
- value (`::Vertx::Buffer`) (defaults to: `nil`) —
  New value for the key

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    1854
    1855
    1856
    1857
    1858
    1859
    1860
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx-redis/redis_client.rb', line 1854

    def set_binary(key=nil,value=nil)
      if key.class == String && value.class.method_defined?(:j_del) && block_given?
        @j_del.java_method(:setBinary, [Java::java.lang.String.java_class,Java::IoVertxCoreBuffer::Buffer.java_class,Java::IoVertxCore::Handler.java_class]).call(key,value.j_del,(Proc.new { |ar| yield(ar.failed ? ar.cause : nil) }))
        return self
      end
      raise ArgumentError, "Invalid arguments when calling set_binary(#{key},#{value})"
    end

### - (`self`) set_binary_with_options(key = nil, value = nil, options = nil) { ... }

Set the string value of a key

Parameters:

- key (`String`) (defaults to: `nil`) —
  Key of which value to set
- value (`::Vertx::Buffer`) (defaults to: `nil`) —
  New value for the key
- options (`Hash`) (defaults to: `nil`) —
  Set options

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    1867
    1868
    1869
    1870
    1871
    1872
    1873
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx-redis/redis_client.rb', line 1867

    def set_binary_with_options(key=nil,value=nil,options=nil)
      if key.class == String && value.class.method_defined?(:j_del) && options.class == Hash && block_given?
        @j_del.java_method(:setBinaryWithOptions, [Java::java.lang.String.java_class,Java::IoVertxCoreBuffer::Buffer.java_class,Java::IoVertxRedisOp::SetOptions.java_class,Java::IoVertxCore::Handler.java_class]).call(key,value.j_del,Java::IoVertxRedisOp::SetOptions.new(::Vertx::Util::Utils.to_json_object(options)),(Proc.new { |ar| yield(ar.failed ? ar.cause : nil) }))
        return self
      end
      raise ArgumentError, "Invalid arguments when calling set_binary_with_options(#{key},#{value},#{options})"
    end

### - (`self`) set_with_options(key = nil, value = nil, options = nil) { ... }

Set the string value of a key

Parameters:

- key (`String`) (defaults to: `nil`) —
  Key of which value to set
- value (`String`) (defaults to: `nil`) —
  New value for the key
- options (`Hash`) (defaults to: `nil`) —
  Set options

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    1842
    1843
    1844
    1845
    1846
    1847
    1848
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx-redis/redis_client.rb', line 1842

    def set_with_options(key=nil,value=nil,options=nil)
      if key.class == String && value.class == String && options.class == Hash && block_given?
        @j_del.java_method(:setWithOptions, [Java::java.lang.String.java_class,Java::java.lang.String.java_class,Java::IoVertxRedisOp::SetOptions.java_class,Java::IoVertxCore::Handler.java_class]).call(key,value,Java::IoVertxRedisOp::SetOptions.new(::Vertx::Util::Utils.to_json_object(options)),(Proc.new { |ar| yield(ar.failed ? ar.cause : nil, ar.succeeded ? ar.result : nil) }))
        return self
      end
      raise ArgumentError, "Invalid arguments when calling set_with_options(#{key},#{value},#{options})"
    end

### - (`self`) setbit(key = nil, offset = nil, bit = nil) { ... }

Sets or clears the bit at offset in the string value stored at key

Parameters:

- key (`String`) (defaults to: `nil`) —
  Key string
- offset (`Fixnum`) (defaults to: `nil`) —
  Bit offset
- bit (`Fixnum`) (defaults to: `nil`) —
  New value - must be 1 or 0

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    1880
    1881
    1882
    1883
    1884
    1885
    1886
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx-redis/redis_client.rb', line 1880

    def setbit(key=nil,offset=nil,bit=nil)
      if key.class == String && offset.class == Fixnum && bit.class == Fixnum && block_given?
        @j_del.java_method(:setbit, [Java::java.lang.String.java_class,Java::long.java_class,Java::int.java_class,Java::IoVertxCore::Handler.java_class]).call(key,offset,bit,(Proc.new { |ar| yield(ar.failed ? ar.cause : nil, ar.succeeded ? ar.result : nil) }))
        return self
      end
      raise ArgumentError, "Invalid arguments when calling setbit(#{key},#{offset},#{bit})"
    end

### - (`self`) setex(key = nil, seconds = nil, value = nil) { ... }

Set the value and expiration of a key

Parameters:

- key (`String`) (defaults to: `nil`) —
  Key string
- seconds (`Fixnum`) (defaults to: `nil`) —
  Number of seconds until the key expires
- value (`String`) (defaults to: `nil`) —
  New value for key

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    1893
    1894
    1895
    1896
    1897
    1898
    1899
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx-redis/redis_client.rb', line 1893

    def setex(key=nil,seconds=nil,value=nil)
      if key.class == String && seconds.class == Fixnum && value.class == String && block_given?
        @j_del.java_method(:setex, [Java::java.lang.String.java_class,Java::long.java_class,Java::java.lang.String.java_class,Java::IoVertxCore::Handler.java_class]).call(key,seconds,value,(Proc.new { |ar| yield(ar.failed ? ar.cause : nil, ar.succeeded ? ar.result : nil) }))
        return self
      end
      raise ArgumentError, "Invalid arguments when calling setex(#{key},#{seconds},#{value})"
    end

### - (`self`) setnx(key = nil, value = nil) { ... }

Set the value of a key, only if the key does not exist

Parameters:

- key (`String`) (defaults to: `nil`) —
  Key of which value to set
- value (`String`) (defaults to: `nil`) —
  New value for the key

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    1905
    1906
    1907
    1908
    1909
    1910
    1911
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx-redis/redis_client.rb', line 1905

    def setnx(key=nil,value=nil)
      if key.class == String && value.class == String && block_given?
        @j_del.java_method(:setnx, [Java::java.lang.String.java_class,Java::java.lang.String.java_class,Java::IoVertxCore::Handler.java_class]).call(key,value,(Proc.new { |ar| yield(ar.failed ? ar.cause : nil, ar.succeeded ? ar.result : nil) }))
        return self
      end
      raise ArgumentError, "Invalid arguments when calling setnx(#{key},#{value})"
    end

### - (`self`) setrange(key = nil, offset = nil, value = nil) { ... }

Overwrite part of a string at key starting at the specified offset

Parameters:

- key (`String`) (defaults to: `nil`) —
  Key string
- offset (`Fixnum`) (defaults to: `nil`) —
  Offset - the maximum offset that you can set is 2^29 -1 (536870911), as Redis Strings are limited to 512 megabytes
- value (`String`) (defaults to: `nil`) —
  Value to overwrite with

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    1918
    1919
    1920
    1921
    1922
    1923
    1924
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx-redis/redis_client.rb', line 1918

    def setrange(key=nil,offset=nil,value=nil)
      if key.class == String && offset.class == Fixnum && value.class == String && block_given?
        @j_del.java_method(:setrange, [Java::java.lang.String.java_class,Java::int.java_class,Java::java.lang.String.java_class,Java::IoVertxCore::Handler.java_class]).call(key,offset,value,(Proc.new { |ar| yield(ar.failed ? ar.cause : nil, ar.succeeded ? ar.result : nil) }))
        return self
      end
      raise ArgumentError, "Invalid arguments when calling setrange(#{key},#{offset},#{value})"
    end

### - (`self`) sinter(keys = nil) { ... }

Intersect multiple sets

Parameters:

- keys (`Array<String>`) (defaults to: `nil`) —
  List of keys to perform intersection on

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    1929
    1930
    1931
    1932
    1933
    1934
    1935
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx-redis/redis_client.rb', line 1929

    def sinter(keys=nil)
      if keys.class == Array && block_given?
        @j_del.java_method(:sinter, [Java::JavaUtil::List.java_class,Java::IoVertxCore::Handler.java_class]).call(keys.map { |element| element },(Proc.new { |ar| yield(ar.failed ? ar.cause : nil, ar.succeeded ? ar.result != nil ? JSON.parse(ar.result.encode) : nil : nil) }))
        return self
      end
      raise ArgumentError, "Invalid arguments when calling sinter(#{keys})"
    end

### - (`self`) sinterstore(destkey = nil, keys = nil) { ... }

Intersect multiple sets and store the resulting set in a key

Parameters:

- destkey (`String`) (defaults to: `nil`) —
  Key where to store the results
- keys (`Array<String>`) (defaults to: `nil`) —
  List of keys to perform intersection on

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    1941
    1942
    1943
    1944
    1945
    1946
    1947
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx-redis/redis_client.rb', line 1941

    def sinterstore(destkey=nil,keys=nil)
      if destkey.class == String && keys.class == Array && block_given?
        @j_del.java_method(:sinterstore, [Java::java.lang.String.java_class,Java::JavaUtil::List.java_class,Java::IoVertxCore::Handler.java_class]).call(destkey,keys.map { |element| element },(Proc.new { |ar| yield(ar.failed ? ar.cause : nil, ar.succeeded ? ar.result : nil) }))
        return self
      end
      raise ArgumentError, "Invalid arguments when calling sinterstore(#{destkey},#{keys})"
    end

### - (`self`) sismember(key = nil, member = nil) { ... }

Determine if a given value is a member of a set

Parameters:

- key (`String`) (defaults to: `nil`) —
  Key string
- member (`String`) (defaults to: `nil`) —
  Member to look for

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    1953
    1954
    1955
    1956
    1957
    1958
    1959
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx-redis/redis_client.rb', line 1953

    def sismember(key=nil,member=nil)
      if key.class == String && member.class == String && block_given?
        @j_del.java_method(:sismember, [Java::java.lang.String.java_class,Java::java.lang.String.java_class,Java::IoVertxCore::Handler.java_class]).call(key,member,(Proc.new { |ar| yield(ar.failed ? ar.cause : nil, ar.succeeded ? ar.result : nil) }))
        return self
      end
      raise ArgumentError, "Invalid arguments when calling sismember(#{key},#{member})"
    end

### - (`self`) slaveof(host = nil, port = nil) { ... }

Make the server a slave of another instance

Parameters:

- host (`String`) (defaults to: `nil`) —
  Host to become this server's master
- port (`Fixnum`) (defaults to: `nil`) —
  Port of our new master

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    1965
    1966
    1967
    1968
    1969
    1970
    1971
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx-redis/redis_client.rb', line 1965

    def slaveof(host=nil,port=nil)
      if host.class == String && port.class == Fixnum && block_given?
        @j_del.java_method(:slaveof, [Java::java.lang.String.java_class,Java::int.java_class,Java::IoVertxCore::Handler.java_class]).call(host,port,(Proc.new { |ar| yield(ar.failed ? ar.cause : nil, ar.succeeded ? ar.result : nil) }))
        return self
      end
      raise ArgumentError, "Invalid arguments when calling slaveof(#{host},#{port})"
    end

### - (`self`) slaveof_noone { ... }

Make this server a master

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    1975
    1976
    1977
    1978
    1979
    1980
    1981
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx-redis/redis_client.rb', line 1975

    def slaveof_noone
      if block_given?
        @j_del.java_method(:slaveofNoone, [Java::IoVertxCore::Handler.java_class]).call((Proc.new { |ar| yield(ar.failed ? ar.cause : nil, ar.succeeded ? ar.result : nil) }))
        return self
      end
      raise ArgumentError, "Invalid arguments when calling slaveof_noone()"
    end

### - (`self`) slowlog_get(limit = nil) { ... }

Read the Redis slow queries log

Parameters:

- limit (`Fixnum`) (defaults to: `nil`) —
  Number of log entries to return. If value is less than zero all entries are returned

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    1986
    1987
    1988
    1989
    1990
    1991
    1992
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx-redis/redis_client.rb', line 1986

    def slowlog_get(limit=nil)
      if limit.class == Fixnum && block_given?
        @j_del.java_method(:slowlogGet, [Java::int.java_class,Java::IoVertxCore::Handler.java_class]).call(limit,(Proc.new { |ar| yield(ar.failed ? ar.cause : nil, ar.succeeded ? ar.result != nil ? JSON.parse(ar.result.encode) : nil : nil) }))
        return self
      end
      raise ArgumentError, "Invalid arguments when calling slowlog_get(#{limit})"
    end

### - (`self`) slowlog_len { ... }

Get the length of the Redis slow queries log

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    1996
    1997
    1998
    1999
    2000
    2001
    2002
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx-redis/redis_client.rb', line 1996

    def slowlog_len
      if block_given?
        @j_del.java_method(:slowlogLen, [Java::IoVertxCore::Handler.java_class]).call((Proc.new { |ar| yield(ar.failed ? ar.cause : nil, ar.succeeded ? ar.result : nil) }))
        return self
      end
      raise ArgumentError, "Invalid arguments when calling slowlog_len()"
    end

### - (`self`) slowlog_reset { ... }

Reset the Redis slow queries log

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    2006
    2007
    2008
    2009
    2010
    2011
    2012
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx-redis/redis_client.rb', line 2006

    def slowlog_reset
      if block_given?
        @j_del.java_method(:slowlogReset, [Java::IoVertxCore::Handler.java_class]).call((Proc.new { |ar| yield(ar.failed ? ar.cause : nil) }))
        return self
      end
      raise ArgumentError, "Invalid arguments when calling slowlog_reset()"
    end

### - (`self`) smembers(key = nil) { ... }

Get all the members in a set

Parameters:

- key (`String`) (defaults to: `nil`) —
  Key string

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    2017
    2018
    2019
    2020
    2021
    2022
    2023
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx-redis/redis_client.rb', line 2017

    def smembers(key=nil)
      if key.class == String && block_given?
        @j_del.java_method(:smembers, [Java::java.lang.String.java_class,Java::IoVertxCore::Handler.java_class]).call(key,(Proc.new { |ar| yield(ar.failed ? ar.cause : nil, ar.succeeded ? ar.result != nil ? JSON.parse(ar.result.encode) : nil : nil) }))
        return self
      end
      raise ArgumentError, "Invalid arguments when calling smembers(#{key})"
    end

### - (`self`) smove(key = nil, destkey = nil, member = nil) { ... }

Move a member from one set to another

Parameters:

- key (`String`) (defaults to: `nil`) —
  Key of source set currently containing the member
- destkey (`String`) (defaults to: `nil`) —
  Key identifying the destination set
- member (`String`) (defaults to: `nil`) —
  Member to move

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    2030
    2031
    2032
    2033
    2034
    2035
    2036
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx-redis/redis_client.rb', line 2030

    def smove(key=nil,destkey=nil,member=nil)
      if key.class == String && destkey.class == String && member.class == String && block_given?
        @j_del.java_method(:smove, [Java::java.lang.String.java_class,Java::java.lang.String.java_class,Java::java.lang.String.java_class,Java::IoVertxCore::Handler.java_class]).call(key,destkey,member,(Proc.new { |ar| yield(ar.failed ? ar.cause : nil, ar.succeeded ? ar.result : nil) }))
        return self
      end
      raise ArgumentError, "Invalid arguments when calling smove(#{key},#{destkey},#{member})"
    end

### - (`self`) sort(key = nil, options = nil) { ... }

Sort the elements in a list, set or sorted set

Parameters:

- key (`String`) (defaults to: `nil`) —
  Key string
- options (`Hash`) (defaults to: `nil`) —
  Sort options

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    2042
    2043
    2044
    2045
    2046
    2047
    2048
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx-redis/redis_client.rb', line 2042

    def sort(key=nil,options=nil)
      if key.class == String && options.class == Hash && block_given?
        @j_del.java_method(:sort, [Java::java.lang.String.java_class,Java::IoVertxRedisOp::SortOptions.java_class,Java::IoVertxCore::Handler.java_class]).call(key,Java::IoVertxRedisOp::SortOptions.new(::Vertx::Util::Utils.to_json_object(options)),(Proc.new { |ar| yield(ar.failed ? ar.cause : nil, ar.succeeded ? ar.result != nil ? JSON.parse(ar.result.encode) : nil : nil) }))
        return self
      end
      raise ArgumentError, "Invalid arguments when calling sort(#{key},#{options})"
    end

### - (`self`) spop(key = nil) { ... }

Remove and return a random member from a set

Parameters:

- key (`String`) (defaults to: `nil`) —
  Key string

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    2053
    2054
    2055
    2056
    2057
    2058
    2059
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx-redis/redis_client.rb', line 2053

    def spop(key=nil)
      if key.class == String && block_given?
        @j_del.java_method(:spop, [Java::java.lang.String.java_class,Java::IoVertxCore::Handler.java_class]).call(key,(Proc.new { |ar| yield(ar.failed ? ar.cause : nil, ar.succeeded ? ar.result : nil) }))
        return self
      end
      raise ArgumentError, "Invalid arguments when calling spop(#{key})"
    end

### - (`self`) spop_many(key = nil, count = nil) { ... }

Remove and return random members from a set

Parameters:

- key (`String`) (defaults to: `nil`) —
  Key string
- count (`Fixnum`) (defaults to: `nil`) —
  Number of members to remove

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    2065
    2066
    2067
    2068
    2069
    2070
    2071
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx-redis/redis_client.rb', line 2065

    def spop_many(key=nil,count=nil)
      if key.class == String && count.class == Fixnum && block_given?
        @j_del.java_method(:spopMany, [Java::java.lang.String.java_class,Java::int.java_class,Java::IoVertxCore::Handler.java_class]).call(key,count,(Proc.new { |ar| yield(ar.failed ? ar.cause : nil, ar.succeeded ? ar.result != nil ? JSON.parse(ar.result.encode) : nil : nil) }))
        return self
      end
      raise ArgumentError, "Invalid arguments when calling spop_many(#{key},#{count})"
    end

### - (`self`) srandmember(key = nil) { ... }

Get one or multiple random members from a set

Parameters:

- key (`String`) (defaults to: `nil`) —
  Key string

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    2076
    2077
    2078
    2079
    2080
    2081
    2082
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx-redis/redis_client.rb', line 2076

    def srandmember(key=nil)
      if key.class == String && block_given?
        @j_del.java_method(:srandmember, [Java::java.lang.String.java_class,Java::IoVertxCore::Handler.java_class]).call(key,(Proc.new { |ar| yield(ar.failed ? ar.cause : nil, ar.succeeded ? ar.result : nil) }))
        return self
      end
      raise ArgumentError, "Invalid arguments when calling srandmember(#{key})"
    end

### - (`self`) srandmember_count(key = nil, count = nil) { ... }

Get one or multiple random members from a set

Parameters:

- key (`String`) (defaults to: `nil`) —
  Key string
- count (`Fixnum`) (defaults to: `nil`) —
  Number of members to get

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    2088
    2089
    2090
    2091
    2092
    2093
    2094
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx-redis/redis_client.rb', line 2088

    def srandmember_count(key=nil,count=nil)
      if key.class == String && count.class == Fixnum && block_given?
        @j_del.java_method(:srandmemberCount, [Java::java.lang.String.java_class,Java::int.java_class,Java::IoVertxCore::Handler.java_class]).call(key,count,(Proc.new { |ar| yield(ar.failed ? ar.cause : nil, ar.succeeded ? ar.result != nil ? JSON.parse(ar.result.encode) : nil : nil) }))
        return self
      end
      raise ArgumentError, "Invalid arguments when calling srandmember_count(#{key},#{count})"
    end

### - (`self`) srem(key = nil, member = nil) { ... }

Remove one member from a set

Parameters:

- key (`String`) (defaults to: `nil`) —
  Key string
- member (`String`) (defaults to: `nil`) —
  Member to remove

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    2100
    2101
    2102
    2103
    2104
    2105
    2106
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx-redis/redis_client.rb', line 2100

    def srem(key=nil,member=nil)
      if key.class == String && member.class == String && block_given?
        @j_del.java_method(:srem, [Java::java.lang.String.java_class,Java::java.lang.String.java_class,Java::IoVertxCore::Handler.java_class]).call(key,member,(Proc.new { |ar| yield(ar.failed ? ar.cause : nil, ar.succeeded ? ar.result : nil) }))
        return self
      end
      raise ArgumentError, "Invalid arguments when calling srem(#{key},#{member})"
    end

### - (`self`) srem_many(key = nil, members = nil) { ... }

Remove one or more members from a set

Parameters:

- key (`String`) (defaults to: `nil`) —
  Key string
- members (`Array<String>`) (defaults to: `nil`) —
  Members to remove

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    2112
    2113
    2114
    2115
    2116
    2117
    2118
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx-redis/redis_client.rb', line 2112

    def srem_many(key=nil,members=nil)
      if key.class == String && members.class == Array && block_given?
        @j_del.java_method(:sremMany, [Java::java.lang.String.java_class,Java::JavaUtil::List.java_class,Java::IoVertxCore::Handler.java_class]).call(key,members.map { |element| element },(Proc.new { |ar| yield(ar.failed ? ar.cause : nil, ar.succeeded ? ar.result : nil) }))
        return self
      end
      raise ArgumentError, "Invalid arguments when calling srem_many(#{key},#{members})"
    end

### - (`self`) sscan(key = nil, cursor = nil, options = nil) { ... }

Incrementally iterate Set elements

Parameters:

- key (`String`) (defaults to: `nil`) —
  Key string
- cursor (`String`) (defaults to: `nil`) —
  Cursor id
- options (`Hash`) (defaults to: `nil`) —
  Scan options

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    2589
    2590
    2591
    2592
    2593
    2594
    2595
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx-redis/redis_client.rb', line 2589

    def sscan(key=nil,cursor=nil,options=nil)
      if key.class == String && cursor.class == String && options.class == Hash && block_given?
        @j_del.java_method(:sscan, [Java::java.lang.String.java_class,Java::java.lang.String.java_class,Java::IoVertxRedisOp::ScanOptions.java_class,Java::IoVertxCore::Handler.java_class]).call(key,cursor,Java::IoVertxRedisOp::ScanOptions.new(::Vertx::Util::Utils.to_json_object(options)),(Proc.new { |ar| yield(ar.failed ? ar.cause : nil, ar.succeeded ? ar.result != nil ? JSON.parse(ar.result.encode) : nil : nil) }))
        return self
      end
      raise ArgumentError, "Invalid arguments when calling sscan(#{key},#{cursor},#{options})"
    end

### - (`self`) strlen(key = nil) { ... }

Get the length of the value stored in a key

Parameters:

- key (`String`) (defaults to: `nil`) —
  Key string

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    2123
    2124
    2125
    2126
    2127
    2128
    2129
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx-redis/redis_client.rb', line 2123

    def strlen(key=nil)
      if key.class == String && block_given?
        @j_del.java_method(:strlen, [Java::java.lang.String.java_class,Java::IoVertxCore::Handler.java_class]).call(key,(Proc.new { |ar| yield(ar.failed ? ar.cause : nil, ar.succeeded ? ar.result : nil) }))
        return self
      end
      raise ArgumentError, "Invalid arguments when calling strlen(#{key})"
    end

### - (`self`) subscribe(channel = nil) { ... }

Listen for messages published to the given channels

Parameters:

- channel (`String`) (defaults to: `nil`) —
  Channel to subscribe to

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    2134
    2135
    2136
    2137
    2138
    2139
    2140
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx-redis/redis_client.rb', line 2134

    def subscribe(channel=nil)
      if channel.class == String && block_given?
        @j_del.java_method(:subscribe, [Java::java.lang.String.java_class,Java::IoVertxCore::Handler.java_class]).call(channel,(Proc.new { |ar| yield(ar.failed ? ar.cause : nil, ar.succeeded ? ar.result != nil ? JSON.parse(ar.result.encode) : nil : nil) }))
        return self
      end
      raise ArgumentError, "Invalid arguments when calling subscribe(#{channel})"
    end

### - (`self`) subscribe_many(channels = nil) { ... }

Listen for messages published to the given channels

Parameters:

- channels (`Array<String>`) (defaults to: `nil`) —
  List of channels to subscribe to

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    2145
    2146
    2147
    2148
    2149
    2150
    2151
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx-redis/redis_client.rb', line 2145

    def subscribe_many(channels=nil)
      if channels.class == Array && block_given?
        @j_del.java_method(:subscribeMany, [Java::JavaUtil::List.java_class,Java::IoVertxCore::Handler.java_class]).call(channels.map { |element| element },(Proc.new { |ar| yield(ar.failed ? ar.cause : nil, ar.succeeded ? ar.result != nil ? JSON.parse(ar.result.encode) : nil : nil) }))
        return self
      end
      raise ArgumentError, "Invalid arguments when calling subscribe_many(#{channels})"
    end

### - (`self`) sunion(keys = nil) { ... }

Add multiple sets

Parameters:

- keys (`Array<String>`) (defaults to: `nil`) —
  List of keys identifying sets to add up

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    2156
    2157
    2158
    2159
    2160
    2161
    2162
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx-redis/redis_client.rb', line 2156

    def sunion(keys=nil)
      if keys.class == Array && block_given?
        @j_del.java_method(:sunion, [Java::JavaUtil::List.java_class,Java::IoVertxCore::Handler.java_class]).call(keys.map { |element| element },(Proc.new { |ar| yield(ar.failed ? ar.cause : nil, ar.succeeded ? ar.result != nil ? JSON.parse(ar.result.encode) : nil : nil) }))
        return self
      end
      raise ArgumentError, "Invalid arguments when calling sunion(#{keys})"
    end

### - (`self`) sunionstore(destkey = nil, keys = nil) { ... }

Add multiple sets and store the resulting set in a key

Parameters:

- destkey (`String`) (defaults to: `nil`) —
  Destination key
- keys (`Array<String>`) (defaults to: `nil`) —
  List of keys identifying sets to add up

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    2168
    2169
    2170
    2171
    2172
    2173
    2174
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx-redis/redis_client.rb', line 2168

    def sunionstore(destkey=nil,keys=nil)
      if destkey.class == String && keys.class == Array && block_given?
        @j_del.java_method(:sunionstore, [Java::java.lang.String.java_class,Java::JavaUtil::List.java_class,Java::IoVertxCore::Handler.java_class]).call(destkey,keys.map { |element| element },(Proc.new { |ar| yield(ar.failed ? ar.cause : nil, ar.succeeded ? ar.result : nil) }))
        return self
      end
      raise ArgumentError, "Invalid arguments when calling sunionstore(#{destkey},#{keys})"
    end

### - (`self`) swapdb(index1 = nil, index2 = nil) { ... }

Swaps two Redis databases

Parameters:

- index1 (`Fixnum`) (defaults to: `nil`) —
  index of first database to swap
- index2 (`Fixnum`) (defaults to: `nil`) —
  index of second database to swap

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    2901
    2902
    2903
    2904
    2905
    2906
    2907
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx-redis/redis_client.rb', line 2901

    def swapdb(index1=nil,index2=nil)
      if index1.class == Fixnum && index2.class == Fixnum && block_given?
        @j_del.java_method(:swapdb, [Java::int.java_class,Java::int.java_class,Java::IoVertxCore::Handler.java_class]).call(index1,index2,(Proc.new { |ar| yield(ar.failed ? ar.cause : nil, ar.succeeded ? ar.result : nil) }))
        return self
      end
      raise ArgumentError, "Invalid arguments when calling swapdb(#{index1},#{index2})"
    end

### - (`self`) sync { ... }

Internal command used for replication

Yields:

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    2178
    2179
    2180
    2181
    2182
    2183
    2184
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx-redis/redis_client.rb', line 2178

    def sync
      if block_given?
        @j_del.java_method(:sync, [Java::IoVertxCore::Handler.java_class]).call((Proc.new { |ar| yield(ar.failed ? ar.cause : nil) }))
        return self
      end
      raise ArgumentError, "Invalid arguments when calling sync()"
    end

### - (`self`) time { ... }

Return the current server time

Yields:

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    2188
    2189
    2190
    2191
    2192
    2193
    2194
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx-redis/redis_client.rb', line 2188

    def time
      if block_given?
        @j_del.java_method(:time, [Java::IoVertxCore::Handler.java_class]).call((Proc.new { |ar| yield(ar.failed ? ar.cause : nil, ar.succeeded ? ar.result != nil ? JSON.parse(ar.result.encode) : nil : nil) }))
        return self
      end
      raise ArgumentError, "Invalid arguments when calling time()"
    end

### - (`self`) touch(key = nil) { ... }

Alters the last access time of a key(s). Returns the number of existing keys specified.

Parameters:

- key (`String`) (defaults to: `nil`) —
  Key String

Yields:

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    2820
    2821
    2822
    2823
    2824
    2825
    2826
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx-redis/redis_client.rb', line 2820

    def touch(key=nil)
      if key.class == String && block_given?
        @j_del.java_method(:touch, [Java::java.lang.String.java_class,Java::IoVertxCore::Handler.java_class]).call(key,(Proc.new { |ar| yield(ar.failed ? ar.cause : nil, ar.succeeded ? ar.result : nil) }))
        return self
      end
      raise ArgumentError, "Invalid arguments when calling touch(#{key})"
    end

### - (`self`) touch_many(keys = nil) { ... }

Alters the last access time of a key(s). Returns the number of existing keys specified.

Parameters:

- keys (`Array<String>`) (defaults to: `nil`) —
  list of keys

Yields:

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    2831
    2832
    2833
    2834
    2835
    2836
    2837
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx-redis/redis_client.rb', line 2831

    def touch_many(keys=nil)
      if keys.class == Array && block_given?
        @j_del.java_method(:touchMany, [Java::JavaUtil::List.java_class,Java::IoVertxCore::Handler.java_class]).call(keys.map { |element| element },(Proc.new { |ar| yield(ar.failed ? ar.cause : nil, ar.succeeded ? ar.result : nil) }))
        return self
      end
      raise ArgumentError, "Invalid arguments when calling touch_many(#{keys})"
    end

### - (`::VertxRedis::RedisTransaction`) transaction

Return a RedisTransaction instance

Returns:

- (`::VertxRedis::RedisTransaction`) —
  transaction instance

Raises:

- (`ArgumentError`)

    2197
    2198
    2199
    2200
    2201
    2202
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx-redis/redis_client.rb', line 2197

    def transaction
      if !block_given?
        return ::Vertx::Util::Utils.safe_create(@j_del.java_method(:transaction, []).call(),::VertxRedis::RedisTransaction)
      end
      raise ArgumentError, "Invalid arguments when calling transaction()"
    end

### - (`self`) ttl(key = nil) { ... }

Get the time to live for a key

Parameters:

- key (`String`) (defaults to: `nil`) —
  Key string

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    2207
    2208
    2209
    2210
    2211
    2212
    2213
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx-redis/redis_client.rb', line 2207

    def ttl(key=nil)
      if key.class == String && block_given?
        @j_del.java_method(:ttl, [Java::java.lang.String.java_class,Java::IoVertxCore::Handler.java_class]).call(key,(Proc.new { |ar| yield(ar.failed ? ar.cause : nil, ar.succeeded ? ar.result : nil) }))
        return self
      end
      raise ArgumentError, "Invalid arguments when calling ttl(#{key})"
    end

### - (`self`) type(key = nil) { ... }

Determine the type stored at key

Parameters:

- key (`String`) (defaults to: `nil`) —
  Key string

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    2218
    2219
    2220
    2221
    2222
    2223
    2224
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx-redis/redis_client.rb', line 2218

    def type(key=nil)
      if key.class == String && block_given?
        @j_del.java_method(:type, [Java::java.lang.String.java_class,Java::IoVertxCore::Handler.java_class]).call(key,(Proc.new { |ar| yield(ar.failed ? ar.cause : nil, ar.succeeded ? ar.result : nil) }))
        return self
      end
      raise ArgumentError, "Invalid arguments when calling type(#{key})"
    end

### - (`self`) unlink(key = nil) { ... }

Delete a key asynchronously in another thread. Otherwise it is just as DEL, but non blocking.

Parameters:

- key (`String`) (defaults to: `nil`) —
  Key to delete

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    2878
    2879
    2880
    2881
    2882
    2883
    2884
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx-redis/redis_client.rb', line 2878

    def unlink(key=nil)
      if key.class == String && block_given?
        @j_del.java_method(:unlink, [Java::java.lang.String.java_class,Java::IoVertxCore::Handler.java_class]).call(key,(Proc.new { |ar| yield(ar.failed ? ar.cause : nil, ar.succeeded ? ar.result : nil) }))
        return self
      end
      raise ArgumentError, "Invalid arguments when calling unlink(#{key})"
    end

### - (`self`) unlink_many(keys = nil) { ... }

Delete multiple keys asynchronously in another thread. Otherwise it is just as DEL, but non blocking.

Parameters:

- keys (`Array<String>`) (defaults to: `nil`) —
  List of keys to delete

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    2889
    2890
    2891
    2892
    2893
    2894
    2895
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx-redis/redis_client.rb', line 2889

    def unlink_many(keys=nil)
      if keys.class == Array && block_given?
        @j_del.java_method(:unlinkMany, [Java::JavaUtil::List.java_class,Java::IoVertxCore::Handler.java_class]).call(keys.map { |element| element },(Proc.new { |ar| yield(ar.failed ? ar.cause : nil, ar.succeeded ? ar.result : nil) }))
        return self
      end
      raise ArgumentError, "Invalid arguments when calling unlink_many(#{keys})"
    end

### - (`self`) unsubscribe(channels = nil) { ... }

Stop listening for messages posted to the given channels

Parameters:

- channels (`Array<String>`) (defaults to: `nil`) —
  List of channels to subscribe to

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    2229
    2230
    2231
    2232
    2233
    2234
    2235
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx-redis/redis_client.rb', line 2229

    def unsubscribe(channels=nil)
      if channels.class == Array && block_given?
        @j_del.java_method(:unsubscribe, [Java::JavaUtil::List.java_class,Java::IoVertxCore::Handler.java_class]).call(channels.map { |element| element },(Proc.new { |ar| yield(ar.failed ? ar.cause : nil) }))
        return self
      end
      raise ArgumentError, "Invalid arguments when calling unsubscribe(#{channels})"
    end

### - (`self`) wait(numSlaves = nil, timeout = nil) { ... }

Wait for the synchronous replication of all the write commands sent in the context of the current connection.

Parameters:

- numSlaves (`Fixnum`) (defaults to: `nil`)
- timeout (`Fixnum`) (defaults to: `nil`)

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    2241
    2242
    2243
    2244
    2245
    2246
    2247
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx-redis/redis_client.rb', line 2241

    def wait(numSlaves=nil,timeout=nil)
      if numSlaves.class == Fixnum && timeout.class == Fixnum && block_given?
        @j_del.java_method(:wait, [Java::long.java_class,Java::long.java_class,Java::IoVertxCore::Handler.java_class]).call(numSlaves,timeout,(Proc.new { |ar| yield(ar.failed ? ar.cause : nil, ar.succeeded ? ar.result : nil) }))
        return self
      end
      raise ArgumentError, "Invalid arguments when calling wait(#{numSlaves},#{timeout})"
    end

### - (`self`) zadd(key = nil, score = nil, member = nil) { ... }

Add one or more members to a sorted set, or update its score if it already exists

Parameters:

- key (`String`) (defaults to: `nil`) —
  Key string
- score (`Float`) (defaults to: `nil`) —
  Score used for sorting
- member (`String`) (defaults to: `nil`) —
  New member key

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    2254
    2255
    2256
    2257
    2258
    2259
    2260
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx-redis/redis_client.rb', line 2254

    def zadd(key=nil,score=nil,member=nil)
      if key.class == String && score.class == Float && member.class == String && block_given?
        @j_del.java_method(:zadd, [Java::java.lang.String.java_class,Java::double.java_class,Java::java.lang.String.java_class,Java::IoVertxCore::Handler.java_class]).call(key,::Vertx::Util::Utils.to_double(score),member,(Proc.new { |ar| yield(ar.failed ? ar.cause : nil, ar.succeeded ? ar.result : nil) }))
        return self
      end
      raise ArgumentError, "Invalid arguments when calling zadd(#{key},#{score},#{member})"
    end

### - (`self`) zadd_many(key = nil, members = nil) { ... }

Add one or more members to a sorted set, or update its score if it already exists

Parameters:

- key (`String`) (defaults to: `nil`) —
  Key string
- members (`Hash{String => Float}`) (defaults to: `nil`) —
  New member keys and their scores

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    2266
    2267
    2268
    2269
    2270
    2271
    2272
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx-redis/redis_client.rb', line 2266

    def zadd_many(key=nil,members=nil)
      if key.class == String && members.class == Hash && block_given?
        @j_del.java_method(:zaddMany, [Java::java.lang.String.java_class,Java::JavaUtil::Map.java_class,Java::IoVertxCore::Handler.java_class]).call(key,Hash[members.map { |k,v| [k,::Vertx::Util::Utils.to_double(v)] }],(Proc.new { |ar| yield(ar.failed ? ar.cause : nil, ar.succeeded ? ar.result : nil) }))
        return self
      end
      raise ArgumentError, "Invalid arguments when calling zadd_many(#{key},#{members})"
    end

### - (`self`) zcard(key = nil) { ... }

Get the number of members in a sorted set

Parameters:

- key (`String`) (defaults to: `nil`) —
  Key string

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    2277
    2278
    2279
    2280
    2281
    2282
    2283
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx-redis/redis_client.rb', line 2277

    def zcard(key=nil)
      if key.class == String && block_given?
        @j_del.java_method(:zcard, [Java::java.lang.String.java_class,Java::IoVertxCore::Handler.java_class]).call(key,(Proc.new { |ar| yield(ar.failed ? ar.cause : nil, ar.succeeded ? ar.result : nil) }))
        return self
      end
      raise ArgumentError, "Invalid arguments when calling zcard(#{key})"
    end

### - (`self`) zcount(key = nil, min = nil, max = nil) { ... }

Count the members in a sorted set with scores within the given values

Parameters:

- key (`String`) (defaults to: `nil`) —
  Key string
- min (`Float`) (defaults to: `nil`) —
  Minimum score
- max (`Float`) (defaults to: `nil`) —
  Maximum score

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    2290
    2291
    2292
    2293
    2294
    2295
    2296
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx-redis/redis_client.rb', line 2290

    def zcount(key=nil,min=nil,max=nil)
      if key.class == String && min.class == Float && max.class == Float && block_given?
        @j_del.java_method(:zcount, [Java::java.lang.String.java_class,Java::double.java_class,Java::double.java_class,Java::IoVertxCore::Handler.java_class]).call(key,::Vertx::Util::Utils.to_double(min),::Vertx::Util::Utils.to_double(max),(Proc.new { |ar| yield(ar.failed ? ar.cause : nil, ar.succeeded ? ar.result : nil) }))
        return self
      end
      raise ArgumentError, "Invalid arguments when calling zcount(#{key},#{min},#{max})"
    end

### - (`self`) zincrby(key = nil, increment = nil, member = nil) { ... }

Increment the score of a member in a sorted set

Parameters:

- key (`String`) (defaults to: `nil`) —
  Key string
- increment (`Float`) (defaults to: `nil`) —
  Increment amount
- member (`String`) (defaults to: `nil`) —
  Member key

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    2303
    2304
    2305
    2306
    2307
    2308
    2309
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx-redis/redis_client.rb', line 2303

    def zincrby(key=nil,increment=nil,member=nil)
      if key.class == String && increment.class == Float && member.class == String && block_given?
        @j_del.java_method(:zincrby, [Java::java.lang.String.java_class,Java::double.java_class,Java::java.lang.String.java_class,Java::IoVertxCore::Handler.java_class]).call(key,::Vertx::Util::Utils.to_double(increment),member,(Proc.new { |ar| yield(ar.failed ? ar.cause : nil, ar.succeeded ? ar.result : nil) }))
        return self
      end
      raise ArgumentError, "Invalid arguments when calling zincrby(#{key},#{increment},#{member})"
    end

### - (`self`) zinterstore(destkey = nil, sets = nil, options = nil) { ... }

Intersect multiple sorted sets and store the resulting sorted set in a new key

Parameters:

- destkey (`String`) (defaults to: `nil`) —
  Destination key
- sets (`Array<String>`) (defaults to: `nil`) —
  List of keys identifying sorted sets to intersect
- options (`:NONE`, `:SUM`, `:MIN`, `:MAX`) (defaults to: `nil`) —
  Aggregation options

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    2316
    2317
    2318
    2319
    2320
    2321
    2322
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx-redis/redis_client.rb', line 2316

    def zinterstore(destkey=nil,sets=nil,options=nil)
      if destkey.class == String && sets.class == Array && options.class == Symbol && block_given?
        @j_del.java_method(:zinterstore, [Java::java.lang.String.java_class,Java::JavaUtil::List.java_class,Java::IoVertxRedisOp::AggregateOptions.java_class,Java::IoVertxCore::Handler.java_class]).call(destkey,sets.map { |element| element },Java::IoVertxRedisOp::AggregateOptions.valueOf(options.to_s),(Proc.new { |ar| yield(ar.failed ? ar.cause : nil, ar.succeeded ? ar.result : nil) }))
        return self
      end
      raise ArgumentError, "Invalid arguments when calling zinterstore(#{destkey},#{sets},#{options})"
    end

### - (`self`) zinterstore_weighed(destkey = nil, sets = nil, options = nil) { ... }

Intersect multiple sorted sets and store the resulting sorted set in a new key using weights for scoring

Parameters:

- destkey (`String`) (defaults to: `nil`) —
  Destination key
- sets (`Hash{String => Float}`) (defaults to: `nil`) —
  List of keys identifying sorted sets to intersect
- options (`:NONE`, `:SUM`, `:MIN`, `:MAX`) (defaults to: `nil`) —
  Aggregation options

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    2329
    2330
    2331
    2332
    2333
    2334
    2335
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx-redis/redis_client.rb', line 2329

    def zinterstore_weighed(destkey=nil,sets=nil,options=nil)
      if destkey.class == String && sets.class == Hash && options.class == Symbol && block_given?
        @j_del.java_method(:zinterstoreWeighed, [Java::java.lang.String.java_class,Java::JavaUtil::Map.java_class,Java::IoVertxRedisOp::AggregateOptions.java_class,Java::IoVertxCore::Handler.java_class]).call(destkey,Hash[sets.map { |k,v| [k,::Vertx::Util::Utils.to_double(v)] }],Java::IoVertxRedisOp::AggregateOptions.valueOf(options.to_s),(Proc.new { |ar| yield(ar.failed ? ar.cause : nil, ar.succeeded ? ar.result : nil) }))
        return self
      end
      raise ArgumentError, "Invalid arguments when calling zinterstore_weighed(#{destkey},#{sets},#{options})"
    end

### - (`self`) zlexcount(key = nil, min = nil, max = nil) { ... }

Count the number of members in a sorted set between a given lexicographical range

Parameters:

- key (`String`) (defaults to: `nil`) —
  Key string
- min (`String`) (defaults to: `nil`) —
  Pattern to compare against for minimum value
- max (`String`) (defaults to: `nil`) —
  Pattern to compare against for maximum value

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    2342
    2343
    2344
    2345
    2346
    2347
    2348
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx-redis/redis_client.rb', line 2342

    def zlexcount(key=nil,min=nil,max=nil)
      if key.class == String && min.class == String && max.class == String && block_given?
        @j_del.java_method(:zlexcount, [Java::java.lang.String.java_class,Java::java.lang.String.java_class,Java::java.lang.String.java_class,Java::IoVertxCore::Handler.java_class]).call(key,min,max,(Proc.new { |ar| yield(ar.failed ? ar.cause : nil, ar.succeeded ? ar.result : nil) }))
        return self
      end
      raise ArgumentError, "Invalid arguments when calling zlexcount(#{key},#{min},#{max})"
    end

### - (`self`) zrange(key = nil, start = nil, stop = nil) { ... }

Return a range of members in a sorted set, by index

Parameters:

- key (`String`) (defaults to: `nil`) —
  Key string
- start (`Fixnum`) (defaults to: `nil`) —
  Start index for the range
- stop (`Fixnum`) (defaults to: `nil`) —
  Stop index for the range - inclusive

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    2355
    2356
    2357
    2358
    2359
    2360
    2361
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx-redis/redis_client.rb', line 2355

    def zrange(key=nil,start=nil,stop=nil)
      if key.class == String && start.class == Fixnum && stop.class == Fixnum && block_given?
        @j_del.java_method(:zrange, [Java::java.lang.String.java_class,Java::long.java_class,Java::long.java_class,Java::IoVertxCore::Handler.java_class]).call(key,start,stop,(Proc.new { |ar| yield(ar.failed ? ar.cause : nil, ar.succeeded ? ar.result != nil ? JSON.parse(ar.result.encode) : nil : nil) }))
        return self
      end
      raise ArgumentError, "Invalid arguments when calling zrange(#{key},#{start},#{stop})"
    end

### - (`self`) zrange_with_options(key = nil, start = nil, stop = nil, options = nil) { ... }

Return a range of members in a sorted set, by index

Parameters:

- key (`String`) (defaults to: `nil`) —
  Key string
- start (`Fixnum`) (defaults to: `nil`) —
  Start index for the range
- stop (`Fixnum`) (defaults to: `nil`) —
  Stop index for the range - inclusive
- options (`:NONE`, `:WITHSCORES`) (defaults to: `nil`) —
  Range options

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    2369
    2370
    2371
    2372
    2373
    2374
    2375
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx-redis/redis_client.rb', line 2369

    def zrange_with_options(key=nil,start=nil,stop=nil,options=nil)
      if key.class == String && start.class == Fixnum && stop.class == Fixnum && options.class == Symbol && block_given?
        @j_del.java_method(:zrangeWithOptions, [Java::java.lang.String.java_class,Java::long.java_class,Java::long.java_class,Java::IoVertxRedisOp::RangeOptions.java_class,Java::IoVertxCore::Handler.java_class]).call(key,start,stop,Java::IoVertxRedisOp::RangeOptions.valueOf(options.to_s),(Proc.new { |ar| yield(ar.failed ? ar.cause : nil, ar.succeeded ? ar.result != nil ? JSON.parse(ar.result.encode) : nil : nil) }))
        return self
      end
      raise ArgumentError, "Invalid arguments when calling zrange_with_options(#{key},#{start},#{stop},#{options})"
    end

### - (`self`) zrangebylex(key = nil, min = nil, max = nil, options = nil) { ... }

Return a range of members in a sorted set, by lexicographical range

Parameters:

- key (`String`) (defaults to: `nil`) —
  Key string
- min (`String`) (defaults to: `nil`) —
  Pattern representing a minimum allowed value
- max (`String`) (defaults to: `nil`) —
  Pattern representing a maximum allowed value
- options (`Hash`) (defaults to: `nil`) —
  Limit options where limit can be specified

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    2383
    2384
    2385
    2386
    2387
    2388
    2389
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx-redis/redis_client.rb', line 2383

    def zrangebylex(key=nil,min=nil,max=nil,options=nil)
      if key.class == String && min.class == String && max.class == String && options.class == Hash && block_given?
        @j_del.java_method(:zrangebylex, [Java::java.lang.String.java_class,Java::java.lang.String.java_class,Java::java.lang.String.java_class,Java::IoVertxRedisOp::LimitOptions.java_class,Java::IoVertxCore::Handler.java_class]).call(key,min,max,Java::IoVertxRedisOp::LimitOptions.new(::Vertx::Util::Utils.to_json_object(options)),(Proc.new { |ar| yield(ar.failed ? ar.cause : nil, ar.succeeded ? ar.result != nil ? JSON.parse(ar.result.encode) : nil : nil) }))
        return self
      end
      raise ArgumentError, "Invalid arguments when calling zrangebylex(#{key},#{min},#{max},#{options})"
    end

### - (`self`) zrangebyscore(key = nil, min = nil, max = nil, options = nil) { ... }

Return a range of members in a sorted set, by score

Parameters:

- key (`String`) (defaults to: `nil`) —
  Key string
- min (`String`) (defaults to: `nil`) —
  Pattern defining a minimum value
- max (`String`) (defaults to: `nil`) —
  Pattern defining a maximum value
- options (`Hash`) (defaults to: `nil`) —
  Range and limit options

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    2397
    2398
    2399
    2400
    2401
    2402
    2403
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx-redis/redis_client.rb', line 2397

    def zrangebyscore(key=nil,min=nil,max=nil,options=nil)
      if key.class == String && min.class == String && max.class == String && options.class == Hash && block_given?
        @j_del.java_method(:zrangebyscore, [Java::java.lang.String.java_class,Java::java.lang.String.java_class,Java::java.lang.String.java_class,Java::IoVertxRedisOp::RangeLimitOptions.java_class,Java::IoVertxCore::Handler.java_class]).call(key,min,max,Java::IoVertxRedisOp::RangeLimitOptions.new(::Vertx::Util::Utils.to_json_object(options)),(Proc.new { |ar| yield(ar.failed ? ar.cause : nil, ar.succeeded ? ar.result != nil ? JSON.parse(ar.result.encode) : nil : nil) }))
        return self
      end
      raise ArgumentError, "Invalid arguments when calling zrangebyscore(#{key},#{min},#{max},#{options})"
    end

### - (`self`) zrank(key = nil, member = nil) { ... }

Determine the index of a member in a sorted set

Parameters:

- key (`String`) (defaults to: `nil`) —
  Key string
- member (`String`) (defaults to: `nil`) —
  Member in the sorted set identified by key

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    2409
    2410
    2411
    2412
    2413
    2414
    2415
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx-redis/redis_client.rb', line 2409

    def zrank(key=nil,member=nil)
      if key.class == String && member.class == String && block_given?
        @j_del.java_method(:zrank, [Java::java.lang.String.java_class,Java::java.lang.String.java_class,Java::IoVertxCore::Handler.java_class]).call(key,member,(Proc.new { |ar| yield(ar.failed ? ar.cause : nil, ar.succeeded ? ar.result : nil) }))
        return self
      end
      raise ArgumentError, "Invalid arguments when calling zrank(#{key},#{member})"
    end

### - (`self`) zrem(key = nil, member = nil) { ... }

Remove one member from a sorted set

Parameters:

- key (`String`) (defaults to: `nil`) —
  Key string
- member (`String`) (defaults to: `nil`) —
  Member in the sorted set identified by key

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    2421
    2422
    2423
    2424
    2425
    2426
    2427
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx-redis/redis_client.rb', line 2421

    def zrem(key=nil,member=nil)
      if key.class == String && member.class == String && block_given?
        @j_del.java_method(:zrem, [Java::java.lang.String.java_class,Java::java.lang.String.java_class,Java::IoVertxCore::Handler.java_class]).call(key,member,(Proc.new { |ar| yield(ar.failed ? ar.cause : nil, ar.succeeded ? ar.result : nil) }))
        return self
      end
      raise ArgumentError, "Invalid arguments when calling zrem(#{key},#{member})"
    end

### - (`self`) zrem_many(key = nil, members = nil) { ... }

Remove one or more members from a sorted set

Parameters:

- key (`String`) (defaults to: `nil`) —
  Key string
- members (`Array<String>`) (defaults to: `nil`) —
  Members in the sorted set identified by key

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    2433
    2434
    2435
    2436
    2437
    2438
    2439
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx-redis/redis_client.rb', line 2433

    def zrem_many(key=nil,members=nil)
      if key.class == String && members.class == Array && block_given?
        @j_del.java_method(:zremMany, [Java::java.lang.String.java_class,Java::JavaUtil::List.java_class,Java::IoVertxCore::Handler.java_class]).call(key,members.map { |element| element },(Proc.new { |ar| yield(ar.failed ? ar.cause : nil, ar.succeeded ? ar.result : nil) }))
        return self
      end
      raise ArgumentError, "Invalid arguments when calling zrem_many(#{key},#{members})"
    end

### - (`self`) zremrangebylex(key = nil, min = nil, max = nil) { ... }

Remove all members in a sorted set between the given lexicographical range

Parameters:

- key (`String`) (defaults to: `nil`) —
  Key string
- min (`String`) (defaults to: `nil`) —
  Pattern defining a minimum value
- max (`String`) (defaults to: `nil`) —
  Pattern defining a maximum value

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    2446
    2447
    2448
    2449
    2450
    2451
    2452
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx-redis/redis_client.rb', line 2446

    def zremrangebylex(key=nil,min=nil,max=nil)
      if key.class == String && min.class == String && max.class == String && block_given?
        @j_del.java_method(:zremrangebylex, [Java::java.lang.String.java_class,Java::java.lang.String.java_class,Java::java.lang.String.java_class,Java::IoVertxCore::Handler.java_class]).call(key,min,max,(Proc.new { |ar| yield(ar.failed ? ar.cause : nil, ar.succeeded ? ar.result : nil) }))
        return self
      end
      raise ArgumentError, "Invalid arguments when calling zremrangebylex(#{key},#{min},#{max})"
    end

### - (`self`) zremrangebyrank(key = nil, start = nil, stop = nil) { ... }

Remove all members in a sorted set within the given indexes

Parameters:

- key (`String`) (defaults to: `nil`) —
  Key string
- start (`Fixnum`) (defaults to: `nil`) —
  Start index
- stop (`Fixnum`) (defaults to: `nil`) —
  Stop index

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    2459
    2460
    2461
    2462
    2463
    2464
    2465
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx-redis/redis_client.rb', line 2459

    def zremrangebyrank(key=nil,start=nil,stop=nil)
      if key.class == String && start.class == Fixnum && stop.class == Fixnum && block_given?
        @j_del.java_method(:zremrangebyrank, [Java::java.lang.String.java_class,Java::long.java_class,Java::long.java_class,Java::IoVertxCore::Handler.java_class]).call(key,start,stop,(Proc.new { |ar| yield(ar.failed ? ar.cause : nil, ar.succeeded ? ar.result : nil) }))
        return self
      end
      raise ArgumentError, "Invalid arguments when calling zremrangebyrank(#{key},#{start},#{stop})"
    end

### - (`self`) zremrangebyscore(key = nil, min = nil, max = nil) { ... }

Remove all members in a sorted set within the given scores

Parameters:

- key (`String`) (defaults to: `nil`) —
  Key string
- min (`String`) (defaults to: `nil`) —
  Pattern defining a minimum value
- max (`String`) (defaults to: `nil`) —
  Pattern defining a maximum value

Yields:

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    2472
    2473
    2474
    2475
    2476
    2477
    2478
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx-redis/redis_client.rb', line 2472

    def zremrangebyscore(key=nil,min=nil,max=nil)
      if key.class == String && min.class == String && max.class == String && block_given?
        @j_del.java_method(:zremrangebyscore, [Java::java.lang.String.java_class,Java::java.lang.String.java_class,Java::java.lang.String.java_class,Java::IoVertxCore::Handler.java_class]).call(key,min,max,(Proc.new { |ar| yield(ar.failed ? ar.cause : nil, ar.succeeded ? ar.result : nil) }))
        return self
      end
      raise ArgumentError, "Invalid arguments when calling zremrangebyscore(#{key},#{min},#{max})"
    end

### - (`self`) zrevrange(key = nil, start = nil, stop = nil, options = nil) { ... }

Return a range of members in a sorted set, by index, with scores ordered from high to low

Parameters:

- key (`String`) (defaults to: `nil`) —
  Key string
- start (`Fixnum`) (defaults to: `nil`) —
  Start index for the range
- stop (`Fixnum`) (defaults to: `nil`) —
  Stop index for the range - inclusive
- options (`:NONE`, `:WITHSCORES`) (defaults to: `nil`) —
  Range options

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    2486
    2487
    2488
    2489
    2490
    2491
    2492
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx-redis/redis_client.rb', line 2486

    def zrevrange(key=nil,start=nil,stop=nil,options=nil)
      if key.class == String && start.class == Fixnum && stop.class == Fixnum && options.class == Symbol && block_given?
        @j_del.java_method(:zrevrange, [Java::java.lang.String.java_class,Java::long.java_class,Java::long.java_class,Java::IoVertxRedisOp::RangeOptions.java_class,Java::IoVertxCore::Handler.java_class]).call(key,start,stop,Java::IoVertxRedisOp::RangeOptions.valueOf(options.to_s),(Proc.new { |ar| yield(ar.failed ? ar.cause : nil, ar.succeeded ? ar.result != nil ? JSON.parse(ar.result.encode) : nil : nil) }))
        return self
      end
      raise ArgumentError, "Invalid arguments when calling zrevrange(#{key},#{start},#{stop},#{options})"
    end

### - (`self`) zrevrangebylex(key = nil, max = nil, min = nil, options = nil) { ... }

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 (`String`) (defaults to: `nil`) —
  Key string
- max (`String`) (defaults to: `nil`) —
  Pattern defining a maximum value
- min (`String`) (defaults to: `nil`) —
  Pattern defining a minimum value
- options (`Hash`) (defaults to: `nil`) —
  Limit options

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    2500
    2501
    2502
    2503
    2504
    2505
    2506
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx-redis/redis_client.rb', line 2500

    def zrevrangebylex(key=nil,max=nil,min=nil,options=nil)
      if key.class == String && max.class == String && min.class == String && options.class == Hash && block_given?
        @j_del.java_method(:zrevrangebylex, [Java::java.lang.String.java_class,Java::java.lang.String.java_class,Java::java.lang.String.java_class,Java::IoVertxRedisOp::LimitOptions.java_class,Java::IoVertxCore::Handler.java_class]).call(key,max,min,Java::IoVertxRedisOp::LimitOptions.new(::Vertx::Util::Utils.to_json_object(options)),(Proc.new { |ar| yield(ar.failed ? ar.cause : nil, ar.succeeded ? ar.result != nil ? JSON.parse(ar.result.encode) : nil : nil) }))
        return self
      end
      raise ArgumentError, "Invalid arguments when calling zrevrangebylex(#{key},#{max},#{min},#{options})"
    end

### - (`self`) zrevrangebyscore(key = nil, max = nil, min = nil, options = nil) { ... }

Return a range of members in a sorted set, by score, with scores ordered from high to low

Parameters:

- key (`String`) (defaults to: `nil`) —
  Key string
- max (`String`) (defaults to: `nil`) —
  Pattern defining a maximum value
- min (`String`) (defaults to: `nil`) —
  Pattern defining a minimum value
- options (`Hash`) (defaults to: `nil`) —
  Range and limit options

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    2514
    2515
    2516
    2517
    2518
    2519
    2520
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx-redis/redis_client.rb', line 2514

    def zrevrangebyscore(key=nil,max=nil,min=nil,options=nil)
      if key.class == String && max.class == String && min.class == String && options.class == Hash && block_given?
        @j_del.java_method(:zrevrangebyscore, [Java::java.lang.String.java_class,Java::java.lang.String.java_class,Java::java.lang.String.java_class,Java::IoVertxRedisOp::RangeLimitOptions.java_class,Java::IoVertxCore::Handler.java_class]).call(key,max,min,Java::IoVertxRedisOp::RangeLimitOptions.new(::Vertx::Util::Utils.to_json_object(options)),(Proc.new { |ar| yield(ar.failed ? ar.cause : nil, ar.succeeded ? ar.result != nil ? JSON.parse(ar.result.encode) : nil : nil) }))
        return self
      end
      raise ArgumentError, "Invalid arguments when calling zrevrangebyscore(#{key},#{max},#{min},#{options})"
    end

### - (`self`) zrevrank(key = nil, member = nil) { ... }

Determine the index of a member in a sorted set, with scores ordered from high to low

Parameters:

- key (`String`) (defaults to: `nil`) —
  Key string
- member (`String`) (defaults to: `nil`) —
  Member in the sorted set identified by key

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    2526
    2527
    2528
    2529
    2530
    2531
    2532
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx-redis/redis_client.rb', line 2526

    def zrevrank(key=nil,member=nil)
      if key.class == String && member.class == String && block_given?
        @j_del.java_method(:zrevrank, [Java::java.lang.String.java_class,Java::java.lang.String.java_class,Java::IoVertxCore::Handler.java_class]).call(key,member,(Proc.new { |ar| yield(ar.failed ? ar.cause : nil, ar.succeeded ? ar.result : nil) }))
        return self
      end
      raise ArgumentError, "Invalid arguments when calling zrevrank(#{key},#{member})"
    end

### - (`self`) zscan(key = nil, cursor = nil, options = nil) { ... }

Incrementally iterate sorted sets elements and associated scores

Parameters:

- key (`String`) (defaults to: `nil`) —
  Key string
- cursor (`String`) (defaults to: `nil`) —
  Cursor id
- options (`Hash`) (defaults to: `nil`) —
  Scan options

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    2615
    2616
    2617
    2618
    2619
    2620
    2621
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx-redis/redis_client.rb', line 2615

    def zscan(key=nil,cursor=nil,options=nil)
      if key.class == String && cursor.class == String && options.class == Hash && block_given?
        @j_del.java_method(:zscan, [Java::java.lang.String.java_class,Java::java.lang.String.java_class,Java::IoVertxRedisOp::ScanOptions.java_class,Java::IoVertxCore::Handler.java_class]).call(key,cursor,Java::IoVertxRedisOp::ScanOptions.new(::Vertx::Util::Utils.to_json_object(options)),(Proc.new { |ar| yield(ar.failed ? ar.cause : nil, ar.succeeded ? ar.result != nil ? JSON.parse(ar.result.encode) : nil : nil) }))
        return self
      end
      raise ArgumentError, "Invalid arguments when calling zscan(#{key},#{cursor},#{options})"
    end

### - (`self`) zscore(key = nil, member = nil) { ... }

Get the score associated with the given member in a sorted set

Parameters:

- key (`String`) (defaults to: `nil`) —
  Key string
- member (`String`) (defaults to: `nil`) —
  Member in the sorted set identified by key

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    2538
    2539
    2540
    2541
    2542
    2543
    2544
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx-redis/redis_client.rb', line 2538

    def zscore(key=nil,member=nil)
      if key.class == String && member.class == String && block_given?
        @j_del.java_method(:zscore, [Java::java.lang.String.java_class,Java::java.lang.String.java_class,Java::IoVertxCore::Handler.java_class]).call(key,member,(Proc.new { |ar| yield(ar.failed ? ar.cause : nil, ar.succeeded ? ar.result : nil) }))
        return self
      end
      raise ArgumentError, "Invalid arguments when calling zscore(#{key},#{member})"
    end

### - (`self`) zunionstore(destkey = nil, sets = nil, options = nil) { ... }

Add multiple sorted sets and store the resulting sorted set in a new key

Parameters:

- destkey (`String`) (defaults to: `nil`) —
  Destination key
- sets (`Array<String>`) (defaults to: `nil`) —
  List of keys identifying sorted sets
- options (`:NONE`, `:SUM`, `:MIN`, `:MAX`) (defaults to: `nil`) —
  Aggregation options

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    2551
    2552
    2553
    2554
    2555
    2556
    2557
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx-redis/redis_client.rb', line 2551

    def zunionstore(destkey=nil,sets=nil,options=nil)
      if destkey.class == String && sets.class == Array && options.class == Symbol && block_given?
        @j_del.java_method(:zunionstore, [Java::java.lang.String.java_class,Java::JavaUtil::List.java_class,Java::IoVertxRedisOp::AggregateOptions.java_class,Java::IoVertxCore::Handler.java_class]).call(destkey,sets.map { |element| element },Java::IoVertxRedisOp::AggregateOptions.valueOf(options.to_s),(Proc.new { |ar| yield(ar.failed ? ar.cause : nil, ar.succeeded ? ar.result : nil) }))
        return self
      end
      raise ArgumentError, "Invalid arguments when calling zunionstore(#{destkey},#{sets},#{options})"
    end

### - (`self`) zunionstore_weighed(key = nil, sets = nil, options = nil) { ... }

Add multiple sorted sets using weights, and store the resulting sorted set in a new key

Parameters:

- key (`String`) (defaults to: `nil`) —
  Destination key
- sets (`Hash{String => Float}`) (defaults to: `nil`) —
  Map containing set-key:weight pairs
- options (`:NONE`, `:SUM`, `:MIN`, `:MAX`) (defaults to: `nil`) —
  Aggregation options

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    2564
    2565
    2566
    2567
    2568
    2569
    2570
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx-redis/redis_client.rb', line 2564

    def zunionstore_weighed(key=nil,sets=nil,options=nil)
      if key.class == String && sets.class == Hash && options.class == Symbol && block_given?
        @j_del.java_method(:zunionstoreWeighed, [Java::java.lang.String.java_class,Java::JavaUtil::Map.java_class,Java::IoVertxRedisOp::AggregateOptions.java_class,Java::IoVertxCore::Handler.java_class]).call(key,Hash[sets.map { |k,v| [k,::Vertx::Util::Utils.to_double(v)] }],Java::IoVertxRedisOp::AggregateOptions.valueOf(options.to_s),(Proc.new { |ar| yield(ar.failed ? ar.cause : nil, ar.succeeded ? ar.result : nil) }))
        return self
      end
      raise ArgumentError, "Invalid arguments when calling zunionstore_weighed(#{key},#{sets},#{options})"
    end