Class: VertxRedis::RedisTransaction

Inherits:

Object

• Object
• VertxRedis::RedisTransaction

show all

Defined in:

/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx-redis/redis_transaction.rb

Overview

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.

18
19
20

# File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx-redis/redis_transaction.rb', line 18

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

27
28
29

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

def self.j_api_type
  @@j_api_type
end

30
31
32

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

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

24
25
26

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

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

21
22
23

# File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx-redis/redis_transaction.rb', line 21

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

47
48
49
50
51
52
53

# File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/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

58
59
60
61
62
63
64

# File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/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

68
69
70
71
72
73
74

# File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/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

78
79
80
81
82
83
84

# File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/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

89
90
91
92
93
94
95

# File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/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

102
103
104
105
106
107
108

# File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/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

115
116
117
118
119
120
121

# File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/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

127
128
129
130
131
132
133

# File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/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

142
143
144
145
146
147
148

# File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx-redis/redis_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

159
160
161
162
163
164
165

# File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/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

171
172
173
174
175
176
177

# File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/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

183
184
185
186
187
188
189

# File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/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

195
196
197
198
199
200
201

# File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/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

207
208
209
210
211
212
213

# File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/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

220
221
222
223
224
225
226

# File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/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

251
252
253
254
255
256
257

# File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/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

231
232
233
234
235
236
237

# File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/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

241
242
243
244
245
246
247

# File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/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

262
263
264
265
266
267
268

# File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/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

273
274
275
276
277
278
279

# File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/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

36
37
38
39
40
41

# File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/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

284
285
286
287
288
289
290

# File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/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

295
296
297
298
299
300
301

# File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/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

306
307
308
309
310
311
312

# File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/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

317
318
319
320
321
322
323

# File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/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

328
329
330
331
332
333
334

# File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/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

349
350
351
352
353
354
355

# File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/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

338
339
340
341
342
343
344

# File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/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

360
361
362
363
364
365
366

# File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/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

372
373
374
375
376
377
378

# File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/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

382
383
384
385
386
387
388

# File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/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

393
394
395
396
397
398
399

# File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/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

405
406
407
408
409
410
411

# File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/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

415
416
417
418
419
420
421

# File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/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

426
427
428
429
430
431
432

# File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/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

436
437
438
439
440
441
442

# File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/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

447
448
449
450
451
452
453

# File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/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

457
458
459
460
461
462
463

# File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/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

468
469
470
471
472
473
474

# File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/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

480
481
482
483
484
485
486

# File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/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

493
494
495
496
497
498
499

# File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/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

504
505
506
507
508
509
510

# File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/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

514
515
516
517
518
519
520

# File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/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

524
525
526
527
528
529
530

# File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/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

534
535
536
537
538
539
540

# File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/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

544
545
546
547
548
549
550

# File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/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

555
556
557
558
559
560
561

# File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/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