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-redis-client/src/main/resources/vertx-redis/redis_client.rb

## Class Method Summary (collapse)

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

## Instance Method Summary (collapse)

- - (::VertxRedis::RedisClient) append(key = nil, value = nil) { ... }
  Append a value to a key.
- - (::VertxRedis::RedisClient) auth(password = nil) { ... }
  Authenticate to the server.
- - (::VertxRedis::RedisClient) bgrewriteaof { ... }
  Asynchronously rewrite the append-only file.
- - (::VertxRedis::RedisClient) bgsave { ... }
  Asynchronously save the dataset to disk.
- - (::VertxRedis::RedisClient) bitcount(key = nil) { ... }
  Count set bits in a string.
- - (::VertxRedis::RedisClient) bitcount_range(key = nil, start = nil, _end = nil) { ... }
  Count set bits in a string.
- - (::VertxRedis::RedisClient) bitop(operation = nil, destkey = nil, keys = nil) { ... }
  Perform bitwise operations between strings.
- - (::VertxRedis::RedisClient) bitpos(key = nil, bit = nil) { ... }
  Find first bit set or clear in a string.
- - (::VertxRedis::RedisClient) bitpos_from(key = nil, bit = nil, start = nil) { ... }
  Find first bit set or clear in a string.
- - (::VertxRedis::RedisClient) bitpos_range(key = nil, bit = nil, start = nil, stop = nil) { ... }
  Find first bit set or clear in a string.
- - (::VertxRedis::RedisClient) blpop(key = nil, seconds = nil) { ... }
  Remove and get the first element in a list, or block until one is available.
- - (::VertxRedis::RedisClient) blpop_many(keys = nil, seconds = nil) { ... }
  Remove and get the first element in any of the lists, or block until one is available.
- - (::VertxRedis::RedisClient) brpop(key = nil, seconds = nil) { ... }
  Remove and get the last element in a list, or block until one is available.
- - (::VertxRedis::RedisClient) brpop_many(keys = nil, seconds = nil) { ... }
  Remove and get the last element in any of the lists, or block until one is available.
- - (::VertxRedis::RedisClient) 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.
- - (::VertxRedis::RedisClient) client_getname { ... }
  Get the current connection name.
- - (::VertxRedis::RedisClient) client_kill(filter = nil) { ... }
  Kill the connection of a client.
- - (::VertxRedis::RedisClient) client_list { ... }
  Get the list of client connections.
- - (::VertxRedis::RedisClient) client_pause(millis = nil) { ... }
  Stop processing commands from clients for some time.
- - (::VertxRedis::RedisClient) client_setname(name = nil) { ... }
  Set the current connection name.
- - (void) close { ... }
  Close the client - when it is fully closed the handler will be called.
- - (::VertxRedis::RedisClient) cluster_slots { ... }
  Get array of Cluster slot to node mappings.
- - (::VertxRedis::RedisClient) command { ... }
  Get array of Redis command details.
- - (::VertxRedis::RedisClient) command_count { ... }
  Get total number of Redis commands.
- - (::VertxRedis::RedisClient) command_getkeys { ... }
  Extract keys given a full Redis command.
- - (::VertxRedis::RedisClient) command_info(commands = nil) { ... }
  Get array of specific Redis command details.
- - (::VertxRedis::RedisClient) config_get(parameter = nil) { ... }
  Get the value of a configuration parameter.
- - (::VertxRedis::RedisClient) config_resetstat { ... }
  Reset the stats returned by INFO.
- - (::VertxRedis::RedisClient) config_rewrite { ... }
  Rewrite the configuration file with the in memory configuration.
- - (::VertxRedis::RedisClient) config_set(parameter = nil, value = nil) { ... }
  Set a configuration parameter to the given value.
- - (::VertxRedis::RedisClient) dbsize { ... }
  Return the number of keys in the selected database.
- - (::VertxRedis::RedisClient) debug_object(key = nil) { ... }
  Get debugging information about a key.
- - (::VertxRedis::RedisClient) debug_segfault { ... }
  Make the server crash.
- - (::VertxRedis::RedisClient) decr(key = nil) { ... }
  Decrement the integer value of a key by one.
- - (::VertxRedis::RedisClient) decrby(key = nil, decrement = nil) { ... }
  Decrement the integer value of a key by the given number.
- - (::VertxRedis::RedisClient) del(keys = nil) { ... }
  Delete a key.
- - (::VertxRedis::RedisClient) discard { ... }
  Discard all commands issued after MULTI.
- - (::VertxRedis::RedisClient) dump(key = nil) { ... }
  Return a serialized version of the value stored at the specified key.
- - (::VertxRedis::RedisClient) echo(message = nil) { ... }
  Echo the given string.
- - (::VertxRedis::RedisClient) eval(script = nil, keys = nil, args = nil) { ... }
  Execute a Lua script server side.
- - (::VertxRedis::RedisClient) evalsha(sha1 = nil, keys = nil, values = nil) { ... }
  Execute a Lua script server side.
- - (::VertxRedis::RedisClient) exec { ... }
  Execute all commands issued after MULTI.
- - (::VertxRedis::RedisClient) exists(key = nil) { ... }
  Determine if a key exists.
- - (::VertxRedis::RedisClient) expire(key = nil, seconds = nil) { ... }
  Set a key's time to live in seconds.
- - (::VertxRedis::RedisClient) expireat(key = nil, seconds = nil) { ... }
  Set the expiration for a key as a UNIX timestamp.
- - (::VertxRedis::RedisClient) flushall { ... }
  Remove all keys from all databases.
- - (::VertxRedis::RedisClient) flushdb { ... }
  Remove all keys from the current database.
- - (::VertxRedis::RedisClient) get(key = nil) { ... }
  Get the value of a key.
- - (::VertxRedis::RedisClient) get_binary(key = nil) { ... }
  Get the value of a key - without decoding as utf-8.
- - (::VertxRedis::RedisClient) getbit(key = nil, offset = nil) { ... }
  Returns the bit value at offset in the string value stored at key.
- - (::VertxRedis::RedisClient) getrange(key = nil, start = nil, _end = nil) { ... }
  Get a substring of the string stored at a key.
- - (::VertxRedis::RedisClient) getset(key = nil, value = nil) { ... }
  Set the string value of a key and return its old value.
- - (::VertxRedis::RedisClient) hdel(key = nil, field = nil) { ... }
  Delete one or more hash fields.
- - (::VertxRedis::RedisClient) hdel_many(key = nil, fields = nil) { ... }
  Delete one or more hash fields.
- - (::VertxRedis::RedisClient) hexists(key = nil, field = nil) { ... }
  Determine if a hash field exists.
- - (::VertxRedis::RedisClient) hget(key = nil, field = nil) { ... }
  Get the value of a hash field.
- - (::VertxRedis::RedisClient) hgetall(key = nil) { ... }
  Get all the fields and values in a hash.
- - (::VertxRedis::RedisClient) hincrby(key = nil, field = nil, increment = nil) { ... }
  Increment the integer value of a hash field by the given number.
- - (::VertxRedis::RedisClient) hincrbyfloat(key = nil, field = nil, increment = nil) { ... }
  Increment the float value of a hash field by the given amount.
- - (::VertxRedis::RedisClient) hkeys(key = nil) { ... }
  Get all the fields in a hash.
- - (::VertxRedis::RedisClient) hlen(key = nil) { ... }
  Get the number of fields in a hash.
- - (::VertxRedis::RedisClient) hmget(key = nil, fields = nil) { ... }
  Get the values of all the given hash fields.
- - (::VertxRedis::RedisClient) hmset(key = nil, values = nil) { ... }
  Set multiple hash fields to multiple values.
- - (::VertxRedis::RedisClient) hscan(key = nil, cursor = nil, options = nil) { ... }
  Incrementally iterate hash fields and associated values.
- - (::VertxRedis::RedisClient) hset(key = nil, field = nil, value = nil) { ... }
  Set the string value of a hash field.
- - (::VertxRedis::RedisClient) hsetnx(key = nil, field = nil, value = nil) { ... }
  Set the value of a hash field, only if the field does not exist.
- - (::VertxRedis::RedisClient) hvals(key = nil) { ... }
  Get all the values in a hash.
- - (::VertxRedis::RedisClient) incr(key = nil) { ... }
  Increment the integer value of a key by one.
- - (::VertxRedis::RedisClient) incrby(key = nil, increment = nil) { ... }
  Increment the integer value of a key by the given amount.
- - (::VertxRedis::RedisClient) incrbyfloat(key = nil, increment = nil) { ... }
  Increment the float value of a key by the given amount.
- - (::VertxRedis::RedisClient) info { ... }
  Get information and statistics about the server.
- - (::VertxRedis::RedisClient) info_section(section = nil) { ... }
  Get information and statistics about the server.
- - (::VertxRedis::RedisClient) keys(pattern = nil) { ... }
  Find all keys matching the given pattern.
- - (::VertxRedis::RedisClient) lastsave { ... }
  Get the UNIX time stamp of the last successful save to disk.
- - (::VertxRedis::RedisClient) lindex(key = nil, index = nil) { ... }
  Get an element from a list by its index.
- - (::VertxRedis::RedisClient) linsert(key = nil, option = nil, pivot = nil, value = nil) { ... }
  Insert an element before or after another element in a list.
- - (::VertxRedis::RedisClient) llen(key = nil) { ... }
  Get the length of a list.
- - (::VertxRedis::RedisClient) lpop(key = nil) { ... }
  Remove and get the first element in a list.
- - (::VertxRedis::RedisClient) lpush(key = nil, value = nil) { ... }
  Prepend one value to a list.
- - (::VertxRedis::RedisClient) lpush_many(key = nil, values = nil) { ... }
  Prepend one or multiple values to a list.
- - (::VertxRedis::RedisClient) lpushx(key = nil, value = nil) { ... }
  Prepend a value to a list, only if the list exists.
- - (::VertxRedis::RedisClient) lrange(key = nil, from = nil, to = nil) { ... }
  Get a range of elements from a list.
- - (::VertxRedis::RedisClient) lrem(key = nil, count = nil, value = nil) { ... }
  Remove elements from a list.
- - (::VertxRedis::RedisClient) lset(key = nil, index = nil, value = nil) { ... }
  Set the value of an element in a list by its index.
- - (::VertxRedis::RedisClient) ltrim(key = nil, from = nil, to = nil) { ... }
  Trim a list to the specified range.
- - (::VertxRedis::RedisClient) mget(key = nil) { ... }
  Get the value of the given key.
- - (::VertxRedis::RedisClient) mget_many(keys = nil) { ... }
  Get the values of all the given keys.
- - (::VertxRedis::RedisClient) migrate(host = nil, port = nil, key = nil, destdb = nil, timeout = nil, options = nil) { ... }
  Atomically transfer a key from a Redis instance to another one.
- - (::VertxRedis::RedisClient) monitor { ... }
  Listen for all requests received by the server in real time.
- - (::VertxRedis::RedisClient) move(key = nil, destdb = nil) { ... }
  Move a key to another database.
- - (::VertxRedis::RedisClient) mset(keyvals = nil) { ... }
  Set multiple keys to multiple values.
- - (::VertxRedis::RedisClient) msetnx(keyvals = nil) { ... }
  Set multiple keys to multiple values, only if none of the keys exist.
- - (::VertxRedis::RedisClient) multi { ... }
  Mark the start of a transaction block.
- - (::VertxRedis::RedisClient) object(key = nil, cmd = nil) { ... }
  Inspect the internals of Redis objects.
- - (::VertxRedis::RedisClient) persist(key = nil) { ... }
  Remove the expiration from a key.
- - (::VertxRedis::RedisClient) pexpire(key = nil, millis = nil) { ... }
  Set a key's time to live in milliseconds.
- - (::VertxRedis::RedisClient) pexpireat(key = nil, millis = nil) { ... }
  Set the expiration for a key as a UNIX timestamp specified in milliseconds.
- - (::VertxRedis::RedisClient) pfadd(key = nil, element = nil) { ... }
  Adds the specified element to the specified HyperLogLog.
- - (::VertxRedis::RedisClient) pfadd_many(key = nil, elements = nil) { ... }
  Adds the specified elements to the specified HyperLogLog.
- - (::VertxRedis::RedisClient) pfcount(key = nil) { ... }
  Return the approximated cardinality of the set observed by the HyperLogLog at key.
- - (::VertxRedis::RedisClient) pfcount_many(keys = nil) { ... }
  Return the approximated cardinality of the set(s) observed by the HyperLogLog at key(s).
- - (::VertxRedis::RedisClient) pfmerge(destkey = nil, keys = nil) { ... }
  Merge N different HyperLogLogs into a single one.
- - (::VertxRedis::RedisClient) ping { ... }
  Ping the server.
- - (::VertxRedis::RedisClient) psetex(key = nil, millis = nil, value = nil) { ... }
  Set the value and expiration in milliseconds of a key.
- - (::VertxRedis::RedisClient) psubscribe(pattern = nil) { ... }
  Listen for messages published to channels matching the given pattern.
- - (::VertxRedis::RedisClient) psubscribe_many(patterns = nil) { ... }
  Listen for messages published to channels matching the given patterns.
- - (::VertxRedis::RedisClient) pttl(key = nil) { ... }
  Get the time to live for a key in milliseconds.
- - (::VertxRedis::RedisClient) publish(channel = nil, message = nil) { ... }
  Post a message to a channel.
- - (::VertxRedis::RedisClient) pubsub_channels(pattern = nil) { ... }
  Lists the currently active channels - only those matching the pattern.
- - (::VertxRedis::RedisClient) pubsub_numpat { ... }
  Returns the number of subscriptions to patterns (that are performed using the PSUBSCRIBE command).
- - (::VertxRedis::RedisClient) pubsub_numsub(channels = nil) { ... }
  Returns the number of subscribers (not counting clients subscribed to patterns) for the specified channels.
- - (::VertxRedis::RedisClient) punsubscribe(patterns = nil) { ... }
  Stop listening for messages posted to channels matching the given patterns.
- - (::VertxRedis::RedisClient) randomkey { ... }
  Return a random key from the keyspace.
- - (::VertxRedis::RedisClient) rename(key = nil, newkey = nil) { ... }
  Rename a key.
- - (::VertxRedis::RedisClient) renamenx(key = nil, newkey = nil) { ... }
  Rename a key, only if the new key does not exist.
- - (::VertxRedis::RedisClient) restore(key = nil, millis = nil, serialized = nil) { ... }
  Create a key using the provided serialized value, previously obtained using DUMP.
- - (::VertxRedis::RedisClient) role { ... }
  Return the role of the instance in the context of replication.
- - (::VertxRedis::RedisClient) rpop(key = nil) { ... }
  Remove and get the last element in a list.
- - (::VertxRedis::RedisClient) rpoplpush(key = nil, destkey = nil) { ... }
  Remove the last element in a list, append it to another list and return it.
- - (::VertxRedis::RedisClient) rpush(key = nil, value = nil) { ... }
  Append one or multiple values to a list.
- - (::VertxRedis::RedisClient) rpush_many(key = nil, values = nil) { ... }
  Append one or multiple values to a list.
- - (::VertxRedis::RedisClient) rpushx(key = nil, value = nil) { ... }
  Append a value to a list, only if the list exists.
- - (::VertxRedis::RedisClient) sadd(key = nil, member = nil) { ... }
  Add a member to a set.
- - (::VertxRedis::RedisClient) sadd_many(key = nil, members = nil) { ... }
  Add one or more members to a set.
- - (::VertxRedis::RedisClient) save { ... }
  Synchronously save the dataset to disk.
- - (::VertxRedis::RedisClient) scan(cursor = nil, options = nil) { ... }
  Incrementally iterate the keys space.
- - (::VertxRedis::RedisClient) scard(key = nil) { ... }
  Get the number of members in a set.
- - (::VertxRedis::RedisClient) script_exists(script = nil) { ... }
  Check existence of script in the script cache.
- - (::VertxRedis::RedisClient) script_exists_many(scripts = nil) { ... }
  Check existence of scripts in the script cache.
- - (::VertxRedis::RedisClient) script_flush { ... }
  Remove all the scripts from the script cache.
- - (::VertxRedis::RedisClient) script_kill { ... }
  Kill the script currently in execution.
- - (::VertxRedis::RedisClient) script_load(script = nil) { ... }
  Load the specified Lua script into the script cache.
- - (::VertxRedis::RedisClient) sdiff(key = nil, cmpkeys = nil) { ... }
  Subtract multiple sets.
- - (::VertxRedis::RedisClient) sdiffstore(destkey = nil, key = nil, cmpkeys = nil) { ... }
  Subtract multiple sets and store the resulting set in a key.
- - (::VertxRedis::RedisClient) select(dbindex = nil) { ... }
  Change the selected database for the current connection.
- - (::VertxRedis::RedisClient) set(key = nil, value = nil) { ... }
  Set the string value of a key.
- - (::VertxRedis::RedisClient) set_binary(key = nil, value = nil) { ... }
  Set the binary string value of a key - without encoding as utf-8.
- - (::VertxRedis::RedisClient) set_with_options(key = nil, value = nil, options = nil) { ... }
  Set the string value of a key.
- - (::VertxRedis::RedisClient) setbit(key = nil, offset = nil, bit = nil) { ... }
  Sets or clears the bit at offset in the string value stored at key.
- - (::VertxRedis::RedisClient) setex(key = nil, seconds = nil, value = nil) { ... }
  Set the value and expiration of a key.
- - (::VertxRedis::RedisClient) setnx(key = nil, value = nil) { ... }
  Set the value of a key, only if the key does not exist.
- - (::VertxRedis::RedisClient) setrange(key = nil, offset = nil, value = nil) { ... }
  Overwrite part of a string at key starting at the specified offset.
- - (::VertxRedis::RedisClient) sinter(keys = nil) { ... }
  Intersect multiple sets.
- - (::VertxRedis::RedisClient) sinterstore(destkey = nil, keys = nil) { ... }
  Intersect multiple sets and store the resulting set in a key.
- - (::VertxRedis::RedisClient) sismember(key = nil, member = nil) { ... }
  Determine if a given value is a member of a set.
- - (::VertxRedis::RedisClient) slaveof(host = nil, port = nil) { ... }
  Make the server a slave of another instance.
- - (::VertxRedis::RedisClient) slaveof_noone { ... }
  Make this server a master.
- - (::VertxRedis::RedisClient) slowlog_get(limit = nil) { ... }
  Read the Redis slow queries log.
- - (::VertxRedis::RedisClient) slowlog_len { ... }
  Get the length of the Redis slow queries log.
- - (::VertxRedis::RedisClient) slowlog_reset { ... }
  Reset the Redis slow queries log.
- - (::VertxRedis::RedisClient) smembers(key = nil) { ... }
  Get all the members in a set.
- - (::VertxRedis::RedisClient) smove(key = nil, destkey = nil, member = nil) { ... }
  Move a member from one set to another.
- - (::VertxRedis::RedisClient) sort(key = nil, options = nil) { ... }
  Sort the elements in a list, set or sorted set.
- - (::VertxRedis::RedisClient) spop(key = nil) { ... }
  Remove and return a random member from a set.
- - (::VertxRedis::RedisClient) spop_many(key = nil, count = nil) { ... }
  Remove and return random members from a set.
- - (::VertxRedis::RedisClient) srandmember(key = nil, count = nil) { ... }
  Get one or multiple random members from a set.
- - (::VertxRedis::RedisClient) srem(key = nil, member = nil) { ... }
  Remove one member from a set.
- - (::VertxRedis::RedisClient) srem_many(key = nil, members = nil) { ... }
  Remove one or more members from a set.
- - (::VertxRedis::RedisClient) sscan(key = nil, cursor = nil, options = nil) { ... }
  Incrementally iterate Set elements.
- - (::VertxRedis::RedisClient) strlen(key = nil) { ... }
  Get the length of the value stored in a key.
- - (::VertxRedis::RedisClient) subscribe(channels = nil) { ... }
  Listen for messages published to the given channels.
- - (::VertxRedis::RedisClient) sunion(keys = nil) { ... }
  Add multiple sets.
- - (::VertxRedis::RedisClient) sunionstore(destkey = nil, keys = nil) { ... }
  Add multiple sets and store the resulting set in a key.
- - (::VertxRedis::RedisClient) sync { ... }
  Internal command used for replication.
- - (::VertxRedis::RedisClient) time { ... }
  Return the current server time.
- - (::VertxRedis::RedisClient) ttl(key = nil) { ... }
  Get the time to live for a key.
- - (::VertxRedis::RedisClient) type(key = nil) { ... }
  Determine the type stored at key.
- - (::VertxRedis::RedisClient) unsubscribe(channels = nil) { ... }
  Stop listening for messages posted to the given channels.
- - (::VertxRedis::RedisClient) unwatch { ... }
  Forget about all watched keys.
- - (::VertxRedis::RedisClient) watch(keys = nil) { ... }
  Watch the given keys to determine execution of the MULTI/EXEC block.
- - (::VertxRedis::RedisClient) zadd(key = nil, score = nil, member = nil) { ... }
  Add one or more members to a sorted set, or update its score if it already exists.
- - (::VertxRedis::RedisClient) zadd_many(key = nil, members = nil) { ... }
  Add one or more members to a sorted set, or update its score if it already exists.
- - (::VertxRedis::RedisClient) zcard(key = nil) { ... }
  Get the number of members in a sorted set.
- - (::VertxRedis::RedisClient) zcount(key = nil, min = nil, max = nil) { ... }
  Count the members in a sorted set with scores within the given values.
- - (::VertxRedis::RedisClient) zincrby(key = nil, increment = nil, member = nil) { ... }
  Increment the score of a member in a sorted set.
- - (::VertxRedis::RedisClient) zinterstore(destkey = nil, sets = nil, options = nil) { ... }
  Intersect multiple sorted sets and store the resulting sorted set in a new key.
- - (::VertxRedis::RedisClient) 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.
- - (::VertxRedis::RedisClient) zlexcount(key = nil, min = nil, max = nil) { ... }
  Count the number of members in a sorted set between a given lexicographical range.
- - (::VertxRedis::RedisClient) zrange(key = nil, start = nil, stop = nil) { ... }
  Return a range of members in a sorted set, by index.
- - (::VertxRedis::RedisClient) zrange_with_options(key = nil, start = nil, stop = nil, options = nil) { ... }
  Return a range of members in a sorted set, by index.
- - (::VertxRedis::RedisClient) zrangebylex(key = nil, min = nil, max = nil, options = nil) { ... }
  Return a range of members in a sorted set, by lexicographical range.
- - (::VertxRedis::RedisClient) zrangebyscore(key = nil, min = nil, max = nil, options = nil) { ... }
  Return a range of members in a sorted set, by score.
- - (::VertxRedis::RedisClient) zrank(key = nil, member = nil) { ... }
  Determine the index of a member in a sorted set.
- - (::VertxRedis::RedisClient) zrem(key = nil, member = nil) { ... }
  Remove one member from a sorted set.
- - (::VertxRedis::RedisClient) zrem_many(key = nil, members = nil) { ... }
  Remove one or more members from a sorted set.
- - (::VertxRedis::RedisClient) zremrangebylex(key = nil, min = nil, max = nil) { ... }
  Remove all members in a sorted set between the given lexicographical range.
- - (::VertxRedis::RedisClient) zremrangebyrank(key = nil, start = nil, stop = nil) { ... }
  Remove all members in a sorted set within the given indexes.
- - (::VertxRedis::RedisClient) zremrangebyscore(key = nil, min = nil, max = nil) { ... }
  Remove all members in a sorted set within the given scores.
- - (::VertxRedis::RedisClient) 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.
- - (::VertxRedis::RedisClient) 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.
- - (::VertxRedis::RedisClient) 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.
- - (::VertxRedis::RedisClient) zrevrank(key = nil, member = nil) { ... }
  Determine the index of a member in a sorted set, with scores ordered from high to low.
- - (::VertxRedis::RedisClient) zscan(key = nil, cursor = nil, options = nil) { ... }
  Incrementally iterate sorted sets elements and associated scores.
- - (::VertxRedis::RedisClient) zscore(key = nil, member = nil) { ... }
  Get the score associated with the given member in a sorted set.
- - (::VertxRedis::RedisClient) zunionstore(destkey = nil, sets = nil, options = nil) { ... }
  Add multiple sorted sets and store the resulting sorted set in a new key.
- - (::VertxRedis::RedisClient) 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

### + (`::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`)

    18
    19
    20
    21
    22
    23
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-redis-client/src/main/resources/vertx-redis/redis_client.rb', line 18

    def self.create(vertx=nil,config=nil)
      if 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

## Instance Method Details

### - (`::VertxRedis::RedisClient`) 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:

- (`::VertxRedis::RedisClient`)

Raises:

- (`ArgumentError`)

    38
    39
    40
    41
    42
    43
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-redis-client/src/main/resources/vertx-redis/redis_client.rb', line 38

    def append(key=nil,value=nil)
      if key.class == String && value.class == String && block_given?
        return ::Vertx::Util::Utils.safe_create(@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) })),::VertxRedis::RedisClient)
      end
      raise ArgumentError, "Invalid arguments when calling append(key,value)"
    end

### - (`::VertxRedis::RedisClient`) 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:

- (`::VertxRedis::RedisClient`)

Raises:

- (`ArgumentError`)

    48
    49
    50
    51
    52
    53
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-redis-client/src/main/resources/vertx-redis/redis_client.rb', line 48

    def auth(password=nil)
      if password.class == String && block_given?
        return ::Vertx::Util::Utils.safe_create(@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) })),::VertxRedis::RedisClient)
      end
      raise ArgumentError, "Invalid arguments when calling auth(password)"
    end

### - (`::VertxRedis::RedisClient`) bgrewriteaof { ... }

Asynchronously rewrite the append-only file

Yields:

Returns:

- (`::VertxRedis::RedisClient`)

Raises:

- (`ArgumentError`)

    57
    58
    59
    60
    61
    62
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-redis-client/src/main/resources/vertx-redis/redis_client.rb', line 57

    def bgrewriteaof
      if block_given?
        return ::Vertx::Util::Utils.safe_create(@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) })),::VertxRedis::RedisClient)
      end
      raise ArgumentError, "Invalid arguments when calling bgrewriteaof()"
    end

### - (`::VertxRedis::RedisClient`) bgsave { ... }

Asynchronously save the dataset to disk

Yields:

Returns:

- (`::VertxRedis::RedisClient`)

Raises:

- (`ArgumentError`)

    66
    67
    68
    69
    70
    71
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-redis-client/src/main/resources/vertx-redis/redis_client.rb', line 66

    def bgsave
      if block_given?
        return ::Vertx::Util::Utils.safe_create(@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) })),::VertxRedis::RedisClient)
      end
      raise ArgumentError, "Invalid arguments when calling bgsave()"
    end

### - (`::VertxRedis::RedisClient`) 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:

- (`::VertxRedis::RedisClient`)

Raises:

- (`ArgumentError`)

    76
    77
    78
    79
    80
    81
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-redis-client/src/main/resources/vertx-redis/redis_client.rb', line 76

    def bitcount(key=nil)
      if key.class == String && block_given?
        return ::Vertx::Util::Utils.safe_create(@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) })),::VertxRedis::RedisClient)
      end
      raise ArgumentError, "Invalid arguments when calling bitcount(key)"
    end

### - (`::VertxRedis::RedisClient`) 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:

- (`::VertxRedis::RedisClient`)

Raises:

- (`ArgumentError`)

    88
    89
    90
    91
    92
    93
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-redis-client/src/main/resources/vertx-redis/redis_client.rb', line 88

    def bitcount_range(key=nil,start=nil,_end=nil)
      if key.class == String && start.class == Fixnum && _end.class == Fixnum && block_given?
        return ::Vertx::Util::Utils.safe_create(@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) })),::VertxRedis::RedisClient)
      end
      raise ArgumentError, "Invalid arguments when calling bitcount_range(key,start,_end)"
    end

### - (`::VertxRedis::RedisClient`) 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:

- (`::VertxRedis::RedisClient`)

Raises:

- (`ArgumentError`)

    100
    101
    102
    103
    104
    105
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-redis-client/src/main/resources/vertx-redis/redis_client.rb', line 100

    def bitop(operation=nil,destkey=nil,keys=nil)
      if operation.class == Symbol && destkey.class == String && keys.class == Array && block_given?
        return ::Vertx::Util::Utils.safe_create(@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),destkey,keys.map { |element| element },(Proc.new { |ar| yield(ar.failed ? ar.cause : nil, ar.succeeded ? ar.result : nil) })),::VertxRedis::RedisClient)
      end
      raise ArgumentError, "Invalid arguments when calling bitop(operation,destkey,keys)"
    end

### - (`::VertxRedis::RedisClient`) 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:

- (`::VertxRedis::RedisClient`)

Raises:

- (`ArgumentError`)

    111
    112
    113
    114
    115
    116
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-redis-client/src/main/resources/vertx-redis/redis_client.rb', line 111

    def bitpos(key=nil,bit=nil)
      if key.class == String && bit.class == Fixnum && block_given?
        return ::Vertx::Util::Utils.safe_create(@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) })),::VertxRedis::RedisClient)
      end
      raise ArgumentError, "Invalid arguments when calling bitpos(key,bit)"
    end

### - (`::VertxRedis::RedisClient`) 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:

- (`::VertxRedis::RedisClient`)

Raises:

- (`ArgumentError`)

    125
    126
    127
    128
    129
    130
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-redis-client/src/main/resources/vertx-redis/redis_client.rb', line 125

    def bitpos_from(key=nil,bit=nil,start=nil)
      if key.class == String && bit.class == Fixnum && start.class == Fixnum && block_given?
        return ::Vertx::Util::Utils.safe_create(@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) })),::VertxRedis::RedisClient)
      end
      raise ArgumentError, "Invalid arguments when calling bitpos_from(key,bit,start)"
    end

### - (`::VertxRedis::RedisClient`) 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:

- (`::VertxRedis::RedisClient`)

Raises:

- (`ArgumentError`)

    141
    142
    143
    144
    145
    146
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-redis-client/src/main/resources/vertx-redis/redis_client.rb', line 141

    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?
        return ::Vertx::Util::Utils.safe_create(@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) })),::VertxRedis::RedisClient)
      end
      raise ArgumentError, "Invalid arguments when calling bitpos_range(key,bit,start,stop)"
    end

### - (`::VertxRedis::RedisClient`) 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:

- (`::VertxRedis::RedisClient`)

Raises:

- (`ArgumentError`)

    152
    153
    154
    155
    156
    157
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-redis-client/src/main/resources/vertx-redis/redis_client.rb', line 152

    def blpop(key=nil,seconds=nil)
      if key.class == String && seconds.class == Fixnum && block_given?
        return ::Vertx::Util::Utils.safe_create(@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) })),::VertxRedis::RedisClient)
      end
      raise ArgumentError, "Invalid arguments when calling blpop(key,seconds)"
    end

### - (`::VertxRedis::RedisClient`) 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:

- (`::VertxRedis::RedisClient`)

Raises:

- (`ArgumentError`)

    163
    164
    165
    166
    167
    168
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-redis-client/src/main/resources/vertx-redis/redis_client.rb', line 163

    def blpop_many(keys=nil,seconds=nil)
      if keys.class == Array && seconds.class == Fixnum && block_given?
        return ::Vertx::Util::Utils.safe_create(@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) })),::VertxRedis::RedisClient)
      end
      raise ArgumentError, "Invalid arguments when calling blpop_many(keys,seconds)"
    end

### - (`::VertxRedis::RedisClient`) 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:

- (`::VertxRedis::RedisClient`)

Raises:

- (`ArgumentError`)

    174
    175
    176
    177
    178
    179
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-redis-client/src/main/resources/vertx-redis/redis_client.rb', line 174

    def brpop(key=nil,seconds=nil)
      if key.class == String && seconds.class == Fixnum && block_given?
        return ::Vertx::Util::Utils.safe_create(@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) })),::VertxRedis::RedisClient)
      end
      raise ArgumentError, "Invalid arguments when calling brpop(key,seconds)"
    end

### - (`::VertxRedis::RedisClient`) 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:

- (`::VertxRedis::RedisClient`)

Raises:

- (`ArgumentError`)

    185
    186
    187
    188
    189
    190
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-redis-client/src/main/resources/vertx-redis/redis_client.rb', line 185

    def brpop_many(keys=nil,seconds=nil)
      if keys.class == Array && seconds.class == Fixnum && block_given?
        return ::Vertx::Util::Utils.safe_create(@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) })),::VertxRedis::RedisClient)
      end
      raise ArgumentError, "Invalid arguments when calling brpop_many(keys,seconds)"
    end

### - (`::VertxRedis::RedisClient`) 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:

- (`::VertxRedis::RedisClient`)

Raises:

- (`ArgumentError`)

    197
    198
    199
    200
    201
    202
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-redis-client/src/main/resources/vertx-redis/redis_client.rb', line 197

    def brpoplpush(key=nil,destkey=nil,seconds=nil)
      if key.class == String && destkey.class == String && seconds.class == Fixnum && block_given?
        return ::Vertx::Util::Utils.safe_create(@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) })),::VertxRedis::RedisClient)
      end
      raise ArgumentError, "Invalid arguments when calling brpoplpush(key,destkey,seconds)"
    end

### - (`::VertxRedis::RedisClient`) client_getname { ... }

Get the current connection name

Yields:

Returns:

- (`::VertxRedis::RedisClient`)

Raises:

- (`ArgumentError`)

    225
    226
    227
    228
    229
    230
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-redis-client/src/main/resources/vertx-redis/redis_client.rb', line 225

    def client_getname
      if block_given?
        return ::Vertx::Util::Utils.safe_create(@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) })),::VertxRedis::RedisClient)
      end
      raise ArgumentError, "Invalid arguments when calling client_getname()"
    end

### - (`::VertxRedis::RedisClient`) 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:

- (`::VertxRedis::RedisClient`)

Raises:

- (`ArgumentError`)

    207
    208
    209
    210
    211
    212
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-redis-client/src/main/resources/vertx-redis/redis_client.rb', line 207

    def client_kill(filter=nil)
      if filter.class == Hash && block_given?
        return ::Vertx::Util::Utils.safe_create(@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) })),::VertxRedis::RedisClient)
      end
      raise ArgumentError, "Invalid arguments when calling client_kill(filter)"
    end

### - (`::VertxRedis::RedisClient`) client_list { ... }

Get the list of client connections

Yields:

Returns:

- (`::VertxRedis::RedisClient`)

Raises:

- (`ArgumentError`)

    216
    217
    218
    219
    220
    221
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-redis-client/src/main/resources/vertx-redis/redis_client.rb', line 216

    def client_list
      if block_given?
        return ::Vertx::Util::Utils.safe_create(@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) })),::VertxRedis::RedisClient)
      end
      raise ArgumentError, "Invalid arguments when calling client_list()"
    end

### - (`::VertxRedis::RedisClient`) 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:

- (`::VertxRedis::RedisClient`)

Raises:

- (`ArgumentError`)

    235
    236
    237
    238
    239
    240
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-redis-client/src/main/resources/vertx-redis/redis_client.rb', line 235

    def client_pause(millis=nil)
      if millis.class == Fixnum && block_given?
        return ::Vertx::Util::Utils.safe_create(@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) })),::VertxRedis::RedisClient)
      end
      raise ArgumentError, "Invalid arguments when calling client_pause(millis)"
    end

### - (`::VertxRedis::RedisClient`) 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:

- (`::VertxRedis::RedisClient`)

Raises:

- (`ArgumentError`)

    245
    246
    247
    248
    249
    250
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-redis-client/src/main/resources/vertx-redis/redis_client.rb', line 245

    def client_setname(name=nil)
      if name.class == String && block_given?
        return ::Vertx::Util::Utils.safe_create(@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) })),::VertxRedis::RedisClient)
      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`)

    27
    28
    29
    30
    31
    32
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-redis-client/src/main/resources/vertx-redis/redis_client.rb', line 27

    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

### - (`::VertxRedis::RedisClient`) cluster_slots { ... }

Get array of Cluster slot to node mappings

Yields:

Returns:

- (`::VertxRedis::RedisClient`)

Raises:

- (`ArgumentError`)

    254
    255
    256
    257
    258
    259
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-redis-client/src/main/resources/vertx-redis/redis_client.rb', line 254

    def cluster_slots
      if block_given?
        return ::Vertx::Util::Utils.safe_create(@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) })),::VertxRedis::RedisClient)
      end
      raise ArgumentError, "Invalid arguments when calling cluster_slots()"
    end

### - (`::VertxRedis::RedisClient`) command { ... }

Get array of Redis command details

Yields:

Returns:

- (`::VertxRedis::RedisClient`)

Raises:

- (`ArgumentError`)

    263
    264
    265
    266
    267
    268
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-redis-client/src/main/resources/vertx-redis/redis_client.rb', line 263

    def command
      if block_given?
        return ::Vertx::Util::Utils.safe_create(@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) })),::VertxRedis::RedisClient)
      end
      raise ArgumentError, "Invalid arguments when calling command()"
    end

### - (`::VertxRedis::RedisClient`) command_count { ... }

Get total number of Redis commands

Yields:

Returns:

- (`::VertxRedis::RedisClient`)

Raises:

- (`ArgumentError`)

    272
    273
    274
    275
    276
    277
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-redis-client/src/main/resources/vertx-redis/redis_client.rb', line 272

    def command_count
      if block_given?
        return ::Vertx::Util::Utils.safe_create(@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) })),::VertxRedis::RedisClient)
      end
      raise ArgumentError, "Invalid arguments when calling command_count()"
    end

### - (`::VertxRedis::RedisClient`) command_getkeys { ... }

Extract keys given a full Redis command

Yields:

Returns:

- (`::VertxRedis::RedisClient`)

Raises:

- (`ArgumentError`)

    281
    282
    283
    284
    285
    286
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-redis-client/src/main/resources/vertx-redis/redis_client.rb', line 281

    def command_getkeys
      if block_given?
        return ::Vertx::Util::Utils.safe_create(@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) })),::VertxRedis::RedisClient)
      end
      raise ArgumentError, "Invalid arguments when calling command_getkeys()"
    end

### - (`::VertxRedis::RedisClient`) 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:

- (`::VertxRedis::RedisClient`)

Raises:

- (`ArgumentError`)

    291
    292
    293
    294
    295
    296
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-redis-client/src/main/resources/vertx-redis/redis_client.rb', line 291

    def command_info(commands=nil)
      if commands.class == Array && block_given?
        return ::Vertx::Util::Utils.safe_create(@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) })),::VertxRedis::RedisClient)
      end
      raise ArgumentError, "Invalid arguments when calling command_info(commands)"
    end

### - (`::VertxRedis::RedisClient`) 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:

- (`::VertxRedis::RedisClient`)

Raises:

- (`ArgumentError`)

    301
    302
    303
    304
    305
    306
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-redis-client/src/main/resources/vertx-redis/redis_client.rb', line 301

    def config_get(parameter=nil)
      if parameter.class == String && block_given?
        return ::Vertx::Util::Utils.safe_create(@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) })),::VertxRedis::RedisClient)
      end
      raise ArgumentError, "Invalid arguments when calling config_get(parameter)"
    end

### - (`::VertxRedis::RedisClient`) config_resetstat { ... }

Reset the stats returned by INFO

Yields:

Returns:

- (`::VertxRedis::RedisClient`)

Raises:

- (`ArgumentError`)

    330
    331
    332
    333
    334
    335
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-redis-client/src/main/resources/vertx-redis/redis_client.rb', line 330

    def config_resetstat
      if block_given?
        return ::Vertx::Util::Utils.safe_create(@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) })),::VertxRedis::RedisClient)
      end
      raise ArgumentError, "Invalid arguments when calling config_resetstat()"
    end

### - (`::VertxRedis::RedisClient`) config_rewrite { ... }

Rewrite the configuration file with the in memory configuration

Yields:

Returns:

- (`::VertxRedis::RedisClient`)

Raises:

- (`ArgumentError`)

    310
    311
    312
    313
    314
    315
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-redis-client/src/main/resources/vertx-redis/redis_client.rb', line 310

    def config_rewrite
      if block_given?
        return ::Vertx::Util::Utils.safe_create(@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) })),::VertxRedis::RedisClient)
      end
      raise ArgumentError, "Invalid arguments when calling config_rewrite()"
    end

### - (`::VertxRedis::RedisClient`) 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:

- (`::VertxRedis::RedisClient`)

Raises:

- (`ArgumentError`)

    321
    322
    323
    324
    325
    326
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-redis-client/src/main/resources/vertx-redis/redis_client.rb', line 321

    def config_set(parameter=nil,value=nil)
      if parameter.class == String && value.class == String && block_given?
        return ::Vertx::Util::Utils.safe_create(@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) })),::VertxRedis::RedisClient)
      end
      raise ArgumentError, "Invalid arguments when calling config_set(parameter,value)"
    end

### - (`::VertxRedis::RedisClient`) dbsize { ... }

Return the number of keys in the selected database

Yields:

Returns:

- (`::VertxRedis::RedisClient`)

Raises:

- (`ArgumentError`)

    339
    340
    341
    342
    343
    344
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-redis-client/src/main/resources/vertx-redis/redis_client.rb', line 339

    def dbsize
      if block_given?
        return ::Vertx::Util::Utils.safe_create(@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) })),::VertxRedis::RedisClient)
      end
      raise ArgumentError, "Invalid arguments when calling dbsize()"
    end

### - (`::VertxRedis::RedisClient`) 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:

- (`::VertxRedis::RedisClient`)

Raises:

- (`ArgumentError`)

    349
    350
    351
    352
    353
    354
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-redis-client/src/main/resources/vertx-redis/redis_client.rb', line 349

    def debug_object(key=nil)
      if key.class == String && block_given?
        return ::Vertx::Util::Utils.safe_create(@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) })),::VertxRedis::RedisClient)
      end
      raise ArgumentError, "Invalid arguments when calling debug_object(key)"
    end

### - (`::VertxRedis::RedisClient`) debug_segfault { ... }

Make the server crash

Yields:

Returns:

- (`::VertxRedis::RedisClient`)

Raises:

- (`ArgumentError`)

    358
    359
    360
    361
    362
    363
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-redis-client/src/main/resources/vertx-redis/redis_client.rb', line 358

    def debug_segfault
      if block_given?
        return ::Vertx::Util::Utils.safe_create(@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) })),::VertxRedis::RedisClient)
      end
      raise ArgumentError, "Invalid arguments when calling debug_segfault()"
    end

### - (`::VertxRedis::RedisClient`) 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:

- (`::VertxRedis::RedisClient`)

Raises:

- (`ArgumentError`)

    368
    369
    370
    371
    372
    373
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-redis-client/src/main/resources/vertx-redis/redis_client.rb', line 368

    def decr(key=nil)
      if key.class == String && block_given?
        return ::Vertx::Util::Utils.safe_create(@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) })),::VertxRedis::RedisClient)
      end
      raise ArgumentError, "Invalid arguments when calling decr(key)"
    end

### - (`::VertxRedis::RedisClient`) 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:

- (`::VertxRedis::RedisClient`)

Raises:

- (`ArgumentError`)

    379
    380
    381
    382
    383
    384
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-redis-client/src/main/resources/vertx-redis/redis_client.rb', line 379

    def decrby(key=nil,decrement=nil)
      if key.class == String && decrement.class == Fixnum && block_given?
        return ::Vertx::Util::Utils.safe_create(@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) })),::VertxRedis::RedisClient)
      end
      raise ArgumentError, "Invalid arguments when calling decrby(key,decrement)"
    end

### - (`::VertxRedis::RedisClient`) del(keys = nil) { ... }

Delete a key

Parameters:

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

Yields:

- Handler for the result of this call.

Returns:

- (`::VertxRedis::RedisClient`)

Raises:

- (`ArgumentError`)

    389
    390
    391
    392
    393
    394
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-redis-client/src/main/resources/vertx-redis/redis_client.rb', line 389

    def del(keys=nil)
      if keys.class == Array && block_given?
        return ::Vertx::Util::Utils.safe_create(@j_del.java_method(:del, [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) })),::VertxRedis::RedisClient)
      end
      raise ArgumentError, "Invalid arguments when calling del(keys)"
    end

### - (`::VertxRedis::RedisClient`) discard { ... }

Discard all commands issued after MULTI

Yields:

Returns:

- (`::VertxRedis::RedisClient`)

Raises:

- (`ArgumentError`)

    398
    399
    400
    401
    402
    403
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-redis-client/src/main/resources/vertx-redis/redis_client.rb', line 398

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

### - (`::VertxRedis::RedisClient`) 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:

- (`::VertxRedis::RedisClient`)

Raises:

- (`ArgumentError`)

    408
    409
    410
    411
    412
    413
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-redis-client/src/main/resources/vertx-redis/redis_client.rb', line 408

    def dump(key=nil)
      if key.class == String && block_given?
        return ::Vertx::Util::Utils.safe_create(@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) })),::VertxRedis::RedisClient)
      end
      raise ArgumentError, "Invalid arguments when calling dump(key)"
    end

### - (`::VertxRedis::RedisClient`) 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:

- (`::VertxRedis::RedisClient`)

Raises:

- (`ArgumentError`)

    418
    419
    420
    421
    422
    423
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-redis-client/src/main/resources/vertx-redis/redis_client.rb', line 418

    def echo(message=nil)
      if message.class == String && block_given?
        return ::Vertx::Util::Utils.safe_create(@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) })),::VertxRedis::RedisClient)
      end
      raise ArgumentError, "Invalid arguments when calling echo(message)"
    end

### - (`::VertxRedis::RedisClient`) eval(script = nil, keys = nil, args = nil) { ... }

Execute a Lua script server side

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:

- (`::VertxRedis::RedisClient`)

Raises:

- (`ArgumentError`)

    430
    431
    432
    433
    434
    435
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-redis-client/src/main/resources/vertx-redis/redis_client.rb', line 430

    def eval(script=nil,keys=nil,args=nil)
      if script.class == String && keys.class == Array && args.class == Array && block_given?
        return ::Vertx::Util::Utils.safe_create(@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) })),::VertxRedis::RedisClient)
      end
      raise ArgumentError, "Invalid arguments when calling eval(script,keys,args)"
    end

### - (`::VertxRedis::RedisClient`) evalsha(sha1 = nil, keys = nil, values = nil) { ... }

Execute a Lua script server side

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:

- (`::VertxRedis::RedisClient`)

Raises:

- (`ArgumentError`)

    442
    443
    444
    445
    446
    447
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-redis-client/src/main/resources/vertx-redis/redis_client.rb', line 442

    def evalsha(sha1=nil,keys=nil,values=nil)
      if sha1.class == String && keys.class == Array && values.class == Array && block_given?
        return ::Vertx::Util::Utils.safe_create(@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) })),::VertxRedis::RedisClient)
      end
      raise ArgumentError, "Invalid arguments when calling evalsha(sha1,keys,values)"
    end

### - (`::VertxRedis::RedisClient`) exec { ... }

Execute all commands issued after MULTI

Yields:

Returns:

- (`::VertxRedis::RedisClient`)

Raises:

- (`ArgumentError`)

    451
    452
    453
    454
    455
    456
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-redis-client/src/main/resources/vertx-redis/redis_client.rb', line 451

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

### - (`::VertxRedis::RedisClient`) 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:

- (`::VertxRedis::RedisClient`)

Raises:

- (`ArgumentError`)

    461
    462
    463
    464
    465
    466
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-redis-client/src/main/resources/vertx-redis/redis_client.rb', line 461

    def exists(key=nil)
      if key.class == String && block_given?
        return ::Vertx::Util::Utils.safe_create(@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) })),::VertxRedis::RedisClient)
      end
      raise ArgumentError, "Invalid arguments when calling exists(key)"
    end

### - (`::VertxRedis::RedisClient`) 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:

- (`::VertxRedis::RedisClient`)

Raises:

- (`ArgumentError`)

    472
    473
    474
    475
    476
    477
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-redis-client/src/main/resources/vertx-redis/redis_client.rb', line 472

    def expire(key=nil,seconds=nil)
      if key.class == String && seconds.class == Fixnum && block_given?
        return ::Vertx::Util::Utils.safe_create(@j_del.java_method(:expire, [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) })),::VertxRedis::RedisClient)
      end
      raise ArgumentError, "Invalid arguments when calling expire(key,seconds)"
    end

### - (`::VertxRedis::RedisClient`) 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:

- (`::VertxRedis::RedisClient`)

Raises:

- (`ArgumentError`)

    483
    484
    485
    486
    487
    488
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-redis-client/src/main/resources/vertx-redis/redis_client.rb', line 483

    def expireat(key=nil,seconds=nil)
      if key.class == String && seconds.class == Fixnum && block_given?
        return ::Vertx::Util::Utils.safe_create(@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) })),::VertxRedis::RedisClient)
      end
      raise ArgumentError, "Invalid arguments when calling expireat(key,seconds)"
    end

### - (`::VertxRedis::RedisClient`) flushall { ... }

Remove all keys from all databases

Yields:

Returns:

- (`::VertxRedis::RedisClient`)

Raises:

- (`ArgumentError`)

    492
    493
    494
    495
    496
    497
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-redis-client/src/main/resources/vertx-redis/redis_client.rb', line 492

    def flushall
      if block_given?
        return ::Vertx::Util::Utils.safe_create(@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) })),::VertxRedis::RedisClient)
      end
      raise ArgumentError, "Invalid arguments when calling flushall()"
    end

### - (`::VertxRedis::RedisClient`) flushdb { ... }

Remove all keys from the current database

Yields:

Returns:

- (`::VertxRedis::RedisClient`)

Raises:

- (`ArgumentError`)

    501
    502
    503
    504
    505
    506
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-redis-client/src/main/resources/vertx-redis/redis_client.rb', line 501

    def flushdb
      if block_given?
        return ::Vertx::Util::Utils.safe_create(@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) })),::VertxRedis::RedisClient)
      end
      raise ArgumentError, "Invalid arguments when calling flushdb()"
    end

### - (`::VertxRedis::RedisClient`) 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:

- (`::VertxRedis::RedisClient`)

Raises:

- (`ArgumentError`)

    511
    512
    513
    514
    515
    516
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-redis-client/src/main/resources/vertx-redis/redis_client.rb', line 511

    def get(key=nil)
      if key.class == String && block_given?
        return ::Vertx::Util::Utils.safe_create(@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) })),::VertxRedis::RedisClient)
      end
      raise ArgumentError, "Invalid arguments when calling get(key)"
    end

### - (`::VertxRedis::RedisClient`) 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:

- (`::VertxRedis::RedisClient`)

Raises:

- (`ArgumentError`)

    521
    522
    523
    524
    525
    526
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-redis-client/src/main/resources/vertx-redis/redis_client.rb', line 521

    def get_binary(key=nil)
      if key.class == String && block_given?
        return ::Vertx::Util::Utils.safe_create(@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 ? ar.result : nil) })),::VertxRedis::RedisClient)
      end
      raise ArgumentError, "Invalid arguments when calling get_binary(key)"
    end

### - (`::VertxRedis::RedisClient`) 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:

- (`::VertxRedis::RedisClient`)

Raises:

- (`ArgumentError`)

    532
    533
    534
    535
    536
    537
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-redis-client/src/main/resources/vertx-redis/redis_client.rb', line 532

    def getbit(key=nil,offset=nil)
      if key.class == String && offset.class == Fixnum && block_given?
        return ::Vertx::Util::Utils.safe_create(@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) })),::VertxRedis::RedisClient)
      end
      raise ArgumentError, "Invalid arguments when calling getbit(key,offset)"
    end

### - (`::VertxRedis::RedisClient`) 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:

- (`::VertxRedis::RedisClient`)

Raises:

- (`ArgumentError`)

    544
    545
    546
    547
    548
    549
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-redis-client/src/main/resources/vertx-redis/redis_client.rb', line 544

    def getrange(key=nil,start=nil,_end=nil)
      if key.class == String && start.class == Fixnum && _end.class == Fixnum && block_given?
        return ::Vertx::Util::Utils.safe_create(@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) })),::VertxRedis::RedisClient)
      end
      raise ArgumentError, "Invalid arguments when calling getrange(key,start,_end)"
    end

### - (`::VertxRedis::RedisClient`) 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:

- (`::VertxRedis::RedisClient`)

Raises:

- (`ArgumentError`)

    555
    556
    557
    558
    559
    560
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-redis-client/src/main/resources/vertx-redis/redis_client.rb', line 555

    def getset(key=nil,value=nil)
      if key.class == String && value.class == String && block_given?
        return ::Vertx::Util::Utils.safe_create(@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) })),::VertxRedis::RedisClient)
      end
      raise ArgumentError, "Invalid arguments when calling getset(key,value)"
    end

### - (`::VertxRedis::RedisClient`) 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:

- (`::VertxRedis::RedisClient`)

Raises:

- (`ArgumentError`)

    566
    567
    568
    569
    570
    571
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-redis-client/src/main/resources/vertx-redis/redis_client.rb', line 566

    def hdel(key=nil,field=nil)
      if key.class == String && field.class == String && block_given?
        return ::Vertx::Util::Utils.safe_create(@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) })),::VertxRedis::RedisClient)
      end
      raise ArgumentError, "Invalid arguments when calling hdel(key,field)"
    end

### - (`::VertxRedis::RedisClient`) 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:

- (`::VertxRedis::RedisClient`)

Raises:

- (`ArgumentError`)

    577
    578
    579
    580
    581
    582
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-redis-client/src/main/resources/vertx-redis/redis_client.rb', line 577

    def hdel_many(key=nil,fields=nil)
      if key.class == String && fields.class == Array && block_given?
        return ::Vertx::Util::Utils.safe_create(@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) })),::VertxRedis::RedisClient)
      end
      raise ArgumentError, "Invalid arguments when calling hdel_many(key,fields)"
    end

### - (`::VertxRedis::RedisClient`) 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:

- (`::VertxRedis::RedisClient`)

Raises:

- (`ArgumentError`)

    588
    589
    590
    591
    592
    593
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-redis-client/src/main/resources/vertx-redis/redis_client.rb', line 588

    def hexists(key=nil,field=nil)
      if key.class == String && field.class == String && block_given?
        return ::Vertx::Util::Utils.safe_create(@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) })),::VertxRedis::RedisClient)
      end
      raise ArgumentError, "Invalid arguments when calling hexists(key,field)"
    end

### - (`::VertxRedis::RedisClient`) 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:

- (`::VertxRedis::RedisClient`)

Raises:

- (`ArgumentError`)

    599
    600
    601
    602
    603
    604
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-redis-client/src/main/resources/vertx-redis/redis_client.rb', line 599

    def hget(key=nil,field=nil)
      if key.class == String && field.class == String && block_given?
        return ::Vertx::Util::Utils.safe_create(@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) })),::VertxRedis::RedisClient)
      end
      raise ArgumentError, "Invalid arguments when calling hget(key,field)"
    end

### - (`::VertxRedis::RedisClient`) 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:

- (`::VertxRedis::RedisClient`)

Raises:

- (`ArgumentError`)

    609
    610
    611
    612
    613
    614
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-redis-client/src/main/resources/vertx-redis/redis_client.rb', line 609

    def hgetall(key=nil)
      if key.class == String && block_given?
        return ::Vertx::Util::Utils.safe_create(@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) })),::VertxRedis::RedisClient)
      end
      raise ArgumentError, "Invalid arguments when calling hgetall(key)"
    end

### - (`::VertxRedis::RedisClient`) 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:

- (`::VertxRedis::RedisClient`)

Raises:

- (`ArgumentError`)

    621
    622
    623
    624
    625
    626
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-redis-client/src/main/resources/vertx-redis/redis_client.rb', line 621

    def hincrby(key=nil,field=nil,increment=nil)
      if key.class == String && field.class == String && increment.class == Fixnum && block_given?
        return ::Vertx::Util::Utils.safe_create(@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) })),::VertxRedis::RedisClient)
      end
      raise ArgumentError, "Invalid arguments when calling hincrby(key,field,increment)"
    end

### - (`::VertxRedis::RedisClient`) 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:

- (`::VertxRedis::RedisClient`)

Raises:

- (`ArgumentError`)

    633
    634
    635
    636
    637
    638
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-redis-client/src/main/resources/vertx-redis/redis_client.rb', line 633

    def hincrbyfloat(key=nil,field=nil,increment=nil)
      if key.class == String && field.class == String && increment.class == Float && block_given?
        return ::Vertx::Util::Utils.safe_create(@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) })),::VertxRedis::RedisClient)
      end
      raise ArgumentError, "Invalid arguments when calling hincrbyfloat(key,field,increment)"
    end

### - (`::VertxRedis::RedisClient`) 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:

- (`::VertxRedis::RedisClient`)

Raises:

- (`ArgumentError`)

    643
    644
    645
    646
    647
    648
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-redis-client/src/main/resources/vertx-redis/redis_client.rb', line 643

    def hkeys(key=nil)
      if key.class == String && block_given?
        return ::Vertx::Util::Utils.safe_create(@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) })),::VertxRedis::RedisClient)
      end
      raise ArgumentError, "Invalid arguments when calling hkeys(key)"
    end

### - (`::VertxRedis::RedisClient`) 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:

- (`::VertxRedis::RedisClient`)

Raises:

- (`ArgumentError`)

    653
    654
    655
    656
    657
    658
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-redis-client/src/main/resources/vertx-redis/redis_client.rb', line 653

    def hlen(key=nil)
      if key.class == String && block_given?
        return ::Vertx::Util::Utils.safe_create(@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) })),::VertxRedis::RedisClient)
      end
      raise ArgumentError, "Invalid arguments when calling hlen(key)"
    end

### - (`::VertxRedis::RedisClient`) 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:

- (`::VertxRedis::RedisClient`)

Raises:

- (`ArgumentError`)

    664
    665
    666
    667
    668
    669
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-redis-client/src/main/resources/vertx-redis/redis_client.rb', line 664

    def hmget(key=nil,fields=nil)
      if key.class == String && fields.class == Array && block_given?
        return ::Vertx::Util::Utils.safe_create(@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) })),::VertxRedis::RedisClient)
      end
      raise ArgumentError, "Invalid arguments when calling hmget(key,fields)"
    end

### - (`::VertxRedis::RedisClient`) hmset(key = nil, values = nil) { ... }

Set multiple hash fields to multiple values

Parameters:

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

Yields:

- Handler for the result of this call.

Returns:

- (`::VertxRedis::RedisClient`)

Raises:

- (`ArgumentError`)

    675
    676
    677
    678
    679
    680
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-redis-client/src/main/resources/vertx-redis/redis_client.rb', line 675

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

### - (`::VertxRedis::RedisClient`) 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:

- (`::VertxRedis::RedisClient`)

Raises:

- (`ArgumentError`)

    2102
    2103
    2104
    2105
    2106
    2107
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-redis-client/src/main/resources/vertx-redis/redis_client.rb', line 2102

    def hscan(key=nil,cursor=nil,options=nil)
      if key.class == String && cursor.class == String && options.class == Hash && block_given?
        return ::Vertx::Util::Utils.safe_create(@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) })),::VertxRedis::RedisClient)
      end
      raise ArgumentError, "Invalid arguments when calling hscan(key,cursor,options)"
    end

### - (`::VertxRedis::RedisClient`) 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:

- (`::VertxRedis::RedisClient`)

Raises:

- (`ArgumentError`)

    687
    688
    689
    690
    691
    692
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-redis-client/src/main/resources/vertx-redis/redis_client.rb', line 687

    def hset(key=nil,field=nil,value=nil)
      if key.class == String && field.class == String && value.class == String && block_given?
        return ::Vertx::Util::Utils.safe_create(@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) })),::VertxRedis::RedisClient)
      end
      raise ArgumentError, "Invalid arguments when calling hset(key,field,value)"
    end

### - (`::VertxRedis::RedisClient`) 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:

- (`::VertxRedis::RedisClient`)

Raises:

- (`ArgumentError`)

    699
    700
    701
    702
    703
    704
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-redis-client/src/main/resources/vertx-redis/redis_client.rb', line 699

    def hsetnx(key=nil,field=nil,value=nil)
      if key.class == String && field.class == String && value.class == String && block_given?
        return ::Vertx::Util::Utils.safe_create(@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) })),::VertxRedis::RedisClient)
      end
      raise ArgumentError, "Invalid arguments when calling hsetnx(key,field,value)"
    end

### - (`::VertxRedis::RedisClient`) 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:

- (`::VertxRedis::RedisClient`)

Raises:

- (`ArgumentError`)

    709
    710
    711
    712
    713
    714
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-redis-client/src/main/resources/vertx-redis/redis_client.rb', line 709

    def hvals(key=nil)
      if key.class == String && block_given?
        return ::Vertx::Util::Utils.safe_create(@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) })),::VertxRedis::RedisClient)
      end
      raise ArgumentError, "Invalid arguments when calling hvals(key)"
    end

### - (`::VertxRedis::RedisClient`) 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:

- (`::VertxRedis::RedisClient`)

Raises:

- (`ArgumentError`)

    719
    720
    721
    722
    723
    724
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-redis-client/src/main/resources/vertx-redis/redis_client.rb', line 719

    def incr(key=nil)
      if key.class == String && block_given?
        return ::Vertx::Util::Utils.safe_create(@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) })),::VertxRedis::RedisClient)
      end
      raise ArgumentError, "Invalid arguments when calling incr(key)"
    end

### - (`::VertxRedis::RedisClient`) 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:

- (`::VertxRedis::RedisClient`)

Raises:

- (`ArgumentError`)

    730
    731
    732
    733
    734
    735
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-redis-client/src/main/resources/vertx-redis/redis_client.rb', line 730

    def incrby(key=nil,increment=nil)
      if key.class == String && increment.class == Fixnum && block_given?
        return ::Vertx::Util::Utils.safe_create(@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) })),::VertxRedis::RedisClient)
      end
      raise ArgumentError, "Invalid arguments when calling incrby(key,increment)"
    end

### - (`::VertxRedis::RedisClient`) 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:

- (`::VertxRedis::RedisClient`)

Raises:

- (`ArgumentError`)

    741
    742
    743
    744
    745
    746
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-redis-client/src/main/resources/vertx-redis/redis_client.rb', line 741

    def incrbyfloat(key=nil,increment=nil)
      if key.class == String && increment.class == Float && block_given?
        return ::Vertx::Util::Utils.safe_create(@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) })),::VertxRedis::RedisClient)
      end
      raise ArgumentError, "Invalid arguments when calling incrbyfloat(key,increment)"
    end

### - (`::VertxRedis::RedisClient`) info { ... }

Get information and statistics about the server

Yields:

- Handler for the result of this call.

Returns:

- (`::VertxRedis::RedisClient`)

Raises:

- (`ArgumentError`)

    750
    751
    752
    753
    754
    755
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-redis-client/src/main/resources/vertx-redis/redis_client.rb', line 750

    def info
      if block_given?
        return ::Vertx::Util::Utils.safe_create(@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) })),::VertxRedis::RedisClient)
      end
      raise ArgumentError, "Invalid arguments when calling info()"
    end

### - (`::VertxRedis::RedisClient`) 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:

- (`::VertxRedis::RedisClient`)

Raises:

- (`ArgumentError`)

    760
    761
    762
    763
    764
    765
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-redis-client/src/main/resources/vertx-redis/redis_client.rb', line 760

    def info_section(section=nil)
      if section.class == String && block_given?
        return ::Vertx::Util::Utils.safe_create(@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) })),::VertxRedis::RedisClient)
      end
      raise ArgumentError, "Invalid arguments when calling info_section(section)"
    end

### - (`::VertxRedis::RedisClient`) 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:

- (`::VertxRedis::RedisClient`)

Raises:

- (`ArgumentError`)

    770
    771
    772
    773
    774
    775
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-redis-client/src/main/resources/vertx-redis/redis_client.rb', line 770

    def keys(pattern=nil)
      if pattern.class == String && block_given?
        return ::Vertx::Util::Utils.safe_create(@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) })),::VertxRedis::RedisClient)
      end
      raise ArgumentError, "Invalid arguments when calling keys(pattern)"
    end

### - (`::VertxRedis::RedisClient`) lastsave { ... }

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

Yields:

Returns:

- (`::VertxRedis::RedisClient`)

Raises:

- (`ArgumentError`)

    779
    780
    781
    782
    783
    784
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-redis-client/src/main/resources/vertx-redis/redis_client.rb', line 779

    def lastsave
      if block_given?
        return ::Vertx::Util::Utils.safe_create(@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) })),::VertxRedis::RedisClient)
      end
      raise ArgumentError, "Invalid arguments when calling lastsave()"
    end

### - (`::VertxRedis::RedisClient`) 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:

- (`::VertxRedis::RedisClient`)

Raises:

- (`ArgumentError`)

    790
    791
    792
    793
    794
    795
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-redis-client/src/main/resources/vertx-redis/redis_client.rb', line 790

    def lindex(key=nil,index=nil)
      if key.class == String && index.class == Fixnum && block_given?
        return ::Vertx::Util::Utils.safe_create(@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) })),::VertxRedis::RedisClient)
      end
      raise ArgumentError, "Invalid arguments when calling lindex(key,index)"
    end

### - (`::VertxRedis::RedisClient`) 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:

- (`::VertxRedis::RedisClient`)

Raises:

- (`ArgumentError`)

    803
    804
    805
    806
    807
    808
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-redis-client/src/main/resources/vertx-redis/redis_client.rb', line 803

    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?
        return ::Vertx::Util::Utils.safe_create(@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),pivot,value,(Proc.new { |ar| yield(ar.failed ? ar.cause : nil, ar.succeeded ? ar.result : nil) })),::VertxRedis::RedisClient)
      end
      raise ArgumentError, "Invalid arguments when calling linsert(key,option,pivot,value)"
    end

### - (`::VertxRedis::RedisClient`) 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:

- (`::VertxRedis::RedisClient`)

Raises:

- (`ArgumentError`)

    813
    814
    815
    816
    817
    818
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-redis-client/src/main/resources/vertx-redis/redis_client.rb', line 813

    def llen(key=nil)
      if key.class == String && block_given?
        return ::Vertx::Util::Utils.safe_create(@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) })),::VertxRedis::RedisClient)
      end
      raise ArgumentError, "Invalid arguments when calling llen(key)"
    end

### - (`::VertxRedis::RedisClient`) 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:

- (`::VertxRedis::RedisClient`)

Raises:

- (`ArgumentError`)

    823
    824
    825
    826
    827
    828
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-redis-client/src/main/resources/vertx-redis/redis_client.rb', line 823

    def lpop(key=nil)
      if key.class == String && block_given?
        return ::Vertx::Util::Utils.safe_create(@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) })),::VertxRedis::RedisClient)
      end
      raise ArgumentError, "Invalid arguments when calling lpop(key)"
    end

### - (`::VertxRedis::RedisClient`) 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:

- (`::VertxRedis::RedisClient`)

Raises:

- (`ArgumentError`)

    845
    846
    847
    848
    849
    850
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-redis-client/src/main/resources/vertx-redis/redis_client.rb', line 845

    def lpush(key=nil,value=nil)
      if key.class == String && value.class == String && block_given?
        return ::Vertx::Util::Utils.safe_create(@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) })),::VertxRedis::RedisClient)
      end
      raise ArgumentError, "Invalid arguments when calling lpush(key,value)"
    end

### - (`::VertxRedis::RedisClient`) 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:

- (`::VertxRedis::RedisClient`)

Raises:

- (`ArgumentError`)

    834
    835
    836
    837
    838
    839
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-redis-client/src/main/resources/vertx-redis/redis_client.rb', line 834

    def lpush_many(key=nil,values=nil)
      if key.class == String && values.class == Array && block_given?
        return ::Vertx::Util::Utils.safe_create(@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) })),::VertxRedis::RedisClient)
      end
      raise ArgumentError, "Invalid arguments when calling lpush_many(key,values)"
    end

### - (`::VertxRedis::RedisClient`) 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:

- (`::VertxRedis::RedisClient`)

Raises:

- (`ArgumentError`)

    856
    857
    858
    859
    860
    861
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-redis-client/src/main/resources/vertx-redis/redis_client.rb', line 856

    def lpushx(key=nil,value=nil)
      if key.class == String && value.class == String && block_given?
        return ::Vertx::Util::Utils.safe_create(@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) })),::VertxRedis::RedisClient)
      end
      raise ArgumentError, "Invalid arguments when calling lpushx(key,value)"
    end

### - (`::VertxRedis::RedisClient`) 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:

- (`::VertxRedis::RedisClient`)

Raises:

- (`ArgumentError`)

    868
    869
    870
    871
    872
    873
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-redis-client/src/main/resources/vertx-redis/redis_client.rb', line 868

    def lrange(key=nil,from=nil,to=nil)
      if key.class == String && from.class == Fixnum && to.class == Fixnum && block_given?
        return ::Vertx::Util::Utils.safe_create(@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) })),::VertxRedis::RedisClient)
      end
      raise ArgumentError, "Invalid arguments when calling lrange(key,from,to)"
    end

### - (`::VertxRedis::RedisClient`) 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:

- (`::VertxRedis::RedisClient`)

Raises:

- (`ArgumentError`)

    880
    881
    882
    883
    884
    885
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-redis-client/src/main/resources/vertx-redis/redis_client.rb', line 880

    def lrem(key=nil,count=nil,value=nil)
      if key.class == String && count.class == Fixnum && value.class == String && block_given?
        return ::Vertx::Util::Utils.safe_create(@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) })),::VertxRedis::RedisClient)
      end
      raise ArgumentError, "Invalid arguments when calling lrem(key,count,value)"
    end

### - (`::VertxRedis::RedisClient`) 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:

- (`::VertxRedis::RedisClient`)

Raises:

- (`ArgumentError`)

    892
    893
    894
    895
    896
    897
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-redis-client/src/main/resources/vertx-redis/redis_client.rb', line 892

    def lset(key=nil,index=nil,value=nil)
      if key.class == String && index.class == Fixnum && value.class == String && block_given?
        return ::Vertx::Util::Utils.safe_create(@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) })),::VertxRedis::RedisClient)
      end
      raise ArgumentError, "Invalid arguments when calling lset(key,index,value)"
    end

### - (`::VertxRedis::RedisClient`) 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:

- (`::VertxRedis::RedisClient`)

Raises:

- (`ArgumentError`)

    904
    905
    906
    907
    908
    909
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-redis-client/src/main/resources/vertx-redis/redis_client.rb', line 904

    def ltrim(key=nil,from=nil,to=nil)
      if key.class == String && from.class == Fixnum && to.class == Fixnum && block_given?
        return ::Vertx::Util::Utils.safe_create(@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) })),::VertxRedis::RedisClient)
      end
      raise ArgumentError, "Invalid arguments when calling ltrim(key,from,to)"
    end

### - (`::VertxRedis::RedisClient`) 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:

- (`::VertxRedis::RedisClient`)

Raises:

- (`ArgumentError`)

    914
    915
    916
    917
    918
    919
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-redis-client/src/main/resources/vertx-redis/redis_client.rb', line 914

    def mget(key=nil)
      if key.class == String && block_given?
        return ::Vertx::Util::Utils.safe_create(@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) })),::VertxRedis::RedisClient)
      end
      raise ArgumentError, "Invalid arguments when calling mget(key)"
    end

### - (`::VertxRedis::RedisClient`) 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:

- (`::VertxRedis::RedisClient`)

Raises:

- (`ArgumentError`)

    924
    925
    926
    927
    928
    929
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-redis-client/src/main/resources/vertx-redis/redis_client.rb', line 924

    def mget_many(keys=nil)
      if keys.class == Array && block_given?
        return ::Vertx::Util::Utils.safe_create(@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) })),::VertxRedis::RedisClient)
      end
      raise ArgumentError, "Invalid arguments when calling mget_many(keys)"
    end

### - (`::VertxRedis::RedisClient`) 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:

- (`::VertxRedis::RedisClient`)

Raises:

- (`ArgumentError`)

    939
    940
    941
    942
    943
    944
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-redis-client/src/main/resources/vertx-redis/redis_client.rb', line 939

    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?
        return ::Vertx::Util::Utils.safe_create(@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) })),::VertxRedis::RedisClient)
      end
      raise ArgumentError, "Invalid arguments when calling migrate(host,port,key,destdb,timeout,options)"
    end

### - (`::VertxRedis::RedisClient`) monitor { ... }

Listen for all requests received by the server in real time

Yields:

Returns:

- (`::VertxRedis::RedisClient`)

Raises:

- (`ArgumentError`)

    948
    949
    950
    951
    952
    953
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-redis-client/src/main/resources/vertx-redis/redis_client.rb', line 948

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

### - (`::VertxRedis::RedisClient`) 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:

- (`::VertxRedis::RedisClient`)

Raises:

- (`ArgumentError`)

    959
    960
    961
    962
    963
    964
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-redis-client/src/main/resources/vertx-redis/redis_client.rb', line 959

    def move(key=nil,destdb=nil)
      if key.class == String && destdb.class == Fixnum && block_given?
        return ::Vertx::Util::Utils.safe_create(@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) })),::VertxRedis::RedisClient)
      end
      raise ArgumentError, "Invalid arguments when calling move(key,destdb)"
    end

### - (`::VertxRedis::RedisClient`) mset(keyvals = nil) { ... }

Set multiple keys to multiple values

Parameters:

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

Yields:

- Handler for the result of this call.

Returns:

- (`::VertxRedis::RedisClient`)

Raises:

- (`ArgumentError`)

    969
    970
    971
    972
    973
    974
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-redis-client/src/main/resources/vertx-redis/redis_client.rb', line 969

    def mset(keyvals=nil)
      if keyvals.class == Hash && block_given?
        return ::Vertx::Util::Utils.safe_create(@j_del.java_method(:mset, [Java::JavaUtil::Map.java_class,Java::IoVertxCore::Handler.java_class]).call(Hash[keyvals.map { |k,v| [k,v] }],(Proc.new { |ar| yield(ar.failed ? ar.cause : nil, ar.succeeded ? ar.result : nil) })),::VertxRedis::RedisClient)
      end
      raise ArgumentError, "Invalid arguments when calling mset(keyvals)"
    end

### - (`::VertxRedis::RedisClient`) msetnx(keyvals = nil) { ... }

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

Parameters:

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

Yields:

- Handler for the result of this call.

Returns:

- (`::VertxRedis::RedisClient`)

Raises:

- (`ArgumentError`)

    979
    980
    981
    982
    983
    984
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-redis-client/src/main/resources/vertx-redis/redis_client.rb', line 979

    def msetnx(keyvals=nil)
      if keyvals.class == Hash && block_given?
        return ::Vertx::Util::Utils.safe_create(@j_del.java_method(:msetnx, [Java::JavaUtil::Map.java_class,Java::IoVertxCore::Handler.java_class]).call(Hash[keyvals.map { |k,v| [k,v] }],(Proc.new { |ar| yield(ar.failed ? ar.cause : nil, ar.succeeded ? ar.result : nil) })),::VertxRedis::RedisClient)
      end
      raise ArgumentError, "Invalid arguments when calling msetnx(keyvals)"
    end

### - (`::VertxRedis::RedisClient`) multi { ... }

Mark the start of a transaction block

Yields:

Returns:

- (`::VertxRedis::RedisClient`)

Raises:

- (`ArgumentError`)

    988
    989
    990
    991
    992
    993
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-redis-client/src/main/resources/vertx-redis/redis_client.rb', line 988

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

### - (`::VertxRedis::RedisClient`) 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:

- (`::VertxRedis::RedisClient`)

Raises:

- (`ArgumentError`)

    999
    1000
    1001
    1002
    1003
    1004
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-redis-client/src/main/resources/vertx-redis/redis_client.rb', line 999

    def object(key=nil,cmd=nil)
      if key.class == String && cmd.class == Symbol && block_given?
        return ::Vertx::Util::Utils.safe_create(@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),(Proc.new { |ar| yield(ar.failed ? ar.cause : nil) })),::VertxRedis::RedisClient)
      end
      raise ArgumentError, "Invalid arguments when calling object(key,cmd)"
    end

### - (`::VertxRedis::RedisClient`) 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:

- (`::VertxRedis::RedisClient`)

Raises:

- (`ArgumentError`)

    1009
    1010
    1011
    1012
    1013
    1014
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-redis-client/src/main/resources/vertx-redis/redis_client.rb', line 1009

    def persist(key=nil)
      if key.class == String && block_given?
        return ::Vertx::Util::Utils.safe_create(@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) })),::VertxRedis::RedisClient)
      end
      raise ArgumentError, "Invalid arguments when calling persist(key)"
    end

### - (`::VertxRedis::RedisClient`) 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:

- (`::VertxRedis::RedisClient`)

Raises:

- (`ArgumentError`)

    1020
    1021
    1022
    1023
    1024
    1025
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-redis-client/src/main/resources/vertx-redis/redis_client.rb', line 1020

    def pexpire(key=nil,millis=nil)
      if key.class == String && millis.class == Fixnum && block_given?
        return ::Vertx::Util::Utils.safe_create(@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) })),::VertxRedis::RedisClient)
      end
      raise ArgumentError, "Invalid arguments when calling pexpire(key,millis)"
    end

### - (`::VertxRedis::RedisClient`) 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:

- (`::VertxRedis::RedisClient`)

Raises:

- (`ArgumentError`)

    1031
    1032
    1033
    1034
    1035
    1036
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-redis-client/src/main/resources/vertx-redis/redis_client.rb', line 1031

    def pexpireat(key=nil,millis=nil)
      if key.class == String && millis.class == Fixnum && block_given?
        return ::Vertx::Util::Utils.safe_create(@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) })),::VertxRedis::RedisClient)
      end
      raise ArgumentError, "Invalid arguments when calling pexpireat(key,millis)"
    end

### - (`::VertxRedis::RedisClient`) 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:

- (`::VertxRedis::RedisClient`)

Raises:

- (`ArgumentError`)

    1042
    1043
    1044
    1045
    1046
    1047
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-redis-client/src/main/resources/vertx-redis/redis_client.rb', line 1042

    def pfadd(key=nil,element=nil)
      if key.class == String && element.class == String && block_given?
        return ::Vertx::Util::Utils.safe_create(@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) })),::VertxRedis::RedisClient)
      end
      raise ArgumentError, "Invalid arguments when calling pfadd(key,element)"
    end

### - (`::VertxRedis::RedisClient`) 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:

- (`::VertxRedis::RedisClient`)

Raises:

- (`ArgumentError`)

    1053
    1054
    1055
    1056
    1057
    1058
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-redis-client/src/main/resources/vertx-redis/redis_client.rb', line 1053

    def pfadd_many(key=nil,elements=nil)
      if key.class == String && elements.class == Array && block_given?
        return ::Vertx::Util::Utils.safe_create(@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) })),::VertxRedis::RedisClient)
      end
      raise ArgumentError, "Invalid arguments when calling pfadd_many(key,elements)"
    end

### - (`::VertxRedis::RedisClient`) 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:

- (`::VertxRedis::RedisClient`)

Raises:

- (`ArgumentError`)

    1063
    1064
    1065
    1066
    1067
    1068
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-redis-client/src/main/resources/vertx-redis/redis_client.rb', line 1063

    def pfcount(key=nil)
      if key.class == String && block_given?
        return ::Vertx::Util::Utils.safe_create(@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) })),::VertxRedis::RedisClient)
      end
      raise ArgumentError, "Invalid arguments when calling pfcount(key)"
    end

### - (`::VertxRedis::RedisClient`) 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:

- (`::VertxRedis::RedisClient`)

Raises:

- (`ArgumentError`)

    1073
    1074
    1075
    1076
    1077
    1078
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-redis-client/src/main/resources/vertx-redis/redis_client.rb', line 1073

    def pfcount_many(keys=nil)
      if keys.class == Array && block_given?
        return ::Vertx::Util::Utils.safe_create(@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) })),::VertxRedis::RedisClient)
      end
      raise ArgumentError, "Invalid arguments when calling pfcount_many(keys)"
    end

### - (`::VertxRedis::RedisClient`) 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:

- (`::VertxRedis::RedisClient`)

Raises:

- (`ArgumentError`)

    1084
    1085
    1086
    1087
    1088
    1089
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-redis-client/src/main/resources/vertx-redis/redis_client.rb', line 1084

    def pfmerge(destkey=nil,keys=nil)
      if destkey.class == String && keys.class == Array && block_given?
        return ::Vertx::Util::Utils.safe_create(@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) })),::VertxRedis::RedisClient)
      end
      raise ArgumentError, "Invalid arguments when calling pfmerge(destkey,keys)"
    end

### - (`::VertxRedis::RedisClient`) ping { ... }

Ping the server

Yields:

Returns:

- (`::VertxRedis::RedisClient`)

Raises:

- (`ArgumentError`)

    1093
    1094
    1095
    1096
    1097
    1098
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-redis-client/src/main/resources/vertx-redis/redis_client.rb', line 1093

    def ping
      if block_given?
        return ::Vertx::Util::Utils.safe_create(@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) })),::VertxRedis::RedisClient)
      end
      raise ArgumentError, "Invalid arguments when calling ping()"
    end

### - (`::VertxRedis::RedisClient`) 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:

- (`::VertxRedis::RedisClient`)

Raises:

- (`ArgumentError`)

    1105
    1106
    1107
    1108
    1109
    1110
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-redis-client/src/main/resources/vertx-redis/redis_client.rb', line 1105

    def psetex(key=nil,millis=nil,value=nil)
      if key.class == String && millis.class == Fixnum && value.class == String && block_given?
        return ::Vertx::Util::Utils.safe_create(@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) })),::VertxRedis::RedisClient)
      end
      raise ArgumentError, "Invalid arguments when calling psetex(key,millis,value)"
    end

### - (`::VertxRedis::RedisClient`) 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:

- (`::VertxRedis::RedisClient`)

Raises:

- (`ArgumentError`)

    1115
    1116
    1117
    1118
    1119
    1120
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-redis-client/src/main/resources/vertx-redis/redis_client.rb', line 1115

    def psubscribe(pattern=nil)
      if pattern.class == String && block_given?
        return ::Vertx::Util::Utils.safe_create(@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) })),::VertxRedis::RedisClient)
      end
      raise ArgumentError, "Invalid arguments when calling psubscribe(pattern)"
    end

### - (`::VertxRedis::RedisClient`) 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:

- (`::VertxRedis::RedisClient`)

Raises:

- (`ArgumentError`)

    1125
    1126
    1127
    1128
    1129
    1130
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-redis-client/src/main/resources/vertx-redis/redis_client.rb', line 1125

    def psubscribe_many(patterns=nil)
      if patterns.class == Array && block_given?
        return ::Vertx::Util::Utils.safe_create(@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) })),::VertxRedis::RedisClient)
      end
      raise ArgumentError, "Invalid arguments when calling psubscribe_many(patterns)"
    end

### - (`::VertxRedis::RedisClient`) 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:

- (`::VertxRedis::RedisClient`)

Raises:

- (`ArgumentError`)

    1164
    1165
    1166
    1167
    1168
    1169
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-redis-client/src/main/resources/vertx-redis/redis_client.rb', line 1164

    def pttl(key=nil)
      if key.class == String && block_given?
        return ::Vertx::Util::Utils.safe_create(@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) })),::VertxRedis::RedisClient)
      end
      raise ArgumentError, "Invalid arguments when calling pttl(key)"
    end

### - (`::VertxRedis::RedisClient`) 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:

- (`::VertxRedis::RedisClient`)

Raises:

- (`ArgumentError`)

    1175
    1176
    1177
    1178
    1179
    1180
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-redis-client/src/main/resources/vertx-redis/redis_client.rb', line 1175

    def publish(channel=nil,message=nil)
      if channel.class == String && message.class == String && block_given?
        return ::Vertx::Util::Utils.safe_create(@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) })),::VertxRedis::RedisClient)
      end
      raise ArgumentError, "Invalid arguments when calling publish(channel,message)"
    end

### - (`::VertxRedis::RedisClient`) 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:

- (`::VertxRedis::RedisClient`)

Raises:

- (`ArgumentError`)

    1135
    1136
    1137
    1138
    1139
    1140
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-redis-client/src/main/resources/vertx-redis/redis_client.rb', line 1135

    def pubsub_channels(pattern=nil)
      if pattern.class == String && block_given?
        return ::Vertx::Util::Utils.safe_create(@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) })),::VertxRedis::RedisClient)
      end
      raise ArgumentError, "Invalid arguments when calling pubsub_channels(pattern)"
    end

### - (`::VertxRedis::RedisClient`) 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:

- (`::VertxRedis::RedisClient`)

Raises:

- (`ArgumentError`)

    1154
    1155
    1156
    1157
    1158
    1159
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-redis-client/src/main/resources/vertx-redis/redis_client.rb', line 1154

    def pubsub_numpat
      if block_given?
        return ::Vertx::Util::Utils.safe_create(@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) })),::VertxRedis::RedisClient)
      end
      raise ArgumentError, "Invalid arguments when calling pubsub_numpat()"
    end

### - (`::VertxRedis::RedisClient`) 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:

- (`::VertxRedis::RedisClient`)

Raises:

- (`ArgumentError`)

    1145
    1146
    1147
    1148
    1149
    1150
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-redis-client/src/main/resources/vertx-redis/redis_client.rb', line 1145

    def pubsub_numsub(channels=nil)
      if channels.class == Array && block_given?
        return ::Vertx::Util::Utils.safe_create(@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) })),::VertxRedis::RedisClient)
      end
      raise ArgumentError, "Invalid arguments when calling pubsub_numsub(channels)"
    end

### - (`::VertxRedis::RedisClient`) 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:

- (`::VertxRedis::RedisClient`)

Raises:

- (`ArgumentError`)

    1185
    1186
    1187
    1188
    1189
    1190
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-redis-client/src/main/resources/vertx-redis/redis_client.rb', line 1185

    def punsubscribe(patterns=nil)
      if patterns.class == Array && block_given?
        return ::Vertx::Util::Utils.safe_create(@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) })),::VertxRedis::RedisClient)
      end
      raise ArgumentError, "Invalid arguments when calling punsubscribe(patterns)"
    end

### - (`::VertxRedis::RedisClient`) randomkey { ... }

Return a random key from the keyspace

Yields:

Returns:

- (`::VertxRedis::RedisClient`)

Raises:

- (`ArgumentError`)

    1194
    1195
    1196
    1197
    1198
    1199
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-redis-client/src/main/resources/vertx-redis/redis_client.rb', line 1194

    def randomkey
      if block_given?
        return ::Vertx::Util::Utils.safe_create(@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) })),::VertxRedis::RedisClient)
      end
      raise ArgumentError, "Invalid arguments when calling randomkey()"
    end

### - (`::VertxRedis::RedisClient`) 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:

- (`::VertxRedis::RedisClient`)

Raises:

- (`ArgumentError`)

    1205
    1206
    1207
    1208
    1209
    1210
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-redis-client/src/main/resources/vertx-redis/redis_client.rb', line 1205

    def rename(key=nil,newkey=nil)
      if key.class == String && newkey.class == String && block_given?
        return ::Vertx::Util::Utils.safe_create(@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) })),::VertxRedis::RedisClient)
      end
      raise ArgumentError, "Invalid arguments when calling rename(key,newkey)"
    end

### - (`::VertxRedis::RedisClient`) 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:

- (`::VertxRedis::RedisClient`)

Raises:

- (`ArgumentError`)

    1216
    1217
    1218
    1219
    1220
    1221
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-redis-client/src/main/resources/vertx-redis/redis_client.rb', line 1216

    def renamenx(key=nil,newkey=nil)
      if key.class == String && newkey.class == String && block_given?
        return ::Vertx::Util::Utils.safe_create(@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) })),::VertxRedis::RedisClient)
      end
      raise ArgumentError, "Invalid arguments when calling renamenx(key,newkey)"
    end

### - (`::VertxRedis::RedisClient`) 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:

- (`::VertxRedis::RedisClient`)

Raises:

- (`ArgumentError`)

    1228
    1229
    1230
    1231
    1232
    1233
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-redis-client/src/main/resources/vertx-redis/redis_client.rb', line 1228

    def restore(key=nil,millis=nil,serialized=nil)
      if key.class == String && millis.class == Fixnum && serialized.class == String && block_given?
        return ::Vertx::Util::Utils.safe_create(@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) })),::VertxRedis::RedisClient)
      end
      raise ArgumentError, "Invalid arguments when calling restore(key,millis,serialized)"
    end

### - (`::VertxRedis::RedisClient`) role { ... }

Return the role of the instance in the context of replication

Yields:

Returns:

- (`::VertxRedis::RedisClient`)

Raises:

- (`ArgumentError`)

    1237
    1238
    1239
    1240
    1241
    1242
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-redis-client/src/main/resources/vertx-redis/redis_client.rb', line 1237

    def role
      if block_given?
        return ::Vertx::Util::Utils.safe_create(@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) })),::VertxRedis::RedisClient)
      end
      raise ArgumentError, "Invalid arguments when calling role()"
    end

### - (`::VertxRedis::RedisClient`) 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:

- (`::VertxRedis::RedisClient`)

Raises:

- (`ArgumentError`)

    1247
    1248
    1249
    1250
    1251
    1252
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-redis-client/src/main/resources/vertx-redis/redis_client.rb', line 1247

    def rpop(key=nil)
      if key.class == String && block_given?
        return ::Vertx::Util::Utils.safe_create(@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) })),::VertxRedis::RedisClient)
      end
      raise ArgumentError, "Invalid arguments when calling rpop(key)"
    end

### - (`::VertxRedis::RedisClient`) 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:

- (`::VertxRedis::RedisClient`)

Raises:

- (`ArgumentError`)

    1258
    1259
    1260
    1261
    1262
    1263
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-redis-client/src/main/resources/vertx-redis/redis_client.rb', line 1258

    def rpoplpush(key=nil,destkey=nil)
      if key.class == String && destkey.class == String && block_given?
        return ::Vertx::Util::Utils.safe_create(@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) })),::VertxRedis::RedisClient)
      end
      raise ArgumentError, "Invalid arguments when calling rpoplpush(key,destkey)"
    end

### - (`::VertxRedis::RedisClient`) 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:

- (`::VertxRedis::RedisClient`)

Raises:

- (`ArgumentError`)

    1280
    1281
    1282
    1283
    1284
    1285
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-redis-client/src/main/resources/vertx-redis/redis_client.rb', line 1280

    def rpush(key=nil,value=nil)
      if key.class == String && value.class == String && block_given?
        return ::Vertx::Util::Utils.safe_create(@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) })),::VertxRedis::RedisClient)
      end
      raise ArgumentError, "Invalid arguments when calling rpush(key,value)"
    end

### - (`::VertxRedis::RedisClient`) 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:

- (`::VertxRedis::RedisClient`)

Raises:

- (`ArgumentError`)

    1269
    1270
    1271
    1272
    1273
    1274
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-redis-client/src/main/resources/vertx-redis/redis_client.rb', line 1269

    def rpush_many(key=nil,values=nil)
      if key.class == String && values.class == Array && block_given?
        return ::Vertx::Util::Utils.safe_create(@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) })),::VertxRedis::RedisClient)
      end
      raise ArgumentError, "Invalid arguments when calling rpush_many(key,values)"
    end

### - (`::VertxRedis::RedisClient`) 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:

- (`::VertxRedis::RedisClient`)

Raises:

- (`ArgumentError`)

    1291
    1292
    1293
    1294
    1295
    1296
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-redis-client/src/main/resources/vertx-redis/redis_client.rb', line 1291

    def rpushx(key=nil,value=nil)
      if key.class == String && value.class == String && block_given?
        return ::Vertx::Util::Utils.safe_create(@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) })),::VertxRedis::RedisClient)
      end
      raise ArgumentError, "Invalid arguments when calling rpushx(key,value)"
    end

### - (`::VertxRedis::RedisClient`) 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:

- (`::VertxRedis::RedisClient`)

Raises:

- (`ArgumentError`)

    1302
    1303
    1304
    1305
    1306
    1307
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-redis-client/src/main/resources/vertx-redis/redis_client.rb', line 1302

    def sadd(key=nil,member=nil)
      if key.class == String && member.class == String && block_given?
        return ::Vertx::Util::Utils.safe_create(@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) })),::VertxRedis::RedisClient)
      end
      raise ArgumentError, "Invalid arguments when calling sadd(key,member)"
    end

### - (`::VertxRedis::RedisClient`) 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:

- (`::VertxRedis::RedisClient`)

Raises:

- (`ArgumentError`)

    1313
    1314
    1315
    1316
    1317
    1318
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-redis-client/src/main/resources/vertx-redis/redis_client.rb', line 1313

    def sadd_many(key=nil,members=nil)
      if key.class == String && members.class == Array && block_given?
        return ::Vertx::Util::Utils.safe_create(@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) })),::VertxRedis::RedisClient)
      end
      raise ArgumentError, "Invalid arguments when calling sadd_many(key,members)"
    end

### - (`::VertxRedis::RedisClient`) save { ... }

Synchronously save the dataset to disk

Yields:

Returns:

- (`::VertxRedis::RedisClient`)

Raises:

- (`ArgumentError`)

    1322
    1323
    1324
    1325
    1326
    1327
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-redis-client/src/main/resources/vertx-redis/redis_client.rb', line 1322

    def save
      if block_given?
        return ::Vertx::Util::Utils.safe_create(@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) })),::VertxRedis::RedisClient)
      end
      raise ArgumentError, "Invalid arguments when calling save()"
    end

### - (`::VertxRedis::RedisClient`) 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:

- (`::VertxRedis::RedisClient`)

Raises:

- (`ArgumentError`)

    2078
    2079
    2080
    2081
    2082
    2083
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-redis-client/src/main/resources/vertx-redis/redis_client.rb', line 2078

    def scan(cursor=nil,options=nil)
      if cursor.class == String && options.class == Hash && block_given?
        return ::Vertx::Util::Utils.safe_create(@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) })),::VertxRedis::RedisClient)
      end
      raise ArgumentError, "Invalid arguments when calling scan(cursor,options)"
    end

### - (`::VertxRedis::RedisClient`) 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:

- (`::VertxRedis::RedisClient`)

Raises:

- (`ArgumentError`)

    1332
    1333
    1334
    1335
    1336
    1337
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-redis-client/src/main/resources/vertx-redis/redis_client.rb', line 1332

    def scard(key=nil)
      if key.class == String && block_given?
        return ::Vertx::Util::Utils.safe_create(@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) })),::VertxRedis::RedisClient)
      end
      raise ArgumentError, "Invalid arguments when calling scard(key)"
    end

### - (`::VertxRedis::RedisClient`) 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:

- (`::VertxRedis::RedisClient`)

Raises:

- (`ArgumentError`)

    1342
    1343
    1344
    1345
    1346
    1347
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-redis-client/src/main/resources/vertx-redis/redis_client.rb', line 1342

    def script_exists(script=nil)
      if script.class == String && block_given?
        return ::Vertx::Util::Utils.safe_create(@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) })),::VertxRedis::RedisClient)
      end
      raise ArgumentError, "Invalid arguments when calling script_exists(script)"
    end

### - (`::VertxRedis::RedisClient`) 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:

- (`::VertxRedis::RedisClient`)

Raises:

- (`ArgumentError`)

    1352
    1353
    1354
    1355
    1356
    1357
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-redis-client/src/main/resources/vertx-redis/redis_client.rb', line 1352

    def script_exists_many(scripts=nil)
      if scripts.class == Array && block_given?
        return ::Vertx::Util::Utils.safe_create(@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) })),::VertxRedis::RedisClient)
      end
      raise ArgumentError, "Invalid arguments when calling script_exists_many(scripts)"
    end

### - (`::VertxRedis::RedisClient`) script_flush { ... }

Remove all the scripts from the script cache.

Yields:

Returns:

- (`::VertxRedis::RedisClient`)

Raises:

- (`ArgumentError`)

    1361
    1362
    1363
    1364
    1365
    1366
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-redis-client/src/main/resources/vertx-redis/redis_client.rb', line 1361

    def script_flush
      if block_given?
        return ::Vertx::Util::Utils.safe_create(@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) })),::VertxRedis::RedisClient)
      end
      raise ArgumentError, "Invalid arguments when calling script_flush()"
    end

### - (`::VertxRedis::RedisClient`) script_kill { ... }

Kill the script currently in execution.

Yields:

Returns:

- (`::VertxRedis::RedisClient`)

Raises:

- (`ArgumentError`)

    1370
    1371
    1372
    1373
    1374
    1375
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-redis-client/src/main/resources/vertx-redis/redis_client.rb', line 1370

    def script_kill
      if block_given?
        return ::Vertx::Util::Utils.safe_create(@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) })),::VertxRedis::RedisClient)
      end
      raise ArgumentError, "Invalid arguments when calling script_kill()"
    end

### - (`::VertxRedis::RedisClient`) 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:

- (`::VertxRedis::RedisClient`)

Raises:

- (`ArgumentError`)

    1380
    1381
    1382
    1383
    1384
    1385
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-redis-client/src/main/resources/vertx-redis/redis_client.rb', line 1380

    def script_load(script=nil)
      if script.class == String && block_given?
        return ::Vertx::Util::Utils.safe_create(@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) })),::VertxRedis::RedisClient)
      end
      raise ArgumentError, "Invalid arguments when calling script_load(script)"
    end

### - (`::VertxRedis::RedisClient`) 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:

- (`::VertxRedis::RedisClient`)

Raises:

- (`ArgumentError`)

    1391
    1392
    1393
    1394
    1395
    1396
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-redis-client/src/main/resources/vertx-redis/redis_client.rb', line 1391

    def sdiff(key=nil,cmpkeys=nil)
      if key.class == String && cmpkeys.class == Array && block_given?
        return ::Vertx::Util::Utils.safe_create(@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) })),::VertxRedis::RedisClient)
      end
      raise ArgumentError, "Invalid arguments when calling sdiff(key,cmpkeys)"
    end

### - (`::VertxRedis::RedisClient`) 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:

- (`::VertxRedis::RedisClient`)

Raises:

- (`ArgumentError`)

    1403
    1404
    1405
    1406
    1407
    1408
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-redis-client/src/main/resources/vertx-redis/redis_client.rb', line 1403

    def sdiffstore(destkey=nil,key=nil,cmpkeys=nil)
      if destkey.class == String && key.class == String && cmpkeys.class == Array && block_given?
        return ::Vertx::Util::Utils.safe_create(@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) })),::VertxRedis::RedisClient)
      end
      raise ArgumentError, "Invalid arguments when calling sdiffstore(destkey,key,cmpkeys)"
    end

### - (`::VertxRedis::RedisClient`) 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:

- (`::VertxRedis::RedisClient`)

Raises:

- (`ArgumentError`)

    1413
    1414
    1415
    1416
    1417
    1418
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-redis-client/src/main/resources/vertx-redis/redis_client.rb', line 1413

    def select(dbindex=nil)
      if dbindex.class == Fixnum && block_given?
        return ::Vertx::Util::Utils.safe_create(@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) })),::VertxRedis::RedisClient)
      end
      raise ArgumentError, "Invalid arguments when calling select(dbindex)"
    end

### - (`::VertxRedis::RedisClient`) 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:

- (`::VertxRedis::RedisClient`)

Raises:

- (`ArgumentError`)

    1424
    1425
    1426
    1427
    1428
    1429
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-redis-client/src/main/resources/vertx-redis/redis_client.rb', line 1424

    def set(key=nil,value=nil)
      if key.class == String && value.class == String && block_given?
        return ::Vertx::Util::Utils.safe_create(@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) })),::VertxRedis::RedisClient)
      end
      raise ArgumentError, "Invalid arguments when calling set(key,value)"
    end

### - (`::VertxRedis::RedisClient`) 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 (`String`) (defaults to: `nil`) —
  New value for the key

Yields:

- Handler for the result of this call.

Returns:

- (`::VertxRedis::RedisClient`)

Raises:

- (`ArgumentError`)

    1447
    1448
    1449
    1450
    1451
    1452
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-redis-client/src/main/resources/vertx-redis/redis_client.rb', line 1447

    def set_binary(key=nil,value=nil)
      if key.class == String && value.class == String && block_given?
        return ::Vertx::Util::Utils.safe_create(@j_del.java_method(:setBinary, [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) })),::VertxRedis::RedisClient)
      end
      raise ArgumentError, "Invalid arguments when calling set_binary(key,value)"
    end

### - (`::VertxRedis::RedisClient`) 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:

- (`::VertxRedis::RedisClient`)

Raises:

- (`ArgumentError`)

    1436
    1437
    1438
    1439
    1440
    1441
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-redis-client/src/main/resources/vertx-redis/redis_client.rb', line 1436

    def set_with_options(key=nil,value=nil,options=nil)
      if key.class == String && value.class == String && options.class == Hash && block_given?
        return ::Vertx::Util::Utils.safe_create(@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) })),::VertxRedis::RedisClient)
      end
      raise ArgumentError, "Invalid arguments when calling set_with_options(key,value,options)"
    end

### - (`::VertxRedis::RedisClient`) 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:

- (`::VertxRedis::RedisClient`)

Raises:

- (`ArgumentError`)

    1459
    1460
    1461
    1462
    1463
    1464
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-redis-client/src/main/resources/vertx-redis/redis_client.rb', line 1459

    def setbit(key=nil,offset=nil,bit=nil)
      if key.class == String && offset.class == Fixnum && bit.class == Fixnum && block_given?
        return ::Vertx::Util::Utils.safe_create(@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) })),::VertxRedis::RedisClient)
      end
      raise ArgumentError, "Invalid arguments when calling setbit(key,offset,bit)"
    end

### - (`::VertxRedis::RedisClient`) 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:

- (`::VertxRedis::RedisClient`)

Raises:

- (`ArgumentError`)

    1471
    1472
    1473
    1474
    1475
    1476
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-redis-client/src/main/resources/vertx-redis/redis_client.rb', line 1471

    def setex(key=nil,seconds=nil,value=nil)
      if key.class == String && seconds.class == Fixnum && value.class == String && block_given?
        return ::Vertx::Util::Utils.safe_create(@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) })),::VertxRedis::RedisClient)
      end
      raise ArgumentError, "Invalid arguments when calling setex(key,seconds,value)"
    end

### - (`::VertxRedis::RedisClient`) 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:

- (`::VertxRedis::RedisClient`)

Raises:

- (`ArgumentError`)

    1482
    1483
    1484
    1485
    1486
    1487
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-redis-client/src/main/resources/vertx-redis/redis_client.rb', line 1482

    def setnx(key=nil,value=nil)
      if key.class == String && value.class == String && block_given?
        return ::Vertx::Util::Utils.safe_create(@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) })),::VertxRedis::RedisClient)
      end
      raise ArgumentError, "Invalid arguments when calling setnx(key,value)"
    end

### - (`::VertxRedis::RedisClient`) 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:

- (`::VertxRedis::RedisClient`)

Raises:

- (`ArgumentError`)

    1494
    1495
    1496
    1497
    1498
    1499
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-redis-client/src/main/resources/vertx-redis/redis_client.rb', line 1494

    def setrange(key=nil,offset=nil,value=nil)
      if key.class == String && offset.class == Fixnum && value.class == String && block_given?
        return ::Vertx::Util::Utils.safe_create(@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) })),::VertxRedis::RedisClient)
      end
      raise ArgumentError, "Invalid arguments when calling setrange(key,offset,value)"
    end

### - (`::VertxRedis::RedisClient`) 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:

- (`::VertxRedis::RedisClient`)

Raises:

- (`ArgumentError`)

    1504
    1505
    1506
    1507
    1508
    1509
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-redis-client/src/main/resources/vertx-redis/redis_client.rb', line 1504

    def sinter(keys=nil)
      if keys.class == Array && block_given?
        return ::Vertx::Util::Utils.safe_create(@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) })),::VertxRedis::RedisClient)
      end
      raise ArgumentError, "Invalid arguments when calling sinter(keys)"
    end

### - (`::VertxRedis::RedisClient`) 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:

- (`::VertxRedis::RedisClient`)

Raises:

- (`ArgumentError`)

    1515
    1516
    1517
    1518
    1519
    1520
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-redis-client/src/main/resources/vertx-redis/redis_client.rb', line 1515

    def sinterstore(destkey=nil,keys=nil)
      if destkey.class == String && keys.class == Array && block_given?
        return ::Vertx::Util::Utils.safe_create(@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) })),::VertxRedis::RedisClient)
      end
      raise ArgumentError, "Invalid arguments when calling sinterstore(destkey,keys)"
    end

### - (`::VertxRedis::RedisClient`) 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:

- (`::VertxRedis::RedisClient`)

Raises:

- (`ArgumentError`)

    1526
    1527
    1528
    1529
    1530
    1531
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-redis-client/src/main/resources/vertx-redis/redis_client.rb', line 1526

    def sismember(key=nil,member=nil)
      if key.class == String && member.class == String && block_given?
        return ::Vertx::Util::Utils.safe_create(@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) })),::VertxRedis::RedisClient)
      end
      raise ArgumentError, "Invalid arguments when calling sismember(key,member)"
    end

### - (`::VertxRedis::RedisClient`) 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:

- (`::VertxRedis::RedisClient`)

Raises:

- (`ArgumentError`)

    1537
    1538
    1539
    1540
    1541
    1542
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-redis-client/src/main/resources/vertx-redis/redis_client.rb', line 1537

    def slaveof(host=nil,port=nil)
      if host.class == String && port.class == Fixnum && block_given?
        return ::Vertx::Util::Utils.safe_create(@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) })),::VertxRedis::RedisClient)
      end
      raise ArgumentError, "Invalid arguments when calling slaveof(host,port)"
    end

### - (`::VertxRedis::RedisClient`) slaveof_noone { ... }

Make this server a master

Yields:

- Handler for the result of this call.

Returns:

- (`::VertxRedis::RedisClient`)

Raises:

- (`ArgumentError`)

    1546
    1547
    1548
    1549
    1550
    1551
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-redis-client/src/main/resources/vertx-redis/redis_client.rb', line 1546

    def slaveof_noone
      if block_given?
        return ::Vertx::Util::Utils.safe_create(@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) })),::VertxRedis::RedisClient)
      end
      raise ArgumentError, "Invalid arguments when calling slaveof_noone()"
    end

### - (`::VertxRedis::RedisClient`) 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:

- (`::VertxRedis::RedisClient`)

Raises:

- (`ArgumentError`)

    1556
    1557
    1558
    1559
    1560
    1561
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-redis-client/src/main/resources/vertx-redis/redis_client.rb', line 1556

    def slowlog_get(limit=nil)
      if limit.class == Fixnum && block_given?
        return ::Vertx::Util::Utils.safe_create(@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) })),::VertxRedis::RedisClient)
      end
      raise ArgumentError, "Invalid arguments when calling slowlog_get(limit)"
    end

### - (`::VertxRedis::RedisClient`) slowlog_len { ... }

Get the length of the Redis slow queries log

Yields:

- Handler for the result of this call.

Returns:

- (`::VertxRedis::RedisClient`)

Raises:

- (`ArgumentError`)

    1565
    1566
    1567
    1568
    1569
    1570
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-redis-client/src/main/resources/vertx-redis/redis_client.rb', line 1565

    def slowlog_len
      if block_given?
        return ::Vertx::Util::Utils.safe_create(@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) })),::VertxRedis::RedisClient)
      end
      raise ArgumentError, "Invalid arguments when calling slowlog_len()"
    end

### - (`::VertxRedis::RedisClient`) slowlog_reset { ... }

Reset the Redis slow queries log

Yields:

- Handler for the result of this call.

Returns:

- (`::VertxRedis::RedisClient`)

Raises:

- (`ArgumentError`)

    1574
    1575
    1576
    1577
    1578
    1579
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-redis-client/src/main/resources/vertx-redis/redis_client.rb', line 1574

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

### - (`::VertxRedis::RedisClient`) 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:

- (`::VertxRedis::RedisClient`)

Raises:

- (`ArgumentError`)

    1584
    1585
    1586
    1587
    1588
    1589
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-redis-client/src/main/resources/vertx-redis/redis_client.rb', line 1584

    def smembers(key=nil)
      if key.class == String && block_given?
        return ::Vertx::Util::Utils.safe_create(@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) })),::VertxRedis::RedisClient)
      end
      raise ArgumentError, "Invalid arguments when calling smembers(key)"
    end

### - (`::VertxRedis::RedisClient`) 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:

- (`::VertxRedis::RedisClient`)

Raises:

- (`ArgumentError`)

    1596
    1597
    1598
    1599
    1600
    1601
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-redis-client/src/main/resources/vertx-redis/redis_client.rb', line 1596

    def smove(key=nil,destkey=nil,member=nil)
      if key.class == String && destkey.class == String && member.class == String && block_given?
        return ::Vertx::Util::Utils.safe_create(@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) })),::VertxRedis::RedisClient)
      end
      raise ArgumentError, "Invalid arguments when calling smove(key,destkey,member)"
    end

### - (`::VertxRedis::RedisClient`) 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:

- (`::VertxRedis::RedisClient`)

Raises:

- (`ArgumentError`)

    1607
    1608
    1609
    1610
    1611
    1612
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-redis-client/src/main/resources/vertx-redis/redis_client.rb', line 1607

    def sort(key=nil,options=nil)
      if key.class == String && options.class == Hash && block_given?
        return ::Vertx::Util::Utils.safe_create(@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) })),::VertxRedis::RedisClient)
      end
      raise ArgumentError, "Invalid arguments when calling sort(key,options)"
    end

### - (`::VertxRedis::RedisClient`) 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:

- (`::VertxRedis::RedisClient`)

Raises:

- (`ArgumentError`)

    1617
    1618
    1619
    1620
    1621
    1622
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-redis-client/src/main/resources/vertx-redis/redis_client.rb', line 1617

    def spop(key=nil)
      if key.class == String && block_given?
        return ::Vertx::Util::Utils.safe_create(@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) })),::VertxRedis::RedisClient)
      end
      raise ArgumentError, "Invalid arguments when calling spop(key)"
    end

### - (`::VertxRedis::RedisClient`) 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:

- (`::VertxRedis::RedisClient`)

Raises:

- (`ArgumentError`)

    1628
    1629
    1630
    1631
    1632
    1633
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-redis-client/src/main/resources/vertx-redis/redis_client.rb', line 1628

    def spop_many(key=nil,count=nil)
      if key.class == String && count.class == Fixnum && block_given?
        return ::Vertx::Util::Utils.safe_create(@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) })),::VertxRedis::RedisClient)
      end
      raise ArgumentError, "Invalid arguments when calling spop_many(key,count)"
    end

### - (`::VertxRedis::RedisClient`) srandmember(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:

- (`::VertxRedis::RedisClient`)

Raises:

- (`ArgumentError`)

    1639
    1640
    1641
    1642
    1643
    1644
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-redis-client/src/main/resources/vertx-redis/redis_client.rb', line 1639

    def srandmember(key=nil,count=nil)
      if key.class == String && count.class == Fixnum && block_given?
        return ::Vertx::Util::Utils.safe_create(@j_del.java_method(:srandmember, [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) })),::VertxRedis::RedisClient)
      end
      raise ArgumentError, "Invalid arguments when calling srandmember(key,count)"
    end

### - (`::VertxRedis::RedisClient`) 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:

- (`::VertxRedis::RedisClient`)

Raises:

- (`ArgumentError`)

    1650
    1651
    1652
    1653
    1654
    1655
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-redis-client/src/main/resources/vertx-redis/redis_client.rb', line 1650

    def srem(key=nil,member=nil)
      if key.class == String && member.class == String && block_given?
        return ::Vertx::Util::Utils.safe_create(@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) })),::VertxRedis::RedisClient)
      end
      raise ArgumentError, "Invalid arguments when calling srem(key,member)"
    end

### - (`::VertxRedis::RedisClient`) 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:

- (`::VertxRedis::RedisClient`)

Raises:

- (`ArgumentError`)

    1661
    1662
    1663
    1664
    1665
    1666
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-redis-client/src/main/resources/vertx-redis/redis_client.rb', line 1661

    def srem_many(key=nil,members=nil)
      if key.class == String && members.class == Array && block_given?
        return ::Vertx::Util::Utils.safe_create(@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) })),::VertxRedis::RedisClient)
      end
      raise ArgumentError, "Invalid arguments when calling srem_many(key,members)"
    end

### - (`::VertxRedis::RedisClient`) 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:

- (`::VertxRedis::RedisClient`)

Raises:

- (`ArgumentError`)

    2090
    2091
    2092
    2093
    2094
    2095
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-redis-client/src/main/resources/vertx-redis/redis_client.rb', line 2090

    def sscan(key=nil,cursor=nil,options=nil)
      if key.class == String && cursor.class == String && options.class == Hash && block_given?
        return ::Vertx::Util::Utils.safe_create(@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) })),::VertxRedis::RedisClient)
      end
      raise ArgumentError, "Invalid arguments when calling sscan(key,cursor,options)"
    end

### - (`::VertxRedis::RedisClient`) 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:

- (`::VertxRedis::RedisClient`)

Raises:

- (`ArgumentError`)

    1671
    1672
    1673
    1674
    1675
    1676
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-redis-client/src/main/resources/vertx-redis/redis_client.rb', line 1671

    def strlen(key=nil)
      if key.class == String && block_given?
        return ::Vertx::Util::Utils.safe_create(@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) })),::VertxRedis::RedisClient)
      end
      raise ArgumentError, "Invalid arguments when calling strlen(key)"
    end

### - (`::VertxRedis::RedisClient`) subscribe(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:

- (`::VertxRedis::RedisClient`)

Raises:

- (`ArgumentError`)

    1681
    1682
    1683
    1684
    1685
    1686
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-redis-client/src/main/resources/vertx-redis/redis_client.rb', line 1681

    def subscribe(channels=nil)
      if channels.class == Array && block_given?
        return ::Vertx::Util::Utils.safe_create(@j_del.java_method(:subscribe, [Java::JavaUtil::List.java_class,Java::IoVertxCore::Handler.java_class]).call(channels.map { |element| element },(Proc.new { |ar| yield(ar.failed ? ar.cause : nil) })),::VertxRedis::RedisClient)
      end
      raise ArgumentError, "Invalid arguments when calling subscribe(channels)"
    end

### - (`::VertxRedis::RedisClient`) 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:

- (`::VertxRedis::RedisClient`)

Raises:

- (`ArgumentError`)

    1691
    1692
    1693
    1694
    1695
    1696
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-redis-client/src/main/resources/vertx-redis/redis_client.rb', line 1691

    def sunion(keys=nil)
      if keys.class == Array && block_given?
        return ::Vertx::Util::Utils.safe_create(@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) })),::VertxRedis::RedisClient)
      end
      raise ArgumentError, "Invalid arguments when calling sunion(keys)"
    end

### - (`::VertxRedis::RedisClient`) 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:

- (`::VertxRedis::RedisClient`)

Raises:

- (`ArgumentError`)

    1702
    1703
    1704
    1705
    1706
    1707
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-redis-client/src/main/resources/vertx-redis/redis_client.rb', line 1702

    def sunionstore(destkey=nil,keys=nil)
      if destkey.class == String && keys.class == Array && block_given?
        return ::Vertx::Util::Utils.safe_create(@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) })),::VertxRedis::RedisClient)
      end
      raise ArgumentError, "Invalid arguments when calling sunionstore(destkey,keys)"
    end

### - (`::VertxRedis::RedisClient`) sync { ... }

Internal command used for replication

Yields:

Returns:

- (`::VertxRedis::RedisClient`)

Raises:

- (`ArgumentError`)

    1711
    1712
    1713
    1714
    1715
    1716
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-redis-client/src/main/resources/vertx-redis/redis_client.rb', line 1711

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

### - (`::VertxRedis::RedisClient`) time { ... }

Return the current server time

Yields:

Returns:

- (`::VertxRedis::RedisClient`)

Raises:

- (`ArgumentError`)

    1720
    1721
    1722
    1723
    1724
    1725
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-redis-client/src/main/resources/vertx-redis/redis_client.rb', line 1720

    def time
      if block_given?
        return ::Vertx::Util::Utils.safe_create(@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) })),::VertxRedis::RedisClient)
      end
      raise ArgumentError, "Invalid arguments when calling time()"
    end

### - (`::VertxRedis::RedisClient`) 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:

- (`::VertxRedis::RedisClient`)

Raises:

- (`ArgumentError`)

    1730
    1731
    1732
    1733
    1734
    1735
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-redis-client/src/main/resources/vertx-redis/redis_client.rb', line 1730

    def ttl(key=nil)
      if key.class == String && block_given?
        return ::Vertx::Util::Utils.safe_create(@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) })),::VertxRedis::RedisClient)
      end
      raise ArgumentError, "Invalid arguments when calling ttl(key)"
    end

### - (`::VertxRedis::RedisClient`) 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:

- (`::VertxRedis::RedisClient`)

Raises:

- (`ArgumentError`)

    1740
    1741
    1742
    1743
    1744
    1745
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-redis-client/src/main/resources/vertx-redis/redis_client.rb', line 1740

    def type(key=nil)
      if key.class == String && block_given?
        return ::Vertx::Util::Utils.safe_create(@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) })),::VertxRedis::RedisClient)
      end
      raise ArgumentError, "Invalid arguments when calling type(key)"
    end

### - (`::VertxRedis::RedisClient`) 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:

- (`::VertxRedis::RedisClient`)

Raises:

- (`ArgumentError`)

    1750
    1751
    1752
    1753
    1754
    1755
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-redis-client/src/main/resources/vertx-redis/redis_client.rb', line 1750

    def unsubscribe(channels=nil)
      if channels.class == Array && block_given?
        return ::Vertx::Util::Utils.safe_create(@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) })),::VertxRedis::RedisClient)
      end
      raise ArgumentError, "Invalid arguments when calling unsubscribe(channels)"
    end

### - (`::VertxRedis::RedisClient`) unwatch { ... }

Forget about all watched keys

Yields:

Returns:

- (`::VertxRedis::RedisClient`)

Raises:

- (`ArgumentError`)

    1759
    1760
    1761
    1762
    1763
    1764
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-redis-client/src/main/resources/vertx-redis/redis_client.rb', line 1759

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

### - (`::VertxRedis::RedisClient`) watch(keys = nil) { ... }

Watch the given keys to determine execution of the MULTI/EXEC block

Parameters:

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

Yields:

- Handler for the result of this call.

Returns:

- (`::VertxRedis::RedisClient`)

Raises:

- (`ArgumentError`)

    1769
    1770
    1771
    1772
    1773
    1774
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-redis-client/src/main/resources/vertx-redis/redis_client.rb', line 1769

    def watch(keys=nil)
      if keys.class == Array && block_given?
        return ::Vertx::Util::Utils.safe_create(@j_del.java_method(:watch, [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) })),::VertxRedis::RedisClient)
      end
      raise ArgumentError, "Invalid arguments when calling watch(keys)"
    end

### - (`::VertxRedis::RedisClient`) 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:

- (`::VertxRedis::RedisClient`)

Raises:

- (`ArgumentError`)

    1781
    1782
    1783
    1784
    1785
    1786
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-redis-client/src/main/resources/vertx-redis/redis_client.rb', line 1781

    def zadd(key=nil,score=nil,member=nil)
      if key.class == String && score.class == Float && member.class == String && block_given?
        return ::Vertx::Util::Utils.safe_create(@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) })),::VertxRedis::RedisClient)
      end
      raise ArgumentError, "Invalid arguments when calling zadd(key,score,member)"
    end

### - (`::VertxRedis::RedisClient`) 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:

- (`::VertxRedis::RedisClient`)

Raises:

- (`ArgumentError`)

    1792
    1793
    1794
    1795
    1796
    1797
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-redis-client/src/main/resources/vertx-redis/redis_client.rb', line 1792

    def zadd_many(key=nil,members=nil)
      if key.class == String && members.class == Hash && block_given?
        return ::Vertx::Util::Utils.safe_create(@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) })),::VertxRedis::RedisClient)
      end
      raise ArgumentError, "Invalid arguments when calling zadd_many(key,members)"
    end

### - (`::VertxRedis::RedisClient`) 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:

- (`::VertxRedis::RedisClient`)

Raises:

- (`ArgumentError`)

    1802
    1803
    1804
    1805
    1806
    1807
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-redis-client/src/main/resources/vertx-redis/redis_client.rb', line 1802

    def zcard(key=nil)
      if key.class == String && block_given?
        return ::Vertx::Util::Utils.safe_create(@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) })),::VertxRedis::RedisClient)
      end
      raise ArgumentError, "Invalid arguments when calling zcard(key)"
    end

### - (`::VertxRedis::RedisClient`) 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:

- (`::VertxRedis::RedisClient`)

Raises:

- (`ArgumentError`)

    1814
    1815
    1816
    1817
    1818
    1819
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-redis-client/src/main/resources/vertx-redis/redis_client.rb', line 1814

    def zcount(key=nil,min=nil,max=nil)
      if key.class == String && min.class == Float && max.class == Float && block_given?
        return ::Vertx::Util::Utils.safe_create(@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) })),::VertxRedis::RedisClient)
      end
      raise ArgumentError, "Invalid arguments when calling zcount(key,min,max)"
    end

### - (`::VertxRedis::RedisClient`) 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:

- (`::VertxRedis::RedisClient`)

Raises:

- (`ArgumentError`)

    1826
    1827
    1828
    1829
    1830
    1831
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-redis-client/src/main/resources/vertx-redis/redis_client.rb', line 1826

    def zincrby(key=nil,increment=nil,member=nil)
      if key.class == String && increment.class == Float && member.class == String && block_given?
        return ::Vertx::Util::Utils.safe_create(@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) })),::VertxRedis::RedisClient)
      end
      raise ArgumentError, "Invalid arguments when calling zincrby(key,increment,member)"
    end

### - (`::VertxRedis::RedisClient`) 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:

- (`::VertxRedis::RedisClient`)

Raises:

- (`ArgumentError`)

    1838
    1839
    1840
    1841
    1842
    1843
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-redis-client/src/main/resources/vertx-redis/redis_client.rb', line 1838

    def zinterstore(destkey=nil,sets=nil,options=nil)
      if destkey.class == String && sets.class == Array && options.class == Symbol && block_given?
        return ::Vertx::Util::Utils.safe_create(@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),(Proc.new { |ar| yield(ar.failed ? ar.cause : nil, ar.succeeded ? ar.result : nil) })),::VertxRedis::RedisClient)
      end
      raise ArgumentError, "Invalid arguments when calling zinterstore(destkey,sets,options)"
    end

### - (`::VertxRedis::RedisClient`) 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:

- (`::VertxRedis::RedisClient`)

Raises:

- (`ArgumentError`)

    1850
    1851
    1852
    1853
    1854
    1855
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-redis-client/src/main/resources/vertx-redis/redis_client.rb', line 1850

    def zinterstore_weighed(destkey=nil,sets=nil,options=nil)
      if destkey.class == String && sets.class == Hash && options.class == Symbol && block_given?
        return ::Vertx::Util::Utils.safe_create(@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),(Proc.new { |ar| yield(ar.failed ? ar.cause : nil, ar.succeeded ? ar.result : nil) })),::VertxRedis::RedisClient)
      end
      raise ArgumentError, "Invalid arguments when calling zinterstore_weighed(destkey,sets,options)"
    end

### - (`::VertxRedis::RedisClient`) 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:

- (`::VertxRedis::RedisClient`)

Raises:

- (`ArgumentError`)

    1862
    1863
    1864
    1865
    1866
    1867
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-redis-client/src/main/resources/vertx-redis/redis_client.rb', line 1862

    def zlexcount(key=nil,min=nil,max=nil)
      if key.class == String && min.class == String && max.class == String && block_given?
        return ::Vertx::Util::Utils.safe_create(@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) })),::VertxRedis::RedisClient)
      end
      raise ArgumentError, "Invalid arguments when calling zlexcount(key,min,max)"
    end

### - (`::VertxRedis::RedisClient`) 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:

- (`::VertxRedis::RedisClient`)

Raises:

- (`ArgumentError`)

    1874
    1875
    1876
    1877
    1878
    1879
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-redis-client/src/main/resources/vertx-redis/redis_client.rb', line 1874

    def zrange(key=nil,start=nil,stop=nil)
      if key.class == String && start.class == Fixnum && stop.class == Fixnum && block_given?
        return ::Vertx::Util::Utils.safe_create(@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) })),::VertxRedis::RedisClient)
      end
      raise ArgumentError, "Invalid arguments when calling zrange(key,start,stop)"
    end

### - (`::VertxRedis::RedisClient`) 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:

- (`::VertxRedis::RedisClient`)

Raises:

- (`ArgumentError`)

    1887
    1888
    1889
    1890
    1891
    1892
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-redis-client/src/main/resources/vertx-redis/redis_client.rb', line 1887

    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?
        return ::Vertx::Util::Utils.safe_create(@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),(Proc.new { |ar| yield(ar.failed ? ar.cause : nil, ar.succeeded ? ar.result != nil ? JSON.parse(ar.result.encode) : nil : nil) })),::VertxRedis::RedisClient)
      end
      raise ArgumentError, "Invalid arguments when calling zrange_with_options(key,start,stop,options)"
    end

### - (`::VertxRedis::RedisClient`) 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:

- (`::VertxRedis::RedisClient`)

Raises:

- (`ArgumentError`)

    1900
    1901
    1902
    1903
    1904
    1905
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-redis-client/src/main/resources/vertx-redis/redis_client.rb', line 1900

    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?
        return ::Vertx::Util::Utils.safe_create(@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) })),::VertxRedis::RedisClient)
      end
      raise ArgumentError, "Invalid arguments when calling zrangebylex(key,min,max,options)"
    end

### - (`::VertxRedis::RedisClient`) 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:

- (`::VertxRedis::RedisClient`)

Raises:

- (`ArgumentError`)

    1913
    1914
    1915
    1916
    1917
    1918
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-redis-client/src/main/resources/vertx-redis/redis_client.rb', line 1913

    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?
        return ::Vertx::Util::Utils.safe_create(@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) })),::VertxRedis::RedisClient)
      end
      raise ArgumentError, "Invalid arguments when calling zrangebyscore(key,min,max,options)"
    end

### - (`::VertxRedis::RedisClient`) 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:

- (`::VertxRedis::RedisClient`)

Raises:

- (`ArgumentError`)

    1924
    1925
    1926
    1927
    1928
    1929
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-redis-client/src/main/resources/vertx-redis/redis_client.rb', line 1924

    def zrank(key=nil,member=nil)
      if key.class == String && member.class == String && block_given?
        return ::Vertx::Util::Utils.safe_create(@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) })),::VertxRedis::RedisClient)
      end
      raise ArgumentError, "Invalid arguments when calling zrank(key,member)"
    end

### - (`::VertxRedis::RedisClient`) 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:

- (`::VertxRedis::RedisClient`)

Raises:

- (`ArgumentError`)

    1935
    1936
    1937
    1938
    1939
    1940
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-redis-client/src/main/resources/vertx-redis/redis_client.rb', line 1935

    def zrem(key=nil,member=nil)
      if key.class == String && member.class == String && block_given?
        return ::Vertx::Util::Utils.safe_create(@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) })),::VertxRedis::RedisClient)
      end
      raise ArgumentError, "Invalid arguments when calling zrem(key,member)"
    end

### - (`::VertxRedis::RedisClient`) 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:

- (`::VertxRedis::RedisClient`)

Raises:

- (`ArgumentError`)

    1946
    1947
    1948
    1949
    1950
    1951
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-redis-client/src/main/resources/vertx-redis/redis_client.rb', line 1946

    def zrem_many(key=nil,members=nil)
      if key.class == String && members.class == Array && block_given?
        return ::Vertx::Util::Utils.safe_create(@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) })),::VertxRedis::RedisClient)
      end
      raise ArgumentError, "Invalid arguments when calling zrem_many(key,members)"
    end

### - (`::VertxRedis::RedisClient`) 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:

- (`::VertxRedis::RedisClient`)

Raises:

- (`ArgumentError`)

    1958
    1959
    1960
    1961
    1962
    1963
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-redis-client/src/main/resources/vertx-redis/redis_client.rb', line 1958

    def zremrangebylex(key=nil,min=nil,max=nil)
      if key.class == String && min.class == String && max.class == String && block_given?
        return ::Vertx::Util::Utils.safe_create(@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) })),::VertxRedis::RedisClient)
      end
      raise ArgumentError, "Invalid arguments when calling zremrangebylex(key,min,max)"
    end

### - (`::VertxRedis::RedisClient`) 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:

- (`::VertxRedis::RedisClient`)

Raises:

- (`ArgumentError`)

    1970
    1971
    1972
    1973
    1974
    1975
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-redis-client/src/main/resources/vertx-redis/redis_client.rb', line 1970

    def zremrangebyrank(key=nil,start=nil,stop=nil)
      if key.class == String && start.class == Fixnum && stop.class == Fixnum && block_given?
        return ::Vertx::Util::Utils.safe_create(@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) })),::VertxRedis::RedisClient)
      end
      raise ArgumentError, "Invalid arguments when calling zremrangebyrank(key,start,stop)"
    end

### - (`::VertxRedis::RedisClient`) 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:

- (`::VertxRedis::RedisClient`)

Raises:

- (`ArgumentError`)

    1982
    1983
    1984
    1985
    1986
    1987
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-redis-client/src/main/resources/vertx-redis/redis_client.rb', line 1982

    def zremrangebyscore(key=nil,min=nil,max=nil)
      if key.class == String && min.class == String && max.class == String && block_given?
        return ::Vertx::Util::Utils.safe_create(@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) })),::VertxRedis::RedisClient)
      end
      raise ArgumentError, "Invalid arguments when calling zremrangebyscore(key,min,max)"
    end

### - (`::VertxRedis::RedisClient`) 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:

- (`::VertxRedis::RedisClient`)

Raises:

- (`ArgumentError`)

    1995
    1996
    1997
    1998
    1999
    2000
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-redis-client/src/main/resources/vertx-redis/redis_client.rb', line 1995

    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?
        return ::Vertx::Util::Utils.safe_create(@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),(Proc.new { |ar| yield(ar.failed ? ar.cause : nil, ar.succeeded ? ar.result != nil ? JSON.parse(ar.result.encode) : nil : nil) })),::VertxRedis::RedisClient)
      end
      raise ArgumentError, "Invalid arguments when calling zrevrange(key,start,stop,options)"
    end

### - (`::VertxRedis::RedisClient`) 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:

- (`::VertxRedis::RedisClient`)

Raises:

- (`ArgumentError`)

    2008
    2009
    2010
    2011
    2012
    2013
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-redis-client/src/main/resources/vertx-redis/redis_client.rb', line 2008

    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?
        return ::Vertx::Util::Utils.safe_create(@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) })),::VertxRedis::RedisClient)
      end
      raise ArgumentError, "Invalid arguments when calling zrevrangebylex(key,max,min,options)"
    end

### - (`::VertxRedis::RedisClient`) 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:

- (`::VertxRedis::RedisClient`)

Raises:

- (`ArgumentError`)

    2021
    2022
    2023
    2024
    2025
    2026
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-redis-client/src/main/resources/vertx-redis/redis_client.rb', line 2021

    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?
        return ::Vertx::Util::Utils.safe_create(@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) })),::VertxRedis::RedisClient)
      end
      raise ArgumentError, "Invalid arguments when calling zrevrangebyscore(key,max,min,options)"
    end

### - (`::VertxRedis::RedisClient`) 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:

- (`::VertxRedis::RedisClient`)

Raises:

- (`ArgumentError`)

    2032
    2033
    2034
    2035
    2036
    2037
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-redis-client/src/main/resources/vertx-redis/redis_client.rb', line 2032

    def zrevrank(key=nil,member=nil)
      if key.class == String && member.class == String && block_given?
        return ::Vertx::Util::Utils.safe_create(@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) })),::VertxRedis::RedisClient)
      end
      raise ArgumentError, "Invalid arguments when calling zrevrank(key,member)"
    end

### - (`::VertxRedis::RedisClient`) 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:

- (`::VertxRedis::RedisClient`)

Raises:

- (`ArgumentError`)

    2114
    2115
    2116
    2117
    2118
    2119
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-redis-client/src/main/resources/vertx-redis/redis_client.rb', line 2114

    def zscan(key=nil,cursor=nil,options=nil)
      if key.class == String && cursor.class == String && options.class == Hash && block_given?
        return ::Vertx::Util::Utils.safe_create(@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) })),::VertxRedis::RedisClient)
      end
      raise ArgumentError, "Invalid arguments when calling zscan(key,cursor,options)"
    end

### - (`::VertxRedis::RedisClient`) 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:

- (`::VertxRedis::RedisClient`)

Raises:

- (`ArgumentError`)

    2043
    2044
    2045
    2046
    2047
    2048
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-redis-client/src/main/resources/vertx-redis/redis_client.rb', line 2043

    def zscore(key=nil,member=nil)
      if key.class == String && member.class == String && block_given?
        return ::Vertx::Util::Utils.safe_create(@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) })),::VertxRedis::RedisClient)
      end
      raise ArgumentError, "Invalid arguments when calling zscore(key,member)"
    end

### - (`::VertxRedis::RedisClient`) 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:

- (`::VertxRedis::RedisClient`)

Raises:

- (`ArgumentError`)

    2055
    2056
    2057
    2058
    2059
    2060
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-redis-client/src/main/resources/vertx-redis/redis_client.rb', line 2055

    def zunionstore(destkey=nil,sets=nil,options=nil)
      if destkey.class == String && sets.class == Array && options.class == Symbol && block_given?
        return ::Vertx::Util::Utils.safe_create(@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),(Proc.new { |ar| yield(ar.failed ? ar.cause : nil, ar.succeeded ? ar.result : nil) })),::VertxRedis::RedisClient)
      end
      raise ArgumentError, "Invalid arguments when calling zunionstore(destkey,sets,options)"
    end

### - (`::VertxRedis::RedisClient`) 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:

- (`::VertxRedis::RedisClient`)

Raises:

- (`ArgumentError`)

    2067
    2068
    2069
    2070
    2071
    2072
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-redis-client/src/main/resources/vertx-redis/redis_client.rb', line 2067

    def zunionstore_weighed(key=nil,sets=nil,options=nil)
      if key.class == String && sets.class == Hash && options.class == Symbol && block_given?
        return ::Vertx::Util::Utils.safe_create(@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),(Proc.new { |ar| yield(ar.failed ? ar.cause : nil, ar.succeeded ? ar.result : nil) })),::VertxRedis::RedisClient)
      end
      raise ArgumentError, "Invalid arguments when calling zunionstore_weighed(key,sets,options)"
    end