Class: VertxRedis::RedisClient

Inherits:
Object
  • Object
show all
Defined in:
/Users/julien/java/vertx-aggregator/modules/vertx-redis-client/src/main/resources/vertx-redis/redis_client.rb

Class Method Summary (collapse)

Instance Method Summary (collapse)

Class Method Details

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

Parameters:

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

Returns:

Raises:

  • (ArgumentError)


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

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

Instance Method Details

- (::VertxRedis::RedisClient) append(key = nil, value = nil) { ... }

Append a value to a key

Parameters:

  • key (String) (defaults to: nil)
    Key string
  • value (String) (defaults to: nil)
    Value to append

Yields:

  • Handler for the result of this call.

Returns:

Raises:

  • (ArgumentError)


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

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

- (::VertxRedis::RedisClient) auth(password = nil) { ... }

Authenticate to the server

Parameters:

  • password (String) (defaults to: nil)
    Password for authentication

Yields:

  • Handler for the result of this call.

Returns:

Raises:

  • (ArgumentError)


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

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

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

Asynchronously rewrite the append-only file

Yields:

Returns:

Raises:

  • (ArgumentError)


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

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

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

Asynchronously save the dataset to disk

Yields:

Returns:

Raises:

  • (ArgumentError)


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

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

- (::VertxRedis::RedisClient) bitcount(key = nil) { ... }

Count set bits in a string

Parameters:

  • key (String) (defaults to: nil)
    Key string

Yields:

  • Handler for the result of this call.

Returns:

Raises:

  • (ArgumentError)


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

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

- (::VertxRedis::RedisClient) bitcount_range(key = nil, start = nil, _end = nil) { ... }

Count set bits in a string

Parameters:

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

Yields:

  • Handler for the result of this call.

Returns:

Raises:

  • (ArgumentError)


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

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

- (::VertxRedis::RedisClient) bitop(operation = nil, destkey = nil, keys = nil) { ... }

Perform bitwise operations between strings

Parameters:

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

Yields:

  • Handler for the result of this call.

Returns:

Raises:

  • (ArgumentError)


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

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

- (::VertxRedis::RedisClient) bitpos(key = nil, bit = nil) { ... }

Find first bit set or clear in a string

Parameters:

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

Yields:

  • Handler for the result of this call.

Returns:

Raises:

  • (ArgumentError)


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

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

- (::VertxRedis::RedisClient) bitpos_from(key = nil, bit = nil, start = nil) { ... }

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

Parameters:

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

Yields:

  • Handler for the result of this call.

Returns:

Raises:

  • (ArgumentError)


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

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

- (::VertxRedis::RedisClient) bitpos_range(key = nil, bit = nil, start = nil, stop = nil) { ... }

Find first bit set or clear in a string Note: when both start, and stop offsets are specified, behaviour is slightly different than if only start is specified

Parameters:

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

Yields:

  • Handler for the result of this call.

Returns:

Raises:

  • (ArgumentError)


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

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

- (::VertxRedis::RedisClient) blpop(key = nil, seconds = nil) { ... }

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

Parameters:

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

Yields:

  • Handler for the result of this call.

Returns:

Raises:

  • (ArgumentError)


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

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

- (::VertxRedis::RedisClient) blpop_many(keys = nil, seconds = nil) { ... }

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

Parameters:

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

Yields:

  • Handler for the result of this call.

Returns:

Raises:

  • (ArgumentError)


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

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

- (::VertxRedis::RedisClient) brpop(key = nil, seconds = nil) { ... }

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

Parameters:

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

Yields:

  • Handler for the result of this call.

Returns:

Raises:

  • (ArgumentError)


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

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

- (::VertxRedis::RedisClient) brpop_many(keys = nil, seconds = nil) { ... }

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

Parameters:

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

Yields:

  • Handler for the result of this call.

Returns:

Raises:

  • (ArgumentError)


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

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

- (::VertxRedis::RedisClient) brpoplpush(key = nil, destkey = nil, seconds = nil) { ... }

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

Parameters:

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

Yields:

  • Handler for the result of this call.

Returns:

Raises:

  • (ArgumentError)


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

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

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

Get the current connection name

Yields:

Returns:

Raises:

  • (ArgumentError)


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

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

- (::VertxRedis::RedisClient) client_kill(filter = nil) { ... }

Kill the connection of a client

Parameters:

  • filter (Hash) (defaults to: nil)
    Filter options

Yields:

  • Handler for the result of this call.

Returns:

Raises:

  • (ArgumentError)


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

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

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

Get the list of client connections

Yields:

Returns:

Raises:

  • (ArgumentError)


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

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

- (::VertxRedis::RedisClient) client_pause(millis = nil) { ... }

Stop processing commands from clients for some time

Parameters:

  • millis (Fixnum) (defaults to: nil)
    Pause time in milliseconds

Yields:

  • Handler for the result of this call.

Returns:

Raises:

  • (ArgumentError)


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

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

- (::VertxRedis::RedisClient) client_setname(name = nil) { ... }

Set the current connection name

Parameters:

  • name (String) (defaults to: nil)
    New name for current connection

Yields:

  • Handler for the result of this call.

Returns:

Raises:

  • (ArgumentError)


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

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

- (void) close { ... }

This method returns an undefined value.

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

Yields:

Raises:

  • (ArgumentError)


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

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

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

Get array of Cluster slot to node mappings

Yields:

Returns:

Raises:

  • (ArgumentError)


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

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

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

Get array of Redis command details

Yields:

Returns:

Raises:

  • (ArgumentError)


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

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

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

Get total number of Redis commands

Yields:

Returns:

Raises:

  • (ArgumentError)


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

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

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

Extract keys given a full Redis command

Yields:

Returns:

Raises:

  • (ArgumentError)


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

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

- (::VertxRedis::RedisClient) command_info(commands = nil) { ... }

Get array of specific Redis command details

Parameters:

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

Yields:

  • Handler for the result of this call.

Returns:

Raises:

  • (ArgumentError)


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

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

- (::VertxRedis::RedisClient) config_get(parameter = nil) { ... }

Get the value of a configuration parameter

Parameters:

  • parameter (String) (defaults to: nil)
    Configuration parameter

Yields:

  • Handler for the result of this call.

Returns:

Raises:

  • (ArgumentError)


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

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

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

Reset the stats returned by INFO

Yields:

Returns:

Raises:

  • (ArgumentError)


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

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

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

Rewrite the configuration file with the in memory configuration

Yields:

Returns:

Raises:

  • (ArgumentError)


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

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

- (::VertxRedis::RedisClient) config_set(parameter = nil, value = nil) { ... }

Set a configuration parameter to the given value

Parameters:

  • parameter (String) (defaults to: nil)
    Configuration parameter
  • value (String) (defaults to: nil)
    New value

Yields:

  • Handler for the result of this call.

Returns:

Raises:

  • (ArgumentError)


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

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

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

Return the number of keys in the selected database

Yields:

Returns:

Raises:

  • (ArgumentError)


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

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

- (::VertxRedis::RedisClient) debug_object(key = nil) { ... }

Get debugging information about a key

Parameters:

  • key (String) (defaults to: nil)
    Key string

Yields:

  • Handler for the result of this call.

Returns:

Raises:

  • (ArgumentError)


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

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

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

Make the server crash

Yields:

Returns:

Raises:

  • (ArgumentError)


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

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

- (::VertxRedis::RedisClient) decr(key = nil) { ... }

Decrement the integer value of a key by one

Parameters:

  • key (String) (defaults to: nil)
    Key string

Yields:

  • Handler for the result of this call.

Returns:

Raises:

  • (ArgumentError)


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

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

- (::VertxRedis::RedisClient) decrby(key = nil, decrement = nil) { ... }

Decrement the integer value of a key by the given number

Parameters:

  • key (String) (defaults to: nil)
    Key string
  • decrement (Fixnum) (defaults to: nil)
    Value by which to decrement

Yields:

  • Handler for the result of this call.

Returns:

Raises:

  • (ArgumentError)


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

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

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

Delete a key

Parameters:

  • keys (Array<String>) (defaults to: nil)
    List of keys to delete

Yields:

  • Handler for the result of this call.

Returns:

Raises:

  • (ArgumentError)


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

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

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

Discard all commands issued after MULTI

Yields:

Returns:

Raises:

  • (ArgumentError)


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

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

- (::VertxRedis::RedisClient) dump(key = nil) { ... }

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

Parameters:

  • key (String) (defaults to: nil)
    Key string

Yields:

  • Handler for the result of this call.

Returns:

Raises:

  • (ArgumentError)


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

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

- (::VertxRedis::RedisClient) echo(message = nil) { ... }

Echo the given string

Parameters:

  • message (String) (defaults to: nil)
    String to echo

Yields:

  • Handler for the result of this call.

Returns:

Raises:

  • (ArgumentError)


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

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

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

Execute a Lua script server side

Parameters:

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

Yields:

  • Handler for the result of this call.

Returns:

Raises:

  • (ArgumentError)


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

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

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

Execute a Lua script server side

Parameters:

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

Yields:

  • Handler for the result of this call.

Returns:

Raises:

  • (ArgumentError)


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

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

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

Execute all commands issued after MULTI

Yields:

Returns:

Raises:

  • (ArgumentError)


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

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

- (::VertxRedis::RedisClient) exists(key = nil) { ... }

Determine if a key exists

Parameters:

  • key (String) (defaults to: nil)
    Key string

Yields:

  • Handler for the result of this call.

Returns:

Raises:

  • (ArgumentError)


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

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

- (::VertxRedis::RedisClient) expire(key = nil, seconds = nil) { ... }

Set a key's time to live in seconds

Parameters:

  • key (String) (defaults to: nil)
    Key string
  • seconds (Fixnum) (defaults to: nil)
    Time to live in seconds

Yields:

  • Handler for the result of this call.

Returns:

Raises:

  • (ArgumentError)


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

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

- (::VertxRedis::RedisClient) expireat(key = nil, seconds = nil) { ... }

Set the expiration for a key as a UNIX timestamp

Parameters:

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

Yields:

  • Handler for the result of this call.

Returns:

Raises:

  • (ArgumentError)


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

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

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

Remove all keys from all databases

Yields:

Returns:

Raises:

  • (ArgumentError)


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

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

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

Remove all keys from the current database

Yields:

Returns:

Raises:

  • (ArgumentError)


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

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

- (::VertxRedis::RedisClient) get(key = nil) { ... }

Get the value of a key

Parameters:

  • key (String) (defaults to: nil)
    Key string

Yields:

  • Handler for the result of this call.

Returns:

Raises:

  • (ArgumentError)


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

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

- (::VertxRedis::RedisClient) get_binary(key = nil) { ... }

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

Parameters:

  • key (String) (defaults to: nil)
    Key string

Yields:

  • Handler for the result of this call.

Returns:

Raises:

  • (ArgumentError)


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

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

- (::VertxRedis::RedisClient) getbit(key = nil, offset = nil) { ... }

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

Parameters:

  • key (String) (defaults to: nil)
    Key string
  • offset (Fixnum) (defaults to: nil)
    Offset in bits

Yields:

  • Handler for the result of this call.

Returns:

Raises:

  • (ArgumentError)


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

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

- (::VertxRedis::RedisClient) getrange(key = nil, start = nil, _end = nil) { ... }

Get a substring of the string stored at a key

Parameters:

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

Yields:

  • Handler for the result of this call.

Returns:

Raises:

  • (ArgumentError)


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

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

- (::VertxRedis::RedisClient) getset(key = nil, value = nil) { ... }

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

Parameters:

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

Yields:

  • Handler for the result of this call.

Returns:

Raises:

  • (ArgumentError)


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

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

- (::VertxRedis::RedisClient) hdel(key = nil, field = nil) { ... }

Delete one or more hash fields

Parameters:

  • key (String) (defaults to: nil)
    Key string
  • field (String) (defaults to: nil)
    Field name

Yields:

  • Handler for the result of this call.

Returns:

Raises:

  • (ArgumentError)


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

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

- (::VertxRedis::RedisClient) hdel_many(key = nil, fields = nil) { ... }

Delete one or more hash fields

Parameters:

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

Yields:

  • Handler for the result of this call.

Returns:

Raises:

  • (ArgumentError)


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

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

- (::VertxRedis::RedisClient) hexists(key = nil, field = nil) { ... }

Determine if a hash field exists

Parameters:

  • key (String) (defaults to: nil)
    Key string
  • field (String) (defaults to: nil)
    Field name

Yields:

  • Handler for the result of this call.

Returns:

Raises:

  • (ArgumentError)


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

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

- (::VertxRedis::RedisClient) hget(key = nil, field = nil) { ... }

Get the value of a hash field

Parameters:

  • key (String) (defaults to: nil)
    Key string
  • field (String) (defaults to: nil)
    Field name

Yields:

  • Handler for the result of this call.

Returns:

Raises:

  • (ArgumentError)


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

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

- (::VertxRedis::RedisClient) hgetall(key = nil) { ... }

Get all the fields and values in a hash

Parameters:

  • key (String) (defaults to: nil)
    Key string

Yields:

  • Handler for the result of this call.

Returns:

Raises:

  • (ArgumentError)


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

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

- (::VertxRedis::RedisClient) hincrby(key = nil, field = nil, increment = nil) { ... }

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

Parameters:

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

Yields:

  • Handler for the result of this call.

Returns:

Raises:

  • (ArgumentError)


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

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

- (::VertxRedis::RedisClient) hincrbyfloat(key = nil, field = nil, increment = nil) { ... }

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

Parameters:

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

Yields:

  • Handler for the result of this call.

Returns:

Raises:

  • (ArgumentError)


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

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

- (::VertxRedis::RedisClient) hkeys(key = nil) { ... }

Get all the fields in a hash

Parameters:

  • key (String) (defaults to: nil)
    Key string

Yields:

  • Handler for the result of this call.

Returns:

Raises:

  • (ArgumentError)


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

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

- (::VertxRedis::RedisClient) hlen(key = nil) { ... }

Get the number of fields in a hash

Parameters:

  • key (String) (defaults to: nil)
    Key string

Yields:

  • Handler for the result of this call.

Returns:

Raises:

  • (ArgumentError)


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

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

- (::VertxRedis::RedisClient) hmget(key = nil, fields = nil) { ... }

Get the values of all the given hash fields

Parameters:

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

Yields:

  • Handler for the result of this call.

Returns:

Raises:

  • (ArgumentError)


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

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

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

Set multiple hash fields to multiple values

Parameters:

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

Yields:

  • Handler for the result of this call.

Returns:

Raises:

  • (ArgumentError)


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

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

- (::VertxRedis::RedisClient) hscan(key = nil, cursor = nil, options = nil) { ... }

Incrementally iterate hash fields and associated values

Parameters:

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

Yields:

  • Handler for the result of this call.

Returns:

Raises:

  • (ArgumentError)


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

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

- (::VertxRedis::RedisClient) hset(key = nil, field = nil, value = nil) { ... }

Set the string value of a hash field

Parameters:

  • key (String) (defaults to: nil)
    Key string
  • field (String) (defaults to: nil)
    Field name
  • value (String) (defaults to: nil)
    New value

Yields:

  • Handler for the result of this call.

Returns:

Raises:

  • (ArgumentError)


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

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

- (::VertxRedis::RedisClient) hsetnx(key = nil, field = nil, value = nil) { ... }

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

Parameters:

  • key (String) (defaults to: nil)
    Key string
  • field (String) (defaults to: nil)
    Field name
  • value (String) (defaults to: nil)
    New value

Yields:

  • Handler for the result of this call.

Returns:

Raises:

  • (ArgumentError)


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

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

- (::VertxRedis::RedisClient) hvals(key = nil) { ... }

Get all the values in a hash

Parameters:

  • key (String) (defaults to: nil)
    Key string

Yields:

  • Handler for the result of this call.

Returns:

Raises:

  • (ArgumentError)


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

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

- (::VertxRedis::RedisClient) incr(key = nil) { ... }

Increment the integer value of a key by one

Parameters:

  • key (String) (defaults to: nil)
    Key string

Yields:

  • Handler for the result of this call.

Returns:

Raises:

  • (ArgumentError)


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

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

- (::VertxRedis::RedisClient) incrby(key = nil, increment = nil) { ... }

Increment the integer value of a key by the given amount

Parameters:

  • key (String) (defaults to: nil)
    Key string
  • increment (Fixnum) (defaults to: nil)
    Value by which to increment

Yields:

  • Handler for the result of this call.

Returns:

Raises:

  • (ArgumentError)


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

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

- (::VertxRedis::RedisClient) incrbyfloat(key = nil, increment = nil) { ... }

Increment the float value of a key by the given amount

Parameters:

  • key (String) (defaults to: nil)
    Key string
  • increment (Float) (defaults to: nil)
    Value by which to increment

Yields:

  • Handler for the result of this call.

Returns:

Raises:

  • (ArgumentError)


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

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

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

Get information and statistics about the server

Yields:

  • Handler for the result of this call.

Returns:

Raises:

  • (ArgumentError)


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

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

- (::VertxRedis::RedisClient) info_section(section = nil) { ... }

Get information and statistics about the server

Parameters:

  • section (String) (defaults to: nil)
    Specific section of information to return

Yields:

  • Handler for the result of this call.

Returns:

Raises:

  • (ArgumentError)


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

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

- (::VertxRedis::RedisClient) keys(pattern = nil) { ... }

Find all keys matching the given pattern

Parameters:

  • pattern (String) (defaults to: nil)
    Pattern to limit the keys returned

Yields:

  • Handler for the result of this call.

Returns:

Raises:

  • (ArgumentError)


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

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

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

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

Yields:

Returns:

Raises:

  • (ArgumentError)


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

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

- (::VertxRedis::RedisClient) lindex(key = nil, index = nil) { ... }

Get an element from a list by its index

Parameters:

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

Yields:

  • Handler for the result of this call.

Returns:

Raises:

  • (ArgumentError)


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

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

- (::VertxRedis::RedisClient) linsert(key = nil, option = nil, pivot = nil, value = nil) { ... }

Insert an element before or after another element in a list

Parameters:

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

Yields:

  • Handler for the result of this call.

Returns:

Raises:

  • (ArgumentError)


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

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

- (::VertxRedis::RedisClient) llen(key = nil) { ... }

Get the length of a list

Parameters:

  • key (String) (defaults to: nil)
    String key

Yields:

  • Handler for the result of this call.

Returns:

Raises:

  • (ArgumentError)


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

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

- (::VertxRedis::RedisClient) lpop(key = nil) { ... }

Remove and get the first element in a list

Parameters:

  • key (String) (defaults to: nil)
    String key

Yields:

  • Handler for the result of this call.

Returns:

Raises:

  • (ArgumentError)


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

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

- (::VertxRedis::RedisClient) lpush(key = nil, value = nil) { ... }

Prepend one value to a list

Parameters:

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

Yields:

  • Handler for the result of this call.

Returns:

Raises:

  • (ArgumentError)


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

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

- (::VertxRedis::RedisClient) lpush_many(key = nil, values = nil) { ... }

Prepend one or multiple values to a list

Parameters:

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

Yields:

  • Handler for the result of this call.

Returns:

Raises:

  • (ArgumentError)


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

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

- (::VertxRedis::RedisClient) lpushx(key = nil, value = nil) { ... }

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

Parameters:

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

Yields:

  • Handler for the result of this call.

Returns:

Raises:

  • (ArgumentError)


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

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

- (::VertxRedis::RedisClient) lrange(key = nil, from = nil, to = nil) { ... }

Get a range of elements from a list

Parameters:

  • key (String) (defaults to: nil)
    Key string
  • from (Fixnum) (defaults to: nil)
    Start index
  • to (Fixnum) (defaults to: nil)
    Stop index

Yields:

  • Handler for the result of this call.

Returns:

Raises:

  • (ArgumentError)


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

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

- (::VertxRedis::RedisClient) lrem(key = nil, count = nil, value = nil) { ... }

Remove elements from a list

Parameters:

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

Yields:

  • Handler for the result of this call.

Returns:

Raises:

  • (ArgumentError)


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

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

- (::VertxRedis::RedisClient) lset(key = nil, index = nil, value = nil) { ... }

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

Parameters:

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

Yields:

  • Handler for the result of this call.

Returns:

Raises:

  • (ArgumentError)


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

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

- (::VertxRedis::RedisClient) ltrim(key = nil, from = nil, to = nil) { ... }

Trim a list to the specified range

Parameters:

  • key (String) (defaults to: nil)
    Key string
  • from (Fixnum) (defaults to: nil)
    Start index
  • to (Fixnum) (defaults to: nil)
    Stop index

Yields:

  • Handler for the result of this call.

Returns:

Raises:

  • (ArgumentError)


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

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

- (::VertxRedis::RedisClient) mget(key = nil) { ... }

Get the value of the given key

Parameters:

  • key (String) (defaults to: nil)
    Key string

Yields:

  • Handler for the result of this call.

Returns:

Raises:

  • (ArgumentError)


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

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

- (::VertxRedis::RedisClient) mget_many(keys = nil) { ... }

Get the values of all the given keys

Parameters:

  • keys (Array<String>) (defaults to: nil)
    List of keys to get

Yields:

  • Handler for the result of this call.

Returns:

Raises:

  • (ArgumentError)


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

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

- (::VertxRedis::RedisClient) migrate(host = nil, port = nil, key = nil, destdb = nil, timeout = nil, options = nil) { ... }

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

Parameters:

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

Yields:

  • Handler for the result of this call.

Returns:

Raises:

  • (ArgumentError)


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

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

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

Listen for all requests received by the server in real time

Yields:

Returns:

Raises:

  • (ArgumentError)


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

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

- (::VertxRedis::RedisClient) move(key = nil, destdb = nil) { ... }

Move a key to another database

Parameters:

  • key (String) (defaults to: nil)
    Key to migrate
  • destdb (Fixnum) (defaults to: nil)
    Destination database index

Yields:

  • Handler for the result of this call.

Returns:

Raises:

  • (ArgumentError)


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

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

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

Set multiple keys to multiple values

Parameters:

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

Yields:

  • Handler for the result of this call.

Returns:

Raises:

  • (ArgumentError)


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

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

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

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

Parameters:

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

Yields:

  • Handler for the result of this call.

Returns:

Raises:

  • (ArgumentError)


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

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

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

Mark the start of a transaction block

Yields:

Returns:

Raises:

  • (ArgumentError)


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

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

- (::VertxRedis::RedisClient) object(key = nil, cmd = nil) { ... }

Inspect the internals of Redis objects

Parameters:

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

Yields:

  • Handler for the result of this call.

Returns:

Raises:

  • (ArgumentError)


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

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

- (::VertxRedis::RedisClient) persist(key = nil) { ... }

Remove the expiration from a key

Parameters:

  • key (String) (defaults to: nil)
    Key string

Yields:

  • Handler for the result of this call.

Returns:

Raises:

  • (ArgumentError)


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

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

- (::VertxRedis::RedisClient) pexpire(key = nil, millis = nil) { ... }

Set a key's time to live in milliseconds

Parameters:

  • key (String) (defaults to: nil)
    String key
  • millis (Fixnum) (defaults to: nil)
    Time to live in milliseconds

Yields:

  • Handler for the result of this call.

Returns:

Raises:

  • (ArgumentError)


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

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

- (::VertxRedis::RedisClient) pexpireat(key = nil, millis = nil) { ... }

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

Parameters:

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

Yields:

  • Handler for the result of this call.

Returns:

Raises:

  • (ArgumentError)


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

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

- (::VertxRedis::RedisClient) pfadd(key = nil, element = nil) { ... }

Adds the specified element to the specified HyperLogLog.

Parameters:

  • key (String) (defaults to: nil)
    Key string
  • element (String) (defaults to: nil)
    Element to add

Yields:

  • Handler for the result of this call.

Returns:

Raises:

  • (ArgumentError)


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

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

- (::VertxRedis::RedisClient) pfadd_many(key = nil, elements = nil) { ... }

Adds the specified elements to the specified HyperLogLog.

Parameters:

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

Yields:

  • Handler for the result of this call.

Returns:

Raises:

  • (ArgumentError)


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

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

- (::VertxRedis::RedisClient) pfcount(key = nil) { ... }

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

Parameters:

  • key (String) (defaults to: nil)
    Key string

Yields:

  • Handler for the result of this call.

Returns:

Raises:

  • (ArgumentError)


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

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

- (::VertxRedis::RedisClient) pfcount_many(keys = nil) { ... }

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

Parameters:

  • keys (Array<String>) (defaults to: nil)
    List of keys

Yields:

  • Handler for the result of this call.

Returns:

Raises:

  • (ArgumentError)


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

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

- (::VertxRedis::RedisClient) pfmerge(destkey = nil, keys = nil) { ... }

Merge N different HyperLogLogs into a single one.

Parameters:

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

Yields:

  • Handler for the result of this call.

Returns:

Raises:

  • (ArgumentError)


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

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

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

Ping the server

Yields:

Returns:

Raises:

  • (ArgumentError)


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

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

- (::VertxRedis::RedisClient) psetex(key = nil, millis = nil, value = nil) { ... }

Set the value and expiration in milliseconds of a key

Parameters:

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

Yields:

  • Handler for the result of this call.

Returns:

Raises:

  • (ArgumentError)


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

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

- (::VertxRedis::RedisClient) psubscribe(pattern = nil) { ... }

Listen for messages published to channels matching the given pattern

Parameters:

  • pattern (String) (defaults to: nil)
    Pattern string

Yields:

  • Handler for the result of this call.

Returns:

Raises:

  • (ArgumentError)


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

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

- (::VertxRedis::RedisClient) psubscribe_many(patterns = nil) { ... }

Listen for messages published to channels matching the given patterns

Parameters:

  • patterns (Array<String>) (defaults to: nil)
    List of patterns

Yields:

  • Handler for the result of this call.

Returns:

Raises:

  • (ArgumentError)


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

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

- (::VertxRedis::RedisClient) pttl(key = nil) { ... }

Get the time to live for a key in milliseconds

Parameters:

  • key (String) (defaults to: nil)
    Key string

Yields:

  • Handler for the result of this call.

Returns:

Raises:

  • (ArgumentError)


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

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

- (::VertxRedis::RedisClient) publish(channel = nil, message = nil) { ... }

Post a message to a channel

Parameters:

  • channel (String) (defaults to: nil)
    Channel key
  • message (String) (defaults to: nil)
    Message to send to channel

Yields:

  • Handler for the result of this call.

Returns:

Raises:

  • (ArgumentError)


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

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

- (::VertxRedis::RedisClient) pubsub_channels(pattern = nil) { ... }

Lists the currently active channels - only those matching the pattern

Parameters:

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

Yields:

  • Handler for the result of this call.

Returns:

Raises:

  • (ArgumentError)


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

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

- (::VertxRedis::RedisClient) pubsub_numpat { ... }

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

Yields:

  • Handler for the result of this call.

Returns:

Raises:

  • (ArgumentError)


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

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

- (::VertxRedis::RedisClient) pubsub_numsub(channels = nil) { ... }

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

Parameters:

  • channels (Array<String>) (defaults to: nil)
    List of channels

Yields:

  • Handler for the result of this call.

Returns:

Raises:

  • (ArgumentError)


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

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

- (::VertxRedis::RedisClient) punsubscribe(patterns = nil) { ... }

Stop listening for messages posted to channels matching the given patterns

Parameters:

  • patterns (Array<String>) (defaults to: nil)
    List of patterns to match against

Yields:

  • Handler for the result of this call.

Returns:

Raises:

  • (ArgumentError)


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

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

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

Return a random key from the keyspace

Yields:

Returns:

Raises:

  • (ArgumentError)


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

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

- (::VertxRedis::RedisClient) rename(key = nil, newkey = nil) { ... }

Rename a key

Parameters:

  • key (String) (defaults to: nil)
    Key string to be renamed
  • newkey (String) (defaults to: nil)
    New key string

Yields:

  • Handler for the result of this call.

Returns:

Raises:

  • (ArgumentError)


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

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

- (::VertxRedis::RedisClient) renamenx(key = nil, newkey = nil) { ... }

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

Parameters:

  • key (String) (defaults to: nil)
    Key string to be renamed
  • newkey (String) (defaults to: nil)
    New key string

Yields:

  • Handler for the result of this call.

Returns:

Raises:

  • (ArgumentError)


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

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

- (::VertxRedis::RedisClient) restore(key = nil, millis = nil, serialized = nil) { ... }

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

Parameters:

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

Yields:

  • Handler for the result of this call.

Returns:

Raises:

  • (ArgumentError)


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

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

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

Return the role of the instance in the context of replication

Yields:

Returns:

Raises:

  • (ArgumentError)


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

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

- (::VertxRedis::RedisClient) rpop(key = nil) { ... }

Remove and get the last element in a list

Parameters:

  • key (String) (defaults to: nil)
    Key string

Yields:

  • Handler for the result of this call.

Returns:

Raises:

  • (ArgumentError)


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

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

- (::VertxRedis::RedisClient) rpoplpush(key = nil, destkey = nil) { ... }

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

Parameters:

  • key (String) (defaults to: nil)
    Key string identifying source list
  • destkey (String) (defaults to: nil)
    Key string identifying destination list

Yields:

  • Handler for the result of this call.

Returns:

Raises:

  • (ArgumentError)


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

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

- (::VertxRedis::RedisClient) rpush(key = nil, value = nil) { ... }

Append one or multiple values to a list

Parameters:

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

Yields:

  • Handler for the result of this call.

Returns:

Raises:

  • (ArgumentError)


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

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

- (::VertxRedis::RedisClient) rpush_many(key = nil, values = nil) { ... }

Append one or multiple values to a list

Parameters:

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

Yields:

  • Handler for the result of this call.

Returns:

Raises:

  • (ArgumentError)


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

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

- (::VertxRedis::RedisClient) rpushx(key = nil, value = nil) { ... }

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

Parameters:

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

Yields:

  • Handler for the result of this call.

Returns:

Raises:

  • (ArgumentError)


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

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

- (::VertxRedis::RedisClient) sadd(key = nil, member = nil) { ... }

Add a member to a set

Parameters:

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

Yields:

  • Handler for the result of this call.

Returns:

Raises:

  • (ArgumentError)


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

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

- (::VertxRedis::RedisClient) sadd_many(key = nil, members = nil) { ... }

Add one or more members to a set

Parameters:

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

Yields:

  • Handler for the result of this call.

Returns:

Raises:

  • (ArgumentError)


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

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

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

Synchronously save the dataset to disk

Yields:

Returns:

Raises:

  • (ArgumentError)


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

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

- (::VertxRedis::RedisClient) scan(cursor = nil, options = nil) { ... }

Incrementally iterate the keys space

Parameters:

  • cursor (String) (defaults to: nil)
    Cursor id
  • options (Hash) (defaults to: nil)
    Scan options

Yields:

  • Handler for the result of this call.

Returns:

Raises:

  • (ArgumentError)


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

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

- (::VertxRedis::RedisClient) scard(key = nil) { ... }

Get the number of members in a set

Parameters:

  • key (String) (defaults to: nil)
    Key string

Yields:

  • Handler for the result of this call.

Returns:

Raises:

  • (ArgumentError)


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

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

- (::VertxRedis::RedisClient) script_exists(script = nil) { ... }

Check existence of script in the script cache.

Parameters:

  • script (String) (defaults to: nil)
    SHA1 digest identifying a script in the script cache

Yields:

  • Handler for the result of this call.

Returns:

Raises:

  • (ArgumentError)


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

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

- (::VertxRedis::RedisClient) script_exists_many(scripts = nil) { ... }

Check existence of scripts in the script cache.

Parameters:

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

Yields:

  • Handler for the result of this call.

Returns:

Raises:

  • (ArgumentError)


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

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

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

Remove all the scripts from the script cache.

Yields:

Returns:

Raises:

  • (ArgumentError)


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

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

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

Kill the script currently in execution.

Yields:

Returns:

Raises:

  • (ArgumentError)


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

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

- (::VertxRedis::RedisClient) script_load(script = nil) { ... }

Load the specified Lua script into the script cache.

Parameters:

  • script (String) (defaults to: nil)
    Lua script

Yields:

  • Handler for the result of this call.

Returns:

Raises:

  • (ArgumentError)


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

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

- (::VertxRedis::RedisClient) sdiff(key = nil, cmpkeys = nil) { ... }

Subtract multiple sets

Parameters:

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

Yields:

  • Handler for the result of this call.

Returns:

Raises:

  • (ArgumentError)


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

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

- (::VertxRedis::RedisClient) sdiffstore(destkey = nil, key = nil, cmpkeys = nil) { ... }

Subtract multiple sets and store the resulting set in a key

Parameters:

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

Yields:

  • Handler for the result of this call.

Returns:

Raises:

  • (ArgumentError)


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

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

- (::VertxRedis::RedisClient) select(dbindex = nil) { ... }

Change the selected database for the current connection

Parameters:

  • dbindex (Fixnum) (defaults to: nil)
    Index identifying the new active database

Yields:

  • Handler for the result of this call.

Returns:

Raises:

  • (ArgumentError)


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

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

- (::VertxRedis::RedisClient) set(key = nil, value = nil) { ... }

Set the string value of a key

Parameters:

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

Yields:

  • Handler for the result of this call.

Returns:

Raises:

  • (ArgumentError)


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

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

- (::VertxRedis::RedisClient) set_binary(key = nil, value = nil) { ... }

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

Parameters:

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

Yields:

  • Handler for the result of this call.

Returns:

Raises:

  • (ArgumentError)


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

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

- (::VertxRedis::RedisClient) set_with_options(key = nil, value = nil, options = nil) { ... }

Set the string value of a key

Parameters:

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

Yields:

  • Handler for the result of this call.

Returns:

Raises:

  • (ArgumentError)


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

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

- (::VertxRedis::RedisClient) setbit(key = nil, offset = nil, bit = nil) { ... }

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

Parameters:

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

Yields:

  • Handler for the result of this call.

Returns:

Raises:

  • (ArgumentError)


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

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

- (::VertxRedis::RedisClient) setex(key = nil, seconds = nil, value = nil) { ... }

Set the value and expiration of a key

Parameters:

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

Yields:

  • Handler for the result of this call.

Returns:

Raises:

  • (ArgumentError)


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

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

- (::VertxRedis::RedisClient) setnx(key = nil, value = nil) { ... }

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

Parameters:

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

Yields:

  • Handler for the result of this call.

Returns:

Raises:

  • (ArgumentError)


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

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

- (::VertxRedis::RedisClient) setrange(key = nil, offset = nil, value = nil) { ... }

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

Parameters:

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

Yields:

  • Handler for the result of this call.

Returns:

Raises:

  • (ArgumentError)


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

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

- (::VertxRedis::RedisClient) sinter(keys = nil) { ... }

Intersect multiple sets

Parameters:

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

Yields:

  • Handler for the result of this call.

Returns:

Raises:

  • (ArgumentError)


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

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

- (::VertxRedis::RedisClient) sinterstore(destkey = nil, keys = nil) { ... }

Intersect multiple sets and store the resulting set in a key

Parameters:

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

Yields:

  • Handler for the result of this call.

Returns:

Raises:

  • (ArgumentError)


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

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

- (::VertxRedis::RedisClient) sismember(key = nil, member = nil) { ... }

Determine if a given value is a member of a set

Parameters:

  • key (String) (defaults to: nil)
    Key string
  • member (String) (defaults to: nil)
    Member to look for

Yields:

  • Handler for the result of this call.

Returns:

Raises:

  • (ArgumentError)


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

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

- (::VertxRedis::RedisClient) slaveof(host = nil, port = nil) { ... }

Make the server a slave of another instance

Parameters:

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

Yields:

  • Handler for the result of this call.

Returns:

Raises:

  • (ArgumentError)


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

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

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

Make this server a master

Yields:

  • Handler for the result of this call.

Returns:

Raises:

  • (ArgumentError)


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

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

- (::VertxRedis::RedisClient) slowlog_get(limit = nil) { ... }

Read the Redis slow queries log

Parameters:

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

Yields:

  • Handler for the result of this call.

Returns:

Raises:

  • (ArgumentError)


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

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

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

Get the length of the Redis slow queries log

Yields:

  • Handler for the result of this call.

Returns:

Raises:

  • (ArgumentError)


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

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

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

Reset the Redis slow queries log

Yields:

  • Handler for the result of this call.

Returns:

Raises:

  • (ArgumentError)


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

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

- (::VertxRedis::RedisClient) smembers(key = nil) { ... }

Get all the members in a set

Parameters:

  • key (String) (defaults to: nil)
    Key string

Yields:

  • Handler for the result of this call.

Returns:

Raises:

  • (ArgumentError)


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

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

- (::VertxRedis::RedisClient) smove(key = nil, destkey = nil, member = nil) { ... }

Move a member from one set to another

Parameters:

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

Yields:

  • Handler for the result of this call.

Returns:

Raises:

  • (ArgumentError)


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

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

- (::VertxRedis::RedisClient) sort(key = nil, options = nil) { ... }

Sort the elements in a list, set or sorted set

Parameters:

  • key (String) (defaults to: nil)
    Key string
  • options (Hash) (defaults to: nil)
    Sort options

Yields:

  • Handler for the result of this call.

Returns:

Raises:

  • (ArgumentError)


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

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

- (::VertxRedis::RedisClient) spop(key = nil) { ... }

Remove and return a random member from a set

Parameters:

  • key (String) (defaults to: nil)
    Key string

Yields:

  • Handler for the result of this call.

Returns:

Raises:

  • (ArgumentError)


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

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

- (::VertxRedis::RedisClient) spop_many(key = nil, count = nil) { ... }

Remove and return random members from a set

Parameters:

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

Yields:

  • Handler for the result of this call.

Returns:

Raises:

  • (ArgumentError)


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

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

- (::VertxRedis::RedisClient) srandmember(key = nil, count = nil) { ... }

Get one or multiple random members from a set

Parameters:

  • key (String) (defaults to: nil)
    Key string
  • count (Fixnum) (defaults to: nil)
    Number of members to get

Yields:

  • Handler for the result of this call.

Returns:

Raises:

  • (ArgumentError)


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

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

- (::VertxRedis::RedisClient) srem(key = nil, member = nil) { ... }

Remove one member from a set

Parameters:

  • key (String) (defaults to: nil)
    Key string
  • member (String) (defaults to: nil)
    Member to remove

Yields:

  • Handler for the result of this call.

Returns:

Raises:

  • (ArgumentError)


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

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

- (::VertxRedis::RedisClient) srem_many(key = nil, members = nil) { ... }

Remove one or more members from a set

Parameters:

  • key (String) (defaults to: nil)
    Key string
  • members (Array<String>) (defaults to: nil)
    Members to remove

Yields:

  • Handler for the result of this call.

Returns:

Raises:

  • (ArgumentError)


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

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

- (::VertxRedis::RedisClient) sscan(key = nil, cursor = nil, options = nil) { ... }

Incrementally iterate Set elements

Parameters:

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

Yields:

  • Handler for the result of this call.

Returns:

Raises:

  • (ArgumentError)


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

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

- (::VertxRedis::RedisClient) strlen(key = nil) { ... }

Get the length of the value stored in a key

Parameters:

  • key (String) (defaults to: nil)
    Key string

Yields:

  • Handler for the result of this call.

Returns:

Raises:

  • (ArgumentError)


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

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

- (::VertxRedis::RedisClient) subscribe(channels = nil) { ... }

Listen for messages published to the given channels

Parameters:

  • channels (Array<String>) (defaults to: nil)
    List of channels to subscribe to

Yields:

  • Handler for the result of this call.

Returns:

Raises:

  • (ArgumentError)


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

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

- (::VertxRedis::RedisClient) sunion(keys = nil) { ... }

Add multiple sets

Parameters:

  • keys (Array<String>) (defaults to: nil)
    List of keys identifying sets to add up

Yields:

  • Handler for the result of this call.

Returns:

Raises:

  • (ArgumentError)


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

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

- (::VertxRedis::RedisClient) sunionstore(destkey = nil, keys = nil) { ... }

Add multiple sets and store the resulting set in a key

Parameters:

  • destkey (String) (defaults to: nil)
    Destination key
  • keys (Array<String>) (defaults to: nil)
    List of keys identifying sets to add up

Yields:

  • Handler for the result of this call.

Returns:

Raises:

  • (ArgumentError)


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

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

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

Internal command used for replication

Yields:

Returns:

Raises:

  • (ArgumentError)


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

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

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

Return the current server time

Yields:

Returns:

Raises:

  • (ArgumentError)


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

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

- (::VertxRedis::RedisClient) ttl(key = nil) { ... }

Get the time to live for a key

Parameters:

  • key (String) (defaults to: nil)
    Key string

Yields:

  • Handler for the result of this call.

Returns:

Raises:

  • (ArgumentError)


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

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

- (::VertxRedis::RedisClient) type(key = nil) { ... }

Determine the type stored at key

Parameters:

  • key (String) (defaults to: nil)
    Key string

Yields:

  • Handler for the result of this call.

Returns:

Raises:

  • (ArgumentError)


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

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

- (::VertxRedis::RedisClient) unsubscribe(channels = nil) { ... }

Stop listening for messages posted to the given channels

Parameters:

  • channels (Array<String>) (defaults to: nil)
    List of channels to subscribe to

Yields:

  • Handler for the result of this call.

Returns:

Raises:

  • (ArgumentError)


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

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

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

Forget about all watched keys

Yields:

Returns:

Raises:

  • (ArgumentError)


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

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

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

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

Parameters:

  • keys (Array<String>) (defaults to: nil)
    List of keys to watch

Yields:

  • Handler for the result of this call.

Returns:

Raises:

  • (ArgumentError)


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

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

- (::VertxRedis::RedisClient) zadd(key = nil, score = nil, member = nil) { ... }

Add one or more members to a sorted set, or update its score if it already exists

Parameters:

  • key (String) (defaults to: nil)
    Key string
  • score (Float) (defaults to: nil)
    Score used for sorting
  • member (String) (defaults to: nil)
    New member key

Yields:

  • Handler for the result of this call.

Returns:

Raises:

  • (ArgumentError)


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

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

- (::VertxRedis::RedisClient) zadd_many(key = nil, members = nil) { ... }

Add one or more members to a sorted set, or update its score if it already exists

Parameters:

  • key (String) (defaults to: nil)
    Key string
  • members (Hash{String => Float}) (defaults to: nil)
    New member keys and their scores

Yields:

  • Handler for the result of this call.

Returns:

Raises:

  • (ArgumentError)


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

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

- (::VertxRedis::RedisClient) zcard(key = nil) { ... }

Get the number of members in a sorted set

Parameters:

  • key (String) (defaults to: nil)
    Key string

Yields:

  • Handler for the result of this call.

Returns:

Raises:

  • (ArgumentError)


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

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

- (::VertxRedis::RedisClient) zcount(key = nil, min = nil, max = nil) { ... }

Count the members in a sorted set with scores within the given values

Parameters:

  • key (String) (defaults to: nil)
    Key string
  • min (Float) (defaults to: nil)
    Minimum score
  • max (Float) (defaults to: nil)
    Maximum score

Yields:

  • Handler for the result of this call.

Returns:

Raises:

  • (ArgumentError)


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

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

- (::VertxRedis::RedisClient) zincrby(key = nil, increment = nil, member = nil) { ... }

Increment the score of a member in a sorted set

Parameters:

  • key (String) (defaults to: nil)
    Key string
  • increment (Float) (defaults to: nil)
    Increment amount
  • member (String) (defaults to: nil)
    Member key

Yields:

  • Handler for the result of this call.

Returns:

Raises:

  • (ArgumentError)


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

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

- (::VertxRedis::RedisClient) zinterstore(destkey = nil, sets = nil, options = nil) { ... }

Intersect multiple sorted sets and store the resulting sorted set in a new key

Parameters:

  • destkey (String) (defaults to: nil)
    Destination key
  • sets (Array<String>) (defaults to: nil)
    List of keys identifying sorted sets to intersect
  • options (:NONE, :SUM, :MIN, :MAX) (defaults to: nil)
    Aggregation options

Yields:

  • Handler for the result of this call.

Returns:

Raises:

  • (ArgumentError)


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

def zinterstore(destkey=nil,sets=nil,options=nil)
  if destkey.class == String && sets.class == Array && options.class == Symbol && block_given?
    return ::Vertx::Util::Utils.safe_create(@j_del.java_method(:zinterstore, [Java::java.lang.String.java_class,Java::JavaUtil::List.java_class,Java::IoVertxRedisOp::AggregateOptions.java_class,Java::IoVertxCore::Handler.java_class]).call(destkey,sets.map { |element| element },Java::IoVertxRedisOp::AggregateOptions.valueOf(options),(Proc.new { |ar| yield(ar.failed ? ar.cause : nil, ar.succeeded ? ar.result : nil) })),::VertxRedis::RedisClient)
  end
  raise ArgumentError, "Invalid arguments when calling zinterstore(destkey,sets,options)"
end

- (::VertxRedis::RedisClient) zinterstore_weighed(destkey = nil, sets = nil, options = nil) { ... }

Intersect multiple sorted sets and store the resulting sorted set in a new key using weights for scoring

Parameters:

  • destkey (String) (defaults to: nil)
    Destination key
  • sets (Hash{String => Float}) (defaults to: nil)
    List of keys identifying sorted sets to intersect
  • options (:NONE, :SUM, :MIN, :MAX) (defaults to: nil)
    Aggregation options

Yields:

  • Handler for the result of this call.

Returns:

Raises:

  • (ArgumentError)


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

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

- (::VertxRedis::RedisClient) zlexcount(key = nil, min = nil, max = nil) { ... }

Count the number of members in a sorted set between a given lexicographical range

Parameters:

  • key (String) (defaults to: nil)
    Key string
  • min (String) (defaults to: nil)
    Pattern to compare against for minimum value
  • max (String) (defaults to: nil)
    Pattern to compare against for maximum value

Yields:

  • Handler for the result of this call.

Returns:

Raises:

  • (ArgumentError)


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

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

- (::VertxRedis::RedisClient) zrange(key = nil, start = nil, stop = nil) { ... }

Return a range of members in a sorted set, by index

Parameters:

  • key (String) (defaults to: nil)
    Key string
  • start (Fixnum) (defaults to: nil)
    Start index for the range
  • stop (Fixnum) (defaults to: nil)
    Stop index for the range - inclusive

Yields:

  • Handler for the result of this call.

Returns:

Raises:

  • (ArgumentError)


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

def zrange(key=nil,start=nil,stop=nil)
  if key.class == String && start.class == Fixnum && stop.class == Fixnum && block_given?
    return ::Vertx::Util::Utils.safe_create(@j_del.java_method(:zrange, [Java::java.lang.String.java_class,Java::long.java_class,Java::long.java_class,Java::IoVertxCore::Handler.java_class]).call(key,start,stop,(Proc.new { |ar| yield(ar.failed ? ar.cause : nil, ar.succeeded ? ar.result != nil ? JSON.parse(ar.result.encode) : nil : nil) })),::VertxRedis::RedisClient)
  end
  raise ArgumentError, "Invalid arguments when calling zrange(key,start,stop)"
end

- (::VertxRedis::RedisClient) zrange_with_options(key = nil, start = nil, stop = nil, options = nil) { ... }

Return a range of members in a sorted set, by index

Parameters:

  • key (String) (defaults to: nil)
    Key string
  • start (Fixnum) (defaults to: nil)
    Start index for the range
  • stop (Fixnum) (defaults to: nil)
    Stop index for the range - inclusive
  • options (:NONE, :WITHSCORES) (defaults to: nil)
    Range options

Yields:

  • Handler for the result of this call.

Returns:

Raises:

  • (ArgumentError)


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

def zrange_with_options(key=nil,start=nil,stop=nil,options=nil)
  if key.class == String && start.class == Fixnum && stop.class == Fixnum && options.class == Symbol && block_given?
    return ::Vertx::Util::Utils.safe_create(@j_del.java_method(:zrangeWithOptions, [Java::java.lang.String.java_class,Java::long.java_class,Java::long.java_class,Java::IoVertxRedisOp::RangeOptions.java_class,Java::IoVertxCore::Handler.java_class]).call(key,start,stop,Java::IoVertxRedisOp::RangeOptions.valueOf(options),(Proc.new { |ar| yield(ar.failed ? ar.cause : nil, ar.succeeded ? ar.result != nil ? JSON.parse(ar.result.encode) : nil : nil) })),::VertxRedis::RedisClient)
  end
  raise ArgumentError, "Invalid arguments when calling zrange_with_options(key,start,stop,options)"
end

- (::VertxRedis::RedisClient) zrangebylex(key = nil, min = nil, max = nil, options = nil) { ... }

Return a range of members in a sorted set, by lexicographical range

Parameters:

  • key (String) (defaults to: nil)
    Key string
  • min (String) (defaults to: nil)
    Pattern representing a minimum allowed value
  • max (String) (defaults to: nil)
    Pattern representing a maximum allowed value
  • options (Hash) (defaults to: nil)
    Limit options where limit can be specified

Yields:

  • Handler for the result of this call.

Returns:

Raises:

  • (ArgumentError)


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

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

- (::VertxRedis::RedisClient) zrangebyscore(key = nil, min = nil, max = nil, options = nil) { ... }

Return a range of members in a sorted set, by score

Parameters:

  • key (String) (defaults to: nil)
    Key string
  • min (String) (defaults to: nil)
    Pattern defining a minimum value
  • max (String) (defaults to: nil)
    Pattern defining a maximum value
  • options (Hash) (defaults to: nil)
    Range and limit options

Yields:

  • Handler for the result of this call.

Returns:

Raises:

  • (ArgumentError)


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

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

- (::VertxRedis::RedisClient) zrank(key = nil, member = nil) { ... }

Determine the index of a member in a sorted set

Parameters:

  • key (String) (defaults to: nil)
    Key string
  • member (String) (defaults to: nil)
    Member in the sorted set identified by key

Yields:

  • Handler for the result of this call.

Returns:

Raises:

  • (ArgumentError)


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

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

- (::VertxRedis::RedisClient) zrem(key = nil, member = nil) { ... }

Remove one member from a sorted set

Parameters:

  • key (String) (defaults to: nil)
    Key string
  • member (String) (defaults to: nil)
    Member in the sorted set identified by key

Yields:

  • Handler for the result of this call.

Returns:

Raises:

  • (ArgumentError)


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

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

- (::VertxRedis::RedisClient) zrem_many(key = nil, members = nil) { ... }

Remove one or more members from a sorted set

Parameters:

  • key (String) (defaults to: nil)
    Key string
  • members (Array<String>) (defaults to: nil)
    Members in the sorted set identified by key

Yields:

  • Handler for the result of this call.

Returns:

Raises:

  • (ArgumentError)


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

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

- (::VertxRedis::RedisClient) zremrangebylex(key = nil, min = nil, max = nil) { ... }

Remove all members in a sorted set between the given lexicographical range

Parameters:

  • key (String) (defaults to: nil)
    Key string
  • min (String) (defaults to: nil)
    Pattern defining a minimum value
  • max (String) (defaults to: nil)
    Pattern defining a maximum value

Yields:

  • Handler for the result of this call.

Returns:

Raises:

  • (ArgumentError)


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

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

- (::VertxRedis::RedisClient) zremrangebyrank(key = nil, start = nil, stop = nil) { ... }

Remove all members in a sorted set within the given indexes

Parameters:

  • key (String) (defaults to: nil)
    Key string
  • start (Fixnum) (defaults to: nil)
    Start index
  • stop (Fixnum) (defaults to: nil)
    Stop index

Yields:

  • Handler for the result of this call.

Returns:

Raises:

  • (ArgumentError)


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

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

- (::VertxRedis::RedisClient) zremrangebyscore(key = nil, min = nil, max = nil) { ... }

Remove all members in a sorted set within the given scores

Parameters:

  • key (String) (defaults to: nil)
    Key string
  • min (String) (defaults to: nil)
    Pattern defining a minimum value
  • max (String) (defaults to: nil)
    Pattern defining a maximum value

Yields:

Returns:

Raises:

  • (ArgumentError)


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

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

- (::VertxRedis::RedisClient) zrevrange(key = nil, start = nil, stop = nil, options = nil) { ... }

Return a range of members in a sorted set, by index, with scores ordered from high to low

Parameters:

  • key (String) (defaults to: nil)
    Key string
  • start (Fixnum) (defaults to: nil)
    Start index for the range
  • stop (Fixnum) (defaults to: nil)
    Stop index for the range - inclusive
  • options (:NONE, :WITHSCORES) (defaults to: nil)
    Range options

Yields:

  • Handler for the result of this call.

Returns:

Raises:

  • (ArgumentError)


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

def zrevrange(key=nil,start=nil,stop=nil,options=nil)
  if key.class == String && start.class == Fixnum && stop.class == Fixnum && options.class == Symbol && block_given?
    return ::Vertx::Util::Utils.safe_create(@j_del.java_method(:zrevrange, [Java::java.lang.String.java_class,Java::long.java_class,Java::long.java_class,Java::IoVertxRedisOp::RangeOptions.java_class,Java::IoVertxCore::Handler.java_class]).call(key,start,stop,Java::IoVertxRedisOp::RangeOptions.valueOf(options),(Proc.new { |ar| yield(ar.failed ? ar.cause : nil, ar.succeeded ? ar.result != nil ? JSON.parse(ar.result.encode) : nil : nil) })),::VertxRedis::RedisClient)
  end
  raise ArgumentError, "Invalid arguments when calling zrevrange(key,start,stop,options)"
end

- (::VertxRedis::RedisClient) zrevrangebylex(key = nil, max = nil, min = nil, options = nil) { ... }

Return a range of members in a sorted set, by score, between the given lexicographical range with scores ordered from high to low

Parameters:

  • key (String) (defaults to: nil)
    Key string
  • max (String) (defaults to: nil)
    Pattern defining a maximum value
  • min (String) (defaults to: nil)
    Pattern defining a minimum value
  • options (Hash) (defaults to: nil)
    Limit options

Yields:

  • Handler for the result of this call.

Returns:

Raises:

  • (ArgumentError)


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

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

- (::VertxRedis::RedisClient) zrevrangebyscore(key = nil, max = nil, min = nil, options = nil) { ... }

Return a range of members in a sorted set, by score, with scores ordered from high to low

Parameters:

  • key (String) (defaults to: nil)
    Key string
  • max (String) (defaults to: nil)
    Pattern defining a maximum value
  • min (String) (defaults to: nil)
    Pattern defining a minimum value
  • options (Hash) (defaults to: nil)
    Range and limit options

Yields:

  • Handler for the result of this call.

Returns:

Raises:

  • (ArgumentError)


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

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

- (::VertxRedis::RedisClient) zrevrank(key = nil, member = nil) { ... }

Determine the index of a member in a sorted set, with scores ordered from high to low

Parameters:

  • key (String) (defaults to: nil)
    Key string
  • member (String) (defaults to: nil)
    Member in the sorted set identified by key

Yields:

  • Handler for the result of this call.

Returns:

Raises:

  • (ArgumentError)


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

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

- (::VertxRedis::RedisClient) zscan(key = nil, cursor = nil, options = nil) { ... }

Incrementally iterate sorted sets elements and associated scores

Parameters:

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

Yields:

  • Handler for the result of this call.

Returns:

Raises:

  • (ArgumentError)


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

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

- (::VertxRedis::RedisClient) zscore(key = nil, member = nil) { ... }

Get the score associated with the given member in a sorted set

Parameters:

  • key (String) (defaults to: nil)
    Key string
  • member (String) (defaults to: nil)
    Member in the sorted set identified by key

Yields:

  • Handler for the result of this call.

Returns:

Raises:

  • (ArgumentError)


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

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

- (::VertxRedis::RedisClient) zunionstore(destkey = nil, sets = nil, options = nil) { ... }

Add multiple sorted sets and store the resulting sorted set in a new key

Parameters:

  • destkey (String) (defaults to: nil)
    Destination key
  • sets (Array<String>) (defaults to: nil)
    List of keys identifying sorted sets
  • options (:NONE, :SUM, :MIN, :MAX) (defaults to: nil)
    Aggregation options

Yields:

  • Handler for the result of this call.

Returns:

Raises:

  • (ArgumentError)


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

def zunionstore(destkey=nil,sets=nil,options=nil)
  if destkey.class == String && sets.class == Array && options.class == Symbol && block_given?
    return ::Vertx::Util::Utils.safe_create(@j_del.java_method(:zunionstore, [Java::java.lang.String.java_class,Java::JavaUtil::List.java_class,Java::IoVertxRedisOp::AggregateOptions.java_class,Java::IoVertxCore::Handler.java_class]).call(destkey,sets.map { |element| element },Java::IoVertxRedisOp::AggregateOptions.valueOf(options),(Proc.new { |ar| yield(ar.failed ? ar.cause : nil, ar.succeeded ? ar.result : nil) })),::VertxRedis::RedisClient)
  end
  raise ArgumentError, "Invalid arguments when calling zunionstore(destkey,sets,options)"
end

- (::VertxRedis::RedisClient) zunionstore_weighed(key = nil, sets = nil, options = nil) { ... }

Add multiple sorted sets using weights, and store the resulting sorted set in a new key

Parameters:

  • key (String) (defaults to: nil)
    Destination key
  • sets (Hash{String => Float}) (defaults to: nil)
    Map containing set-key:weight pairs
  • options (:NONE, :SUM, :MIN, :MAX) (defaults to: nil)
    Aggregation options

Yields:

  • Handler for the result of this call.

Returns:

Raises:

  • (ArgumentError)


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

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