Class List Method List File List

# Class: VertxRedis::RedisTransaction

Inherits:
  Object
  - Object
  - VertxRedis::RedisTransaction
  show all
Defined in:
  /Users/julien/java/vertx-stack/stack-docs/target/rb/vertx-redis/redis_transaction.rb

## Overview

This Interface represents a TX

## Constant Summary

@@j_api_type =

      Object.new

## Class Method Summary (collapse)

- + (Boolean) accept?(obj)
- + (Object) j_api_type
- + (Object) j_class
- + (Object) unwrap(obj)
- + (Object) wrap(obj)

## Instance Method Summary (collapse)

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

## Class Method Details

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

Returns:

- (`Boolean`)

    18
    19
    20
    # File '/Users/julien/java/vertx-stack/stack-docs/target/rb/vertx-redis/redis_transaction.rb', line 18

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

### + (`Object`) j_api_type

    27
    28
    29
    # File '/Users/julien/java/vertx-stack/stack-docs/target/rb/vertx-redis/redis_transaction.rb', line 27

    def self.j_api_type
      @@j_api_type
    end

### + (`Object`) j_class

    30
    31
    32
    # File '/Users/julien/java/vertx-stack/stack-docs/target/rb/vertx-redis/redis_transaction.rb', line 30

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

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

    24
    25
    26
    # File '/Users/julien/java/vertx-stack/stack-docs/target/rb/vertx-redis/redis_transaction.rb', line 24

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

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

    21
    22
    23
    # File '/Users/julien/java/vertx-stack/stack-docs/target/rb/vertx-redis/redis_transaction.rb', line 21

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

## Instance Method Details

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

Append a value to a key

Parameters:

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

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    47
    48
    49
    50
    51
    52
    53
    # File '/Users/julien/java/vertx-stack/stack-docs/target/rb/vertx-redis/redis_transaction.rb', line 47

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

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

Authenticate to the server

Parameters:

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

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    58
    59
    60
    61
    62
    63
    64
    # File '/Users/julien/java/vertx-stack/stack-docs/target/rb/vertx-redis/redis_transaction.rb', line 58

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

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

Asynchronously rewrite the append-only file

Yields:

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    68
    69
    70
    71
    72
    73
    74
    # File '/Users/julien/java/vertx-stack/stack-docs/target/rb/vertx-redis/redis_transaction.rb', line 68

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

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

Asynchronously save the dataset to disk

Yields:

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    78
    79
    80
    81
    82
    83
    84
    # File '/Users/julien/java/vertx-stack/stack-docs/target/rb/vertx-redis/redis_transaction.rb', line 78

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

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

Count set bits in a string

Parameters:

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

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    89
    90
    91
    92
    93
    94
    95
    # File '/Users/julien/java/vertx-stack/stack-docs/target/rb/vertx-redis/redis_transaction.rb', line 89

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

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

Count set bits in a string

Parameters:

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

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    102
    103
    104
    105
    106
    107
    108
    # File '/Users/julien/java/vertx-stack/stack-docs/target/rb/vertx-redis/redis_transaction.rb', line 102

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

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

Perform bitwise operations between strings

Parameters:

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

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    115
    116
    117
    118
    119
    120
    121
    # File '/Users/julien/java/vertx-stack/stack-docs/target/rb/vertx-redis/redis_transaction.rb', line 115

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

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

Find first bit set or clear in a string

Parameters:

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

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    127
    128
    129
    130
    131
    132
    133
    # File '/Users/julien/java/vertx-stack/stack-docs/target/rb/vertx-redis/redis_transaction.rb', line 127

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

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

Find first bit set or clear in a string

See also bitposRange() method, which takes start, and stop offset.

Parameters:

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

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    142
    143
    144
    145
    146
    147
    148
    # File '/Users/julien/java/vertx-stack/stack-docs/target/rb/vertx-redis/redis_transaction.rb', line 142

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

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

Find first bit set or clear in a string

Note: when both start, and stop offsets are specified, behaviour is slightly different than if only start is specified

Parameters:

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

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    159
    160
    161
    162
    163
    164
    165
    # File '/Users/julien/java/vertx-stack/stack-docs/target/rb/vertx-redis/redis_transaction.rb', line 159

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

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

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

Parameters:

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

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    171
    172
    173
    174
    175
    176
    177
    # File '/Users/julien/java/vertx-stack/stack-docs/target/rb/vertx-redis/redis_transaction.rb', line 171

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

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

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

Parameters:

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

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    183
    184
    185
    186
    187
    188
    189
    # File '/Users/julien/java/vertx-stack/stack-docs/target/rb/vertx-redis/redis_transaction.rb', line 183

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

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

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

Parameters:

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

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    195
    196
    197
    198
    199
    200
    201
    # File '/Users/julien/java/vertx-stack/stack-docs/target/rb/vertx-redis/redis_transaction.rb', line 195

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

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

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

Parameters:

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

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    207
    208
    209
    210
    211
    212
    213
    # File '/Users/julien/java/vertx-stack/stack-docs/target/rb/vertx-redis/redis_transaction.rb', line 207

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

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

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

Parameters:

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

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    220
    221
    222
    223
    224
    225
    226
    # File '/Users/julien/java/vertx-stack/stack-docs/target/rb/vertx-redis/redis_transaction.rb', line 220

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

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

Get the current connection name

Yields:

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    251
    252
    253
    254
    255
    256
    257
    # File '/Users/julien/java/vertx-stack/stack-docs/target/rb/vertx-redis/redis_transaction.rb', line 251

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

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

Kill the connection of a client

Parameters:

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

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    231
    232
    233
    234
    235
    236
    237
    # File '/Users/julien/java/vertx-stack/stack-docs/target/rb/vertx-redis/redis_transaction.rb', line 231

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

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

Get the list of client connections

Yields:

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    241
    242
    243
    244
    245
    246
    247
    # File '/Users/julien/java/vertx-stack/stack-docs/target/rb/vertx-redis/redis_transaction.rb', line 241

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

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

Stop processing commands from clients for some time

Parameters:

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

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    262
    263
    264
    265
    266
    267
    268
    # File '/Users/julien/java/vertx-stack/stack-docs/target/rb/vertx-redis/redis_transaction.rb', line 262

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

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

Set the current connection name

Parameters:

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

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    273
    274
    275
    276
    277
    278
    279
    # File '/Users/julien/java/vertx-stack/stack-docs/target/rb/vertx-redis/redis_transaction.rb', line 273

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

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

This method returns an undefined value.

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

Yields:

Raises:

- (`ArgumentError`)

    36
    37
    38
    39
    40
    41
    # File '/Users/julien/java/vertx-stack/stack-docs/target/rb/vertx-redis/redis_transaction.rb', line 36

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

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

Assign new hash slots to receiving node.

Parameters:

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

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    284
    285
    286
    287
    288
    289
    290
    # File '/Users/julien/java/vertx-stack/stack-docs/target/rb/vertx-redis/redis_transaction.rb', line 284

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

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

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

Parameters:

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

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    295
    296
    297
    298
    299
    300
    301
    # File '/Users/julien/java/vertx-stack/stack-docs/target/rb/vertx-redis/redis_transaction.rb', line 295

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

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

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

Parameters:

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

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    306
    307
    308
    309
    310
    311
    312
    # File '/Users/julien/java/vertx-stack/stack-docs/target/rb/vertx-redis/redis_transaction.rb', line 306

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

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

Set hash slots as unbound in receiving node.

Parameters:

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

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    317
    318
    319
    320
    321
    322
    323
    # File '/Users/julien/java/vertx-stack/stack-docs/target/rb/vertx-redis/redis_transaction.rb', line 317

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

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

Set hash slots as unbound in receiving node.

Parameters:

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

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    328
    329
    330
    331
    332
    333
    334
    # File '/Users/julien/java/vertx-stack/stack-docs/target/rb/vertx-redis/redis_transaction.rb', line 328

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

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

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

Parameters:

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

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    349
    350
    351
    352
    353
    354
    355
    # File '/Users/julien/java/vertx-stack/stack-docs/target/rb/vertx-redis/redis_transaction.rb', line 349

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

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

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

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    338
    339
    340
    341
    342
    343
    344
    # File '/Users/julien/java/vertx-stack/stack-docs/target/rb/vertx-redis/redis_transaction.rb', line 338

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

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

Remove a node from the nodes table.

Parameters:

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

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    360
    361
    362
    363
    364
    365
    366
    # File '/Users/julien/java/vertx-stack/stack-docs/target/rb/vertx-redis/redis_transaction.rb', line 360

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

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

Return local key names in the specified hash slot.

Parameters:

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

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    372
    373
    374
    375
    376
    377
    378
    # File '/Users/julien/java/vertx-stack/stack-docs/target/rb/vertx-redis/redis_transaction.rb', line 372

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

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

Provides info about Redis Cluster node state.

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    382
    383
    384
    385
    386
    387
    388
    # File '/Users/julien/java/vertx-stack/stack-docs/target/rb/vertx-redis/redis_transaction.rb', line 382

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

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

Returns the hash slot of the specified key.

Parameters:

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

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    393
    394
    395
    396
    397
    398
    399
    # File '/Users/julien/java/vertx-stack/stack-docs/target/rb/vertx-redis/redis_transaction.rb', line 393

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

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

Force a node cluster to handshake with another node.

Parameters:

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

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    405
    406
    407
    408
    409
    410
    411
    # File '/Users/julien/java/vertx-stack/stack-docs/target/rb/vertx-redis/redis_transaction.rb', line 405

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

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

Get Cluster config for the node.

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    415
    416
    417
    418
    419
    420
    421
    # File '/Users/julien/java/vertx-stack/stack-docs/target/rb/vertx-redis/redis_transaction.rb', line 415

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

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

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

Parameters:

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

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    426
    427
    428
    429
    430
    431
    432
    # File '/Users/julien/java/vertx-stack/stack-docs/target/rb/vertx-redis/redis_transaction.rb', line 426

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

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

Reset a Redis Cluster node.

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    436
    437
    438
    439
    440
    441
    442
    # File '/Users/julien/java/vertx-stack/stack-docs/target/rb/vertx-redis/redis_transaction.rb', line 436

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

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

Reset a Redis Cluster node.

Parameters:

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

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    447
    448
    449
    450
    451
    452
    453
    # File '/Users/julien/java/vertx-stack/stack-docs/target/rb/vertx-redis/redis_transaction.rb', line 447

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

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

Forces the node to save cluster state on disk.

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    457
    458
    459
    460
    461
    462
    463
    # File '/Users/julien/java/vertx-stack/stack-docs/target/rb/vertx-redis/redis_transaction.rb', line 457

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

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

Set the configuration epoch in a new node.

Parameters:

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

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    468
    469
    470
    471
    472
    473
    474
    # File '/Users/julien/java/vertx-stack/stack-docs/target/rb/vertx-redis/redis_transaction.rb', line 468

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

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

Bind an hash slot to a specific node.

Parameters:

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

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    480
    481
    482
    483
    484
    485
    486
    # File '/Users/julien/java/vertx-stack/stack-docs/target/rb/vertx-redis/redis_transaction.rb', line 480

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

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

Bind an hash slot to a specific node.

Parameters:

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

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    493
    494
    495
    496
    497
    498
    499
    # File '/Users/julien/java/vertx-stack/stack-docs/target/rb/vertx-redis/redis_transaction.rb', line 493

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

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

List slave nodes of the specified master node.

Parameters:

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

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    504
    505
    506
    507
    508
    509
    510
    # File '/Users/julien/java/vertx-stack/stack-docs/target/rb/vertx-redis/redis_transaction.rb', line 504

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

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

Get array of Cluster slot to node mappings

Yields:

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    514
    515
    516
    517
    518
    519
    520
    # File '/Users/julien/java/vertx-stack/stack-docs/target/rb/vertx-redis/redis_transaction.rb', line 514

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

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

Get array of Redis command details

Yields:

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    524
    525
    526
    527
    528
    529
    530
    # File '/Users/julien/java/vertx-stack/stack-docs/target/rb/vertx-redis/redis_transaction.rb', line 524

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

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

Get total number of Redis commands

Yields:

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    534
    535
    536
    537
    538
    539
    540
    # File '/Users/julien/java/vertx-stack/stack-docs/target/rb/vertx-redis/redis_transaction.rb', line 534

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

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

Extract keys given a full Redis command

Yields:

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    544
    545
    546
    547
    548
    549
    550
    # File '/Users/julien/java/vertx-stack/stack-docs/target/rb/vertx-redis/redis_transaction.rb', line 544

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

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

Get array of specific Redis command details

Parameters:

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

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    555
    556
    557
    558
    559
    560
    561
    # File '/Users/julien/java/vertx-stack/stack-docs/target/rb/vertx-redis/redis_transaction.rb', line 555

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

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

Get the value of a configuration parameter

Parameters:

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

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    566
    567
    568
    569
    570
    571
    572
    # File '/Users/julien/java/vertx-stack/stack-docs/target/rb/vertx-redis/redis_transaction.rb', line 566

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

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

Reset the stats returned by INFO

Yields:

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    598
    599
    600
    601
    602
    603
    604
    # File '/Users/julien/java/vertx-stack/stack-docs/target/rb/vertx-redis/redis_transaction.rb', line 598

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

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

Rewrite the configuration file with the in memory configuration

Yields:

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    576
    577
    578
    579
    580
    581
    582
    # File '/Users/julien/java/vertx-stack/stack-docs/target/rb/vertx-redis/redis_transaction.rb', line 576

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

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

Set a configuration parameter to the given value

Parameters:

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

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    588
    589
    590
    591
    592
    593
    594
    # File '/Users/julien/java/vertx-stack/stack-docs/target/rb/vertx-redis/redis_transaction.rb', line 588

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

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

Return the number of keys in the selected database

Yields:

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    608
    609
    610
    611
    612
    613
    614
    # File '/Users/julien/java/vertx-stack/stack-docs/target/rb/vertx-redis/redis_transaction.rb', line 608

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

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

Get debugging information about a key

Parameters:

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

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    619
    620
    621
    622
    623
    624
    625
    # File '/Users/julien/java/vertx-stack/stack-docs/target/rb/vertx-redis/redis_transaction.rb', line 619

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

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

Make the server crash

Yields:

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    629
    630
    631
    632
    633
    634
    635
    # File '/Users/julien/java/vertx-stack/stack-docs/target/rb/vertx-redis/redis_transaction.rb', line 629

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

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

Decrement the integer value of a key by one

Parameters:

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

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    640
    641
    642
    643
    644
    645
    646
    # File '/Users/julien/java/vertx-stack/stack-docs/target/rb/vertx-redis/redis_transaction.rb', line 640

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

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

Decrement the integer value of a key by the given number

Parameters:

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

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    652
    653
    654
    655
    656
    657
    658
    # File '/Users/julien/java/vertx-stack/stack-docs/target/rb/vertx-redis/redis_transaction.rb', line 652

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

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

Delete a key

Parameters:

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

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    663
    664
    665
    666
    667
    668
    669
    # File '/Users/julien/java/vertx-stack/stack-docs/target/rb/vertx-redis/redis_transaction.rb', line 663

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

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

Delete many keys

Parameters:

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

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    674
    675
    676
    677
    678
    679
    680
    # File '/Users/julien/java/vertx-stack/stack-docs/target/rb/vertx-redis/redis_transaction.rb', line 674

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

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

Discard all commands issued after MULTI

Yields:

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    684
    685
    686
    687
    688
    689
    690
    # File '/Users/julien/java/vertx-stack/stack-docs/target/rb/vertx-redis/redis_transaction.rb', line 684

    def discard
      if block_given?
        @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) }))
        return self
      end
      raise ArgumentError, "Invalid arguments when calling discard()"
    end

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

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

Parameters:

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

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    695
    696
    697
    698
    699
    700
    701
    # File '/Users/julien/java/vertx-stack/stack-docs/target/rb/vertx-redis/redis_transaction.rb', line 695

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

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

Echo the given string

Parameters:

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

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    706
    707
    708
    709
    710
    711
    712
    # File '/Users/julien/java/vertx-stack/stack-docs/target/rb/vertx-redis/redis_transaction.rb', line 706

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

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

Execute a Lua script server side. Due to the dynamic nature of this command any response type could be returned for This reason and to ensure type safety the reply is always guaranteed to be a JsonArray.

When a reply if for example a String the handler will be called with a JsonArray with a single element containing the String.

Parameters:

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

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    723
    724
    725
    726
    727
    728
    729
    # File '/Users/julien/java/vertx-stack/stack-docs/target/rb/vertx-redis/redis_transaction.rb', line 723

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

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

Execute a Lua script server side. Due to the dynamic nature of this command any response type could be returned for This reason and to ensure type safety the reply is always guaranteed to be a JsonArray.

When a reply if for example a String the handler will be called with a JsonArray with a single element containing the String.

Parameters:

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

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    740
    741
    742
    743
    744
    745
    746
    # File '/Users/julien/java/vertx-stack/stack-docs/target/rb/vertx-redis/redis_transaction.rb', line 740

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

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

Execute all commands issued after MULTI

Yields:

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    750
    751
    752
    753
    754
    755
    756
    # File '/Users/julien/java/vertx-stack/stack-docs/target/rb/vertx-redis/redis_transaction.rb', line 750

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

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

Determine if a key exists

Parameters:

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

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    761
    762
    763
    764
    765
    766
    767
    # File '/Users/julien/java/vertx-stack/stack-docs/target/rb/vertx-redis/redis_transaction.rb', line 761

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

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

Determine if one or many keys exist

Parameters:

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

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    772
    773
    774
    775
    776
    777
    778
    # File '/Users/julien/java/vertx-stack/stack-docs/target/rb/vertx-redis/redis_transaction.rb', line 772

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

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

Set a key's time to live in seconds

Parameters:

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

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    784
    785
    786
    787
    788
    789
    790
    # File '/Users/julien/java/vertx-stack/stack-docs/target/rb/vertx-redis/redis_transaction.rb', line 784

    def expire(key=nil,seconds=nil)
      if key.class == String && seconds.class == Fixnum && block_given?
        @j_del.java_method(:expire, [Java::java.lang.String.java_class,Java::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) }))
        return self
      end
      raise ArgumentError, "Invalid arguments when calling expire(#{key},#{seconds})"
    end

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

Set the expiration for a key as a UNIX timestamp

Parameters:

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

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    796
    797
    798
    799
    800
    801
    802
    # File '/Users/julien/java/vertx-stack/stack-docs/target/rb/vertx-redis/redis_transaction.rb', line 796

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

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

Remove all keys from all databases

Yields:

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    806
    807
    808
    809
    810
    811
    812
    # File '/Users/julien/java/vertx-stack/stack-docs/target/rb/vertx-redis/redis_transaction.rb', line 806

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

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

Remove all keys from the current database

Yields:

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    816
    817
    818
    819
    820
    821
    822
    # File '/Users/julien/java/vertx-stack/stack-docs/target/rb/vertx-redis/redis_transaction.rb', line 816

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

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

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

Parameters:

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

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    2650
    2651
    2652
    2653
    2654
    2655
    2656
    # File '/Users/julien/java/vertx-stack/stack-docs/target/rb/vertx-redis/redis_transaction.rb', line 2650

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

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

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

Parameters:

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

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    2662
    2663
    2664
    2665
    2666
    2667
    2668
    # File '/Users/julien/java/vertx-stack/stack-docs/target/rb/vertx-redis/redis_transaction.rb', line 2662

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

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

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

Parameters:

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

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    2727
    2728
    2729
    2730
    2731
    2732
    2733
    # File '/Users/julien/java/vertx-stack/stack-docs/target/rb/vertx-redis/redis_transaction.rb', line 2727

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

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

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

Parameters:

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

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    2741
    2742
    2743
    2744
    2745
    2746
    2747
    # File '/Users/julien/java/vertx-stack/stack-docs/target/rb/vertx-redis/redis_transaction.rb', line 2741

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

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

Return valid Geohash strings representing the position of one or more elements in a sorted set value representing a geospatial index (where elements were added using GEOADD).

Parameters:

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

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    2675
    2676
    2677
    2678
    2679
    2680
    2681
    # File '/Users/julien/java/vertx-stack/stack-docs/target/rb/vertx-redis/redis_transaction.rb', line 2675

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

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

Return valid Geohash strings representing the position of one or more elements in a sorted set value representing a geospatial index (where elements were added using GEOADD).

Parameters:

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

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    2688
    2689
    2690
    2691
    2692
    2693
    2694
    # File '/Users/julien/java/vertx-stack/stack-docs/target/rb/vertx-redis/redis_transaction.rb', line 2688

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

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

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

Parameters:

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

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    2701
    2702
    2703
    2704
    2705
    2706
    2707
    # File '/Users/julien/java/vertx-stack/stack-docs/target/rb/vertx-redis/redis_transaction.rb', line 2701

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

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

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

Parameters:

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

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    2714
    2715
    2716
    2717
    2718
    2719
    2720
    # File '/Users/julien/java/vertx-stack/stack-docs/target/rb/vertx-redis/redis_transaction.rb', line 2714

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

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

Return the members of a sorted set populated with geospatial information using GEOADD, which are within the borders of the area specified with the center location and the maximum distance from the center (the radius).

Parameters:

- key (`String`) (defaults to: `nil`) —
  Key string
- longitude (`Float`) (defaults to: `nil`) —
  longitude
- latitude (`Float`) (defaults to: `nil`) —
  latitude
- radius (`Float`) (defaults to: `nil`) —
  radius
- unit (`:m`, `:km`, `:mi`, `:ft`) (defaults to: `nil`) —
  geo unit

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    2757
    2758
    2759
    2760
    2761
    2762
    2763
    # File '/Users/julien/java/vertx-stack/stack-docs/target/rb/vertx-redis/redis_transaction.rb', line 2757

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

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

Return the members of a sorted set populated with geospatial information using GEOADD, which are within the borders of the area specified with the center location and the maximum distance from the center (the radius).

Parameters:

- key (`String`) (defaults to: `nil`) —
  Key string
- longitude (`Float`) (defaults to: `nil`) —
  longitude
- latitude (`Float`) (defaults to: `nil`) —
  latitude
- radius (`Float`) (defaults to: `nil`) —
  radius
- unit (`:m`, `:km`, `:mi`, `:ft`) (defaults to: `nil`) —
  geo unit
- options (`Hash`) (defaults to: `nil`) —
  geo radius options

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    2774
    2775
    2776
    2777
    2778
    2779
    2780
    # File '/Users/julien/java/vertx-stack/stack-docs/target/rb/vertx-redis/redis_transaction.rb', line 2774

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

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

This command is exactly like GEORADIUS with the sole difference that instead of taking, as the center of the area to query, a longitude and latitude value, it takes the name of a member already existing inside the geospatial index represented by the sorted set.

Parameters:

- key (`String`) (defaults to: `nil`) —
  Key string
- member (`String`) (defaults to: `nil`) —
  member
- radius (`Float`) (defaults to: `nil`) —
  radius
- unit (`:m`, `:km`, `:mi`, `:ft`) (defaults to: `nil`) —
  geo unit

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    2790
    2791
    2792
    2793
    2794
    2795
    2796
    # File '/Users/julien/java/vertx-stack/stack-docs/target/rb/vertx-redis/redis_transaction.rb', line 2790

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

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

This command is exactly like GEORADIUS with the sole difference that instead of taking, as the center of the area to query, a longitude and latitude value, it takes the name of a member already existing inside the geospatial index represented by the sorted set.

Parameters:

- key (`String`) (defaults to: `nil`) —
  Key string
- member (`String`) (defaults to: `nil`) —
  member
- radius (`Float`) (defaults to: `nil`) —
  radius
- unit (`:m`, `:km`, `:mi`, `:ft`) (defaults to: `nil`) —
  geo unit
- options (`Hash`) (defaults to: `nil`) —
  geo radius options

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    2807
    2808
    2809
    2810
    2811
    2812
    2813
    # File '/Users/julien/java/vertx-stack/stack-docs/target/rb/vertx-redis/redis_transaction.rb', line 2807

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

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

Get the value of a key

Parameters:

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

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    827
    828
    829
    830
    831
    832
    833
    # File '/Users/julien/java/vertx-stack/stack-docs/target/rb/vertx-redis/redis_transaction.rb', line 827

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

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

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

Parameters:

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

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    838
    839
    840
    841
    842
    843
    844
    # File '/Users/julien/java/vertx-stack/stack-docs/target/rb/vertx-redis/redis_transaction.rb', line 838

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

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

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

Parameters:

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

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    850
    851
    852
    853
    854
    855
    856
    # File '/Users/julien/java/vertx-stack/stack-docs/target/rb/vertx-redis/redis_transaction.rb', line 850

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

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

Get a substring of the string stored at a key

Parameters:

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

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    863
    864
    865
    866
    867
    868
    869
    # File '/Users/julien/java/vertx-stack/stack-docs/target/rb/vertx-redis/redis_transaction.rb', line 863

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

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

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

Parameters:

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

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    875
    876
    877
    878
    879
    880
    881
    # File '/Users/julien/java/vertx-stack/stack-docs/target/rb/vertx-redis/redis_transaction.rb', line 875

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

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

Delete one or more hash fields

Parameters:

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

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    887
    888
    889
    890
    891
    892
    893
    # File '/Users/julien/java/vertx-stack/stack-docs/target/rb/vertx-redis/redis_transaction.rb', line 887

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

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

Delete one or more hash fields

Parameters:

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

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    899
    900
    901
    902
    903
    904
    905
    # File '/Users/julien/java/vertx-stack/stack-docs/target/rb/vertx-redis/redis_transaction.rb', line 899

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

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

Determine if a hash field exists

Parameters:

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

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    911
    912
    913
    914
    915
    916
    917
    # File '/Users/julien/java/vertx-stack/stack-docs/target/rb/vertx-redis/redis_transaction.rb', line 911

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

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

Get the value of a hash field

Parameters:

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

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    923
    924
    925
    926
    927
    928
    929
    # File '/Users/julien/java/vertx-stack/stack-docs/target/rb/vertx-redis/redis_transaction.rb', line 923

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

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

Get all the fields and values in a hash

Parameters:

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

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    934
    935
    936
    937
    938
    939
    940
    # File '/Users/julien/java/vertx-stack/stack-docs/target/rb/vertx-redis/redis_transaction.rb', line 934

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

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

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

Parameters:

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

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    947
    948
    949
    950
    951
    952
    953
    # File '/Users/julien/java/vertx-stack/stack-docs/target/rb/vertx-redis/redis_transaction.rb', line 947

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

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

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

Parameters:

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

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    960
    961
    962
    963
    964
    965
    966
    # File '/Users/julien/java/vertx-stack/stack-docs/target/rb/vertx-redis/redis_transaction.rb', line 960

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

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

Get all the fields in a hash

Parameters:

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

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    971
    972
    973
    974
    975
    976
    977
    # File '/Users/julien/java/vertx-stack/stack-docs/target/rb/vertx-redis/redis_transaction.rb', line 971

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

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

Get the number of fields in a hash

Parameters:

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

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    982
    983
    984
    985
    986
    987
    988
    # File '/Users/julien/java/vertx-stack/stack-docs/target/rb/vertx-redis/redis_transaction.rb', line 982

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

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

Get the values of all the given hash fields

Parameters:

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

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    994
    995
    996
    997
    998
    999
    1000
    # File '/Users/julien/java/vertx-stack/stack-docs/target/rb/vertx-redis/redis_transaction.rb', line 994

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

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

Set multiple hash fields to multiple values

Parameters:

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

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    1006
    1007
    1008
    1009
    1010
    1011
    1012
    # File '/Users/julien/java/vertx-stack/stack-docs/target/rb/vertx-redis/redis_transaction.rb', line 1006

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

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

Incrementally iterate hash fields and associated values

Parameters:

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

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    2623
    2624
    2625
    2626
    2627
    2628
    2629
    # File '/Users/julien/java/vertx-stack/stack-docs/target/rb/vertx-redis/redis_transaction.rb', line 2623

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

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

Set the string value of a hash field

Parameters:

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

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    1019
    1020
    1021
    1022
    1023
    1024
    1025
    # File '/Users/julien/java/vertx-stack/stack-docs/target/rb/vertx-redis/redis_transaction.rb', line 1019

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

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

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

Parameters:

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

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    1032
    1033
    1034
    1035
    1036
    1037
    1038
    # File '/Users/julien/java/vertx-stack/stack-docs/target/rb/vertx-redis/redis_transaction.rb', line 1032

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

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

Get all the values in a hash

Parameters:

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

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    1043
    1044
    1045
    1046
    1047
    1048
    1049
    # File '/Users/julien/java/vertx-stack/stack-docs/target/rb/vertx-redis/redis_transaction.rb', line 1043

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

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

Increment the integer value of a key by one

Parameters:

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

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    1054
    1055
    1056
    1057
    1058
    1059
    1060
    # File '/Users/julien/java/vertx-stack/stack-docs/target/rb/vertx-redis/redis_transaction.rb', line 1054

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

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

Increment the integer value of a key by the given amount

Parameters:

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

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    1066
    1067
    1068
    1069
    1070
    1071
    1072
    # File '/Users/julien/java/vertx-stack/stack-docs/target/rb/vertx-redis/redis_transaction.rb', line 1066

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

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

Increment the float value of a key by the given amount

Parameters:

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

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    1078
    1079
    1080
    1081
    1082
    1083
    1084
    # File '/Users/julien/java/vertx-stack/stack-docs/target/rb/vertx-redis/redis_transaction.rb', line 1078

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

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

Get information and statistics about the server

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    1088
    1089
    1090
    1091
    1092
    1093
    1094
    # File '/Users/julien/java/vertx-stack/stack-docs/target/rb/vertx-redis/redis_transaction.rb', line 1088

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

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

Get information and statistics about the server

Parameters:

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

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    1099
    1100
    1101
    1102
    1103
    1104
    1105
    # File '/Users/julien/java/vertx-stack/stack-docs/target/rb/vertx-redis/redis_transaction.rb', line 1099

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

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

Find all keys matching the given pattern

Parameters:

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

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    1110
    1111
    1112
    1113
    1114
    1115
    1116
    # File '/Users/julien/java/vertx-stack/stack-docs/target/rb/vertx-redis/redis_transaction.rb', line 1110

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

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

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

Yields:

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    1120
    1121
    1122
    1123
    1124
    1125
    1126
    # File '/Users/julien/java/vertx-stack/stack-docs/target/rb/vertx-redis/redis_transaction.rb', line 1120

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

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

Get an element from a list by its index

Parameters:

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

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    1132
    1133
    1134
    1135
    1136
    1137
    1138
    # File '/Users/julien/java/vertx-stack/stack-docs/target/rb/vertx-redis/redis_transaction.rb', line 1132

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

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

Insert an element before or after another element in a list

Parameters:

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

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    1146
    1147
    1148
    1149
    1150
    1151
    1152
    # File '/Users/julien/java/vertx-stack/stack-docs/target/rb/vertx-redis/redis_transaction.rb', line 1146

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

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

Get the length of a list

Parameters:

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

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    1157
    1158
    1159
    1160
    1161
    1162
    1163
    # File '/Users/julien/java/vertx-stack/stack-docs/target/rb/vertx-redis/redis_transaction.rb', line 1157

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

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

Remove and get the first element in a list

Parameters:

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

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    1168
    1169
    1170
    1171
    1172
    1173
    1174
    # File '/Users/julien/java/vertx-stack/stack-docs/target/rb/vertx-redis/redis_transaction.rb', line 1168

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

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

Prepend one value to a list

Parameters:

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

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    1192
    1193
    1194
    1195
    1196
    1197
    1198
    # File '/Users/julien/java/vertx-stack/stack-docs/target/rb/vertx-redis/redis_transaction.rb', line 1192

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

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

Prepend one or multiple values to a list

Parameters:

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

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    1180
    1181
    1182
    1183
    1184
    1185
    1186
    # File '/Users/julien/java/vertx-stack/stack-docs/target/rb/vertx-redis/redis_transaction.rb', line 1180

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

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

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

Parameters:

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

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    1204
    1205
    1206
    1207
    1208
    1209
    1210
    # File '/Users/julien/java/vertx-stack/stack-docs/target/rb/vertx-redis/redis_transaction.rb', line 1204

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

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

Get a range of elements from a list

Parameters:

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

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    1217
    1218
    1219
    1220
    1221
    1222
    1223
    # File '/Users/julien/java/vertx-stack/stack-docs/target/rb/vertx-redis/redis_transaction.rb', line 1217

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

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

Remove elements from a list

Parameters:

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

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    1230
    1231
    1232
    1233
    1234
    1235
    1236
    # File '/Users/julien/java/vertx-stack/stack-docs/target/rb/vertx-redis/redis_transaction.rb', line 1230

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

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

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

Parameters:

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

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    1243
    1244
    1245
    1246
    1247
    1248
    1249
    # File '/Users/julien/java/vertx-stack/stack-docs/target/rb/vertx-redis/redis_transaction.rb', line 1243

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

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

Trim a list to the specified range

Parameters:

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

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    1256
    1257
    1258
    1259
    1260
    1261
    1262
    # File '/Users/julien/java/vertx-stack/stack-docs/target/rb/vertx-redis/redis_transaction.rb', line 1256

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

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

Get the value of the given key

Parameters:

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

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    1267
    1268
    1269
    1270
    1271
    1272
    1273
    # File '/Users/julien/java/vertx-stack/stack-docs/target/rb/vertx-redis/redis_transaction.rb', line 1267

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

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

Get the values of all the given keys

Parameters:

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

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    1278
    1279
    1280
    1281
    1282
    1283
    1284
    # File '/Users/julien/java/vertx-stack/stack-docs/target/rb/vertx-redis/redis_transaction.rb', line 1278

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

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

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

Parameters:

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

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    1294
    1295
    1296
    1297
    1298
    1299
    1300
    # File '/Users/julien/java/vertx-stack/stack-docs/target/rb/vertx-redis/redis_transaction.rb', line 1294

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

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

Listen for all requests received by the server in real time

Yields:

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    1304
    1305
    1306
    1307
    1308
    1309
    1310
    # File '/Users/julien/java/vertx-stack/stack-docs/target/rb/vertx-redis/redis_transaction.rb', line 1304

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

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

Move a key to another database

Parameters:

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

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    1316
    1317
    1318
    1319
    1320
    1321
    1322
    # File '/Users/julien/java/vertx-stack/stack-docs/target/rb/vertx-redis/redis_transaction.rb', line 1316

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

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

Set multiple keys to multiple values

Parameters:

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

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    1327
    1328
    1329
    1330
    1331
    1332
    1333
    # File '/Users/julien/java/vertx-stack/stack-docs/target/rb/vertx-redis/redis_transaction.rb', line 1327

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

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

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

Parameters:

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

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    1338
    1339
    1340
    1341
    1342
    1343
    1344
    # File '/Users/julien/java/vertx-stack/stack-docs/target/rb/vertx-redis/redis_transaction.rb', line 1338

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

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

Mark the start of a RedisTransaction block

Yields:

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    1348
    1349
    1350
    1351
    1352
    1353
    1354
    # File '/Users/julien/java/vertx-stack/stack-docs/target/rb/vertx-redis/redis_transaction.rb', line 1348

    def multi
      if block_given?
        @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) }))
        return self
      end
      raise ArgumentError, "Invalid arguments when calling multi()"
    end

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

Inspect the internals of Redis objects

Parameters:

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

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    1360
    1361
    1362
    1363
    1364
    1365
    1366
    # File '/Users/julien/java/vertx-stack/stack-docs/target/rb/vertx-redis/redis_transaction.rb', line 1360

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

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

Remove the expiration from a key

Parameters:

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

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    1371
    1372
    1373
    1374
    1375
    1376
    1377
    # File '/Users/julien/java/vertx-stack/stack-docs/target/rb/vertx-redis/redis_transaction.rb', line 1371

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

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

Set a key's time to live in milliseconds

Parameters:

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

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    1383
    1384
    1385
    1386
    1387
    1388
    1389
    # File '/Users/julien/java/vertx-stack/stack-docs/target/rb/vertx-redis/redis_transaction.rb', line 1383

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

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

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

Parameters:

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

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    1395
    1396
    1397
    1398
    1399
    1400
    1401
    # File '/Users/julien/java/vertx-stack/stack-docs/target/rb/vertx-redis/redis_transaction.rb', line 1395

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

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

Adds the specified element to the specified HyperLogLog.

Parameters:

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

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    1407
    1408
    1409
    1410
    1411
    1412
    1413
    # File '/Users/julien/java/vertx-stack/stack-docs/target/rb/vertx-redis/redis_transaction.rb', line 1407

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

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

Adds the specified elements to the specified HyperLogLog.

Parameters:

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

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    1419
    1420
    1421
    1422
    1423
    1424
    1425
    # File '/Users/julien/java/vertx-stack/stack-docs/target/rb/vertx-redis/redis_transaction.rb', line 1419

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

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

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

Parameters:

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

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    1430
    1431
    1432
    1433
    1434
    1435
    1436
    # File '/Users/julien/java/vertx-stack/stack-docs/target/rb/vertx-redis/redis_transaction.rb', line 1430

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

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

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

Parameters:

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

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    1441
    1442
    1443
    1444
    1445
    1446
    1447
    # File '/Users/julien/java/vertx-stack/stack-docs/target/rb/vertx-redis/redis_transaction.rb', line 1441

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

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

Merge N different HyperLogLogs into a single one.

Parameters:

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

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    1453
    1454
    1455
    1456
    1457
    1458
    1459
    # File '/Users/julien/java/vertx-stack/stack-docs/target/rb/vertx-redis/redis_transaction.rb', line 1453

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

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

Ping the server

Yields:

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    1463
    1464
    1465
    1466
    1467
    1468
    1469
    # File '/Users/julien/java/vertx-stack/stack-docs/target/rb/vertx-redis/redis_transaction.rb', line 1463

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

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

Set the value and expiration in milliseconds of a key

Parameters:

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

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    1476
    1477
    1478
    1479
    1480
    1481
    1482
    # File '/Users/julien/java/vertx-stack/stack-docs/target/rb/vertx-redis/redis_transaction.rb', line 1476

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

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

Listen for messages published to channels matching the given pattern

Parameters:

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

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    1487
    1488
    1489
    1490
    1491
    1492
    1493
    # File '/Users/julien/java/vertx-stack/stack-docs/target/rb/vertx-redis/redis_transaction.rb', line 1487

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

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

Listen for messages published to channels matching the given patterns

Parameters:

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

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    1498
    1499
    1500
    1501
    1502
    1503
    1504
    # File '/Users/julien/java/vertx-stack/stack-docs/target/rb/vertx-redis/redis_transaction.rb', line 1498

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

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

Get the time to live for a key in milliseconds

Parameters:

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

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    1541
    1542
    1543
    1544
    1545
    1546
    1547
    # File '/Users/julien/java/vertx-stack/stack-docs/target/rb/vertx-redis/redis_transaction.rb', line 1541

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

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

Post a message to a channel

Parameters:

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

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    1553
    1554
    1555
    1556
    1557
    1558
    1559
    # File '/Users/julien/java/vertx-stack/stack-docs/target/rb/vertx-redis/redis_transaction.rb', line 1553

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

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

Lists the currently active channels - only those matching the pattern

Parameters:

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

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    1509
    1510
    1511
    1512
    1513
    1514
    1515
    # File '/Users/julien/java/vertx-stack/stack-docs/target/rb/vertx-redis/redis_transaction.rb', line 1509

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

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

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

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    1530
    1531
    1532
    1533
    1534
    1535
    1536
    # File '/Users/julien/java/vertx-stack/stack-docs/target/rb/vertx-redis/redis_transaction.rb', line 1530

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

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

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

Parameters:

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

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    1520
    1521
    1522
    1523
    1524
    1525
    1526
    # File '/Users/julien/java/vertx-stack/stack-docs/target/rb/vertx-redis/redis_transaction.rb', line 1520

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

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

Stop listening for messages posted to channels matching the given patterns

Parameters:

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

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    1564
    1565
    1566
    1567
    1568
    1569
    1570
    # File '/Users/julien/java/vertx-stack/stack-docs/target/rb/vertx-redis/redis_transaction.rb', line 1564

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

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

Return a random key from the keyspace

Yields:

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    1574
    1575
    1576
    1577
    1578
    1579
    1580
    # File '/Users/julien/java/vertx-stack/stack-docs/target/rb/vertx-redis/redis_transaction.rb', line 1574

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

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

Rename a key

Parameters:

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

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    1586
    1587
    1588
    1589
    1590
    1591
    1592
    # File '/Users/julien/java/vertx-stack/stack-docs/target/rb/vertx-redis/redis_transaction.rb', line 1586

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

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

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

Parameters:

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

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    1598
    1599
    1600
    1601
    1602
    1603
    1604
    # File '/Users/julien/java/vertx-stack/stack-docs/target/rb/vertx-redis/redis_transaction.rb', line 1598

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

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

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

Parameters:

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

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    1611
    1612
    1613
    1614
    1615
    1616
    1617
    # File '/Users/julien/java/vertx-stack/stack-docs/target/rb/vertx-redis/redis_transaction.rb', line 1611

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

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

Return the role of the instance in the context of replication

Yields:

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    1621
    1622
    1623
    1624
    1625
    1626
    1627
    # File '/Users/julien/java/vertx-stack/stack-docs/target/rb/vertx-redis/redis_transaction.rb', line 1621

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

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

Remove and get the last element in a list

Parameters:

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

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    1632
    1633
    1634
    1635
    1636
    1637
    1638
    # File '/Users/julien/java/vertx-stack/stack-docs/target/rb/vertx-redis/redis_transaction.rb', line 1632

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

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

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

Parameters:

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

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    1644
    1645
    1646
    1647
    1648
    1649
    1650
    # File '/Users/julien/java/vertx-stack/stack-docs/target/rb/vertx-redis/redis_transaction.rb', line 1644

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

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

Append one or multiple values to a list

Parameters:

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

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    1668
    1669
    1670
    1671
    1672
    1673
    1674
    # File '/Users/julien/java/vertx-stack/stack-docs/target/rb/vertx-redis/redis_transaction.rb', line 1668

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

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

Append one or multiple values to a list

Parameters:

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

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    1656
    1657
    1658
    1659
    1660
    1661
    1662
    # File '/Users/julien/java/vertx-stack/stack-docs/target/rb/vertx-redis/redis_transaction.rb', line 1656

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

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

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

Parameters:

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

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    1680
    1681
    1682
    1683
    1684
    1685
    1686
    # File '/Users/julien/java/vertx-stack/stack-docs/target/rb/vertx-redis/redis_transaction.rb', line 1680

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

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

Add a member to a set

Parameters:

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

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    1692
    1693
    1694
    1695
    1696
    1697
    1698
    # File '/Users/julien/java/vertx-stack/stack-docs/target/rb/vertx-redis/redis_transaction.rb', line 1692

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

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

Add one or more members to a set

Parameters:

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

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    1704
    1705
    1706
    1707
    1708
    1709
    1710
    # File '/Users/julien/java/vertx-stack/stack-docs/target/rb/vertx-redis/redis_transaction.rb', line 1704

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

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

Synchronously save the dataset to disk

Yields:

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    1714
    1715
    1716
    1717
    1718
    1719
    1720
    # File '/Users/julien/java/vertx-stack/stack-docs/target/rb/vertx-redis/redis_transaction.rb', line 1714

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

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

Incrementally iterate the keys space

Parameters:

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

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    2597
    2598
    2599
    2600
    2601
    2602
    2603
    # File '/Users/julien/java/vertx-stack/stack-docs/target/rb/vertx-redis/redis_transaction.rb', line 2597

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

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

Get the number of members in a set

Parameters:

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

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    1725
    1726
    1727
    1728
    1729
    1730
    1731
    # File '/Users/julien/java/vertx-stack/stack-docs/target/rb/vertx-redis/redis_transaction.rb', line 1725

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

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

Check existence of script in the script cache.

Parameters:

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

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    1736
    1737
    1738
    1739
    1740
    1741
    1742
    # File '/Users/julien/java/vertx-stack/stack-docs/target/rb/vertx-redis/redis_transaction.rb', line 1736

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

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

Check existence of scripts in the script cache.

Parameters:

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

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    1747
    1748
    1749
    1750
    1751
    1752
    1753
    # File '/Users/julien/java/vertx-stack/stack-docs/target/rb/vertx-redis/redis_transaction.rb', line 1747

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

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

Remove all the scripts from the script cache.

Yields:

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    1757
    1758
    1759
    1760
    1761
    1762
    1763
    # File '/Users/julien/java/vertx-stack/stack-docs/target/rb/vertx-redis/redis_transaction.rb', line 1757

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

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

Kill the script currently in execution.

Yields:

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    1767
    1768
    1769
    1770
    1771
    1772
    1773
    # File '/Users/julien/java/vertx-stack/stack-docs/target/rb/vertx-redis/redis_transaction.rb', line 1767

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

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

Load the specified Lua script into the script cache.

Parameters:

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

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    1778
    1779
    1780
    1781
    1782
    1783
    1784
    # File '/Users/julien/java/vertx-stack/stack-docs/target/rb/vertx-redis/redis_transaction.rb', line 1778

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

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

Subtract multiple sets

Parameters:

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

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    1790
    1791
    1792
    1793
    1794
    1795
    1796
    # File '/Users/julien/java/vertx-stack/stack-docs/target/rb/vertx-redis/redis_transaction.rb', line 1790

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

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

Subtract multiple sets and store the resulting set in a key

Parameters:

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

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    1803
    1804
    1805
    1806
    1807
    1808
    1809
    # File '/Users/julien/java/vertx-stack/stack-docs/target/rb/vertx-redis/redis_transaction.rb', line 1803

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

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

Change the selected database for the current connection

Parameters:

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

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    1814
    1815
    1816
    1817
    1818
    1819
    1820
    # File '/Users/julien/java/vertx-stack/stack-docs/target/rb/vertx-redis/redis_transaction.rb', line 1814

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

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

Set the string value of a key

Parameters:

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

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    1826
    1827
    1828
    1829
    1830
    1831
    1832
    # File '/Users/julien/java/vertx-stack/stack-docs/target/rb/vertx-redis/redis_transaction.rb', line 1826

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

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

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

Parameters:

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

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    1851
    1852
    1853
    1854
    1855
    1856
    1857
    # File '/Users/julien/java/vertx-stack/stack-docs/target/rb/vertx-redis/redis_transaction.rb', line 1851

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

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

Set the string value of a key

Parameters:

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

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    1864
    1865
    1866
    1867
    1868
    1869
    1870
    # File '/Users/julien/java/vertx-stack/stack-docs/target/rb/vertx-redis/redis_transaction.rb', line 1864

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

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

Set the string value of a key

Parameters:

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

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    1839
    1840
    1841
    1842
    1843
    1844
    1845
    # File '/Users/julien/java/vertx-stack/stack-docs/target/rb/vertx-redis/redis_transaction.rb', line 1839

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

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

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

Parameters:

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

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    1877
    1878
    1879
    1880
    1881
    1882
    1883
    # File '/Users/julien/java/vertx-stack/stack-docs/target/rb/vertx-redis/redis_transaction.rb', line 1877

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

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

Set the value and expiration of a key

Parameters:

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

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    1890
    1891
    1892
    1893
    1894
    1895
    1896
    # File '/Users/julien/java/vertx-stack/stack-docs/target/rb/vertx-redis/redis_transaction.rb', line 1890

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

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

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

Parameters:

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

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    1902
    1903
    1904
    1905
    1906
    1907
    1908
    # File '/Users/julien/java/vertx-stack/stack-docs/target/rb/vertx-redis/redis_transaction.rb', line 1902

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

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

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

Parameters:

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

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    1915
    1916
    1917
    1918
    1919
    1920
    1921
    # File '/Users/julien/java/vertx-stack/stack-docs/target/rb/vertx-redis/redis_transaction.rb', line 1915

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

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

Intersect multiple sets

Parameters:

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

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    1926
    1927
    1928
    1929
    1930
    1931
    1932
    # File '/Users/julien/java/vertx-stack/stack-docs/target/rb/vertx-redis/redis_transaction.rb', line 1926

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

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

Intersect multiple sets and store the resulting set in a key

Parameters:

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

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    1938
    1939
    1940
    1941
    1942
    1943
    1944
    # File '/Users/julien/java/vertx-stack/stack-docs/target/rb/vertx-redis/redis_transaction.rb', line 1938

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

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

Determine if a given value is a member of a set

Parameters:

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

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    1950
    1951
    1952
    1953
    1954
    1955
    1956
    # File '/Users/julien/java/vertx-stack/stack-docs/target/rb/vertx-redis/redis_transaction.rb', line 1950

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

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

Make the server a slave of another instance

Parameters:

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

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    1962
    1963
    1964
    1965
    1966
    1967
    1968
    # File '/Users/julien/java/vertx-stack/stack-docs/target/rb/vertx-redis/redis_transaction.rb', line 1962

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

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

Make this server a master

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    1972
    1973
    1974
    1975
    1976
    1977
    1978
    # File '/Users/julien/java/vertx-stack/stack-docs/target/rb/vertx-redis/redis_transaction.rb', line 1972

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

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

Read the Redis slow queries log

Parameters:

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

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    1983
    1984
    1985
    1986
    1987
    1988
    1989
    # File '/Users/julien/java/vertx-stack/stack-docs/target/rb/vertx-redis/redis_transaction.rb', line 1983

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

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

Get the length of the Redis slow queries log

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    1993
    1994
    1995
    1996
    1997
    1998
    1999
    # File '/Users/julien/java/vertx-stack/stack-docs/target/rb/vertx-redis/redis_transaction.rb', line 1993

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

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

Reset the Redis slow queries log

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    2003
    2004
    2005
    2006
    2007
    2008
    2009
    # File '/Users/julien/java/vertx-stack/stack-docs/target/rb/vertx-redis/redis_transaction.rb', line 2003

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

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

Get all the members in a set

Parameters:

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

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    2014
    2015
    2016
    2017
    2018
    2019
    2020
    # File '/Users/julien/java/vertx-stack/stack-docs/target/rb/vertx-redis/redis_transaction.rb', line 2014

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

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

Move a member from one set to another

Parameters:

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

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    2027
    2028
    2029
    2030
    2031
    2032
    2033
    # File '/Users/julien/java/vertx-stack/stack-docs/target/rb/vertx-redis/redis_transaction.rb', line 2027

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

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

Sort the elements in a list, set or sorted set

Parameters:

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

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    2039
    2040
    2041
    2042
    2043
    2044
    2045
    # File '/Users/julien/java/vertx-stack/stack-docs/target/rb/vertx-redis/redis_transaction.rb', line 2039

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

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

Remove and return a random member from a set

Parameters:

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

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    2050
    2051
    2052
    2053
    2054
    2055
    2056
    # File '/Users/julien/java/vertx-stack/stack-docs/target/rb/vertx-redis/redis_transaction.rb', line 2050

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

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

Remove and return random members from a set

Parameters:

- key (`String`) (defaults to: `nil`) —
  Key string
- count (`Fixnum`) (defaults to: `nil`) —
  Number of members to remove

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    2062
    2063
    2064
    2065
    2066
    2067
    2068
    # File '/Users/julien/java/vertx-stack/stack-docs/target/rb/vertx-redis/redis_transaction.rb', line 2062

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

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

Get one or multiple random members from a set

Parameters:

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

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    2073
    2074
    2075
    2076
    2077
    2078
    2079
    # File '/Users/julien/java/vertx-stack/stack-docs/target/rb/vertx-redis/redis_transaction.rb', line 2073

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

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

Get one or multiple random members from a set

Parameters:

- key (`String`) (defaults to: `nil`) —
  Key string
- count (`Fixnum`) (defaults to: `nil`) —
  Number of members to get

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    2085
    2086
    2087
    2088
    2089
    2090
    2091
    # File '/Users/julien/java/vertx-stack/stack-docs/target/rb/vertx-redis/redis_transaction.rb', line 2085

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

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

Remove one member from a set

Parameters:

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

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    2097
    2098
    2099
    2100
    2101
    2102
    2103
    # File '/Users/julien/java/vertx-stack/stack-docs/target/rb/vertx-redis/redis_transaction.rb', line 2097

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

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

Remove one or more members from a set

Parameters:

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

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    2109
    2110
    2111
    2112
    2113
    2114
    2115
    # File '/Users/julien/java/vertx-stack/stack-docs/target/rb/vertx-redis/redis_transaction.rb', line 2109

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

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

Incrementally iterate Set elements

Parameters:

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

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    2610
    2611
    2612
    2613
    2614
    2615
    2616
    # File '/Users/julien/java/vertx-stack/stack-docs/target/rb/vertx-redis/redis_transaction.rb', line 2610

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

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

Get the length of the value stored in a key

Parameters:

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

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    2120
    2121
    2122
    2123
    2124
    2125
    2126
    # File '/Users/julien/java/vertx-stack/stack-docs/target/rb/vertx-redis/redis_transaction.rb', line 2120

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

### - (`self`) subscribe(channel = nil) { ... }

Listen for messages published to the given channels

Parameters:

- channel (`String`) (defaults to: `nil`) —
  Channel to subscribe to

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    2131
    2132
    2133
    2134
    2135
    2136
    2137
    # File '/Users/julien/java/vertx-stack/stack-docs/target/rb/vertx-redis/redis_transaction.rb', line 2131

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

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

Listen for messages published to the given channels

Parameters:

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

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    2142
    2143
    2144
    2145
    2146
    2147
    2148
    # File '/Users/julien/java/vertx-stack/stack-docs/target/rb/vertx-redis/redis_transaction.rb', line 2142

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

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

Add multiple sets

Parameters:

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

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    2153
    2154
    2155
    2156
    2157
    2158
    2159
    # File '/Users/julien/java/vertx-stack/stack-docs/target/rb/vertx-redis/redis_transaction.rb', line 2153

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

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

Add multiple sets and store the resulting set in a key

Parameters:

- destkey (`String`) (defaults to: `nil`) —
  Destination key
- keys (`Array<String>`) (defaults to: `nil`) —
  List of keys identifying sets to add up

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    2165
    2166
    2167
    2168
    2169
    2170
    2171
    # File '/Users/julien/java/vertx-stack/stack-docs/target/rb/vertx-redis/redis_transaction.rb', line 2165

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

### - (`self`) swapdb(index1 = nil, index2 = nil) { ... }

Swaps two Redis databases

Parameters:

- index1 (`Fixnum`) (defaults to: `nil`) —
  index of first database to swap
- index2 (`Fixnum`) (defaults to: `nil`) —
  index of second database to swap

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    2841
    2842
    2843
    2844
    2845
    2846
    2847
    # File '/Users/julien/java/vertx-stack/stack-docs/target/rb/vertx-redis/redis_transaction.rb', line 2841

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

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

Internal command used for replication

Yields:

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    2175
    2176
    2177
    2178
    2179
    2180
    2181
    # File '/Users/julien/java/vertx-stack/stack-docs/target/rb/vertx-redis/redis_transaction.rb', line 2175

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

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

Return the current server time

Yields:

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    2185
    2186
    2187
    2188
    2189
    2190
    2191
    # File '/Users/julien/java/vertx-stack/stack-docs/target/rb/vertx-redis/redis_transaction.rb', line 2185

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

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

Get the time to live for a key

Parameters:

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

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    2196
    2197
    2198
    2199
    2200
    2201
    2202
    # File '/Users/julien/java/vertx-stack/stack-docs/target/rb/vertx-redis/redis_transaction.rb', line 2196

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

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

Determine the type stored at key

Parameters:

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

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    2207
    2208
    2209
    2210
    2211
    2212
    2213
    # File '/Users/julien/java/vertx-stack/stack-docs/target/rb/vertx-redis/redis_transaction.rb', line 2207

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

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

Delete a key asynchronously in another thread. Otherwise it is just as DEL, but non blocking.

Parameters:

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

Yields:

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    2818
    2819
    2820
    2821
    2822
    2823
    2824
    # File '/Users/julien/java/vertx-stack/stack-docs/target/rb/vertx-redis/redis_transaction.rb', line 2818

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

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

Delete multiple keys asynchronously in another thread. Otherwise it is just as DEL, but non blocking.

Parameters:

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

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    2829
    2830
    2831
    2832
    2833
    2834
    2835
    # File '/Users/julien/java/vertx-stack/stack-docs/target/rb/vertx-redis/redis_transaction.rb', line 2829

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

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

Stop listening for messages posted to the given channels

Parameters:

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

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    2218
    2219
    2220
    2221
    2222
    2223
    2224
    # File '/Users/julien/java/vertx-stack/stack-docs/target/rb/vertx-redis/redis_transaction.rb', line 2218

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

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

Forget about all watched keys

Yields:

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    2228
    2229
    2230
    2231
    2232
    2233
    2234
    # File '/Users/julien/java/vertx-stack/stack-docs/target/rb/vertx-redis/redis_transaction.rb', line 2228

    def unwatch
      if block_given?
        @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) }))
        return self
      end
      raise ArgumentError, "Invalid arguments when calling unwatch()"
    end

### - (`self`) wait(numSlaves = nil, timeout = nil) { ... }

Wait for the synchronous replication of all the write commands sent in the context of the current connection.

Parameters:

- numSlaves (`Fixnum`) (defaults to: `nil`)
- timeout (`Fixnum`) (defaults to: `nil`)

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    2240
    2241
    2242
    2243
    2244
    2245
    2246
    # File '/Users/julien/java/vertx-stack/stack-docs/target/rb/vertx-redis/redis_transaction.rb', line 2240

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

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

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

Parameters:

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

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    2251
    2252
    2253
    2254
    2255
    2256
    2257
    # File '/Users/julien/java/vertx-stack/stack-docs/target/rb/vertx-redis/redis_transaction.rb', line 2251

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

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

- (`self`)

Raises:

- (`ArgumentError`)

    2262
    2263
    2264
    2265
    2266
    2267
    2268
    # File '/Users/julien/java/vertx-stack/stack-docs/target/rb/vertx-redis/redis_transaction.rb', line 2262

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

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

Add one or more members to a sorted set, or update its score if it already exists

Parameters:

- key (`String`) (defaults to: `nil`) —
  Key string
- score (`Float`) (defaults to: `nil`) —
  Score used for sorting
- member (`String`) (defaults to: `nil`) —
  New member key

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    2275
    2276
    2277
    2278
    2279
    2280
    2281
    # File '/Users/julien/java/vertx-stack/stack-docs/target/rb/vertx-redis/redis_transaction.rb', line 2275

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

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

Add one or more members to a sorted set, or update its score if it already exists

Parameters:

- key (`String`) (defaults to: `nil`) —
  Key string
- members (`Hash{String => Float}`) (defaults to: `nil`) —
  New member keys and their scores

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    2287
    2288
    2289
    2290
    2291
    2292
    2293
    # File '/Users/julien/java/vertx-stack/stack-docs/target/rb/vertx-redis/redis_transaction.rb', line 2287

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

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

Get the number of members in a sorted set

Parameters:

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

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    2298
    2299
    2300
    2301
    2302
    2303
    2304
    # File '/Users/julien/java/vertx-stack/stack-docs/target/rb/vertx-redis/redis_transaction.rb', line 2298

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

### - (`self`) zcount(key = nil, min = nil, max = nil) { ... }

Count the members in a sorted set with scores within the given values

Parameters:

- key (`String`) (defaults to: `nil`) —
  Key string
- min (`Float`) (defaults to: `nil`) —
  Minimum score
- max (`Float`) (defaults to: `nil`) —
  Maximum score

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    2311
    2312
    2313
    2314
    2315
    2316
    2317
    # File '/Users/julien/java/vertx-stack/stack-docs/target/rb/vertx-redis/redis_transaction.rb', line 2311

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

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

Increment the score of a member in a sorted set

Parameters:

- key (`String`) (defaults to: `nil`) —
  Key string
- increment (`Float`) (defaults to: `nil`) —
  Increment amount
- member (`String`) (defaults to: `nil`) —
  Member key

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    2324
    2325
    2326
    2327
    2328
    2329
    2330
    # File '/Users/julien/java/vertx-stack/stack-docs/target/rb/vertx-redis/redis_transaction.rb', line 2324

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

### - (`self`) zinterstore(destkey = nil, sets = nil, options = nil) { ... }

Intersect multiple sorted sets and store the resulting sorted set in a new key

Parameters:

- destkey (`String`) (defaults to: `nil`) —
  Destination key
- sets (`Array<String>`) (defaults to: `nil`) —
  List of keys identifying sorted sets to intersect
- options (`:NONE`, `:SUM`, `:MIN`, `:MAX`) (defaults to: `nil`) —
  Aggregation options

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    2337
    2338
    2339
    2340
    2341
    2342
    2343
    # File '/Users/julien/java/vertx-stack/stack-docs/target/rb/vertx-redis/redis_transaction.rb', line 2337

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

### - (`self`) zinterstore_weighed(destkey = nil, sets = nil, options = nil) { ... }

Intersect multiple sorted sets and store the resulting sorted set in a new key using weights for scoring

Parameters:

- destkey (`String`) (defaults to: `nil`) —
  Destination key
- sets (`Hash{String => Float}`) (defaults to: `nil`) —
  List of keys identifying sorted sets to intersect
- options (`:NONE`, `:SUM`, `:MIN`, `:MAX`) (defaults to: `nil`) —
  Aggregation options

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    2350
    2351
    2352
    2353
    2354
    2355
    2356
    # File '/Users/julien/java/vertx-stack/stack-docs/target/rb/vertx-redis/redis_transaction.rb', line 2350

    def zinterstore_weighed(destkey=nil,sets=nil,options=nil)
      if destkey.class == String && sets.class == Hash && options.class == Symbol && block_given?
        @j_del.java_method(:zinterstoreWeighed, [Java::java.lang.String.java_class,Java::JavaUtil::Map.java_class,Java::IoVertxRedisOp::AggregateOptions.java_class,Java::IoVertxCore::Handler.java_class]).call(destkey,Hash[sets.map { |k,v| [k,::Vertx::Util::Utils.to_double(v)] }],Java::IoVertxRedisOp::AggregateOptions.valueOf(options.to_s),(Proc.new { |ar| yield(ar.failed ? ar.cause : nil, ar.succeeded ? ar.result : nil) }))
        return self
      end
      raise ArgumentError, "Invalid arguments when calling zinterstore_weighed(#{destkey},#{sets},#{options})"
    end

### - (`self`) zlexcount(key = nil, min = nil, max = nil) { ... }

Count the number of members in a sorted set between a given lexicographical range

Parameters:

- key (`String`) (defaults to: `nil`) —
  Key string
- min (`String`) (defaults to: `nil`) —
  Pattern to compare against for minimum value
- max (`String`) (defaults to: `nil`) —
  Pattern to compare against for maximum value

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    2363
    2364
    2365
    2366
    2367
    2368
    2369
    # File '/Users/julien/java/vertx-stack/stack-docs/target/rb/vertx-redis/redis_transaction.rb', line 2363

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

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

Return a range of members in a sorted set, by index

Parameters:

- key (`String`) (defaults to: `nil`) —
  Key string
- start (`Fixnum`) (defaults to: `nil`) —
  Start index for the range
- stop (`Fixnum`) (defaults to: `nil`) —
  Stop index for the range - inclusive

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    2376
    2377
    2378
    2379
    2380
    2381
    2382
    # File '/Users/julien/java/vertx-stack/stack-docs/target/rb/vertx-redis/redis_transaction.rb', line 2376

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

### - (`self`) zrange_with_options(key = nil, start = nil, stop = nil, options = nil) { ... }

Return a range of members in a sorted set, by index

Parameters:

- key (`String`) (defaults to: `nil`) —
  Key string
- start (`Fixnum`) (defaults to: `nil`) —
  Start index for the range
- stop (`Fixnum`) (defaults to: `nil`) —
  Stop index for the range - inclusive
- options (`:NONE`, `:WITHSCORES`) (defaults to: `nil`) —
  Range options

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    2390
    2391
    2392
    2393
    2394
    2395
    2396
    # File '/Users/julien/java/vertx-stack/stack-docs/target/rb/vertx-redis/redis_transaction.rb', line 2390

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

### - (`self`) zrangebylex(key = nil, min = nil, max = nil, options = nil) { ... }

Return a range of members in a sorted set, by lexicographical range

Parameters:

- key (`String`) (defaults to: `nil`) —
  Key string
- min (`String`) (defaults to: `nil`) —
  Pattern representing a minimum allowed value
- max (`String`) (defaults to: `nil`) —
  Pattern representing a maximum allowed value
- options (`Hash`) (defaults to: `nil`) —
  Limit options where limit can be specified

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    2404
    2405
    2406
    2407
    2408
    2409
    2410
    # File '/Users/julien/java/vertx-stack/stack-docs/target/rb/vertx-redis/redis_transaction.rb', line 2404

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

### - (`self`) zrangebyscore(key = nil, min = nil, max = nil, options = nil) { ... }

Return a range of members in a sorted set, by score

Parameters:

- key (`String`) (defaults to: `nil`) —
  Key string
- min (`String`) (defaults to: `nil`) —
  Pattern defining a minimum value
- max (`String`) (defaults to: `nil`) —
  Pattern defining a maximum value
- options (`Hash`) (defaults to: `nil`) —
  Range and limit options

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    2418
    2419
    2420
    2421
    2422
    2423
    2424
    # File '/Users/julien/java/vertx-stack/stack-docs/target/rb/vertx-redis/redis_transaction.rb', line 2418

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

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

Determine the index of a member in a sorted set

Parameters:

- key (`String`) (defaults to: `nil`) —
  Key string
- member (`String`) (defaults to: `nil`) —
  Member in the sorted set identified by key

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    2430
    2431
    2432
    2433
    2434
    2435
    2436
    # File '/Users/julien/java/vertx-stack/stack-docs/target/rb/vertx-redis/redis_transaction.rb', line 2430

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

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

Remove one member from a sorted set

Parameters:

- key (`String`) (defaults to: `nil`) —
  Key string
- member (`String`) (defaults to: `nil`) —
  Member in the sorted set identified by key

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    2442
    2443
    2444
    2445
    2446
    2447
    2448
    # File '/Users/julien/java/vertx-stack/stack-docs/target/rb/vertx-redis/redis_transaction.rb', line 2442

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

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

Remove one or more members from a sorted set

Parameters:

- key (`String`) (defaults to: `nil`) —
  Key string
- members (`Array<String>`) (defaults to: `nil`) —
  Members in the sorted set identified by key

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    2454
    2455
    2456
    2457
    2458
    2459
    2460
    # File '/Users/julien/java/vertx-stack/stack-docs/target/rb/vertx-redis/redis_transaction.rb', line 2454

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

### - (`self`) zremrangebylex(key = nil, min = nil, max = nil) { ... }

Remove all members in a sorted set between the given lexicographical range

Parameters:

- key (`String`) (defaults to: `nil`) —
  Key string
- min (`String`) (defaults to: `nil`) —
  Pattern defining a minimum value
- max (`String`) (defaults to: `nil`) —
  Pattern defining a maximum value

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    2467
    2468
    2469
    2470
    2471
    2472
    2473
    # File '/Users/julien/java/vertx-stack/stack-docs/target/rb/vertx-redis/redis_transaction.rb', line 2467

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

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

Remove all members in a sorted set within the given indexes

Parameters:

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

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    2480
    2481
    2482
    2483
    2484
    2485
    2486
    # File '/Users/julien/java/vertx-stack/stack-docs/target/rb/vertx-redis/redis_transaction.rb', line 2480

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

### - (`self`) zremrangebyscore(key = nil, min = nil, max = nil) { ... }

Remove all members in a sorted set within the given scores

Parameters:

- key (`String`) (defaults to: `nil`) —
  Key string
- min (`String`) (defaults to: `nil`) —
  Pattern defining a minimum value
- max (`String`) (defaults to: `nil`) —
  Pattern defining a maximum value

Yields:

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    2493
    2494
    2495
    2496
    2497
    2498
    2499
    # File '/Users/julien/java/vertx-stack/stack-docs/target/rb/vertx-redis/redis_transaction.rb', line 2493

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

### - (`self`) zrevrange(key = nil, start = nil, stop = nil, options = nil) { ... }

Return a range of members in a sorted set, by index, with scores ordered from high to low

Parameters:

- key (`String`) (defaults to: `nil`) —
  Key string
- start (`Fixnum`) (defaults to: `nil`) —
  Start index for the range
- stop (`Fixnum`) (defaults to: `nil`) —
  Stop index for the range - inclusive
- options (`:NONE`, `:WITHSCORES`) (defaults to: `nil`) —
  Range options

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    2507
    2508
    2509
    2510
    2511
    2512
    2513
    # File '/Users/julien/java/vertx-stack/stack-docs/target/rb/vertx-redis/redis_transaction.rb', line 2507

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

### - (`self`) zrevrangebylex(key = nil, max = nil, min = nil, options = nil) { ... }

Return a range of members in a sorted set, by score, between the given lexicographical range with scores ordered from high to low

Parameters:

- key (`String`) (defaults to: `nil`) —
  Key string
- max (`String`) (defaults to: `nil`) —
  Pattern defining a maximum value
- min (`String`) (defaults to: `nil`) —
  Pattern defining a minimum value
- options (`Hash`) (defaults to: `nil`) —
  Limit options

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    2521
    2522
    2523
    2524
    2525
    2526
    2527
    # File '/Users/julien/java/vertx-stack/stack-docs/target/rb/vertx-redis/redis_transaction.rb', line 2521

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

### - (`self`) zrevrangebyscore(key = nil, max = nil, min = nil, options = nil) { ... }

Return a range of members in a sorted set, by score, with scores ordered from high to low

Parameters:

- key (`String`) (defaults to: `nil`) —
  Key string
- max (`String`) (defaults to: `nil`) —
  Pattern defining a maximum value
- min (`String`) (defaults to: `nil`) —
  Pattern defining a minimum value
- options (`Hash`) (defaults to: `nil`) —
  Range and limit options

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    2535
    2536
    2537
    2538
    2539
    2540
    2541
    # File '/Users/julien/java/vertx-stack/stack-docs/target/rb/vertx-redis/redis_transaction.rb', line 2535

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

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

Determine the index of a member in a sorted set, with scores ordered from high to low

Parameters:

- key (`String`) (defaults to: `nil`) —
  Key string
- member (`String`) (defaults to: `nil`) —
  Member in the sorted set identified by key

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    2547
    2548
    2549
    2550
    2551
    2552
    2553
    # File '/Users/julien/java/vertx-stack/stack-docs/target/rb/vertx-redis/redis_transaction.rb', line 2547

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

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

Incrementally iterate sorted sets elements and associated scores

Parameters:

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

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    2636
    2637
    2638
    2639
    2640
    2641
    2642
    # File '/Users/julien/java/vertx-stack/stack-docs/target/rb/vertx-redis/redis_transaction.rb', line 2636

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

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

Get the score associated with the given member in a sorted set

Parameters:

- key (`String`) (defaults to: `nil`) —
  Key string
- member (`String`) (defaults to: `nil`) —
  Member in the sorted set identified by key

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    2559
    2560
    2561
    2562
    2563
    2564
    2565
    # File '/Users/julien/java/vertx-stack/stack-docs/target/rb/vertx-redis/redis_transaction.rb', line 2559

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

### - (`self`) zunionstore(destkey = nil, sets = nil, options = nil) { ... }

Add multiple sorted sets and store the resulting sorted set in a new key

Parameters:

- destkey (`String`) (defaults to: `nil`) —
  Destination key
- sets (`Array<String>`) (defaults to: `nil`) —
  List of keys identifying sorted sets
- options (`:NONE`, `:SUM`, `:MIN`, `:MAX`) (defaults to: `nil`) —
  Aggregation options

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    2572
    2573
    2574
    2575
    2576
    2577
    2578
    # File '/Users/julien/java/vertx-stack/stack-docs/target/rb/vertx-redis/redis_transaction.rb', line 2572

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

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

Add multiple sorted sets using weights, and store the resulting sorted set in a new key

Parameters:

- key (`String`) (defaults to: `nil`) —
  Destination key
- sets (`Hash{String => Float}`) (defaults to: `nil`) —
  Map containing set-key:weight pairs
- options (`:NONE`, `:SUM`, `:MIN`, `:MAX`) (defaults to: `nil`) —
  Aggregation options

Yields:

- Handler for the result of this call.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    2585
    2586
    2587
    2588
    2589
    2590
    2591
    # File '/Users/julien/java/vertx-stack/stack-docs/target/rb/vertx-redis/redis_transaction.rb', line 2585

    def zunionstore_weighed(key=nil,sets=nil,options=nil)
      if key.class == String && sets.class == Hash && options.class == Symbol && block_given?
        @j_del.java_method(:zunionstoreWeighed, [Java::java.lang.String.java_class,Java::JavaUtil::Map.java_class,Java::IoVertxRedisOp::AggregateOptions.java_class,Java::IoVertxCore::Handler.java_class]).call(key,Hash[sets.map { |k,v| [k,::Vertx::Util::Utils.to_double(v)] }],Java::IoVertxRedisOp::AggregateOptions.valueOf(options.to_s),(Proc.new { |ar| yield(ar.failed ? ar.cause : nil, ar.succeeded ? ar.result : nil) }))
        return self
      end
      raise ArgumentError, "Invalid arguments when calling zunionstore_weighed(#{key},#{sets},#{options})"
    end