io.vertx.rxjava.redis.RedisClient Maven / Gradle / Ivy
The newest version!
/*
* Copyright 2014 Red Hat, Inc.
*
* Red Hat licenses this file to you under the Apache License, version 2.0
* (the "License"); you may not use this file except in compliance with the
* License. You may obtain a copy of the License at:
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
* WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
* License for the specific language governing permissions and limitations
* under the License.
*/
package io.vertx.rxjava.redis;
import java.util.Map;
import rx.Observable;
import rx.Single;
import io.vertx.redis.op.BitOperation;
import io.vertx.redis.op.ResetOptions;
import io.vertx.redis.op.ObjectCmd;
import io.vertx.redis.op.KillFilter;
import io.vertx.redis.op.ClientReplyOptions;
import java.util.Map;
import io.vertx.redis.op.GeoUnit;
import io.vertx.core.json.JsonObject;
import io.vertx.core.AsyncResult;
import io.vertx.redis.op.RangeOptions;
import io.vertx.redis.op.GeoMember;
import io.vertx.redis.op.GeoRadiusOptions;
import io.vertx.redis.op.InsertOptions;
import io.vertx.redis.op.AggregateOptions;
import io.vertx.redis.op.SetOptions;
import io.vertx.redis.op.SortOptions;
import io.vertx.redis.op.MigrateOptions;
import io.vertx.redis.op.ScanOptions;
import io.vertx.redis.op.BitFieldOptions;
import io.vertx.redis.op.ScriptDebugOptions;
import io.vertx.rxjava.core.Vertx;
import io.vertx.redis.op.FailoverOptions;
import io.vertx.redis.op.SlotCmd;
import io.vertx.redis.op.BitFieldOverflowOptions;
import io.vertx.redis.op.RangeLimitOptions;
import io.vertx.redis.op.LimitOptions;
import io.vertx.core.json.JsonArray;
import java.util.List;
import io.vertx.rxjava.core.buffer.Buffer;
import io.vertx.redis.RedisOptions;
import io.vertx.core.Handler;
@io.vertx.lang.rxjava.RxGen(io.vertx.redis.RedisClient.class)
public class RedisClient {
@Override
public String toString() {
return delegate.toString();
}
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
RedisClient that = (RedisClient) o;
return delegate.equals(that.delegate);
}
@Override
public int hashCode() {
return delegate.hashCode();
}
public static final io.vertx.lang.rxjava.TypeArg __TYPE_ARG = new io.vertx.lang.rxjava.TypeArg<>(
obj -> new RedisClient((io.vertx.redis.RedisClient) obj),
RedisClient::getDelegate
);
private final io.vertx.redis.RedisClient delegate;
public RedisClient(io.vertx.redis.RedisClient delegate) {
this.delegate = delegate;
}
public io.vertx.redis.RedisClient getDelegate() {
return delegate;
}
public static RedisClient create(Vertx vertx) {
RedisClient ret = RedisClient.newInstance(io.vertx.redis.RedisClient.create(vertx.getDelegate()));
return ret;
}
public static RedisClient create(Vertx vertx, RedisOptions config) {
RedisClient ret = RedisClient.newInstance(io.vertx.redis.RedisClient.create(vertx.getDelegate(), config));
return ret;
}
/**
* Close the client - when it is fully closed the handler will be called.
* @param handler
*/
public void close(Handler> handler) {
delegate.close(handler);
}
/**
* Close the client - when it is fully closed the handler will be called.
* @return
* @deprecated use {@link #rxClose} instead
*/
@Deprecated()
public Observable closeObservable() {
io.vertx.rx.java.ObservableFuture handler = io.vertx.rx.java.RxHelper.observableFuture();
close(handler.toHandler());
return handler;
}
/**
* Close the client - when it is fully closed the handler will be called.
* @return
*/
public Single rxClose() {
return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
close(fut);
}));
}
/**
* Append a value to a key
* @param key Key string
* @param value Value to append
* @param handler Handler for the result of this call.
* @return
*/
public RedisClient append(String key, String value, Handler> handler) {
delegate.append(key, value, handler);
return this;
}
/**
* Append a value to a key
* @param key Key string
* @param value Value to append
* @return
* @deprecated use {@link #rxAppend} instead
*/
@Deprecated()
public Observable appendObservable(String key, String value) {
io.vertx.rx.java.ObservableFuture handler = io.vertx.rx.java.RxHelper.observableFuture();
append(key, value, handler.toHandler());
return handler;
}
/**
* Append a value to a key
* @param key Key string
* @param value Value to append
* @return
*/
public Single rxAppend(String key, String value) {
return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
append(key, value, fut);
}));
}
/**
* Authenticate to the server
* @param password Password for authentication
* @param handler Handler for the result of this call.
* @return
*/
public RedisClient auth(String password, Handler> handler) {
delegate.auth(password, handler);
return this;
}
/**
* Authenticate to the server
* @param password Password for authentication
* @return
* @deprecated use {@link #rxAuth} instead
*/
@Deprecated()
public Observable authObservable(String password) {
io.vertx.rx.java.ObservableFuture handler = io.vertx.rx.java.RxHelper.observableFuture();
auth(password, handler.toHandler());
return handler;
}
/**
* Authenticate to the server
* @param password Password for authentication
* @return
*/
public Single rxAuth(String password) {
return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
auth(password, fut);
}));
}
/**
* Asynchronously rewrite the append-only file
* @param handler
* @return
*/
public RedisClient bgrewriteaof(Handler> handler) {
delegate.bgrewriteaof(handler);
return this;
}
/**
* Asynchronously rewrite the append-only file
* @return
* @deprecated use {@link #rxBgrewriteaof} instead
*/
@Deprecated()
public Observable bgrewriteaofObservable() {
io.vertx.rx.java.ObservableFuture handler = io.vertx.rx.java.RxHelper.observableFuture();
bgrewriteaof(handler.toHandler());
return handler;
}
/**
* Asynchronously rewrite the append-only file
* @return
*/
public Single rxBgrewriteaof() {
return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
bgrewriteaof(fut);
}));
}
/**
* Asynchronously save the dataset to disk
* @param handler
* @return
*/
public RedisClient bgsave(Handler> handler) {
delegate.bgsave(handler);
return this;
}
/**
* Asynchronously save the dataset to disk
* @return
* @deprecated use {@link #rxBgsave} instead
*/
@Deprecated()
public Observable bgsaveObservable() {
io.vertx.rx.java.ObservableFuture handler = io.vertx.rx.java.RxHelper.observableFuture();
bgsave(handler.toHandler());
return handler;
}
/**
* Asynchronously save the dataset to disk
* @return
*/
public Single rxBgsave() {
return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
bgsave(fut);
}));
}
/**
* Count set bits in a string
* @param key Key string
* @param handler Handler for the result of this call.
* @return
*/
public RedisClient bitcount(String key, Handler> handler) {
delegate.bitcount(key, handler);
return this;
}
/**
* Count set bits in a string
* @param key Key string
* @return
* @deprecated use {@link #rxBitcount} instead
*/
@Deprecated()
public Observable bitcountObservable(String key) {
io.vertx.rx.java.ObservableFuture handler = io.vertx.rx.java.RxHelper.observableFuture();
bitcount(key, handler.toHandler());
return handler;
}
/**
* Count set bits in a string
* @param key Key string
* @return
*/
public Single rxBitcount(String key) {
return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
bitcount(key, fut);
}));
}
/**
* Count set bits in a string
* @param key Key string
* @param start Start index
* @param end End index
* @param handler Handler for the result of this call.
* @return
*/
public RedisClient bitcountRange(String key, long start, long end, Handler> handler) {
delegate.bitcountRange(key, start, end, handler);
return this;
}
/**
* Count set bits in a string
* @param key Key string
* @param start Start index
* @param end End index
* @return
* @deprecated use {@link #rxBitcountRange} instead
*/
@Deprecated()
public Observable bitcountRangeObservable(String key, long start, long end) {
io.vertx.rx.java.ObservableFuture handler = io.vertx.rx.java.RxHelper.observableFuture();
bitcountRange(key, start, end, handler.toHandler());
return handler;
}
/**
* Count set bits in a string
* @param key Key string
* @param start Start index
* @param end End index
* @return
*/
public Single rxBitcountRange(String key, long start, long end) {
return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
bitcountRange(key, start, end, fut);
}));
}
/**
* Perform bitwise operations between strings
* @param operation Bitwise operation to perform
* @param destkey Destination key where result is stored
* @param keys List of keys on which to perform the operation
* @param handler Handler for the result of this call.
* @return
*/
public RedisClient bitop(BitOperation operation, String destkey, List keys, Handler> handler) {
delegate.bitop(operation, destkey, keys, handler);
return this;
}
/**
* Perform bitwise operations between strings
* @param operation Bitwise operation to perform
* @param destkey Destination key where result is stored
* @param keys List of keys on which to perform the operation
* @return
* @deprecated use {@link #rxBitop} instead
*/
@Deprecated()
public Observable bitopObservable(BitOperation operation, String destkey, List keys) {
io.vertx.rx.java.ObservableFuture handler = io.vertx.rx.java.RxHelper.observableFuture();
bitop(operation, destkey, keys, handler.toHandler());
return handler;
}
/**
* Perform bitwise operations between strings
* @param operation Bitwise operation to perform
* @param destkey Destination key where result is stored
* @param keys List of keys on which to perform the operation
* @return
*/
public Single rxBitop(BitOperation operation, String destkey, List keys) {
return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
bitop(operation, destkey, keys, fut);
}));
}
/**
* Find first bit set or clear in a string
* @param key Key string
* @param bit What bit value to look for - must be 1, or 0
* @param handler Handler for the result of this call.
* @return
*/
public RedisClient bitpos(String key, int bit, Handler> handler) {
delegate.bitpos(key, bit, handler);
return this;
}
/**
* Find first bit set or clear in a string
* @param key Key string
* @param bit What bit value to look for - must be 1, or 0
* @return
* @deprecated use {@link #rxBitpos} instead
*/
@Deprecated()
public Observable bitposObservable(String key, int bit) {
io.vertx.rx.java.ObservableFuture handler = io.vertx.rx.java.RxHelper.observableFuture();
bitpos(key, bit, handler.toHandler());
return handler;
}
/**
* Find first bit set or clear in a string
* @param key Key string
* @param bit What bit value to look for - must be 1, or 0
* @return
*/
public Single rxBitpos(String key, int bit) {
return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
bitpos(key, bit, fut);
}));
}
/**
* Find first bit set or clear in a string
*
* See also bitposRange() method, which takes start, and stop offset.
* @param key Key string
* @param bit What bit value to look for - must be 1, or 0
* @param start Start offset
* @param handler Handler for the result of this call.
* @return
*/
public RedisClient bitposFrom(String key, int bit, int start, Handler> handler) {
delegate.bitposFrom(key, bit, start, handler);
return this;
}
/**
* Find first bit set or clear in a string
*
* See also bitposRange() method, which takes start, and stop offset.
* @param key Key string
* @param bit What bit value to look for - must be 1, or 0
* @param start Start offset
* @return
* @deprecated use {@link #rxBitposFrom} instead
*/
@Deprecated()
public Observable bitposFromObservable(String key, int bit, int start) {
io.vertx.rx.java.ObservableFuture handler = io.vertx.rx.java.RxHelper.observableFuture();
bitposFrom(key, bit, start, handler.toHandler());
return handler;
}
/**
* Find first bit set or clear in a string
*
* See also bitposRange() method, which takes start, and stop offset.
* @param key Key string
* @param bit What bit value to look for - must be 1, or 0
* @param start Start offset
* @return
*/
public Single rxBitposFrom(String key, int bit, int start) {
return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
bitposFrom(key, bit, start, fut);
}));
}
/**
* 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
* @param key Key string
* @param bit What bit value to look for - must be 1, or 0
* @param start Start offset
* @param stop End offset - inclusive
* @param handler Handler for the result of this call.
* @return
*/
public RedisClient bitposRange(String key, int bit, int start, int stop, Handler> handler) {
delegate.bitposRange(key, bit, start, stop, handler);
return this;
}
/**
* 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
* @param key Key string
* @param bit What bit value to look for - must be 1, or 0
* @param start Start offset
* @param stop End offset - inclusive
* @return
* @deprecated use {@link #rxBitposRange} instead
*/
@Deprecated()
public Observable bitposRangeObservable(String key, int bit, int start, int stop) {
io.vertx.rx.java.ObservableFuture handler = io.vertx.rx.java.RxHelper.observableFuture();
bitposRange(key, bit, start, stop, handler.toHandler());
return handler;
}
/**
* 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
* @param key Key string
* @param bit What bit value to look for - must be 1, or 0
* @param start Start offset
* @param stop End offset - inclusive
* @return
*/
public Single rxBitposRange(String key, int bit, int start, int stop) {
return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
bitposRange(key, bit, start, stop, fut);
}));
}
/**
* Remove and get the first element in a list, or block until one is available
* @param key Key string identifying a list to watch
* @param seconds Timeout in seconds
* @param handler Handler for the result of this call.
* @return
*/
public RedisClient blpop(String key, int seconds, Handler> handler) {
delegate.blpop(key, seconds, handler);
return this;
}
/**
* Remove and get the first element in a list, or block until one is available
* @param key Key string identifying a list to watch
* @param seconds Timeout in seconds
* @return
* @deprecated use {@link #rxBlpop} instead
*/
@Deprecated()
public Observable blpopObservable(String key, int seconds) {
io.vertx.rx.java.ObservableFuture handler = io.vertx.rx.java.RxHelper.observableFuture();
blpop(key, seconds, handler.toHandler());
return handler;
}
/**
* Remove and get the first element in a list, or block until one is available
* @param key Key string identifying a list to watch
* @param seconds Timeout in seconds
* @return
*/
public Single rxBlpop(String key, int seconds) {
return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
blpop(key, seconds, fut);
}));
}
/**
* Remove and get the first element in any of the lists, or block until one is available
* @param keys List of key strings identifying lists to watch
* @param seconds Timeout in seconds
* @param handler Handler for the result of this call.
* @return
*/
public RedisClient blpopMany(List keys, int seconds, Handler> handler) {
delegate.blpopMany(keys, seconds, handler);
return this;
}
/**
* Remove and get the first element in any of the lists, or block until one is available
* @param keys List of key strings identifying lists to watch
* @param seconds Timeout in seconds
* @return
* @deprecated use {@link #rxBlpopMany} instead
*/
@Deprecated()
public Observable blpopManyObservable(List keys, int seconds) {
io.vertx.rx.java.ObservableFuture handler = io.vertx.rx.java.RxHelper.observableFuture();
blpopMany(keys, seconds, handler.toHandler());
return handler;
}
/**
* Remove and get the first element in any of the lists, or block until one is available
* @param keys List of key strings identifying lists to watch
* @param seconds Timeout in seconds
* @return
*/
public Single rxBlpopMany(List keys, int seconds) {
return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
blpopMany(keys, seconds, fut);
}));
}
/**
* Remove and get the last element in a list, or block until one is available
* @param key Key string identifying a list to watch
* @param seconds Timeout in seconds
* @param handler Handler for the result of this call.
* @return
*/
public RedisClient brpop(String key, int seconds, Handler> handler) {
delegate.brpop(key, seconds, handler);
return this;
}
/**
* Remove and get the last element in a list, or block until one is available
* @param key Key string identifying a list to watch
* @param seconds Timeout in seconds
* @return
* @deprecated use {@link #rxBrpop} instead
*/
@Deprecated()
public Observable brpopObservable(String key, int seconds) {
io.vertx.rx.java.ObservableFuture handler = io.vertx.rx.java.RxHelper.observableFuture();
brpop(key, seconds, handler.toHandler());
return handler;
}
/**
* Remove and get the last element in a list, or block until one is available
* @param key Key string identifying a list to watch
* @param seconds Timeout in seconds
* @return
*/
public Single rxBrpop(String key, int seconds) {
return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
brpop(key, seconds, fut);
}));
}
/**
* Remove and get the last element in any of the lists, or block until one is available
* @param keys List of key strings identifying lists to watch
* @param seconds Timeout in seconds
* @param handler Handler for the result of this call.
* @return
*/
public RedisClient brpopMany(List keys, int seconds, Handler> handler) {
delegate.brpopMany(keys, seconds, handler);
return this;
}
/**
* Remove and get the last element in any of the lists, or block until one is available
* @param keys List of key strings identifying lists to watch
* @param seconds Timeout in seconds
* @return
* @deprecated use {@link #rxBrpopMany} instead
*/
@Deprecated()
public Observable brpopManyObservable(List keys, int seconds) {
io.vertx.rx.java.ObservableFuture handler = io.vertx.rx.java.RxHelper.observableFuture();
brpopMany(keys, seconds, handler.toHandler());
return handler;
}
/**
* Remove and get the last element in any of the lists, or block until one is available
* @param keys List of key strings identifying lists to watch
* @param seconds Timeout in seconds
* @return
*/
public Single rxBrpopMany(List keys, int seconds) {
return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
brpopMany(keys, seconds, fut);
}));
}
/**
* Pop a value from a list, push it to another list and return it; or block until one is available
* @param key Key string identifying the source list
* @param destkey Key string identifying the destination list
* @param seconds Timeout in seconds
* @param handler Handler for the result of this call.
* @return
*/
public RedisClient brpoplpush(String key, String destkey, int seconds, Handler> handler) {
delegate.brpoplpush(key, destkey, seconds, handler);
return this;
}
/**
* Pop a value from a list, push it to another list and return it; or block until one is available
* @param key Key string identifying the source list
* @param destkey Key string identifying the destination list
* @param seconds Timeout in seconds
* @return
* @deprecated use {@link #rxBrpoplpush} instead
*/
@Deprecated()
public Observable brpoplpushObservable(String key, String destkey, int seconds) {
io.vertx.rx.java.ObservableFuture handler = io.vertx.rx.java.RxHelper.observableFuture();
brpoplpush(key, destkey, seconds, handler.toHandler());
return handler;
}
/**
* Pop a value from a list, push it to another list and return it; or block until one is available
* @param key Key string identifying the source list
* @param destkey Key string identifying the destination list
* @param seconds Timeout in seconds
* @return
*/
public Single rxBrpoplpush(String key, String destkey, int seconds) {
return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
brpoplpush(key, destkey, seconds, fut);
}));
}
/**
* Kill the connection of a client
* @param filter Filter options
* @param handler Handler for the result of this call.
* @return
*/
public RedisClient clientKill(KillFilter filter, Handler> handler) {
delegate.clientKill(filter, handler);
return this;
}
/**
* Kill the connection of a client
* @param filter Filter options
* @return
* @deprecated use {@link #rxClientKill} instead
*/
@Deprecated()
public Observable clientKillObservable(KillFilter filter) {
io.vertx.rx.java.ObservableFuture handler = io.vertx.rx.java.RxHelper.observableFuture();
clientKill(filter, handler.toHandler());
return handler;
}
/**
* Kill the connection of a client
* @param filter Filter options
* @return
*/
public Single rxClientKill(KillFilter filter) {
return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
clientKill(filter, fut);
}));
}
/**
* Get the list of client connections
* @param handler
* @return
*/
public RedisClient clientList(Handler> handler) {
delegate.clientList(handler);
return this;
}
/**
* Get the list of client connections
* @return
* @deprecated use {@link #rxClientList} instead
*/
@Deprecated()
public Observable clientListObservable() {
io.vertx.rx.java.ObservableFuture handler = io.vertx.rx.java.RxHelper.observableFuture();
clientList(handler.toHandler());
return handler;
}
/**
* Get the list of client connections
* @return
*/
public Single rxClientList() {
return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
clientList(fut);
}));
}
/**
* Get the current connection name
* @param handler
* @return
*/
public RedisClient clientGetname(Handler> handler) {
delegate.clientGetname(handler);
return this;
}
/**
* Get the current connection name
* @return
* @deprecated use {@link #rxClientGetname} instead
*/
@Deprecated()
public Observable clientGetnameObservable() {
io.vertx.rx.java.ObservableFuture handler = io.vertx.rx.java.RxHelper.observableFuture();
clientGetname(handler.toHandler());
return handler;
}
/**
* Get the current connection name
* @return
*/
public Single rxClientGetname() {
return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
clientGetname(fut);
}));
}
/**
* Stop processing commands from clients for some time
* @param millis Pause time in milliseconds
* @param handler Handler for the result of this call.
* @return
*/
public RedisClient clientPause(long millis, Handler> handler) {
delegate.clientPause(millis, handler);
return this;
}
/**
* Stop processing commands from clients for some time
* @param millis Pause time in milliseconds
* @return
* @deprecated use {@link #rxClientPause} instead
*/
@Deprecated()
public Observable clientPauseObservable(long millis) {
io.vertx.rx.java.ObservableFuture handler = io.vertx.rx.java.RxHelper.observableFuture();
clientPause(millis, handler.toHandler());
return handler;
}
/**
* Stop processing commands from clients for some time
* @param millis Pause time in milliseconds
* @return
*/
public Single rxClientPause(long millis) {
return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
clientPause(millis, fut);
}));
}
/**
* Set the current connection name
* @param name New name for current connection
* @param handler Handler for the result of this call.
* @return
*/
public RedisClient clientSetname(String name, Handler> handler) {
delegate.clientSetname(name, handler);
return this;
}
/**
* Set the current connection name
* @param name New name for current connection
* @return
* @deprecated use {@link #rxClientSetname} instead
*/
@Deprecated()
public Observable clientSetnameObservable(String name) {
io.vertx.rx.java.ObservableFuture handler = io.vertx.rx.java.RxHelper.observableFuture();
clientSetname(name, handler.toHandler());
return handler;
}
/**
* Set the current connection name
* @param name New name for current connection
* @return
*/
public Single rxClientSetname(String name) {
return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
clientSetname(name, fut);
}));
}
/**
* Assign new hash slots to receiving node.
* @param slots
* @param handler Handler for the result of this call.
* @return
*/
public RedisClient clusterAddslots(List slots, Handler> handler) {
delegate.clusterAddslots(slots, handler);
return this;
}
/**
* Assign new hash slots to receiving node.
* @param slots
* @return
* @deprecated use {@link #rxClusterAddslots} instead
*/
@Deprecated()
public Observable clusterAddslotsObservable(List slots) {
io.vertx.rx.java.ObservableFuture handler = io.vertx.rx.java.RxHelper.observableFuture();
clusterAddslots(slots, handler.toHandler());
return handler;
}
/**
* Assign new hash slots to receiving node.
* @param slots
* @return
*/
public Single rxClusterAddslots(List slots) {
return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
clusterAddslots(slots, fut);
}));
}
/**
* Return the number of failure reports active for a given node.
* @param nodeId
* @param handler Handler for the result of this call.
* @return
*/
public RedisClient clusterCountFailureReports(String nodeId, Handler> handler) {
delegate.clusterCountFailureReports(nodeId, handler);
return this;
}
/**
* Return the number of failure reports active for a given node.
* @param nodeId
* @return
* @deprecated use {@link #rxClusterCountFailureReports} instead
*/
@Deprecated()
public Observable clusterCountFailureReportsObservable(String nodeId) {
io.vertx.rx.java.ObservableFuture handler = io.vertx.rx.java.RxHelper.observableFuture();
clusterCountFailureReports(nodeId, handler.toHandler());
return handler;
}
/**
* Return the number of failure reports active for a given node.
* @param nodeId
* @return
*/
public Single rxClusterCountFailureReports(String nodeId) {
return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
clusterCountFailureReports(nodeId, fut);
}));
}
/**
* Return the number of local keys in the specified hash slot.
* @param slot
* @param handler Handler for the result of this call.
* @return
*/
public RedisClient clusterCountkeysinslot(long slot, Handler> handler) {
delegate.clusterCountkeysinslot(slot, handler);
return this;
}
/**
* Return the number of local keys in the specified hash slot.
* @param slot
* @return
* @deprecated use {@link #rxClusterCountkeysinslot} instead
*/
@Deprecated()
public Observable clusterCountkeysinslotObservable(long slot) {
io.vertx.rx.java.ObservableFuture handler = io.vertx.rx.java.RxHelper.observableFuture();
clusterCountkeysinslot(slot, handler.toHandler());
return handler;
}
/**
* Return the number of local keys in the specified hash slot.
* @param slot
* @return
*/
public Single rxClusterCountkeysinslot(long slot) {
return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
clusterCountkeysinslot(slot, fut);
}));
}
/**
* Set hash slots as unbound in receiving node.
* @param slot
* @param handler Handler for the result of this call.
* @return
*/
public RedisClient clusterDelslots(long slot, Handler> handler) {
delegate.clusterDelslots(slot, handler);
return this;
}
/**
* Set hash slots as unbound in receiving node.
* @param slot
* @return
* @deprecated use {@link #rxClusterDelslots} instead
*/
@Deprecated()
public Observable clusterDelslotsObservable(long slot) {
io.vertx.rx.java.ObservableFuture handler = io.vertx.rx.java.RxHelper.observableFuture();
clusterDelslots(slot, handler.toHandler());
return handler;
}
/**
* Set hash slots as unbound in receiving node.
* @param slot
* @return
*/
public Single rxClusterDelslots(long slot) {
return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
clusterDelslots(slot, fut);
}));
}
/**
* Set hash slots as unbound in receiving node.
* @param slots
* @param handler Handler for the result of this call.
* @return
*/
public RedisClient clusterDelslotsMany(List slots, Handler> handler) {
delegate.clusterDelslotsMany(slots, handler);
return this;
}
/**
* Set hash slots as unbound in receiving node.
* @param slots
* @return
* @deprecated use {@link #rxClusterDelslotsMany} instead
*/
@Deprecated()
public Observable clusterDelslotsManyObservable(List slots) {
io.vertx.rx.java.ObservableFuture handler = io.vertx.rx.java.RxHelper.observableFuture();
clusterDelslotsMany(slots, handler.toHandler());
return handler;
}
/**
* Set hash slots as unbound in receiving node.
* @param slots
* @return
*/
public Single rxClusterDelslotsMany(List slots) {
return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
clusterDelslotsMany(slots, fut);
}));
}
/**
* Forces a slave to perform a manual failover of its master.
* @param handler Handler for the result of this call.
* @return
*/
public RedisClient clusterFailover(Handler> handler) {
delegate.clusterFailover(handler);
return this;
}
/**
* Forces a slave to perform a manual failover of its master.
* @return
* @deprecated use {@link #rxClusterFailover} instead
*/
@Deprecated()
public Observable clusterFailoverObservable() {
io.vertx.rx.java.ObservableFuture handler = io.vertx.rx.java.RxHelper.observableFuture();
clusterFailover(handler.toHandler());
return handler;
}
/**
* Forces a slave to perform a manual failover of its master.
* @return
*/
public Single rxClusterFailover() {
return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
clusterFailover(fut);
}));
}
/**
* Forces a slave to perform a manual failover of its master.
* @param options
* @param handler Handler for the result of this call.
* @return
*/
public RedisClient clusterFailOverWithOptions(FailoverOptions options, Handler> handler) {
delegate.clusterFailOverWithOptions(options, handler);
return this;
}
/**
* Forces a slave to perform a manual failover of its master.
* @param options
* @return
* @deprecated use {@link #rxClusterFailOverWithOptions} instead
*/
@Deprecated()
public Observable clusterFailOverWithOptionsObservable(FailoverOptions options) {
io.vertx.rx.java.ObservableFuture handler = io.vertx.rx.java.RxHelper.observableFuture();
clusterFailOverWithOptions(options, handler.toHandler());
return handler;
}
/**
* Forces a slave to perform a manual failover of its master.
* @param options
* @return
*/
public Single rxClusterFailOverWithOptions(FailoverOptions options) {
return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
clusterFailOverWithOptions(options, fut);
}));
}
/**
* Remove a node from the nodes table.
* @param nodeId
* @param handler Handler for the result of this call.
* @return
*/
public RedisClient clusterForget(String nodeId, Handler> handler) {
delegate.clusterForget(nodeId, handler);
return this;
}
/**
* Remove a node from the nodes table.
* @param nodeId
* @return
* @deprecated use {@link #rxClusterForget} instead
*/
@Deprecated()
public Observable clusterForgetObservable(String nodeId) {
io.vertx.rx.java.ObservableFuture handler = io.vertx.rx.java.RxHelper.observableFuture();
clusterForget(nodeId, handler.toHandler());
return handler;
}
/**
* Remove a node from the nodes table.
* @param nodeId
* @return
*/
public Single rxClusterForget(String nodeId) {
return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
clusterForget(nodeId, fut);
}));
}
/**
* Return local key names in the specified hash slot.
* @param slot
* @param count
* @param handler Handler for the result of this call.
* @return
*/
public RedisClient clusterGetkeysinslot(long slot, long count, Handler> handler) {
delegate.clusterGetkeysinslot(slot, count, handler);
return this;
}
/**
* Return local key names in the specified hash slot.
* @param slot
* @param count
* @return
* @deprecated use {@link #rxClusterGetkeysinslot} instead
*/
@Deprecated()
public Observable clusterGetkeysinslotObservable(long slot, long count) {
io.vertx.rx.java.ObservableFuture handler = io.vertx.rx.java.RxHelper.observableFuture();
clusterGetkeysinslot(slot, count, handler.toHandler());
return handler;
}
/**
* Return local key names in the specified hash slot.
* @param slot
* @param count
* @return
*/
public Single rxClusterGetkeysinslot(long slot, long count) {
return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
clusterGetkeysinslot(slot, count, fut);
}));
}
/**
* Provides info about Redis Cluster node state.
* @param handler Handler for the result of this call.
* @return
*/
public RedisClient clusterInfo(Handler> handler) {
delegate.clusterInfo(handler);
return this;
}
/**
* Provides info about Redis Cluster node state.
* @return
* @deprecated use {@link #rxClusterInfo} instead
*/
@Deprecated()
public Observable clusterInfoObservable() {
io.vertx.rx.java.ObservableFuture handler = io.vertx.rx.java.RxHelper.observableFuture();
clusterInfo(handler.toHandler());
return handler;
}
/**
* Provides info about Redis Cluster node state.
* @return
*/
public Single rxClusterInfo() {
return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
clusterInfo(fut);
}));
}
/**
* Returns the hash slot of the specified key.
* @param key
* @param handler Handler for the result of this call.
* @return
*/
public RedisClient clusterKeyslot(String key, Handler> handler) {
delegate.clusterKeyslot(key, handler);
return this;
}
/**
* Returns the hash slot of the specified key.
* @param key
* @return
* @deprecated use {@link #rxClusterKeyslot} instead
*/
@Deprecated()
public Observable clusterKeyslotObservable(String key) {
io.vertx.rx.java.ObservableFuture handler = io.vertx.rx.java.RxHelper.observableFuture();
clusterKeyslot(key, handler.toHandler());
return handler;
}
/**
* Returns the hash slot of the specified key.
* @param key
* @return
*/
public Single rxClusterKeyslot(String key) {
return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
clusterKeyslot(key, fut);
}));
}
/**
* Force a node cluster to handshake with another node.
* @param ip
* @param port
* @param handler Handler for the result of this call.
* @return
*/
public RedisClient clusterMeet(String ip, long port, Handler> handler) {
delegate.clusterMeet(ip, port, handler);
return this;
}
/**
* Force a node cluster to handshake with another node.
* @param ip
* @param port
* @return
* @deprecated use {@link #rxClusterMeet} instead
*/
@Deprecated()
public Observable clusterMeetObservable(String ip, long port) {
io.vertx.rx.java.ObservableFuture handler = io.vertx.rx.java.RxHelper.observableFuture();
clusterMeet(ip, port, handler.toHandler());
return handler;
}
/**
* Force a node cluster to handshake with another node.
* @param ip
* @param port
* @return
*/
public Single rxClusterMeet(String ip, long port) {
return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
clusterMeet(ip, port, fut);
}));
}
/**
* Get Cluster config for the node.
* @param handler Handler for the result of this call.
* @return
*/
public RedisClient clusterNodes(Handler> handler) {
delegate.clusterNodes(handler);
return this;
}
/**
* Get Cluster config for the node.
* @return
* @deprecated use {@link #rxClusterNodes} instead
*/
@Deprecated()
public Observable clusterNodesObservable() {
io.vertx.rx.java.ObservableFuture handler = io.vertx.rx.java.RxHelper.observableFuture();
clusterNodes(handler.toHandler());
return handler;
}
/**
* Get Cluster config for the node.
* @return
*/
public Single rxClusterNodes() {
return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
clusterNodes(fut);
}));
}
/**
* Reconfigure a node as a slave of the specified master node.
* @param nodeId
* @param handler Handler for the result of this call.
* @return
*/
public RedisClient clusterReplicate(String nodeId, Handler> handler) {
delegate.clusterReplicate(nodeId, handler);
return this;
}
/**
* Reconfigure a node as a slave of the specified master node.
* @param nodeId
* @return
* @deprecated use {@link #rxClusterReplicate} instead
*/
@Deprecated()
public Observable clusterReplicateObservable(String nodeId) {
io.vertx.rx.java.ObservableFuture handler = io.vertx.rx.java.RxHelper.observableFuture();
clusterReplicate(nodeId, handler.toHandler());
return handler;
}
/**
* Reconfigure a node as a slave of the specified master node.
* @param nodeId
* @return
*/
public Single rxClusterReplicate(String nodeId) {
return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
clusterReplicate(nodeId, fut);
}));
}
/**
* Reset a Redis Cluster node.
* @param handler Handler for the result of this call.
* @return
*/
public RedisClient clusterReset(Handler> handler) {
delegate.clusterReset(handler);
return this;
}
/**
* Reset a Redis Cluster node.
* @return
* @deprecated use {@link #rxClusterReset} instead
*/
@Deprecated()
public Observable clusterResetObservable() {
io.vertx.rx.java.ObservableFuture handler = io.vertx.rx.java.RxHelper.observableFuture();
clusterReset(handler.toHandler());
return handler;
}
/**
* Reset a Redis Cluster node.
* @return
*/
public Single rxClusterReset() {
return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
clusterReset(fut);
}));
}
/**
* Reset a Redis Cluster node.
* @param options
* @param handler Handler for the result of this call.
* @return
*/
public RedisClient clusterResetWithOptions(ResetOptions options, Handler> handler) {
delegate.clusterResetWithOptions(options, handler);
return this;
}
/**
* Reset a Redis Cluster node.
* @param options
* @return
* @deprecated use {@link #rxClusterResetWithOptions} instead
*/
@Deprecated()
public Observable clusterResetWithOptionsObservable(ResetOptions options) {
io.vertx.rx.java.ObservableFuture handler = io.vertx.rx.java.RxHelper.observableFuture();
clusterResetWithOptions(options, handler.toHandler());
return handler;
}
/**
* Reset a Redis Cluster node.
* @param options
* @return
*/
public Single rxClusterResetWithOptions(ResetOptions options) {
return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
clusterResetWithOptions(options, fut);
}));
}
/**
* Forces the node to save cluster state on disk.
* @param handler Handler for the result of this call.
* @return
*/
public RedisClient clusterSaveconfig(Handler> handler) {
delegate.clusterSaveconfig(handler);
return this;
}
/**
* Forces the node to save cluster state on disk.
* @return
* @deprecated use {@link #rxClusterSaveconfig} instead
*/
@Deprecated()
public Observable clusterSaveconfigObservable() {
io.vertx.rx.java.ObservableFuture handler = io.vertx.rx.java.RxHelper.observableFuture();
clusterSaveconfig(handler.toHandler());
return handler;
}
/**
* Forces the node to save cluster state on disk.
* @return
*/
public Single rxClusterSaveconfig() {
return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
clusterSaveconfig(fut);
}));
}
/**
* Set the configuration epoch in a new node.
* @param epoch
* @param handler Handler for the result of this call.
* @return
*/
public RedisClient clusterSetConfigEpoch(long epoch, Handler> handler) {
delegate.clusterSetConfigEpoch(epoch, handler);
return this;
}
/**
* Set the configuration epoch in a new node.
* @param epoch
* @return
* @deprecated use {@link #rxClusterSetConfigEpoch} instead
*/
@Deprecated()
public Observable clusterSetConfigEpochObservable(long epoch) {
io.vertx.rx.java.ObservableFuture handler = io.vertx.rx.java.RxHelper.observableFuture();
clusterSetConfigEpoch(epoch, handler.toHandler());
return handler;
}
/**
* Set the configuration epoch in a new node.
* @param epoch
* @return
*/
public Single rxClusterSetConfigEpoch(long epoch) {
return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
clusterSetConfigEpoch(epoch, fut);
}));
}
/**
* Bind an hash slot to a specific node.
* @param slot
* @param subcommand
* @param handler Handler for the result of this call.
* @return
*/
public RedisClient clusterSetslot(long slot, SlotCmd subcommand, Handler> handler) {
delegate.clusterSetslot(slot, subcommand, handler);
return this;
}
/**
* Bind an hash slot to a specific node.
* @param slot
* @param subcommand
* @return
* @deprecated use {@link #rxClusterSetslot} instead
*/
@Deprecated()
public Observable clusterSetslotObservable(long slot, SlotCmd subcommand) {
io.vertx.rx.java.ObservableFuture handler = io.vertx.rx.java.RxHelper.observableFuture();
clusterSetslot(slot, subcommand, handler.toHandler());
return handler;
}
/**
* Bind an hash slot to a specific node.
* @param slot
* @param subcommand
* @return
*/
public Single rxClusterSetslot(long slot, SlotCmd subcommand) {
return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
clusterSetslot(slot, subcommand, fut);
}));
}
/**
* Bind an hash slot to a specific node.
* @param slot
* @param subcommand
* @param nodeId
* @param handler Handler for the result of this call.
* @return
*/
public RedisClient clusterSetslotWithNode(long slot, SlotCmd subcommand, String nodeId, Handler> handler) {
delegate.clusterSetslotWithNode(slot, subcommand, nodeId, handler);
return this;
}
/**
* Bind an hash slot to a specific node.
* @param slot
* @param subcommand
* @param nodeId
* @return
* @deprecated use {@link #rxClusterSetslotWithNode} instead
*/
@Deprecated()
public Observable clusterSetslotWithNodeObservable(long slot, SlotCmd subcommand, String nodeId) {
io.vertx.rx.java.ObservableFuture handler = io.vertx.rx.java.RxHelper.observableFuture();
clusterSetslotWithNode(slot, subcommand, nodeId, handler.toHandler());
return handler;
}
/**
* Bind an hash slot to a specific node.
* @param slot
* @param subcommand
* @param nodeId
* @return
*/
public Single rxClusterSetslotWithNode(long slot, SlotCmd subcommand, String nodeId) {
return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
clusterSetslotWithNode(slot, subcommand, nodeId, fut);
}));
}
/**
* List slave nodes of the specified master node.
* @param nodeId
* @param handler Handler for the result of this call.
* @return
*/
public RedisClient clusterSlaves(String nodeId, Handler> handler) {
delegate.clusterSlaves(nodeId, handler);
return this;
}
/**
* List slave nodes of the specified master node.
* @param nodeId
* @return
* @deprecated use {@link #rxClusterSlaves} instead
*/
@Deprecated()
public Observable clusterSlavesObservable(String nodeId) {
io.vertx.rx.java.ObservableFuture handler = io.vertx.rx.java.RxHelper.observableFuture();
clusterSlaves(nodeId, handler.toHandler());
return handler;
}
/**
* List slave nodes of the specified master node.
* @param nodeId
* @return
*/
public Single rxClusterSlaves(String nodeId) {
return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
clusterSlaves(nodeId, fut);
}));
}
/**
* Get array of Cluster slot to node mappings
* @param handler
* @return
*/
public RedisClient clusterSlots(Handler> handler) {
delegate.clusterSlots(handler);
return this;
}
/**
* Get array of Cluster slot to node mappings
* @return
* @deprecated use {@link #rxClusterSlots} instead
*/
@Deprecated()
public Observable clusterSlotsObservable() {
io.vertx.rx.java.ObservableFuture handler = io.vertx.rx.java.RxHelper.observableFuture();
clusterSlots(handler.toHandler());
return handler;
}
/**
* Get array of Cluster slot to node mappings
* @return
*/
public Single rxClusterSlots() {
return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
clusterSlots(fut);
}));
}
/**
* Get array of Redis command details
* @param handler
* @return
*/
public RedisClient command(Handler> handler) {
delegate.command(handler);
return this;
}
/**
* Get array of Redis command details
* @return
* @deprecated use {@link #rxCommand} instead
*/
@Deprecated()
public Observable commandObservable() {
io.vertx.rx.java.ObservableFuture handler = io.vertx.rx.java.RxHelper.observableFuture();
command(handler.toHandler());
return handler;
}
/**
* Get array of Redis command details
* @return
*/
public Single rxCommand() {
return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
command(fut);
}));
}
/**
* Get total number of Redis commands
* @param handler
* @return
*/
public RedisClient commandCount(Handler> handler) {
delegate.commandCount(handler);
return this;
}
/**
* Get total number of Redis commands
* @return
* @deprecated use {@link #rxCommandCount} instead
*/
@Deprecated()
public Observable commandCountObservable() {
io.vertx.rx.java.ObservableFuture handler = io.vertx.rx.java.RxHelper.observableFuture();
commandCount(handler.toHandler());
return handler;
}
/**
* Get total number of Redis commands
* @return
*/
public Single rxCommandCount() {
return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
commandCount(fut);
}));
}
/**
* Extract keys given a full Redis command
* @param handler
* @return
*/
public RedisClient commandGetkeys(Handler> handler) {
delegate.commandGetkeys(handler);
return this;
}
/**
* Extract keys given a full Redis command
* @return
* @deprecated use {@link #rxCommandGetkeys} instead
*/
@Deprecated()
public Observable commandGetkeysObservable() {
io.vertx.rx.java.ObservableFuture handler = io.vertx.rx.java.RxHelper.observableFuture();
commandGetkeys(handler.toHandler());
return handler;
}
/**
* Extract keys given a full Redis command
* @return
*/
public Single rxCommandGetkeys() {
return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
commandGetkeys(fut);
}));
}
/**
* Get array of specific Redis command details
* @param commands List of commands to get info for
* @param handler Handler for the result of this call.
* @return
*/
public RedisClient commandInfo(List commands, Handler> handler) {
delegate.commandInfo(commands, handler);
return this;
}
/**
* Get array of specific Redis command details
* @param commands List of commands to get info for
* @return
* @deprecated use {@link #rxCommandInfo} instead
*/
@Deprecated()
public Observable commandInfoObservable(List commands) {
io.vertx.rx.java.ObservableFuture handler = io.vertx.rx.java.RxHelper.observableFuture();
commandInfo(commands, handler.toHandler());
return handler;
}
/**
* Get array of specific Redis command details
* @param commands List of commands to get info for
* @return
*/
public Single rxCommandInfo(List commands) {
return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
commandInfo(commands, fut);
}));
}
/**
* Get the value of a configuration parameter
* @param parameter Configuration parameter
* @param handler Handler for the result of this call.
* @return
*/
public RedisClient configGet(String parameter, Handler> handler) {
delegate.configGet(parameter, handler);
return this;
}
/**
* Get the value of a configuration parameter
* @param parameter Configuration parameter
* @return
* @deprecated use {@link #rxConfigGet} instead
*/
@Deprecated()
public Observable configGetObservable(String parameter) {
io.vertx.rx.java.ObservableFuture handler = io.vertx.rx.java.RxHelper.observableFuture();
configGet(parameter, handler.toHandler());
return handler;
}
/**
* Get the value of a configuration parameter
* @param parameter Configuration parameter
* @return
*/
public Single rxConfigGet(String parameter) {
return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
configGet(parameter, fut);
}));
}
/**
* Rewrite the configuration file with the in memory configuration
* @param handler
* @return
*/
public RedisClient configRewrite(Handler> handler) {
delegate.configRewrite(handler);
return this;
}
/**
* Rewrite the configuration file with the in memory configuration
* @return
* @deprecated use {@link #rxConfigRewrite} instead
*/
@Deprecated()
public Observable configRewriteObservable() {
io.vertx.rx.java.ObservableFuture handler = io.vertx.rx.java.RxHelper.observableFuture();
configRewrite(handler.toHandler());
return handler;
}
/**
* Rewrite the configuration file with the in memory configuration
* @return
*/
public Single rxConfigRewrite() {
return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
configRewrite(fut);
}));
}
/**
* Set a configuration parameter to the given value
* @param parameter Configuration parameter
* @param value New value
* @param handler Handler for the result of this call.
* @return
*/
public RedisClient configSet(String parameter, String value, Handler> handler) {
delegate.configSet(parameter, value, handler);
return this;
}
/**
* Set a configuration parameter to the given value
* @param parameter Configuration parameter
* @param value New value
* @return
* @deprecated use {@link #rxConfigSet} instead
*/
@Deprecated()
public Observable configSetObservable(String parameter, String value) {
io.vertx.rx.java.ObservableFuture handler = io.vertx.rx.java.RxHelper.observableFuture();
configSet(parameter, value, handler.toHandler());
return handler;
}
/**
* Set a configuration parameter to the given value
* @param parameter Configuration parameter
* @param value New value
* @return
*/
public Single rxConfigSet(String parameter, String value) {
return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
configSet(parameter, value, fut);
}));
}
/**
* Reset the stats returned by INFO
* @param handler
* @return
*/
public RedisClient configResetstat(Handler> handler) {
delegate.configResetstat(handler);
return this;
}
/**
* Reset the stats returned by INFO
* @return
* @deprecated use {@link #rxConfigResetstat} instead
*/
@Deprecated()
public Observable configResetstatObservable() {
io.vertx.rx.java.ObservableFuture handler = io.vertx.rx.java.RxHelper.observableFuture();
configResetstat(handler.toHandler());
return handler;
}
/**
* Reset the stats returned by INFO
* @return
*/
public Single rxConfigResetstat() {
return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
configResetstat(fut);
}));
}
/**
* Return the number of keys in the selected database
* @param handler
* @return
*/
public RedisClient dbsize(Handler> handler) {
delegate.dbsize(handler);
return this;
}
/**
* Return the number of keys in the selected database
* @return
* @deprecated use {@link #rxDbsize} instead
*/
@Deprecated()
public Observable dbsizeObservable() {
io.vertx.rx.java.ObservableFuture handler = io.vertx.rx.java.RxHelper.observableFuture();
dbsize(handler.toHandler());
return handler;
}
/**
* Return the number of keys in the selected database
* @return
*/
public Single rxDbsize() {
return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
dbsize(fut);
}));
}
/**
* Get debugging information about a key
* @param key Key string
* @param handler Handler for the result of this call.
* @return
*/
public RedisClient debugObject(String key, Handler> handler) {
delegate.debugObject(key, handler);
return this;
}
/**
* Get debugging information about a key
* @param key Key string
* @return
* @deprecated use {@link #rxDebugObject} instead
*/
@Deprecated()
public Observable debugObjectObservable(String key) {
io.vertx.rx.java.ObservableFuture handler = io.vertx.rx.java.RxHelper.observableFuture();
debugObject(key, handler.toHandler());
return handler;
}
/**
* Get debugging information about a key
* @param key Key string
* @return
*/
public Single rxDebugObject(String key) {
return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
debugObject(key, fut);
}));
}
/**
* Make the server crash
* @param handler
* @return
*/
public RedisClient debugSegfault(Handler> handler) {
delegate.debugSegfault(handler);
return this;
}
/**
* Make the server crash
* @return
* @deprecated use {@link #rxDebugSegfault} instead
*/
@Deprecated()
public Observable debugSegfaultObservable() {
io.vertx.rx.java.ObservableFuture handler = io.vertx.rx.java.RxHelper.observableFuture();
debugSegfault(handler.toHandler());
return handler;
}
/**
* Make the server crash
* @return
*/
public Single rxDebugSegfault() {
return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
debugSegfault(fut);
}));
}
/**
* Decrement the integer value of a key by one
* @param key Key string
* @param handler Handler for the result of this call.
* @return
*/
public RedisClient decr(String key, Handler> handler) {
delegate.decr(key, handler);
return this;
}
/**
* Decrement the integer value of a key by one
* @param key Key string
* @return
* @deprecated use {@link #rxDecr} instead
*/
@Deprecated()
public Observable decrObservable(String key) {
io.vertx.rx.java.ObservableFuture handler = io.vertx.rx.java.RxHelper.observableFuture();
decr(key, handler.toHandler());
return handler;
}
/**
* Decrement the integer value of a key by one
* @param key Key string
* @return
*/
public Single rxDecr(String key) {
return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
decr(key, fut);
}));
}
/**
* Decrement the integer value of a key by the given number
* @param key Key string
* @param decrement Value by which to decrement
* @param handler Handler for the result of this call.
* @return
*/
public RedisClient decrby(String key, long decrement, Handler> handler) {
delegate.decrby(key, decrement, handler);
return this;
}
/**
* Decrement the integer value of a key by the given number
* @param key Key string
* @param decrement Value by which to decrement
* @return
* @deprecated use {@link #rxDecrby} instead
*/
@Deprecated()
public Observable decrbyObservable(String key, long decrement) {
io.vertx.rx.java.ObservableFuture handler = io.vertx.rx.java.RxHelper.observableFuture();
decrby(key, decrement, handler.toHandler());
return handler;
}
/**
* Decrement the integer value of a key by the given number
* @param key Key string
* @param decrement Value by which to decrement
* @return
*/
public Single rxDecrby(String key, long decrement) {
return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
decrby(key, decrement, fut);
}));
}
/**
* Delete a key
* @param key Keys to delete
* @param handler Handler for the result of this call.
* @return
*/
public RedisClient del(String key, Handler> handler) {
delegate.del(key, handler);
return this;
}
/**
* Delete a key
* @param key Keys to delete
* @return
* @deprecated use {@link #rxDel} instead
*/
@Deprecated()
public Observable delObservable(String key) {
io.vertx.rx.java.ObservableFuture handler = io.vertx.rx.java.RxHelper.observableFuture();
del(key, handler.toHandler());
return handler;
}
/**
* Delete a key
* @param key Keys to delete
* @return
*/
public Single rxDel(String key) {
return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
del(key, fut);
}));
}
/**
* Delete many keys
* @param keys List of keys to delete
* @param handler Handler for the result of this call.
* @return
*/
public RedisClient delMany(List keys, Handler> handler) {
delegate.delMany(keys, handler);
return this;
}
/**
* Delete many keys
* @param keys List of keys to delete
* @return
* @deprecated use {@link #rxDelMany} instead
*/
@Deprecated()
public Observable