Class: VertxRedis::RedisClient

Inherits:

Object

• Object
• VertxRedis::RedisClient

show all

Defined in:

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

Constant Summary

@@j_api_type =

Object.new

Class Method Summary (collapse)

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

Instance Method Summary (collapse)

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

20
21
22

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

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

38
39
40
41
42
43
44
45

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

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

29
30
31

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

def self.j_api_type
  @@j_api_type
end

32
33
34

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

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

26
27
28

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

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

23
24
25

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

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

60
61
62
63
64
65
66

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

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

71
72
73
74
75
76
77

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

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

81
82
83
84
85
86
87

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

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

91
92
93
94
95
96
97

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

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

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_client.rb', line 102

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

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_client.rb', line 115

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

2852
2853
2854
2855
2856
2857
2858

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

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

2865
2866
2867
2868
2869
2870
2871

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

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

128
129
130
131
132
133
134

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

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

140
141
142
143
144
145
146

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

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

155
156
157
158
159
160
161

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

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

172
173
174
175
176
177
178

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

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

184
185
186
187
188
189
190

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

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

196
197
198
199
200
201
202

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

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

208
209
210
211
212
213
214

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

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

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_client.rb', line 220

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

233
234
235
236
237
238
239

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

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

264
265
266
267
268
269
270

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

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

244
245
246
247
248
249
250

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

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

254
255
256
257
258
259
260

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

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

275
276
277
278
279
280
281

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

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

2795
2796
2797
2798
2799
2800
2801

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

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

286
287
288
289
290
291
292

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

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

49
50
51
52
53
54

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

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

297
298
299
300
301
302
303

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

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

308
309
310
311
312
313
314

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

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

319
320
321
322
323
324
325

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

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

330
331
332
333
334
335
336

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

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

341
342
343
344
345
346
347

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

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

362
363
364
365
366
367
368

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

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

351
352
353
354
355
356
357

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

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

373
374
375
376
377
378
379

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

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

385
386
387
388
389
390
391

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

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

395
396
397
398
399
400
401

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

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

406
407
408
409
410
411
412

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

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

418
419
420
421
422
423
424

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

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

428
429
430
431
432
433
434

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

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

439
440
441
442
443
444
445

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

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

449
450
451
452
453
454
455

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

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

460
461
462
463
464
465
466

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

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

470
471
472
473
474
475
476

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

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

481
482
483
484
485
486
487

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

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

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_client.rb', line 493

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