http://nexus.sonatype.org/oss-repository-hosting.html/vertx-parent/vertx-rx/vertx-rx-java: Sonatype helps open source projects to set up Maven repositories on https://oss.sonatype.org/ (Eclipse) 
/*
 * 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.client;

import rx.Observable;
import rx.Single;
import io.vertx.rx.java.RxHelper;
import io.vertx.rx.java.WriteStreamSubscriber;
import io.vertx.rx.java.SingleOnSubscribeAdapter;
import java.util.Map;
import java.util.Set;
import java.util.List;
import java.util.Iterator;
import java.util.function.Function;
import java.util.stream.Collectors;
import io.vertx.core.Handler;
import io.vertx.core.AsyncResult;
import io.vertx.core.json.JsonObject;
import io.vertx.core.json.JsonArray;
import io.vertx.lang.rx.RxGen;
import io.vertx.lang.rx.TypeArg;
import io.vertx.lang.rx.MappingIterator;


Auto generated Redis API client wrapper.

 NOTE: This class has been automatically generated from the original non RX-ified interface using Vert.x codegen. 
/**
 * <b>Auto generated</b> Redis API client wrapper.
 *
 * <p/>
 * NOTE: This class has been automatically generated from the {@link io.vertx.redis.client.RedisAPI original} non RX-ified interface using Vert.x codegen.
 */

@RxGen(io.vertx.redis.client.RedisAPI.class)
public class RedisAPI {

  @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;
    RedisAPI that = (RedisAPI) o;
    return delegate.equals(that.delegate);
  }
  
  @Override
  public int hashCode() {
    return delegate.hashCode();
  }

  public static final TypeArg<RedisAPI> __TYPE_ARG = new TypeArg<>(    obj -> new RedisAPI((io.vertx.redis.client.RedisAPI) obj),
    RedisAPI::getDelegate
  );

  private final io.vertx.redis.client.RedisAPI delegate;
  
  public RedisAPI(io.vertx.redis.client.RedisAPI delegate) {
    this.delegate = delegate;
  }

  public RedisAPI(Object delegate) {
    this.delegate = (io.vertx.redis.client.RedisAPI)delegate;
  }

  public io.vertx.redis.client.RedisAPI getDelegate() {
    return delegate;
  }

  public void close() { 
    delegate.close();
  }

  
Redis command acl.

Params:
  • args – 
  • handler – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/acl">acl</a>.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI acl(List<String> args, Handler<AsyncResult<io.vertx.rxjava.redis.client.Response>> handler) { 
    delegate.acl(args, new Handler<AsyncResult<io.vertx.redis.client.Response>>() {
      public void handle(AsyncResult<io.vertx.redis.client.Response> ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

  
Redis command acl.

Params:
  • args – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/acl">acl</a>.
   * @param args 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI acl(List<String> args) {
    return 
acl(args, ar -> { });
  }

    
Redis command acl.

Params:
  • args – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/acl">acl</a>.
   * @param args 
   * @return fluent self
   */
  public Single<io.vertx.rxjava.redis.client.Response> rxAcl(List<String> args) { 
    return Single.create(new SingleOnSubscribeAdapter<>(fut -> {
      acl(args, fut);
    }));
  }

  
Redis command append.

Params:
  • arg0 – 
  • arg1 – 
  • handler – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/append">append</a>.
   * @param arg0 
   * @param arg1 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI append(String arg0, String arg1, Handler<AsyncResult<io.vertx.rxjava.redis.client.Response>> handler) { 
    delegate.append(arg0, arg1, new Handler<AsyncResult<io.vertx.redis.client.Response>>() {
      public void handle(AsyncResult<io.vertx.redis.client.Response> ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

  
Redis command append.

Params:
  • arg0 – 
  • arg1 – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/append">append</a>.
   * @param arg0 
   * @param arg1 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI append(String arg0, String arg1) {
    return 
append(arg0, arg1, ar -> { });
  }

    
Redis command append.

Params:
  • arg0 – 
  • arg1 – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/append">append</a>.
   * @param arg0 
   * @param arg1 
   * @return fluent self
   */
  public Single<io.vertx.rxjava.redis.client.Response> rxAppend(String arg0, String arg1) { 
    return Single.create(new SingleOnSubscribeAdapter<>(fut -> {
      append(arg0, arg1, fut);
    }));
  }

  
Redis command asking.

Params:
  • handler – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/asking">asking</a>.
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI asking(Handler<AsyncResult<io.vertx.rxjava.redis.client.Response>> handler) { 
    delegate.asking(new Handler<AsyncResult<io.vertx.redis.client.Response>>() {
      public void handle(AsyncResult<io.vertx.redis.client.Response> ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

  
Redis command asking.

Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/asking">asking</a>.
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI asking() {
    return 
asking(ar -> { });
  }

    
Redis command asking.

Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/asking">asking</a>.
   * @return fluent self
   */
  public Single<io.vertx.rxjava.redis.client.Response> rxAsking() { 
    return Single.create(new SingleOnSubscribeAdapter<>(fut -> {
      asking(fut);
    }));
  }

  
Redis command auth.

Params:
  • args – 
  • handler – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/auth">auth</a>.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI auth(List<String> args, Handler<AsyncResult<io.vertx.rxjava.redis.client.Response>> handler) { 
    delegate.auth(args, new Handler<AsyncResult<io.vertx.redis.client.Response>>() {
      public void handle(AsyncResult<io.vertx.redis.client.Response> ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

  
Redis command auth.

Params:
  • args – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/auth">auth</a>.
   * @param args 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI auth(List<String> args) {
    return 
auth(args, ar -> { });
  }

    
Redis command auth.

Params:
  • args – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/auth">auth</a>.
   * @param args 
   * @return fluent self
   */
  public Single<io.vertx.rxjava.redis.client.Response> rxAuth(List<String> args) { 
    return Single.create(new SingleOnSubscribeAdapter<>(fut -> {
      auth(args, fut);
    }));
  }

  
Redis command bgrewriteaof.

Params:
  • handler – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/bgrewriteaof">bgrewriteaof</a>.
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI bgrewriteaof(Handler<AsyncResult<io.vertx.rxjava.redis.client.Response>> handler) { 
    delegate.bgrewriteaof(new Handler<AsyncResult<io.vertx.redis.client.Response>>() {
      public void handle(AsyncResult<io.vertx.redis.client.Response> ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

  
Redis command bgrewriteaof.

Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/bgrewriteaof">bgrewriteaof</a>.
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI bgrewriteaof() {
    return 
bgrewriteaof(ar -> { });
  }

    
Redis command bgrewriteaof.

Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/bgrewriteaof">bgrewriteaof</a>.
   * @return fluent self
   */
  public Single<io.vertx.rxjava.redis.client.Response> rxBgrewriteaof() { 
    return Single.create(new SingleOnSubscribeAdapter<>(fut -> {
      bgrewriteaof(fut);
    }));
  }

  
Redis command bgsave.

Params:
  • args – 
  • handler – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/bgsave">bgsave</a>.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI bgsave(List<String> args, Handler<AsyncResult<io.vertx.rxjava.redis.client.Response>> handler) { 
    delegate.bgsave(args, new Handler<AsyncResult<io.vertx.redis.client.Response>>() {
      public void handle(AsyncResult<io.vertx.redis.client.Response> ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

  
Redis command bgsave.

Params:
  • args – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/bgsave">bgsave</a>.
   * @param args 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI bgsave(List<String> args) {
    return 
bgsave(args, ar -> { });
  }

    
Redis command bgsave.

Params:
  • args – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/bgsave">bgsave</a>.
   * @param args 
   * @return fluent self
   */
  public Single<io.vertx.rxjava.redis.client.Response> rxBgsave(List<String> args) { 
    return Single.create(new SingleOnSubscribeAdapter<>(fut -> {
      bgsave(args, fut);
    }));
  }

  
Redis command bitcount.

Params:
  • args – 
  • handler – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/bitcount">bitcount</a>.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI bitcount(List<String> args, Handler<AsyncResult<io.vertx.rxjava.redis.client.Response>> handler) { 
    delegate.bitcount(args, new Handler<AsyncResult<io.vertx.redis.client.Response>>() {
      public void handle(AsyncResult<io.vertx.redis.client.Response> ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

  
Redis command bitcount.

Params:
  • args – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/bitcount">bitcount</a>.
   * @param args 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI bitcount(List<String> args) {
    return 
bitcount(args, ar -> { });
  }

    
Redis command bitcount.

Params:
  • args – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/bitcount">bitcount</a>.
   * @param args 
   * @return fluent self
   */
  public Single<io.vertx.rxjava.redis.client.Response> rxBitcount(List<String> args) { 
    return Single.create(new SingleOnSubscribeAdapter<>(fut -> {
      bitcount(args, fut);
    }));
  }

  
Redis command bitfield.

Params:
  • args – 
  • handler – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/bitfield">bitfield</a>.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI bitfield(List<String> args, Handler<AsyncResult<io.vertx.rxjava.redis.client.Response>> handler) { 
    delegate.bitfield(args, new Handler<AsyncResult<io.vertx.redis.client.Response>>() {
      public void handle(AsyncResult<io.vertx.redis.client.Response> ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

  
Redis command bitfield.

Params:
  • args – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/bitfield">bitfield</a>.
   * @param args 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI bitfield(List<String> args) {
    return 
bitfield(args, ar -> { });
  }

    
Redis command bitfield.

Params:
  • args – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/bitfield">bitfield</a>.
   * @param args 
   * @return fluent self
   */
  public Single<io.vertx.rxjava.redis.client.Response> rxBitfield(List<String> args) { 
    return Single.create(new SingleOnSubscribeAdapter<>(fut -> {
      bitfield(args, fut);
    }));
  }

  
Redis command bitfieldRo.

Params:
  • args – 
  • handler – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/bitfield_ro">bitfieldRo</a>.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI bitfieldRo(List<String> args, Handler<AsyncResult<io.vertx.rxjava.redis.client.Response>> handler) { 
    delegate.bitfieldRo(args, new Handler<AsyncResult<io.vertx.redis.client.Response>>() {
      public void handle(AsyncResult<io.vertx.redis.client.Response> ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

  
Redis command bitfieldRo.

Params:
  • args – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/bitfield_ro">bitfieldRo</a>.
   * @param args 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI bitfieldRo(List<String> args) {
    return 
bitfieldRo(args, ar -> { });
  }

    
Redis command bitfieldRo.

Params:
  • args – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/bitfield_ro">bitfieldRo</a>.
   * @param args 
   * @return fluent self
   */
  public Single<io.vertx.rxjava.redis.client.Response> rxBitfieldRo(List<String> args) { 
    return Single.create(new SingleOnSubscribeAdapter<>(fut -> {
      bitfieldRo(args, fut);
    }));
  }

  
Redis command bitop.

Params:
  • args – 
  • handler – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/bitop">bitop</a>.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI bitop(List<String> args, Handler<AsyncResult<io.vertx.rxjava.redis.client.Response>> handler) { 
    delegate.bitop(args, new Handler<AsyncResult<io.vertx.redis.client.Response>>() {
      public void handle(AsyncResult<io.vertx.redis.client.Response> ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

  
Redis command bitop.

Params:
  • args – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/bitop">bitop</a>.
   * @param args 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI bitop(List<String> args) {
    return 
bitop(args, ar -> { });
  }

    
Redis command bitop.

Params:
  • args – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/bitop">bitop</a>.
   * @param args 
   * @return fluent self
   */
  public Single<io.vertx.rxjava.redis.client.Response> rxBitop(List<String> args) { 
    return Single.create(new SingleOnSubscribeAdapter<>(fut -> {
      bitop(args, fut);
    }));
  }

  
Redis command bitpos.

Params:
  • args – 
  • handler – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/bitpos">bitpos</a>.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI bitpos(List<String> args, Handler<AsyncResult<io.vertx.rxjava.redis.client.Response>> handler) { 
    delegate.bitpos(args, new Handler<AsyncResult<io.vertx.redis.client.Response>>() {
      public void handle(AsyncResult<io.vertx.redis.client.Response> ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

  
Redis command bitpos.

Params:
  • args – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/bitpos">bitpos</a>.
   * @param args 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI bitpos(List<String> args) {
    return 
bitpos(args, ar -> { });
  }

    
Redis command bitpos.

Params:
  • args – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/bitpos">bitpos</a>.
   * @param args 
   * @return fluent self
   */
  public Single<io.vertx.rxjava.redis.client.Response> rxBitpos(List<String> args) { 
    return Single.create(new SingleOnSubscribeAdapter<>(fut -> {
      bitpos(args, fut);
    }));
  }

  
Redis command blpop.

Params:
  • args – 
  • handler – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/blpop">blpop</a>.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI blpop(List<String> args, Handler<AsyncResult<io.vertx.rxjava.redis.client.Response>> handler) { 
    delegate.blpop(args, new Handler<AsyncResult<io.vertx.redis.client.Response>>() {
      public void handle(AsyncResult<io.vertx.redis.client.Response> ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

  
Redis command blpop.

Params:
  • args – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/blpop">blpop</a>.
   * @param args 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI blpop(List<String> args) {
    return 
blpop(args, ar -> { });
  }

    
Redis command blpop.

Params:
  • args – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/blpop">blpop</a>.
   * @param args 
   * @return fluent self
   */
  public Single<io.vertx.rxjava.redis.client.Response> rxBlpop(List<String> args) { 
    return Single.create(new SingleOnSubscribeAdapter<>(fut -> {
      blpop(args, fut);
    }));
  }

  
Redis command brpop.

Params:
  • args – 
  • handler – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/brpop">brpop</a>.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI brpop(List<String> args, Handler<AsyncResult<io.vertx.rxjava.redis.client.Response>> handler) { 
    delegate.brpop(args, new Handler<AsyncResult<io.vertx.redis.client.Response>>() {
      public void handle(AsyncResult<io.vertx.redis.client.Response> ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

  
Redis command brpop.

Params:
  • args – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/brpop">brpop</a>.
   * @param args 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI brpop(List<String> args) {
    return 
brpop(args, ar -> { });
  }

    
Redis command brpop.

Params:
  • args – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/brpop">brpop</a>.
   * @param args 
   * @return fluent self
   */
  public Single<io.vertx.rxjava.redis.client.Response> rxBrpop(List<String> args) { 
    return Single.create(new SingleOnSubscribeAdapter<>(fut -> {
      brpop(args, fut);
    }));
  }

  
Redis command brpoplpush.

Params:
  • arg0 – 
  • arg1 – 
  • arg2 – 
  • handler – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/brpoplpush">brpoplpush</a>.
   * @param arg0 
   * @param arg1 
   * @param arg2 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI brpoplpush(String arg0, String arg1, String arg2, Handler<AsyncResult<io.vertx.rxjava.redis.client.Response>> handler) { 
    delegate.brpoplpush(arg0, arg1, arg2, new Handler<AsyncResult<io.vertx.redis.client.Response>>() {
      public void handle(AsyncResult<io.vertx.redis.client.Response> ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

  
Redis command brpoplpush.

Params:
  • arg0 – 
  • arg1 – 
  • arg2 – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/brpoplpush">brpoplpush</a>.
   * @param arg0 
   * @param arg1 
   * @param arg2 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI brpoplpush(String arg0, String arg1, String arg2) {
    return 
brpoplpush(arg0, arg1, arg2, ar -> { });
  }

    
Redis command brpoplpush.

Params:
  • arg0 – 
  • arg1 – 
  • arg2 – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/brpoplpush">brpoplpush</a>.
   * @param arg0 
   * @param arg1 
   * @param arg2 
   * @return fluent self
   */
  public Single<io.vertx.rxjava.redis.client.Response> rxBrpoplpush(String arg0, String arg1, String arg2) { 
    return Single.create(new SingleOnSubscribeAdapter<>(fut -> {
      brpoplpush(arg0, arg1, arg2, fut);
    }));
  }

  
Redis command bzpopmax.

Params:
  • args – 
  • handler – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/bzpopmax">bzpopmax</a>.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI bzpopmax(List<String> args, Handler<AsyncResult<io.vertx.rxjava.redis.client.Response>> handler) { 
    delegate.bzpopmax(args, new Handler<AsyncResult<io.vertx.redis.client.Response>>() {
      public void handle(AsyncResult<io.vertx.redis.client.Response> ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

  
Redis command bzpopmax.

Params:
  • args – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/bzpopmax">bzpopmax</a>.
   * @param args 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI bzpopmax(List<String> args) {
    return 
bzpopmax(args, ar -> { });
  }

    
Redis command bzpopmax.

Params:
  • args – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/bzpopmax">bzpopmax</a>.
   * @param args 
   * @return fluent self
   */
  public Single<io.vertx.rxjava.redis.client.Response> rxBzpopmax(List<String> args) { 
    return Single.create(new SingleOnSubscribeAdapter<>(fut -> {
      bzpopmax(args, fut);
    }));
  }

  
Redis command bzpopmin.

Params:
  • args – 
  • handler – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/bzpopmin">bzpopmin</a>.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI bzpopmin(List<String> args, Handler<AsyncResult<io.vertx.rxjava.redis.client.Response>> handler) { 
    delegate.bzpopmin(args, new Handler<AsyncResult<io.vertx.redis.client.Response>>() {
      public void handle(AsyncResult<io.vertx.redis.client.Response> ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

  
Redis command bzpopmin.

Params:
  • args – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/bzpopmin">bzpopmin</a>.
   * @param args 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI bzpopmin(List<String> args) {
    return 
bzpopmin(args, ar -> { });
  }

    
Redis command bzpopmin.

Params:
  • args – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/bzpopmin">bzpopmin</a>.
   * @param args 
   * @return fluent self
   */
  public Single<io.vertx.rxjava.redis.client.Response> rxBzpopmin(List<String> args) { 
    return Single.create(new SingleOnSubscribeAdapter<>(fut -> {
      bzpopmin(args, fut);
    }));
  }

  
Redis command client.

Params:
  • args – 
  • handler – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/client">client</a>.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI client(List<String> args, Handler<AsyncResult<io.vertx.rxjava.redis.client.Response>> handler) { 
    delegate.client(args, new Handler<AsyncResult<io.vertx.redis.client.Response>>() {
      public void handle(AsyncResult<io.vertx.redis.client.Response> ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

  
Redis command client.

Params:
  • args – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/client">client</a>.
   * @param args 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI client(List<String> args) {
    return 
client(args, ar -> { });
  }

    
Redis command client.

Params:
  • args – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/client">client</a>.
   * @param args 
   * @return fluent self
   */
  public Single<io.vertx.rxjava.redis.client.Response> rxClient(List<String> args) { 
    return Single.create(new SingleOnSubscribeAdapter<>(fut -> {
      client(args, fut);
    }));
  }

  
Redis command cluster.

Params:
  • args – 
  • handler – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/cluster">cluster</a>.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI cluster(List<String> args, Handler<AsyncResult<io.vertx.rxjava.redis.client.Response>> handler) { 
    delegate.cluster(args, new Handler<AsyncResult<io.vertx.redis.client.Response>>() {
      public void handle(AsyncResult<io.vertx.redis.client.Response> ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

  
Redis command cluster.

Params:
  • args – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/cluster">cluster</a>.
   * @param args 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI cluster(List<String> args) {
    return 
cluster(args, ar -> { });
  }

    
Redis command cluster.

Params:
  • args – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/cluster">cluster</a>.
   * @param args 
   * @return fluent self
   */
  public Single<io.vertx.rxjava.redis.client.Response> rxCluster(List<String> args) { 
    return Single.create(new SingleOnSubscribeAdapter<>(fut -> {
      cluster(args, fut);
    }));
  }

  
Redis command command.

Params:
  • args – 
  • handler – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/command">command</a>.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI command(List<String> args, Handler<AsyncResult<io.vertx.rxjava.redis.client.Response>> handler) { 
    delegate.command(args, new Handler<AsyncResult<io.vertx.redis.client.Response>>() {
      public void handle(AsyncResult<io.vertx.redis.client.Response> ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

  
Redis command command.

Params:
  • args – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/command">command</a>.
   * @param args 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI command(List<String> args) {
    return 
command(args, ar -> { });
  }

    
Redis command command.

Params:
  • args – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/command">command</a>.
   * @param args 
   * @return fluent self
   */
  public Single<io.vertx.rxjava.redis.client.Response> rxCommand(List<String> args) { 
    return Single.create(new SingleOnSubscribeAdapter<>(fut -> {
      command(args, fut);
    }));
  }

  
Redis command config.

Params:
  • args – 
  • handler – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/config">config</a>.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI config(List<String> args, Handler<AsyncResult<io.vertx.rxjava.redis.client.Response>> handler) { 
    delegate.config(args, new Handler<AsyncResult<io.vertx.redis.client.Response>>() {
      public void handle(AsyncResult<io.vertx.redis.client.Response> ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

  
Redis command config.

Params:
  • args – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/config">config</a>.
   * @param args 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI config(List<String> args) {
    return 
config(args, ar -> { });
  }

    
Redis command config.

Params:
  • args – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/config">config</a>.
   * @param args 
   * @return fluent self
   */
  public Single<io.vertx.rxjava.redis.client.Response> rxConfig(List<String> args) { 
    return Single.create(new SingleOnSubscribeAdapter<>(fut -> {
      config(args, fut);
    }));
  }

  
Redis command dbsize.

Params:
  • handler – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/dbsize">dbsize</a>.
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI dbsize(Handler<AsyncResult<io.vertx.rxjava.redis.client.Response>> handler) { 
    delegate.dbsize(new Handler<AsyncResult<io.vertx.redis.client.Response>>() {
      public void handle(AsyncResult<io.vertx.redis.client.Response> ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

  
Redis command dbsize.

Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/dbsize">dbsize</a>.
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI dbsize() {
    return 
dbsize(ar -> { });
  }

    
Redis command dbsize.

Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/dbsize">dbsize</a>.
   * @return fluent self
   */
  public Single<io.vertx.rxjava.redis.client.Response> rxDbsize() { 
    return Single.create(new SingleOnSubscribeAdapter<>(fut -> {
      dbsize(fut);
    }));
  }

  
Redis command debug.

Params:
  • args – 
  • handler – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/debug">debug</a>.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI debug(List<String> args, Handler<AsyncResult<io.vertx.rxjava.redis.client.Response>> handler) { 
    delegate.debug(args, new Handler<AsyncResult<io.vertx.redis.client.Response>>() {
      public void handle(AsyncResult<io.vertx.redis.client.Response> ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

  
Redis command debug.

Params:
  • args – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/debug">debug</a>.
   * @param args 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI debug(List<String> args) {
    return 
debug(args, ar -> { });
  }

    
Redis command debug.

Params:
  • args – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/debug">debug</a>.
   * @param args 
   * @return fluent self
   */
  public Single<io.vertx.rxjava.redis.client.Response> rxDebug(List<String> args) { 
    return Single.create(new SingleOnSubscribeAdapter<>(fut -> {
      debug(args, fut);
    }));
  }

  
Redis command decr.

Params:
  • arg0 – 
  • handler – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/decr">decr</a>.
   * @param arg0 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI decr(String arg0, Handler<AsyncResult<io.vertx.rxjava.redis.client.Response>> handler) { 
    delegate.decr(arg0, new Handler<AsyncResult<io.vertx.redis.client.Response>>() {
      public void handle(AsyncResult<io.vertx.redis.client.Response> ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

  
Redis command decr.

Params:
  • arg0 – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/decr">decr</a>.
   * @param arg0 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI decr(String arg0) {
    return 
decr(arg0, ar -> { });
  }

    
Redis command decr.

Params:
  • arg0 – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/decr">decr</a>.
   * @param arg0 
   * @return fluent self
   */
  public Single<io.vertx.rxjava.redis.client.Response> rxDecr(String arg0) { 
    return Single.create(new SingleOnSubscribeAdapter<>(fut -> {
      decr(arg0, fut);
    }));
  }

  
Redis command decrby.

Params:
  • arg0 – 
  • arg1 – 
  • handler – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/decrby">decrby</a>.
   * @param arg0 
   * @param arg1 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI decrby(String arg0, String arg1, Handler<AsyncResult<io.vertx.rxjava.redis.client.Response>> handler) { 
    delegate.decrby(arg0, arg1, new Handler<AsyncResult<io.vertx.redis.client.Response>>() {
      public void handle(AsyncResult<io.vertx.redis.client.Response> ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

  
Redis command decrby.

Params:
  • arg0 – 
  • arg1 – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/decrby">decrby</a>.
   * @param arg0 
   * @param arg1 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI decrby(String arg0, String arg1) {
    return 
decrby(arg0, arg1, ar -> { });
  }

    
Redis command decrby.

Params:
  • arg0 – 
  • arg1 – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/decrby">decrby</a>.
   * @param arg0 
   * @param arg1 
   * @return fluent self
   */
  public Single<io.vertx.rxjava.redis.client.Response> rxDecrby(String arg0, String arg1) { 
    return Single.create(new SingleOnSubscribeAdapter<>(fut -> {
      decrby(arg0, arg1, fut);
    }));
  }

  
Redis command del.

Params:
  • args – 
  • handler – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/del">del</a>.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI del(List<String> args, Handler<AsyncResult<io.vertx.rxjava.redis.client.Response>> handler) { 
    delegate.del(args, new Handler<AsyncResult<io.vertx.redis.client.Response>>() {
      public void handle(AsyncResult<io.vertx.redis.client.Response> ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

  
Redis command del.

Params:
  • args – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/del">del</a>.
   * @param args 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI del(List<String> args) {
    return 
del(args, ar -> { });
  }

    
Redis command del.

Params:
  • args – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/del">del</a>.
   * @param args 
   * @return fluent self
   */
  public Single<io.vertx.rxjava.redis.client.Response> rxDel(List<String> args) { 
    return Single.create(new SingleOnSubscribeAdapter<>(fut -> {
      del(args, fut);
    }));
  }

  
Redis command discard.

Params:
  • handler – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/discard">discard</a>.
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI discard(Handler<AsyncResult<io.vertx.rxjava.redis.client.Response>> handler) { 
    delegate.discard(new Handler<AsyncResult<io.vertx.redis.client.Response>>() {
      public void handle(AsyncResult<io.vertx.redis.client.Response> ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

  
Redis command discard.

Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/discard">discard</a>.
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI discard() {
    return 
discard(ar -> { });
  }

    
Redis command discard.

Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/discard">discard</a>.
   * @return fluent self
   */
  public Single<io.vertx.rxjava.redis.client.Response> rxDiscard() { 
    return Single.create(new SingleOnSubscribeAdapter<>(fut -> {
      discard(fut);
    }));
  }

  
Redis command dump.

Params:
  • arg0 – 
  • handler – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/dump">dump</a>.
   * @param arg0 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI dump(String arg0, Handler<AsyncResult<io.vertx.rxjava.redis.client.Response>> handler) { 
    delegate.dump(arg0, new Handler<AsyncResult<io.vertx.redis.client.Response>>() {
      public void handle(AsyncResult<io.vertx.redis.client.Response> ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

  
Redis command dump.

Params:
  • arg0 – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/dump">dump</a>.
   * @param arg0 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI dump(String arg0) {
    return 
dump(arg0, ar -> { });
  }

    
Redis command dump.

Params:
  • arg0 – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/dump">dump</a>.
   * @param arg0 
   * @return fluent self
   */
  public Single<io.vertx.rxjava.redis.client.Response> rxDump(String arg0) { 
    return Single.create(new SingleOnSubscribeAdapter<>(fut -> {
      dump(arg0, fut);
    }));
  }

  
Redis command echo.

Params:
  • arg0 – 
  • handler – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/echo">echo</a>.
   * @param arg0 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI echo(String arg0, Handler<AsyncResult<io.vertx.rxjava.redis.client.Response>> handler) { 
    delegate.echo(arg0, new Handler<AsyncResult<io.vertx.redis.client.Response>>() {
      public void handle(AsyncResult<io.vertx.redis.client.Response> ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

  
Redis command echo.

Params:
  • arg0 – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/echo">echo</a>.
   * @param arg0 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI echo(String arg0) {
    return 
echo(arg0, ar -> { });
  }

    
Redis command echo.

Params:
  • arg0 – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/echo">echo</a>.
   * @param arg0 
   * @return fluent self
   */
  public Single<io.vertx.rxjava.redis.client.Response> rxEcho(String arg0) { 
    return Single.create(new SingleOnSubscribeAdapter<>(fut -> {
      echo(arg0, fut);
    }));
  }

  
Redis command eval.

Params:
  • args – 
  • handler – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/eval">eval</a>.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI eval(List<String> args, Handler<AsyncResult<io.vertx.rxjava.redis.client.Response>> handler) { 
    delegate.eval(args, new Handler<AsyncResult<io.vertx.redis.client.Response>>() {
      public void handle(AsyncResult<io.vertx.redis.client.Response> ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

  
Redis command eval.

Params:
  • args – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/eval">eval</a>.
   * @param args 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI eval(List<String> args) {
    return 
eval(args, ar -> { });
  }

    
Redis command eval.

Params:
  • args – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/eval">eval</a>.
   * @param args 
   * @return fluent self
   */
  public Single<io.vertx.rxjava.redis.client.Response> rxEval(List<String> args) { 
    return Single.create(new SingleOnSubscribeAdapter<>(fut -> {
      eval(args, fut);
    }));
  }

  
Redis command evalsha.

Params:
  • args – 
  • handler – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/evalsha">evalsha</a>.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI evalsha(List<String> args, Handler<AsyncResult<io.vertx.rxjava.redis.client.Response>> handler) { 
    delegate.evalsha(args, new Handler<AsyncResult<io.vertx.redis.client.Response>>() {
      public void handle(AsyncResult<io.vertx.redis.client.Response> ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

  
Redis command evalsha.

Params:
  • args – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/evalsha">evalsha</a>.
   * @param args 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI evalsha(List<String> args) {
    return 
evalsha(args, ar -> { });
  }

    
Redis command evalsha.

Params:
  • args – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/evalsha">evalsha</a>.
   * @param args 
   * @return fluent self
   */
  public Single<io.vertx.rxjava.redis.client.Response> rxEvalsha(List<String> args) { 
    return Single.create(new SingleOnSubscribeAdapter<>(fut -> {
      evalsha(args, fut);
    }));
  }

  
Redis command exec.

Params:
  • handler – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/exec">exec</a>.
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI exec(Handler<AsyncResult<io.vertx.rxjava.redis.client.Response>> handler) { 
    delegate.exec(new Handler<AsyncResult<io.vertx.redis.client.Response>>() {
      public void handle(AsyncResult<io.vertx.redis.client.Response> ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

  
Redis command exec.

Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/exec">exec</a>.
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI exec() {
    return 
exec(ar -> { });
  }

    
Redis command exec.

Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/exec">exec</a>.
   * @return fluent self
   */
  public Single<io.vertx.rxjava.redis.client.Response> rxExec() { 
    return Single.create(new SingleOnSubscribeAdapter<>(fut -> {
      exec(fut);
    }));
  }

  
Redis command exists.

Params:
  • args – 
  • handler – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/exists">exists</a>.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI exists(List<String> args, Handler<AsyncResult<io.vertx.rxjava.redis.client.Response>> handler) { 
    delegate.exists(args, new Handler<AsyncResult<io.vertx.redis.client.Response>>() {
      public void handle(AsyncResult<io.vertx.redis.client.Response> ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

  
Redis command exists.

Params:
  • args – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/exists">exists</a>.
   * @param args 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI exists(List<String> args) {
    return 
exists(args, ar -> { });
  }

    
Redis command exists.

Params:
  • args – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/exists">exists</a>.
   * @param args 
   * @return fluent self
   */
  public Single<io.vertx.rxjava.redis.client.Response> rxExists(List<String> args) { 
    return Single.create(new SingleOnSubscribeAdapter<>(fut -> {
      exists(args, fut);
    }));
  }

  
Redis command expire.

Params:
  • arg0 – 
  • arg1 – 
  • handler – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/expire">expire</a>.
   * @param arg0 
   * @param arg1 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI expire(String arg0, String arg1, Handler<AsyncResult<io.vertx.rxjava.redis.client.Response>> handler) { 
    delegate.expire(arg0, arg1, new Handler<AsyncResult<io.vertx.redis.client.Response>>() {
      public void handle(AsyncResult<io.vertx.redis.client.Response> ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

  
Redis command expire.

Params:
  • arg0 – 
  • arg1 – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/expire">expire</a>.
   * @param arg0 
   * @param arg1 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI expire(String arg0, String arg1) {
    return 
expire(arg0, arg1, ar -> { });
  }

    
Redis command expire.

Params:
  • arg0 – 
  • arg1 – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/expire">expire</a>.
   * @param arg0 
   * @param arg1 
   * @return fluent self
   */
  public Single<io.vertx.rxjava.redis.client.Response> rxExpire(String arg0, String arg1) { 
    return Single.create(new SingleOnSubscribeAdapter<>(fut -> {
      expire(arg0, arg1, fut);
    }));
  }

  
Redis command expireat.

Params:
  • arg0 – 
  • arg1 – 
  • handler – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/expireat">expireat</a>.
   * @param arg0 
   * @param arg1 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI expireat(String arg0, String arg1, Handler<AsyncResult<io.vertx.rxjava.redis.client.Response>> handler) { 
    delegate.expireat(arg0, arg1, new Handler<AsyncResult<io.vertx.redis.client.Response>>() {
      public void handle(AsyncResult<io.vertx.redis.client.Response> ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

  
Redis command expireat.

Params:
  • arg0 – 
  • arg1 – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/expireat">expireat</a>.
   * @param arg0 
   * @param arg1 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI expireat(String arg0, String arg1) {
    return 
expireat(arg0, arg1, ar -> { });
  }

    
Redis command expireat.

Params:
  • arg0 – 
  • arg1 – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/expireat">expireat</a>.
   * @param arg0 
   * @param arg1 
   * @return fluent self
   */
  public Single<io.vertx.rxjava.redis.client.Response> rxExpireat(String arg0, String arg1) { 
    return Single.create(new SingleOnSubscribeAdapter<>(fut -> {
      expireat(arg0, arg1, fut);
    }));
  }

  
Redis command flushall.

Params:
  • args – 
  • handler – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/flushall">flushall</a>.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI flushall(List<String> args, Handler<AsyncResult<io.vertx.rxjava.redis.client.Response>> handler) { 
    delegate.flushall(args, new Handler<AsyncResult<io.vertx.redis.client.Response>>() {
      public void handle(AsyncResult<io.vertx.redis.client.Response> ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

  
Redis command flushall.

Params:
  • args – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/flushall">flushall</a>.
   * @param args 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI flushall(List<String> args) {
    return 
flushall(args, ar -> { });
  }

    
Redis command flushall.

Params:
  • args – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/flushall">flushall</a>.
   * @param args 
   * @return fluent self
   */
  public Single<io.vertx.rxjava.redis.client.Response> rxFlushall(List<String> args) { 
    return Single.create(new SingleOnSubscribeAdapter<>(fut -> {
      flushall(args, fut);
    }));
  }

  
Redis command flushdb.

Params:
  • args – 
  • handler – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/flushdb">flushdb</a>.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI flushdb(List<String> args, Handler<AsyncResult<io.vertx.rxjava.redis.client.Response>> handler) { 
    delegate.flushdb(args, new Handler<AsyncResult<io.vertx.redis.client.Response>>() {
      public void handle(AsyncResult<io.vertx.redis.client.Response> ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

  
Redis command flushdb.

Params:
  • args – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/flushdb">flushdb</a>.
   * @param args 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI flushdb(List<String> args) {
    return 
flushdb(args, ar -> { });
  }

    
Redis command flushdb.

Params:
  • args – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/flushdb">flushdb</a>.
   * @param args 
   * @return fluent self
   */
  public Single<io.vertx.rxjava.redis.client.Response> rxFlushdb(List<String> args) { 
    return Single.create(new SingleOnSubscribeAdapter<>(fut -> {
      flushdb(args, fut);
    }));
  }

  
Redis command geoadd.

Params:
  • args – 
  • handler – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/geoadd">geoadd</a>.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI geoadd(List<String> args, Handler<AsyncResult<io.vertx.rxjava.redis.client.Response>> handler) { 
    delegate.geoadd(args, new Handler<AsyncResult<io.vertx.redis.client.Response>>() {
      public void handle(AsyncResult<io.vertx.redis.client.Response> ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

  
Redis command geoadd.

Params:
  • args – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/geoadd">geoadd</a>.
   * @param args 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI geoadd(List<String> args) {
    return 
geoadd(args, ar -> { });
  }

    
Redis command geoadd.

Params:
  • args – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/geoadd">geoadd</a>.
   * @param args 
   * @return fluent self
   */
  public Single<io.vertx.rxjava.redis.client.Response> rxGeoadd(List<String> args) { 
    return Single.create(new SingleOnSubscribeAdapter<>(fut -> {
      geoadd(args, fut);
    }));
  }

  
Redis command geodist.

Params:
  • args – 
  • handler – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/geodist">geodist</a>.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI geodist(List<String> args, Handler<AsyncResult<io.vertx.rxjava.redis.client.Response>> handler) { 
    delegate.geodist(args, new Handler<AsyncResult<io.vertx.redis.client.Response>>() {
      public void handle(AsyncResult<io.vertx.redis.client.Response> ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

  
Redis command geodist.

Params:
  • args – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/geodist">geodist</a>.
   * @param args 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI geodist(List<String> args) {
    return 
geodist(args, ar -> { });
  }

    
Redis command geodist.

Params:
  • args – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/geodist">geodist</a>.
   * @param args 
   * @return fluent self
   */
  public Single<io.vertx.rxjava.redis.client.Response> rxGeodist(List<String> args) { 
    return Single.create(new SingleOnSubscribeAdapter<>(fut -> {
      geodist(args, fut);
    }));
  }

  
Redis command geohash.

Params:
  • args – 
  • handler – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/geohash">geohash</a>.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI geohash(List<String> args, Handler<AsyncResult<io.vertx.rxjava.redis.client.Response>> handler) { 
    delegate.geohash(args, new Handler<AsyncResult<io.vertx.redis.client.Response>>() {
      public void handle(AsyncResult<io.vertx.redis.client.Response> ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

  
Redis command geohash.

Params:
  • args – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/geohash">geohash</a>.
   * @param args 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI geohash(List<String> args) {
    return 
geohash(args, ar -> { });
  }

    
Redis command geohash.

Params:
  • args – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/geohash">geohash</a>.
   * @param args 
   * @return fluent self
   */
  public Single<io.vertx.rxjava.redis.client.Response> rxGeohash(List<String> args) { 
    return Single.create(new SingleOnSubscribeAdapter<>(fut -> {
      geohash(args, fut);
    }));
  }

  
Redis command geopos.

Params:
  • args – 
  • handler – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/geopos">geopos</a>.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI geopos(List<String> args, Handler<AsyncResult<io.vertx.rxjava.redis.client.Response>> handler) { 
    delegate.geopos(args, new Handler<AsyncResult<io.vertx.redis.client.Response>>() {
      public void handle(AsyncResult<io.vertx.redis.client.Response> ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

  
Redis command geopos.

Params:
  • args – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/geopos">geopos</a>.
   * @param args 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI geopos(List<String> args) {
    return 
geopos(args, ar -> { });
  }

    
Redis command geopos.

Params:
  • args – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/geopos">geopos</a>.
   * @param args 
   * @return fluent self
   */
  public Single<io.vertx.rxjava.redis.client.Response> rxGeopos(List<String> args) { 
    return Single.create(new SingleOnSubscribeAdapter<>(fut -> {
      geopos(args, fut);
    }));
  }

  
Redis command georadius.

Params:
  • args – 
  • handler – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/georadius">georadius</a>.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI georadius(List<String> args, Handler<AsyncResult<io.vertx.rxjava.redis.client.Response>> handler) { 
    delegate.georadius(args, new Handler<AsyncResult<io.vertx.redis.client.Response>>() {
      public void handle(AsyncResult<io.vertx.redis.client.Response> ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

  
Redis command georadius.

Params:
  • args – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/georadius">georadius</a>.
   * @param args 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI georadius(List<String> args) {
    return 
georadius(args, ar -> { });
  }

    
Redis command georadius.

Params:
  • args – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/georadius">georadius</a>.
   * @param args 
   * @return fluent self
   */
  public Single<io.vertx.rxjava.redis.client.Response> rxGeoradius(List<String> args) { 
    return Single.create(new SingleOnSubscribeAdapter<>(fut -> {
      georadius(args, fut);
    }));
  }

  
Redis command georadiusRo.

Params:
  • args – 
  • handler – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/georadius_ro">georadiusRo</a>.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI georadiusRo(List<String> args, Handler<AsyncResult<io.vertx.rxjava.redis.client.Response>> handler) { 
    delegate.georadiusRo(args, new Handler<AsyncResult<io.vertx.redis.client.Response>>() {
      public void handle(AsyncResult<io.vertx.redis.client.Response> ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

  
Redis command georadiusRo.

Params:
  • args – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/georadius_ro">georadiusRo</a>.
   * @param args 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI georadiusRo(List<String> args) {
    return 
georadiusRo(args, ar -> { });
  }

    
Redis command georadiusRo.

Params:
  • args – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/georadius_ro">georadiusRo</a>.
   * @param args 
   * @return fluent self
   */
  public Single<io.vertx.rxjava.redis.client.Response> rxGeoradiusRo(List<String> args) { 
    return Single.create(new SingleOnSubscribeAdapter<>(fut -> {
      georadiusRo(args, fut);
    }));
  }

  
Redis command georadiusbymember.

Params:
  • args – 
  • handler – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/georadiusbymember">georadiusbymember</a>.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI georadiusbymember(List<String> args, Handler<AsyncResult<io.vertx.rxjava.redis.client.Response>> handler) { 
    delegate.georadiusbymember(args, new Handler<AsyncResult<io.vertx.redis.client.Response>>() {
      public void handle(AsyncResult<io.vertx.redis.client.Response> ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

  
Redis command georadiusbymember.

Params:
  • args – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/georadiusbymember">georadiusbymember</a>.
   * @param args 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI georadiusbymember(List<String> args) {
    return 
georadiusbymember(args, ar -> { });
  }

    
Redis command georadiusbymember.

Params:
  • args – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/georadiusbymember">georadiusbymember</a>.
   * @param args 
   * @return fluent self
   */
  public Single<io.vertx.rxjava.redis.client.Response> rxGeoradiusbymember(List<String> args) { 
    return Single.create(new SingleOnSubscribeAdapter<>(fut -> {
      georadiusbymember(args, fut);
    }));
  }

  
Redis command georadiusbymemberRo.

Params:
  • args – 
  • handler – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/georadiusbymember_ro">georadiusbymemberRo</a>.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI georadiusbymemberRo(List<String> args, Handler<AsyncResult<io.vertx.rxjava.redis.client.Response>> handler) { 
    delegate.georadiusbymemberRo(args, new Handler<AsyncResult<io.vertx.redis.client.Response>>() {
      public void handle(AsyncResult<io.vertx.redis.client.Response> ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

  
Redis command georadiusbymemberRo.

Params:
  • args – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/georadiusbymember_ro">georadiusbymemberRo</a>.
   * @param args 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI georadiusbymemberRo(List<String> args) {
    return 
georadiusbymemberRo(args, ar -> { });
  }

    
Redis command georadiusbymemberRo.

Params:
  • args – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/georadiusbymember_ro">georadiusbymemberRo</a>.
   * @param args 
   * @return fluent self
   */
  public Single<io.vertx.rxjava.redis.client.Response> rxGeoradiusbymemberRo(List<String> args) { 
    return Single.create(new SingleOnSubscribeAdapter<>(fut -> {
      georadiusbymemberRo(args, fut);
    }));
  }

  
Redis command get.

Params:
  • arg0 – 
  • handler – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/get">get</a>.
   * @param arg0 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI get(String arg0, Handler<AsyncResult<io.vertx.rxjava.redis.client.Response>> handler) { 
    delegate.get(arg0, new Handler<AsyncResult<io.vertx.redis.client.Response>>() {
      public void handle(AsyncResult<io.vertx.redis.client.Response> ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

  
Redis command get.

Params:
  • arg0 – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/get">get</a>.
   * @param arg0 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI get(String arg0) {
    return 
get(arg0, ar -> { });
  }

    
Redis command get.

Params:
  • arg0 – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/get">get</a>.
   * @param arg0 
   * @return fluent self
   */
  public Single<io.vertx.rxjava.redis.client.Response> rxGet(String arg0) { 
    return Single.create(new SingleOnSubscribeAdapter<>(fut -> {
      get(arg0, fut);
    }));
  }

  
Redis command getbit.

Params:
  • arg0 – 
  • arg1 – 
  • handler – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/getbit">getbit</a>.
   * @param arg0 
   * @param arg1 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI getbit(String arg0, String arg1, Handler<AsyncResult<io.vertx.rxjava.redis.client.Response>> handler) { 
    delegate.getbit(arg0, arg1, new Handler<AsyncResult<io.vertx.redis.client.Response>>() {
      public void handle(AsyncResult<io.vertx.redis.client.Response> ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

  
Redis command getbit.

Params:
  • arg0 – 
  • arg1 – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/getbit">getbit</a>.
   * @param arg0 
   * @param arg1 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI getbit(String arg0, String arg1) {
    return 
getbit(arg0, arg1, ar -> { });
  }

    
Redis command getbit.

Params:
  • arg0 – 
  • arg1 – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/getbit">getbit</a>.
   * @param arg0 
   * @param arg1 
   * @return fluent self
   */
  public Single<io.vertx.rxjava.redis.client.Response> rxGetbit(String arg0, String arg1) { 
    return Single.create(new SingleOnSubscribeAdapter<>(fut -> {
      getbit(arg0, arg1, fut);
    }));
  }

  
Redis command getrange.

Params:
  • arg0 – 
  • arg1 – 
  • arg2 – 
  • handler – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/getrange">getrange</a>.
   * @param arg0 
   * @param arg1 
   * @param arg2 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI getrange(String arg0, String arg1, String arg2, Handler<AsyncResult<io.vertx.rxjava.redis.client.Response>> handler) { 
    delegate.getrange(arg0, arg1, arg2, new Handler<AsyncResult<io.vertx.redis.client.Response>>() {
      public void handle(AsyncResult<io.vertx.redis.client.Response> ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

  
Redis command getrange.

Params:
  • arg0 – 
  • arg1 – 
  • arg2 – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/getrange">getrange</a>.
   * @param arg0 
   * @param arg1 
   * @param arg2 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI getrange(String arg0, String arg1, String arg2) {
    return 
getrange(arg0, arg1, arg2, ar -> { });
  }

    
Redis command getrange.

Params:
  • arg0 – 
  • arg1 – 
  • arg2 – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/getrange">getrange</a>.
   * @param arg0 
   * @param arg1 
   * @param arg2 
   * @return fluent self
   */
  public Single<io.vertx.rxjava.redis.client.Response> rxGetrange(String arg0, String arg1, String arg2) { 
    return Single.create(new SingleOnSubscribeAdapter<>(fut -> {
      getrange(arg0, arg1, arg2, fut);
    }));
  }

  
Redis command getset.

Params:
  • arg0 – 
  • arg1 – 
  • handler – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/getset">getset</a>.
   * @param arg0 
   * @param arg1 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI getset(String arg0, String arg1, Handler<AsyncResult<io.vertx.rxjava.redis.client.Response>> handler) { 
    delegate.getset(arg0, arg1, new Handler<AsyncResult<io.vertx.redis.client.Response>>() {
      public void handle(AsyncResult<io.vertx.redis.client.Response> ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

  
Redis command getset.

Params:
  • arg0 – 
  • arg1 – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/getset">getset</a>.
   * @param arg0 
   * @param arg1 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI getset(String arg0, String arg1) {
    return 
getset(arg0, arg1, ar -> { });
  }

    
Redis command getset.

Params:
  • arg0 – 
  • arg1 – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/getset">getset</a>.
   * @param arg0 
   * @param arg1 
   * @return fluent self
   */
  public Single<io.vertx.rxjava.redis.client.Response> rxGetset(String arg0, String arg1) { 
    return Single.create(new SingleOnSubscribeAdapter<>(fut -> {
      getset(arg0, arg1, fut);
    }));
  }

  
Redis command hdel.

Params:
  • args – 
  • handler – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/hdel">hdel</a>.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI hdel(List<String> args, Handler<AsyncResult<io.vertx.rxjava.redis.client.Response>> handler) { 
    delegate.hdel(args, new Handler<AsyncResult<io.vertx.redis.client.Response>>() {
      public void handle(AsyncResult<io.vertx.redis.client.Response> ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

  
Redis command hdel.

Params:
  • args – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/hdel">hdel</a>.
   * @param args 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI hdel(List<String> args) {
    return 
hdel(args, ar -> { });
  }

    
Redis command hdel.

Params:
  • args – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/hdel">hdel</a>.
   * @param args 
   * @return fluent self
   */
  public Single<io.vertx.rxjava.redis.client.Response> rxHdel(List<String> args) { 
    return Single.create(new SingleOnSubscribeAdapter<>(fut -> {
      hdel(args, fut);
    }));
  }

  
Redis command hello.

Params:
  • args – 
  • handler – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/hello">hello</a>.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI hello(List<String> args, Handler<AsyncResult<io.vertx.rxjava.redis.client.Response>> handler) { 
    delegate.hello(args, new Handler<AsyncResult<io.vertx.redis.client.Response>>() {
      public void handle(AsyncResult<io.vertx.redis.client.Response> ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

  
Redis command hello.

Params:
  • args – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/hello">hello</a>.
   * @param args 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI hello(List<String> args) {
    return 
hello(args, ar -> { });
  }

    
Redis command hello.

Params:
  • args – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/hello">hello</a>.
   * @param args 
   * @return fluent self
   */
  public Single<io.vertx.rxjava.redis.client.Response> rxHello(List<String> args) { 
    return Single.create(new SingleOnSubscribeAdapter<>(fut -> {
      hello(args, fut);
    }));
  }

  
Redis command hexists.

Params:
  • arg0 – 
  • arg1 – 
  • handler – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/hexists">hexists</a>.
   * @param arg0 
   * @param arg1 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI hexists(String arg0, String arg1, Handler<AsyncResult<io.vertx.rxjava.redis.client.Response>> handler) { 
    delegate.hexists(arg0, arg1, new Handler<AsyncResult<io.vertx.redis.client.Response>>() {
      public void handle(AsyncResult<io.vertx.redis.client.Response> ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

  
Redis command hexists.

Params:
  • arg0 – 
  • arg1 – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/hexists">hexists</a>.
   * @param arg0 
   * @param arg1 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI hexists(String arg0, String arg1) {
    return 
hexists(arg0, arg1, ar -> { });
  }

    
Redis command hexists.

Params:
  • arg0 – 
  • arg1 – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/hexists">hexists</a>.
   * @param arg0 
   * @param arg1 
   * @return fluent self
   */
  public Single<io.vertx.rxjava.redis.client.Response> rxHexists(String arg0, String arg1) { 
    return Single.create(new SingleOnSubscribeAdapter<>(fut -> {
      hexists(arg0, arg1, fut);
    }));
  }

  
Redis command hget.

Params:
  • arg0 – 
  • arg1 – 
  • handler – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/hget">hget</a>.
   * @param arg0 
   * @param arg1 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI hget(String arg0, String arg1, Handler<AsyncResult<io.vertx.rxjava.redis.client.Response>> handler) { 
    delegate.hget(arg0, arg1, new Handler<AsyncResult<io.vertx.redis.client.Response>>() {
      public void handle(AsyncResult<io.vertx.redis.client.Response> ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

  
Redis command hget.

Params:
  • arg0 – 
  • arg1 – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/hget">hget</a>.
   * @param arg0 
   * @param arg1 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI hget(String arg0, String arg1) {
    return 
hget(arg0, arg1, ar -> { });
  }

    
Redis command hget.

Params:
  • arg0 – 
  • arg1 – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/hget">hget</a>.
   * @param arg0 
   * @param arg1 
   * @return fluent self
   */
  public Single<io.vertx.rxjava.redis.client.Response> rxHget(String arg0, String arg1) { 
    return Single.create(new SingleOnSubscribeAdapter<>(fut -> {
      hget(arg0, arg1, fut);
    }));
  }

  
Redis command hgetall.

Params:
  • arg0 – 
  • handler – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/hgetall">hgetall</a>.
   * @param arg0 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI hgetall(String arg0, Handler<AsyncResult<io.vertx.rxjava.redis.client.Response>> handler) { 
    delegate.hgetall(arg0, new Handler<AsyncResult<io.vertx.redis.client.Response>>() {
      public void handle(AsyncResult<io.vertx.redis.client.Response> ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

  
Redis command hgetall.

Params:
  • arg0 – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/hgetall">hgetall</a>.
   * @param arg0 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI hgetall(String arg0) {
    return 
hgetall(arg0, ar -> { });
  }

    
Redis command hgetall.

Params:
  • arg0 – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/hgetall">hgetall</a>.
   * @param arg0 
   * @return fluent self
   */
  public Single<io.vertx.rxjava.redis.client.Response> rxHgetall(String arg0) { 
    return Single.create(new SingleOnSubscribeAdapter<>(fut -> {
      hgetall(arg0, fut);
    }));
  }

  
Redis command hincrby.

Params:
  • arg0 – 
  • arg1 – 
  • arg2 – 
  • handler – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/hincrby">hincrby</a>.
   * @param arg0 
   * @param arg1 
   * @param arg2 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI hincrby(String arg0, String arg1, String arg2, Handler<AsyncResult<io.vertx.rxjava.redis.client.Response>> handler) { 
    delegate.hincrby(arg0, arg1, arg2, new Handler<AsyncResult<io.vertx.redis.client.Response>>() {
      public void handle(AsyncResult<io.vertx.redis.client.Response> ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

  
Redis command hincrby.

Params:
  • arg0 – 
  • arg1 – 
  • arg2 – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/hincrby">hincrby</a>.
   * @param arg0 
   * @param arg1 
   * @param arg2 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI hincrby(String arg0, String arg1, String arg2) {
    return 
hincrby(arg0, arg1, arg2, ar -> { });
  }

    
Redis command hincrby.

Params:
  • arg0 – 
  • arg1 – 
  • arg2 – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/hincrby">hincrby</a>.
   * @param arg0 
   * @param arg1 
   * @param arg2 
   * @return fluent self
   */
  public Single<io.vertx.rxjava.redis.client.Response> rxHincrby(String arg0, String arg1, String arg2) { 
    return Single.create(new SingleOnSubscribeAdapter<>(fut -> {
      hincrby(arg0, arg1, arg2, fut);
    }));
  }

  
Redis command hincrbyfloat.

Params:
  • arg0 – 
  • arg1 – 
  • arg2 – 
  • handler – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/hincrbyfloat">hincrbyfloat</a>.
   * @param arg0 
   * @param arg1 
   * @param arg2 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI hincrbyfloat(String arg0, String arg1, String arg2, Handler<AsyncResult<io.vertx.rxjava.redis.client.Response>> handler) { 
    delegate.hincrbyfloat(arg0, arg1, arg2, new Handler<AsyncResult<io.vertx.redis.client.Response>>() {
      public void handle(AsyncResult<io.vertx.redis.client.Response> ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

  
Redis command hincrbyfloat.

Params:
  • arg0 – 
  • arg1 – 
  • arg2 – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/hincrbyfloat">hincrbyfloat</a>.
   * @param arg0 
   * @param arg1 
   * @param arg2 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI hincrbyfloat(String arg0, String arg1, String arg2) {
    return 
hincrbyfloat(arg0, arg1, arg2, ar -> { });
  }

    
Redis command hincrbyfloat.

Params:
  • arg0 – 
  • arg1 – 
  • arg2 – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/hincrbyfloat">hincrbyfloat</a>.
   * @param arg0 
   * @param arg1 
   * @param arg2 
   * @return fluent self
   */
  public Single<io.vertx.rxjava.redis.client.Response> rxHincrbyfloat(String arg0, String arg1, String arg2) { 
    return Single.create(new SingleOnSubscribeAdapter<>(fut -> {
      hincrbyfloat(arg0, arg1, arg2, fut);
    }));
  }

  
Redis command hkeys.

Params:
  • arg0 – 
  • handler – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/hkeys">hkeys</a>.
   * @param arg0 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI hkeys(String arg0, Handler<AsyncResult<io.vertx.rxjava.redis.client.Response>> handler) { 
    delegate.hkeys(arg0, new Handler<AsyncResult<io.vertx.redis.client.Response>>() {
      public void handle(AsyncResult<io.vertx.redis.client.Response> ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

  
Redis command hkeys.

Params:
  • arg0 – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/hkeys">hkeys</a>.
   * @param arg0 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI hkeys(String arg0) {
    return 
hkeys(arg0, ar -> { });
  }

    
Redis command hkeys.

Params:
  • arg0 – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/hkeys">hkeys</a>.
   * @param arg0 
   * @return fluent self
   */
  public Single<io.vertx.rxjava.redis.client.Response> rxHkeys(String arg0) { 
    return Single.create(new SingleOnSubscribeAdapter<>(fut -> {
      hkeys(arg0, fut);
    }));
  }

  
Redis command hlen.

Params:
  • arg0 – 
  • handler – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/hlen">hlen</a>.
   * @param arg0 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI hlen(String arg0, Handler<AsyncResult<io.vertx.rxjava.redis.client.Response>> handler) { 
    delegate.hlen(arg0, new Handler<AsyncResult<io.vertx.redis.client.Response>>() {
      public void handle(AsyncResult<io.vertx.redis.client.Response> ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

  
Redis command hlen.

Params:
  • arg0 – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/hlen">hlen</a>.
   * @param arg0 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI hlen(String arg0) {
    return 
hlen(arg0, ar -> { });
  }

    
Redis command hlen.

Params:
  • arg0 – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/hlen">hlen</a>.
   * @param arg0 
   * @return fluent self
   */
  public Single<io.vertx.rxjava.redis.client.Response> rxHlen(String arg0) { 
    return Single.create(new SingleOnSubscribeAdapter<>(fut -> {
      hlen(arg0, fut);
    }));
  }

  
Redis command hmget.

Params:
  • args – 
  • handler – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/hmget">hmget</a>.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI hmget(List<String> args, Handler<AsyncResult<io.vertx.rxjava.redis.client.Response>> handler) { 
    delegate.hmget(args, new Handler<AsyncResult<io.vertx.redis.client.Response>>() {
      public void handle(AsyncResult<io.vertx.redis.client.Response> ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

  
Redis command hmget.

Params:
  • args – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/hmget">hmget</a>.
   * @param args 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI hmget(List<String> args) {
    return 
hmget(args, ar -> { });
  }

    
Redis command hmget.

Params:
  • args – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/hmget">hmget</a>.
   * @param args 
   * @return fluent self
   */
  public Single<io.vertx.rxjava.redis.client.Response> rxHmget(List<String> args) { 
    return Single.create(new SingleOnSubscribeAdapter<>(fut -> {
      hmget(args, fut);
    }));
  }

  
Redis command hmset.

Params:
  • args – 
  • handler – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/hmset">hmset</a>.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI hmset(List<String> args, Handler<AsyncResult<io.vertx.rxjava.redis.client.Response>> handler) { 
    delegate.hmset(args, new Handler<AsyncResult<io.vertx.redis.client.Response>>() {
      public void handle(AsyncResult<io.vertx.redis.client.Response> ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

  
Redis command hmset.

Params:
  • args – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/hmset">hmset</a>.
   * @param args 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI hmset(List<String> args) {
    return 
hmset(args, ar -> { });
  }

    
Redis command hmset.

Params:
  • args – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/hmset">hmset</a>.
   * @param args 
   * @return fluent self
   */
  public Single<io.vertx.rxjava.redis.client.Response> rxHmset(List<String> args) { 
    return Single.create(new SingleOnSubscribeAdapter<>(fut -> {
      hmset(args, fut);
    }));
  }

  
Redis command host.

Params:
  • args – 
  • handler – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/host:">host</a>.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI host(List<String> args, Handler<AsyncResult<io.vertx.rxjava.redis.client.Response>> handler) { 
    delegate.host(args, new Handler<AsyncResult<io.vertx.redis.client.Response>>() {
      public void handle(AsyncResult<io.vertx.redis.client.Response> ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

  
Redis command host.

Params:
  • args – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/host:">host</a>.
   * @param args 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI host(List<String> args) {
    return 
host(args, ar -> { });
  }

    
Redis command host.

Params:
  • args – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/host:">host</a>.
   * @param args 
   * @return fluent self
   */
  public Single<io.vertx.rxjava.redis.client.Response> rxHost(List<String> args) { 
    return Single.create(new SingleOnSubscribeAdapter<>(fut -> {
      host(args, fut);
    }));
  }

  
Redis command hscan.

Params:
  • args – 
  • handler – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/hscan">hscan</a>.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI hscan(List<String> args, Handler<AsyncResult<io.vertx.rxjava.redis.client.Response>> handler) { 
    delegate.hscan(args, new Handler<AsyncResult<io.vertx.redis.client.Response>>() {
      public void handle(AsyncResult<io.vertx.redis.client.Response> ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

  
Redis command hscan.

Params:
  • args – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/hscan">hscan</a>.
   * @param args 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI hscan(List<String> args) {
    return 
hscan(args, ar -> { });
  }

    
Redis command hscan.

Params:
  • args – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/hscan">hscan</a>.
   * @param args 
   * @return fluent self
   */
  public Single<io.vertx.rxjava.redis.client.Response> rxHscan(List<String> args) { 
    return Single.create(new SingleOnSubscribeAdapter<>(fut -> {
      hscan(args, fut);
    }));
  }

  
Redis command hset.

Params:
  • args – 
  • handler – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/hset">hset</a>.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI hset(List<String> args, Handler<AsyncResult<io.vertx.rxjava.redis.client.Response>> handler) { 
    delegate.hset(args, new Handler<AsyncResult<io.vertx.redis.client.Response>>() {
      public void handle(AsyncResult<io.vertx.redis.client.Response> ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

  
Redis command hset.

Params:
  • args – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/hset">hset</a>.
   * @param args 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI hset(List<String> args) {
    return 
hset(args, ar -> { });
  }

    
Redis command hset.

Params:
  • args – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/hset">hset</a>.
   * @param args 
   * @return fluent self
   */
  public Single<io.vertx.rxjava.redis.client.Response> rxHset(List<String> args) { 
    return Single.create(new SingleOnSubscribeAdapter<>(fut -> {
      hset(args, fut);
    }));
  }

  
Redis command hsetnx.

Params:
  • arg0 – 
  • arg1 – 
  • arg2 – 
  • handler – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/hsetnx">hsetnx</a>.
   * @param arg0 
   * @param arg1 
   * @param arg2 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI hsetnx(String arg0, String arg1, String arg2, Handler<AsyncResult<io.vertx.rxjava.redis.client.Response>> handler) { 
    delegate.hsetnx(arg0, arg1, arg2, new Handler<AsyncResult<io.vertx.redis.client.Response>>() {
      public void handle(AsyncResult<io.vertx.redis.client.Response> ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

  
Redis command hsetnx.

Params:
  • arg0 – 
  • arg1 – 
  • arg2 – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/hsetnx">hsetnx</a>.
   * @param arg0 
   * @param arg1 
   * @param arg2 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI hsetnx(String arg0, String arg1, String arg2) {
    return 
hsetnx(arg0, arg1, arg2, ar -> { });
  }

    
Redis command hsetnx.

Params:
  • arg0 – 
  • arg1 – 
  • arg2 – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/hsetnx">hsetnx</a>.
   * @param arg0 
   * @param arg1 
   * @param arg2 
   * @return fluent self
   */
  public Single<io.vertx.rxjava.redis.client.Response> rxHsetnx(String arg0, String arg1, String arg2) { 
    return Single.create(new SingleOnSubscribeAdapter<>(fut -> {
      hsetnx(arg0, arg1, arg2, fut);
    }));
  }

  
Redis command hstrlen.

Params:
  • arg0 – 
  • arg1 – 
  • handler – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/hstrlen">hstrlen</a>.
   * @param arg0 
   * @param arg1 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI hstrlen(String arg0, String arg1, Handler<AsyncResult<io.vertx.rxjava.redis.client.Response>> handler) { 
    delegate.hstrlen(arg0, arg1, new Handler<AsyncResult<io.vertx.redis.client.Response>>() {
      public void handle(AsyncResult<io.vertx.redis.client.Response> ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

  
Redis command hstrlen.

Params:
  • arg0 – 
  • arg1 – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/hstrlen">hstrlen</a>.
   * @param arg0 
   * @param arg1 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI hstrlen(String arg0, String arg1) {
    return 
hstrlen(arg0, arg1, ar -> { });
  }

    
Redis command hstrlen.

Params:
  • arg0 – 
  • arg1 – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/hstrlen">hstrlen</a>.
   * @param arg0 
   * @param arg1 
   * @return fluent self
   */
  public Single<io.vertx.rxjava.redis.client.Response> rxHstrlen(String arg0, String arg1) { 
    return Single.create(new SingleOnSubscribeAdapter<>(fut -> {
      hstrlen(arg0, arg1, fut);
    }));
  }

  
Redis command hvals.

Params:
  • arg0 – 
  • handler – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/hvals">hvals</a>.
   * @param arg0 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI hvals(String arg0, Handler<AsyncResult<io.vertx.rxjava.redis.client.Response>> handler) { 
    delegate.hvals(arg0, new Handler<AsyncResult<io.vertx.redis.client.Response>>() {
      public void handle(AsyncResult<io.vertx.redis.client.Response> ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

  
Redis command hvals.

Params:
  • arg0 – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/hvals">hvals</a>.
   * @param arg0 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI hvals(String arg0) {
    return 
hvals(arg0, ar -> { });
  }

    
Redis command hvals.

Params:
  • arg0 – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/hvals">hvals</a>.
   * @param arg0 
   * @return fluent self
   */
  public Single<io.vertx.rxjava.redis.client.Response> rxHvals(String arg0) { 
    return Single.create(new SingleOnSubscribeAdapter<>(fut -> {
      hvals(arg0, fut);
    }));
  }

  
Redis command incr.

Params:
  • arg0 – 
  • handler – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/incr">incr</a>.
   * @param arg0 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI incr(String arg0, Handler<AsyncResult<io.vertx.rxjava.redis.client.Response>> handler) { 
    delegate.incr(arg0, new Handler<AsyncResult<io.vertx.redis.client.Response>>() {
      public void handle(AsyncResult<io.vertx.redis.client.Response> ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

  
Redis command incr.

Params:
  • arg0 – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/incr">incr</a>.
   * @param arg0 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI incr(String arg0) {
    return 
incr(arg0, ar -> { });
  }

    
Redis command incr.

Params:
  • arg0 – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/incr">incr</a>.
   * @param arg0 
   * @return fluent self
   */
  public Single<io.vertx.rxjava.redis.client.Response> rxIncr(String arg0) { 
    return Single.create(new SingleOnSubscribeAdapter<>(fut -> {
      incr(arg0, fut);
    }));
  }

  
Redis command incrby.

Params:
  • arg0 – 
  • arg1 – 
  • handler – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/incrby">incrby</a>.
   * @param arg0 
   * @param arg1 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI incrby(String arg0, String arg1, Handler<AsyncResult<io.vertx.rxjava.redis.client.Response>> handler) { 
    delegate.incrby(arg0, arg1, new Handler<AsyncResult<io.vertx.redis.client.Response>>() {
      public void handle(AsyncResult<io.vertx.redis.client.Response> ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

  
Redis command incrby.

Params:
  • arg0 – 
  • arg1 – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/incrby">incrby</a>.
   * @param arg0 
   * @param arg1 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI incrby(String arg0, String arg1) {
    return 
incrby(arg0, arg1, ar -> { });
  }

    
Redis command incrby.

Params:
  • arg0 – 
  • arg1 – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/incrby">incrby</a>.
   * @param arg0 
   * @param arg1 
   * @return fluent self
   */
  public Single<io.vertx.rxjava.redis.client.Response> rxIncrby(String arg0, String arg1) { 
    return Single.create(new SingleOnSubscribeAdapter<>(fut -> {
      incrby(arg0, arg1, fut);
    }));
  }

  
Redis command incrbyfloat.

Params:
  • arg0 – 
  • arg1 – 
  • handler – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/incrbyfloat">incrbyfloat</a>.
   * @param arg0 
   * @param arg1 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI incrbyfloat(String arg0, String arg1, Handler<AsyncResult<io.vertx.rxjava.redis.client.Response>> handler) { 
    delegate.incrbyfloat(arg0, arg1, new Handler<AsyncResult<io.vertx.redis.client.Response>>() {
      public void handle(AsyncResult<io.vertx.redis.client.Response> ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

  
Redis command incrbyfloat.

Params:
  • arg0 – 
  • arg1 – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/incrbyfloat">incrbyfloat</a>.
   * @param arg0 
   * @param arg1 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI incrbyfloat(String arg0, String arg1) {
    return 
incrbyfloat(arg0, arg1, ar -> { });
  }

    
Redis command incrbyfloat.

Params:
  • arg0 – 
  • arg1 – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/incrbyfloat">incrbyfloat</a>.
   * @param arg0 
   * @param arg1 
   * @return fluent self
   */
  public Single<io.vertx.rxjava.redis.client.Response> rxIncrbyfloat(String arg0, String arg1) { 
    return Single.create(new SingleOnSubscribeAdapter<>(fut -> {
      incrbyfloat(arg0, arg1, fut);
    }));
  }

  
Redis command info.

Params:
  • args – 
  • handler – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/info">info</a>.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI info(List<String> args, Handler<AsyncResult<io.vertx.rxjava.redis.client.Response>> handler) { 
    delegate.info(args, new Handler<AsyncResult<io.vertx.redis.client.Response>>() {
      public void handle(AsyncResult<io.vertx.redis.client.Response> ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

  
Redis command info.

Params:
  • args – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/info">info</a>.
   * @param args 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI info(List<String> args) {
    return 
info(args, ar -> { });
  }

    
Redis command info.

Params:
  • args – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/info">info</a>.
   * @param args 
   * @return fluent self
   */
  public Single<io.vertx.rxjava.redis.client.Response> rxInfo(List<String> args) { 
    return Single.create(new SingleOnSubscribeAdapter<>(fut -> {
      info(args, fut);
    }));
  }

  
Redis command keys.

Params:
  • arg0 – 
  • handler – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/keys">keys</a>.
   * @param arg0 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI keys(String arg0, Handler<AsyncResult<io.vertx.rxjava.redis.client.Response>> handler) { 
    delegate.keys(arg0, new Handler<AsyncResult<io.vertx.redis.client.Response>>() {
      public void handle(AsyncResult<io.vertx.redis.client.Response> ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

  
Redis command keys.

Params:
  • arg0 – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/keys">keys</a>.
   * @param arg0 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI keys(String arg0) {
    return 
keys(arg0, ar -> { });
  }

    
Redis command keys.

Params:
  • arg0 – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/keys">keys</a>.
   * @param arg0 
   * @return fluent self
   */
  public Single<io.vertx.rxjava.redis.client.Response> rxKeys(String arg0) { 
    return Single.create(new SingleOnSubscribeAdapter<>(fut -> {
      keys(arg0, fut);
    }));
  }

  
Redis command lastsave.

Params:
  • handler – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/lastsave">lastsave</a>.
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI lastsave(Handler<AsyncResult<io.vertx.rxjava.redis.client.Response>> handler) { 
    delegate.lastsave(new Handler<AsyncResult<io.vertx.redis.client.Response>>() {
      public void handle(AsyncResult<io.vertx.redis.client.Response> ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

  
Redis command lastsave.

Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/lastsave">lastsave</a>.
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI lastsave() {
    return 
lastsave(ar -> { });
  }

    
Redis command lastsave.

Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/lastsave">lastsave</a>.
   * @return fluent self
   */
  public Single<io.vertx.rxjava.redis.client.Response> rxLastsave() { 
    return Single.create(new SingleOnSubscribeAdapter<>(fut -> {
      lastsave(fut);
    }));
  }

  
Redis command latency.

Params:
  • args – 
  • handler – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/latency">latency</a>.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI latency(List<String> args, Handler<AsyncResult<io.vertx.rxjava.redis.client.Response>> handler) { 
    delegate.latency(args, new Handler<AsyncResult<io.vertx.redis.client.Response>>() {
      public void handle(AsyncResult<io.vertx.redis.client.Response> ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

  
Redis command latency.

Params:
  • args – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/latency">latency</a>.
   * @param args 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI latency(List<String> args) {
    return 
latency(args, ar -> { });
  }

    
Redis command latency.

Params:
  • args – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/latency">latency</a>.
   * @param args 
   * @return fluent self
   */
  public Single<io.vertx.rxjava.redis.client.Response> rxLatency(List<String> args) { 
    return Single.create(new SingleOnSubscribeAdapter<>(fut -> {
      latency(args, fut);
    }));
  }

  
Redis command lindex.

Params:
  • arg0 – 
  • arg1 – 
  • handler – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/lindex">lindex</a>.
   * @param arg0 
   * @param arg1 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI lindex(String arg0, String arg1, Handler<AsyncResult<io.vertx.rxjava.redis.client.Response>> handler) { 
    delegate.lindex(arg0, arg1, new Handler<AsyncResult<io.vertx.redis.client.Response>>() {
      public void handle(AsyncResult<io.vertx.redis.client.Response> ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

  
Redis command lindex.

Params:
  • arg0 – 
  • arg1 – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/lindex">lindex</a>.
   * @param arg0 
   * @param arg1 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI lindex(String arg0, String arg1) {
    return 
lindex(arg0, arg1, ar -> { });
  }

    
Redis command lindex.

Params:
  • arg0 – 
  • arg1 – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/lindex">lindex</a>.
   * @param arg0 
   * @param arg1 
   * @return fluent self
   */
  public Single<io.vertx.rxjava.redis.client.Response> rxLindex(String arg0, String arg1) { 
    return Single.create(new SingleOnSubscribeAdapter<>(fut -> {
      lindex(arg0, arg1, fut);
    }));
  }

  
Redis command linsert.

Params:
  • arg0 – 
  • arg1 – 
  • arg2 – 
  • arg3 – 
  • handler – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/linsert">linsert</a>.
   * @param arg0 
   * @param arg1 
   * @param arg2 
   * @param arg3 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI linsert(String arg0, String arg1, String arg2, String arg3, Handler<AsyncResult<io.vertx.rxjava.redis.client.Response>> handler) { 
    delegate.linsert(arg0, arg1, arg2, arg3, new Handler<AsyncResult<io.vertx.redis.client.Response>>() {
      public void handle(AsyncResult<io.vertx.redis.client.Response> ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

  
Redis command linsert.

Params:
  • arg0 – 
  • arg1 – 
  • arg2 – 
  • arg3 – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/linsert">linsert</a>.
   * @param arg0 
   * @param arg1 
   * @param arg2 
   * @param arg3 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI linsert(String arg0, String arg1, String arg2, String arg3) {
    return 
linsert(arg0, arg1, arg2, arg3, ar -> { });
  }

    
Redis command linsert.

Params:
  • arg0 – 
  • arg1 – 
  • arg2 – 
  • arg3 – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/linsert">linsert</a>.
   * @param arg0 
   * @param arg1 
   * @param arg2 
   * @param arg3 
   * @return fluent self
   */
  public Single<io.vertx.rxjava.redis.client.Response> rxLinsert(String arg0, String arg1, String arg2, String arg3) { 
    return Single.create(new SingleOnSubscribeAdapter<>(fut -> {
      linsert(arg0, arg1, arg2, arg3, fut);
    }));
  }

  
Redis command llen.

Params:
  • arg0 – 
  • handler – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/llen">llen</a>.
   * @param arg0 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI llen(String arg0, Handler<AsyncResult<io.vertx.rxjava.redis.client.Response>> handler) { 
    delegate.llen(arg0, new Handler<AsyncResult<io.vertx.redis.client.Response>>() {
      public void handle(AsyncResult<io.vertx.redis.client.Response> ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

  
Redis command llen.

Params:
  • arg0 – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/llen">llen</a>.
   * @param arg0 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI llen(String arg0) {
    return 
llen(arg0, ar -> { });
  }

    
Redis command llen.

Params:
  • arg0 – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/llen">llen</a>.
   * @param arg0 
   * @return fluent self
   */
  public Single<io.vertx.rxjava.redis.client.Response> rxLlen(String arg0) { 
    return Single.create(new SingleOnSubscribeAdapter<>(fut -> {
      llen(arg0, fut);
    }));
  }

  
Redis command lolwut.

Params:
  • args – 
  • handler – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/lolwut">lolwut</a>.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI lolwut(List<String> args, Handler<AsyncResult<io.vertx.rxjava.redis.client.Response>> handler) { 
    delegate.lolwut(args, new Handler<AsyncResult<io.vertx.redis.client.Response>>() {
      public void handle(AsyncResult<io.vertx.redis.client.Response> ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

  
Redis command lolwut.

Params:
  • args – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/lolwut">lolwut</a>.
   * @param args 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI lolwut(List<String> args) {
    return 
lolwut(args, ar -> { });
  }

    
Redis command lolwut.

Params:
  • args – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/lolwut">lolwut</a>.
   * @param args 
   * @return fluent self
   */
  public Single<io.vertx.rxjava.redis.client.Response> rxLolwut(List<String> args) { 
    return Single.create(new SingleOnSubscribeAdapter<>(fut -> {
      lolwut(args, fut);
    }));
  }

  
Redis command lpop.

Params:
  • arg0 – 
  • handler – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/lpop">lpop</a>.
   * @param arg0 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI lpop(String arg0, Handler<AsyncResult<io.vertx.rxjava.redis.client.Response>> handler) { 
    delegate.lpop(arg0, new Handler<AsyncResult<io.vertx.redis.client.Response>>() {
      public void handle(AsyncResult<io.vertx.redis.client.Response> ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

  
Redis command lpop.

Params:
  • arg0 – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/lpop">lpop</a>.
   * @param arg0 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI lpop(String arg0) {
    return 
lpop(arg0, ar -> { });
  }

    
Redis command lpop.

Params:
  • arg0 – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/lpop">lpop</a>.
   * @param arg0 
   * @return fluent self
   */
  public Single<io.vertx.rxjava.redis.client.Response> rxLpop(String arg0) { 
    return Single.create(new SingleOnSubscribeAdapter<>(fut -> {
      lpop(arg0, fut);
    }));
  }

  
Redis command lpush.

Params:
  • args – 
  • handler – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/lpush">lpush</a>.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI lpush(List<String> args, Handler<AsyncResult<io.vertx.rxjava.redis.client.Response>> handler) { 
    delegate.lpush(args, new Handler<AsyncResult<io.vertx.redis.client.Response>>() {
      public void handle(AsyncResult<io.vertx.redis.client.Response> ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

  
Redis command lpush.

Params:
  • args – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/lpush">lpush</a>.
   * @param args 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI lpush(List<String> args) {
    return 
lpush(args, ar -> { });
  }

    
Redis command lpush.

Params:
  • args – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/lpush">lpush</a>.
   * @param args 
   * @return fluent self
   */
  public Single<io.vertx.rxjava.redis.client.Response> rxLpush(List<String> args) { 
    return Single.create(new SingleOnSubscribeAdapter<>(fut -> {
      lpush(args, fut);
    }));
  }

  
Redis command lpushx.

Params:
  • args – 
  • handler – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/lpushx">lpushx</a>.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI lpushx(List<String> args, Handler<AsyncResult<io.vertx.rxjava.redis.client.Response>> handler) { 
    delegate.lpushx(args, new Handler<AsyncResult<io.vertx.redis.client.Response>>() {
      public void handle(AsyncResult<io.vertx.redis.client.Response> ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

  
Redis command lpushx.

Params:
  • args – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/lpushx">lpushx</a>.
   * @param args 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI lpushx(List<String> args) {
    return 
lpushx(args, ar -> { });
  }

    
Redis command lpushx.

Params:
  • args – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/lpushx">lpushx</a>.
   * @param args 
   * @return fluent self
   */
  public Single<io.vertx.rxjava.redis.client.Response> rxLpushx(List<String> args) { 
    return Single.create(new SingleOnSubscribeAdapter<>(fut -> {
      lpushx(args, fut);
    }));
  }

  
Redis command lrange.

Params:
  • arg0 – 
  • arg1 – 
  • arg2 – 
  • handler – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/lrange">lrange</a>.
   * @param arg0 
   * @param arg1 
   * @param arg2 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI lrange(String arg0, String arg1, String arg2, Handler<AsyncResult<io.vertx.rxjava.redis.client.Response>> handler) { 
    delegate.lrange(arg0, arg1, arg2, new Handler<AsyncResult<io.vertx.redis.client.Response>>() {
      public void handle(AsyncResult<io.vertx.redis.client.Response> ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

  
Redis command lrange.

Params:
  • arg0 – 
  • arg1 – 
  • arg2 – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/lrange">lrange</a>.
   * @param arg0 
   * @param arg1 
   * @param arg2 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI lrange(String arg0, String arg1, String arg2) {
    return 
lrange(arg0, arg1, arg2, ar -> { });
  }

    
Redis command lrange.

Params:
  • arg0 – 
  • arg1 – 
  • arg2 – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/lrange">lrange</a>.
   * @param arg0 
   * @param arg1 
   * @param arg2 
   * @return fluent self
   */
  public Single<io.vertx.rxjava.redis.client.Response> rxLrange(String arg0, String arg1, String arg2) { 
    return Single.create(new SingleOnSubscribeAdapter<>(fut -> {
      lrange(arg0, arg1, arg2, fut);
    }));
  }

  
Redis command lrem.

Params:
  • arg0 – 
  • arg1 – 
  • arg2 – 
  • handler – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/lrem">lrem</a>.
   * @param arg0 
   * @param arg1 
   * @param arg2 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI lrem(String arg0, String arg1, String arg2, Handler<AsyncResult<io.vertx.rxjava.redis.client.Response>> handler) { 
    delegate.lrem(arg0, arg1, arg2, new Handler<AsyncResult<io.vertx.redis.client.Response>>() {
      public void handle(AsyncResult<io.vertx.redis.client.Response> ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

  
Redis command lrem.

Params:
  • arg0 – 
  • arg1 – 
  • arg2 – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/lrem">lrem</a>.
   * @param arg0 
   * @param arg1 
   * @param arg2 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI lrem(String arg0, String arg1, String arg2) {
    return 
lrem(arg0, arg1, arg2, ar -> { });
  }

    
Redis command lrem.

Params:
  • arg0 – 
  • arg1 – 
  • arg2 – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/lrem">lrem</a>.
   * @param arg0 
   * @param arg1 
   * @param arg2 
   * @return fluent self
   */
  public Single<io.vertx.rxjava.redis.client.Response> rxLrem(String arg0, String arg1, String arg2) { 
    return Single.create(new SingleOnSubscribeAdapter<>(fut -> {
      lrem(arg0, arg1, arg2, fut);
    }));
  }

  
Redis command lset.

Params:
  • arg0 – 
  • arg1 – 
  • arg2 – 
  • handler – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/lset">lset</a>.
   * @param arg0 
   * @param arg1 
   * @param arg2 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI lset(String arg0, String arg1, String arg2, Handler<AsyncResult<io.vertx.rxjava.redis.client.Response>> handler) { 
    delegate.lset(arg0, arg1, arg2, new Handler<AsyncResult<io.vertx.redis.client.Response>>() {
      public void handle(AsyncResult<io.vertx.redis.client.Response> ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

  
Redis command lset.

Params:
  • arg0 – 
  • arg1 – 
  • arg2 – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/lset">lset</a>.
   * @param arg0 
   * @param arg1 
   * @param arg2 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI lset(String arg0, String arg1, String arg2) {
    return 
lset(arg0, arg1, arg2, ar -> { });
  }

    
Redis command lset.

Params:
  • arg0 – 
  • arg1 – 
  • arg2 – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/lset">lset</a>.
   * @param arg0 
   * @param arg1 
   * @param arg2 
   * @return fluent self
   */
  public Single<io.vertx.rxjava.redis.client.Response> rxLset(String arg0, String arg1, String arg2) { 
    return Single.create(new SingleOnSubscribeAdapter<>(fut -> {
      lset(arg0, arg1, arg2, fut);
    }));
  }

  
Redis command ltrim.

Params:
  • arg0 – 
  • arg1 – 
  • arg2 – 
  • handler – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/ltrim">ltrim</a>.
   * @param arg0 
   * @param arg1 
   * @param arg2 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI ltrim(String arg0, String arg1, String arg2, Handler<AsyncResult<io.vertx.rxjava.redis.client.Response>> handler) { 
    delegate.ltrim(arg0, arg1, arg2, new Handler<AsyncResult<io.vertx.redis.client.Response>>() {
      public void handle(AsyncResult<io.vertx.redis.client.Response> ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

  
Redis command ltrim.

Params:
  • arg0 – 
  • arg1 – 
  • arg2 – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/ltrim">ltrim</a>.
   * @param arg0 
   * @param arg1 
   * @param arg2 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI ltrim(String arg0, String arg1, String arg2) {
    return 
ltrim(arg0, arg1, arg2, ar -> { });
  }

    
Redis command ltrim.

Params:
  • arg0 – 
  • arg1 – 
  • arg2 – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/ltrim">ltrim</a>.
   * @param arg0 
   * @param arg1 
   * @param arg2 
   * @return fluent self
   */
  public Single<io.vertx.rxjava.redis.client.Response> rxLtrim(String arg0, String arg1, String arg2) { 
    return Single.create(new SingleOnSubscribeAdapter<>(fut -> {
      ltrim(arg0, arg1, arg2, fut);
    }));
  }

  
Redis command memory.

Params:
  • args – 
  • handler – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/memory">memory</a>.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI memory(List<String> args, Handler<AsyncResult<io.vertx.rxjava.redis.client.Response>> handler) { 
    delegate.memory(args, new Handler<AsyncResult<io.vertx.redis.client.Response>>() {
      public void handle(AsyncResult<io.vertx.redis.client.Response> ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

  
Redis command memory.

Params:
  • args – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/memory">memory</a>.
   * @param args 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI memory(List<String> args) {
    return 
memory(args, ar -> { });
  }

    
Redis command memory.

Params:
  • args – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/memory">memory</a>.
   * @param args 
   * @return fluent self
   */
  public Single<io.vertx.rxjava.redis.client.Response> rxMemory(List<String> args) { 
    return Single.create(new SingleOnSubscribeAdapter<>(fut -> {
      memory(args, fut);
    }));
  }

  
Redis command mget.

Params:
  • args – 
  • handler – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/mget">mget</a>.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI mget(List<String> args, Handler<AsyncResult<io.vertx.rxjava.redis.client.Response>> handler) { 
    delegate.mget(args, new Handler<AsyncResult<io.vertx.redis.client.Response>>() {
      public void handle(AsyncResult<io.vertx.redis.client.Response> ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

  
Redis command mget.

Params:
  • args – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/mget">mget</a>.
   * @param args 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI mget(List<String> args) {
    return 
mget(args, ar -> { });
  }

    
Redis command mget.

Params:
  • args – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/mget">mget</a>.
   * @param args 
   * @return fluent self
   */
  public Single<io.vertx.rxjava.redis.client.Response> rxMget(List<String> args) { 
    return Single.create(new SingleOnSubscribeAdapter<>(fut -> {
      mget(args, fut);
    }));
  }

  
Redis command migrate.

Params:
  • args – 
  • handler – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/migrate">migrate</a>.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI migrate(List<String> args, Handler<AsyncResult<io.vertx.rxjava.redis.client.Response>> handler) { 
    delegate.migrate(args, new Handler<AsyncResult<io.vertx.redis.client.Response>>() {
      public void handle(AsyncResult<io.vertx.redis.client.Response> ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

  
Redis command migrate.

Params:
  • args – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/migrate">migrate</a>.
   * @param args 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI migrate(List<String> args) {
    return 
migrate(args, ar -> { });
  }

    
Redis command migrate.

Params:
  • args – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/migrate">migrate</a>.
   * @param args 
   * @return fluent self
   */
  public Single<io.vertx.rxjava.redis.client.Response> rxMigrate(List<String> args) { 
    return Single.create(new SingleOnSubscribeAdapter<>(fut -> {
      migrate(args, fut);
    }));
  }

  
Redis command module.

Params:
  • args – 
  • handler – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/module">module</a>.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI module(List<String> args, Handler<AsyncResult<io.vertx.rxjava.redis.client.Response>> handler) { 
    delegate.module(args, new Handler<AsyncResult<io.vertx.redis.client.Response>>() {
      public void handle(AsyncResult<io.vertx.redis.client.Response> ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

  
Redis command module.

Params:
  • args – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/module">module</a>.
   * @param args 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI module(List<String> args) {
    return 
module(args, ar -> { });
  }

    
Redis command module.

Params:
  • args – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/module">module</a>.
   * @param args 
   * @return fluent self
   */
  public Single<io.vertx.rxjava.redis.client.Response> rxModule(List<String> args) { 
    return Single.create(new SingleOnSubscribeAdapter<>(fut -> {
      module(args, fut);
    }));
  }

  
Redis command monitor.

Params:
  • handler – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/monitor">monitor</a>.
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI monitor(Handler<AsyncResult<io.vertx.rxjava.redis.client.Response>> handler) { 
    delegate.monitor(new Handler<AsyncResult<io.vertx.redis.client.Response>>() {
      public void handle(AsyncResult<io.vertx.redis.client.Response> ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

  
Redis command monitor.

Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/monitor">monitor</a>.
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI monitor() {
    return 
monitor(ar -> { });
  }

    
Redis command monitor.

Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/monitor">monitor</a>.
   * @return fluent self
   */
  public Single<io.vertx.rxjava.redis.client.Response> rxMonitor() { 
    return Single.create(new SingleOnSubscribeAdapter<>(fut -> {
      monitor(fut);
    }));
  }

  
Redis command move.

Params:
  • arg0 – 
  • arg1 – 
  • handler – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/move">move</a>.
   * @param arg0 
   * @param arg1 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI move(String arg0, String arg1, Handler<AsyncResult<io.vertx.rxjava.redis.client.Response>> handler) { 
    delegate.move(arg0, arg1, new Handler<AsyncResult<io.vertx.redis.client.Response>>() {
      public void handle(AsyncResult<io.vertx.redis.client.Response> ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

  
Redis command move.

Params:
  • arg0 – 
  • arg1 – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/move">move</a>.
   * @param arg0 
   * @param arg1 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI move(String arg0, String arg1) {
    return 
move(arg0, arg1, ar -> { });
  }

    
Redis command move.

Params:
  • arg0 – 
  • arg1 – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/move">move</a>.
   * @param arg0 
   * @param arg1 
   * @return fluent self
   */
  public Single<io.vertx.rxjava.redis.client.Response> rxMove(String arg0, String arg1) { 
    return Single.create(new SingleOnSubscribeAdapter<>(fut -> {
      move(arg0, arg1, fut);
    }));
  }

  
Redis command mset.

Params:
  • args – 
  • handler – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/mset">mset</a>.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI mset(List<String> args, Handler<AsyncResult<io.vertx.rxjava.redis.client.Response>> handler) { 
    delegate.mset(args, new Handler<AsyncResult<io.vertx.redis.client.Response>>() {
      public void handle(AsyncResult<io.vertx.redis.client.Response> ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

  
Redis command mset.

Params:
  • args – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/mset">mset</a>.
   * @param args 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI mset(List<String> args) {
    return 
mset(args, ar -> { });
  }

    
Redis command mset.

Params:
  • args – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/mset">mset</a>.
   * @param args 
   * @return fluent self
   */
  public Single<io.vertx.rxjava.redis.client.Response> rxMset(List<String> args) { 
    return Single.create(new SingleOnSubscribeAdapter<>(fut -> {
      mset(args, fut);
    }));
  }

  
Redis command msetnx.

Params:
  • args – 
  • handler – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/msetnx">msetnx</a>.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI msetnx(List<String> args, Handler<AsyncResult<io.vertx.rxjava.redis.client.Response>> handler) { 
    delegate.msetnx(args, new Handler<AsyncResult<io.vertx.redis.client.Response>>() {
      public void handle(AsyncResult<io.vertx.redis.client.Response> ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

  
Redis command msetnx.

Params:
  • args – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/msetnx">msetnx</a>.
   * @param args 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI msetnx(List<String> args) {
    return 
msetnx(args, ar -> { });
  }

    
Redis command msetnx.

Params:
  • args – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/msetnx">msetnx</a>.
   * @param args 
   * @return fluent self
   */
  public Single<io.vertx.rxjava.redis.client.Response> rxMsetnx(List<String> args) { 
    return Single.create(new SingleOnSubscribeAdapter<>(fut -> {
      msetnx(args, fut);
    }));
  }

  
Redis command multi.

Params:
  • handler – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/multi">multi</a>.
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI multi(Handler<AsyncResult<io.vertx.rxjava.redis.client.Response>> handler) { 
    delegate.multi(new Handler<AsyncResult<io.vertx.redis.client.Response>>() {
      public void handle(AsyncResult<io.vertx.redis.client.Response> ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

  
Redis command multi.

Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/multi">multi</a>.
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI multi() {
    return 
multi(ar -> { });
  }

    
Redis command multi.

Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/multi">multi</a>.
   * @return fluent self
   */
  public Single<io.vertx.rxjava.redis.client.Response> rxMulti() { 
    return Single.create(new SingleOnSubscribeAdapter<>(fut -> {
      multi(fut);
    }));
  }

  
Redis command object.

Params:
  • args – 
  • handler – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/object">object</a>.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI object(List<String> args, Handler<AsyncResult<io.vertx.rxjava.redis.client.Response>> handler) { 
    delegate.object(args, new Handler<AsyncResult<io.vertx.redis.client.Response>>() {
      public void handle(AsyncResult<io.vertx.redis.client.Response> ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

  
Redis command object.

Params:
  • args – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/object">object</a>.
   * @param args 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI object(List<String> args) {
    return 
object(args, ar -> { });
  }

    
Redis command object.

Params:
  • args – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/object">object</a>.
   * @param args 
   * @return fluent self
   */
  public Single<io.vertx.rxjava.redis.client.Response> rxObject(List<String> args) { 
    return Single.create(new SingleOnSubscribeAdapter<>(fut -> {
      object(args, fut);
    }));
  }

  
Redis command persist.

Params:
  • arg0 – 
  • handler – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/persist">persist</a>.
   * @param arg0 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI persist(String arg0, Handler<AsyncResult<io.vertx.rxjava.redis.client.Response>> handler) { 
    delegate.persist(arg0, new Handler<AsyncResult<io.vertx.redis.client.Response>>() {
      public void handle(AsyncResult<io.vertx.redis.client.Response> ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

  
Redis command persist.

Params:
  • arg0 – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/persist">persist</a>.
   * @param arg0 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI persist(String arg0) {
    return 
persist(arg0, ar -> { });
  }

    
Redis command persist.

Params:
  • arg0 – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/persist">persist</a>.
   * @param arg0 
   * @return fluent self
   */
  public Single<io.vertx.rxjava.redis.client.Response> rxPersist(String arg0) { 
    return Single.create(new SingleOnSubscribeAdapter<>(fut -> {
      persist(arg0, fut);
    }));
  }

  
Redis command pexpire.

Params:
  • arg0 – 
  • arg1 – 
  • handler – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/pexpire">pexpire</a>.
   * @param arg0 
   * @param arg1 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI pexpire(String arg0, String arg1, Handler<AsyncResult<io.vertx.rxjava.redis.client.Response>> handler) { 
    delegate.pexpire(arg0, arg1, new Handler<AsyncResult<io.vertx.redis.client.Response>>() {
      public void handle(AsyncResult<io.vertx.redis.client.Response> ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

  
Redis command pexpire.

Params:
  • arg0 – 
  • arg1 – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/pexpire">pexpire</a>.
   * @param arg0 
   * @param arg1 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI pexpire(String arg0, String arg1) {
    return 
pexpire(arg0, arg1, ar -> { });
  }

    
Redis command pexpire.

Params:
  • arg0 – 
  • arg1 – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/pexpire">pexpire</a>.
   * @param arg0 
   * @param arg1 
   * @return fluent self
   */
  public Single<io.vertx.rxjava.redis.client.Response> rxPexpire(String arg0, String arg1) { 
    return Single.create(new SingleOnSubscribeAdapter<>(fut -> {
      pexpire(arg0, arg1, fut);
    }));
  }

  
Redis command pexpireat.

Params:
  • arg0 – 
  • arg1 – 
  • handler – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/pexpireat">pexpireat</a>.
   * @param arg0 
   * @param arg1 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI pexpireat(String arg0, String arg1, Handler<AsyncResult<io.vertx.rxjava.redis.client.Response>> handler) { 
    delegate.pexpireat(arg0, arg1, new Handler<AsyncResult<io.vertx.redis.client.Response>>() {
      public void handle(AsyncResult<io.vertx.redis.client.Response> ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

  
Redis command pexpireat.

Params:
  • arg0 – 
  • arg1 – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/pexpireat">pexpireat</a>.
   * @param arg0 
   * @param arg1 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI pexpireat(String arg0, String arg1) {
    return 
pexpireat(arg0, arg1, ar -> { });
  }

    
Redis command pexpireat.

Params:
  • arg0 – 
  • arg1 – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/pexpireat">pexpireat</a>.
   * @param arg0 
   * @param arg1 
   * @return fluent self
   */
  public Single<io.vertx.rxjava.redis.client.Response> rxPexpireat(String arg0, String arg1) { 
    return Single.create(new SingleOnSubscribeAdapter<>(fut -> {
      pexpireat(arg0, arg1, fut);
    }));
  }

  
Redis command pfadd.

Params:
  • args – 
  • handler – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/pfadd">pfadd</a>.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI pfadd(List<String> args, Handler<AsyncResult<io.vertx.rxjava.redis.client.Response>> handler) { 
    delegate.pfadd(args, new Handler<AsyncResult<io.vertx.redis.client.Response>>() {
      public void handle(AsyncResult<io.vertx.redis.client.Response> ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

  
Redis command pfadd.

Params:
  • args – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/pfadd">pfadd</a>.
   * @param args 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI pfadd(List<String> args) {
    return 
pfadd(args, ar -> { });
  }

    
Redis command pfadd.

Params:
  • args – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/pfadd">pfadd</a>.
   * @param args 
   * @return fluent self
   */
  public Single<io.vertx.rxjava.redis.client.Response> rxPfadd(List<String> args) { 
    return Single.create(new SingleOnSubscribeAdapter<>(fut -> {
      pfadd(args, fut);
    }));
  }

  
Redis command pfcount.

Params:
  • args – 
  • handler – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/pfcount">pfcount</a>.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI pfcount(List<String> args, Handler<AsyncResult<io.vertx.rxjava.redis.client.Response>> handler) { 
    delegate.pfcount(args, new Handler<AsyncResult<io.vertx.redis.client.Response>>() {
      public void handle(AsyncResult<io.vertx.redis.client.Response> ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

  
Redis command pfcount.

Params:
  • args – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/pfcount">pfcount</a>.
   * @param args 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI pfcount(List<String> args) {
    return 
pfcount(args, ar -> { });
  }

    
Redis command pfcount.

Params:
  • args – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/pfcount">pfcount</a>.
   * @param args 
   * @return fluent self
   */
  public Single<io.vertx.rxjava.redis.client.Response> rxPfcount(List<String> args) { 
    return Single.create(new SingleOnSubscribeAdapter<>(fut -> {
      pfcount(args, fut);
    }));
  }

  
Redis command pfdebug.

Params:
  • args – 
  • handler – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/pfdebug">pfdebug</a>.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI pfdebug(List<String> args, Handler<AsyncResult<io.vertx.rxjava.redis.client.Response>> handler) { 
    delegate.pfdebug(args, new Handler<AsyncResult<io.vertx.redis.client.Response>>() {
      public void handle(AsyncResult<io.vertx.redis.client.Response> ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

  
Redis command pfdebug.

Params:
  • args – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/pfdebug">pfdebug</a>.
   * @param args 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI pfdebug(List<String> args) {
    return 
pfdebug(args, ar -> { });
  }

    
Redis command pfdebug.

Params:
  • args – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/pfdebug">pfdebug</a>.
   * @param args 
   * @return fluent self
   */
  public Single<io.vertx.rxjava.redis.client.Response> rxPfdebug(List<String> args) { 
    return Single.create(new SingleOnSubscribeAdapter<>(fut -> {
      pfdebug(args, fut);
    }));
  }

  
Redis command pfmerge.

Params:
  • args – 
  • handler – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/pfmerge">pfmerge</a>.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI pfmerge(List<String> args, Handler<AsyncResult<io.vertx.rxjava.redis.client.Response>> handler) { 
    delegate.pfmerge(args, new Handler<AsyncResult<io.vertx.redis.client.Response>>() {
      public void handle(AsyncResult<io.vertx.redis.client.Response> ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

  
Redis command pfmerge.

Params:
  • args – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/pfmerge">pfmerge</a>.
   * @param args 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI pfmerge(List<String> args) {
    return 
pfmerge(args, ar -> { });
  }

    
Redis command pfmerge.

Params:
  • args – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/pfmerge">pfmerge</a>.
   * @param args 
   * @return fluent self
   */
  public Single<io.vertx.rxjava.redis.client.Response> rxPfmerge(List<String> args) { 
    return Single.create(new SingleOnSubscribeAdapter<>(fut -> {
      pfmerge(args, fut);
    }));
  }

  
Redis command pfselftest.

Params:
  • handler – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/pfselftest">pfselftest</a>.
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI pfselftest(Handler<AsyncResult<io.vertx.rxjava.redis.client.Response>> handler) { 
    delegate.pfselftest(new Handler<AsyncResult<io.vertx.redis.client.Response>>() {
      public void handle(AsyncResult<io.vertx.redis.client.Response> ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

  
Redis command pfselftest.

Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/pfselftest">pfselftest</a>.
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI pfselftest() {
    return 
pfselftest(ar -> { });
  }

    
Redis command pfselftest.

Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/pfselftest">pfselftest</a>.
   * @return fluent self
   */
  public Single<io.vertx.rxjava.redis.client.Response> rxPfselftest() { 
    return Single.create(new SingleOnSubscribeAdapter<>(fut -> {
      pfselftest(fut);
    }));
  }

  
Redis command ping.

Params:
  • args – 
  • handler – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/ping">ping</a>.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI ping(List<String> args, Handler<AsyncResult<io.vertx.rxjava.redis.client.Response>> handler) { 
    delegate.ping(args, new Handler<AsyncResult<io.vertx.redis.client.Response>>() {
      public void handle(AsyncResult<io.vertx.redis.client.Response> ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

  
Redis command ping.

Params:
  • args – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/ping">ping</a>.
   * @param args 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI ping(List<String> args) {
    return 
ping(args, ar -> { });
  }

    
Redis command ping.

Params:
  • args – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/ping">ping</a>.
   * @param args 
   * @return fluent self
   */
  public Single<io.vertx.rxjava.redis.client.Response> rxPing(List<String> args) { 
    return Single.create(new SingleOnSubscribeAdapter<>(fut -> {
      ping(args, fut);
    }));
  }

  
Redis command post.

Params:
  • args – 
  • handler – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/post">post</a>.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI post(List<String> args, Handler<AsyncResult<io.vertx.rxjava.redis.client.Response>> handler) { 
    delegate.post(args, new Handler<AsyncResult<io.vertx.redis.client.Response>>() {
      public void handle(AsyncResult<io.vertx.redis.client.Response> ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

  
Redis command post.

Params:
  • args – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/post">post</a>.
   * @param args 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI post(List<String> args) {
    return 
post(args, ar -> { });
  }

    
Redis command post.

Params:
  • args – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/post">post</a>.
   * @param args 
   * @return fluent self
   */
  public Single<io.vertx.rxjava.redis.client.Response> rxPost(List<String> args) { 
    return Single.create(new SingleOnSubscribeAdapter<>(fut -> {
      post(args, fut);
    }));
  }

  
Redis command psetex.

Params:
  • arg0 – 
  • arg1 – 
  • arg2 – 
  • handler – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/psetex">psetex</a>.
   * @param arg0 
   * @param arg1 
   * @param arg2 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI psetex(String arg0, String arg1, String arg2, Handler<AsyncResult<io.vertx.rxjava.redis.client.Response>> handler) { 
    delegate.psetex(arg0, arg1, arg2, new Handler<AsyncResult<io.vertx.redis.client.Response>>() {
      public void handle(AsyncResult<io.vertx.redis.client.Response> ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

  
Redis command psetex.

Params:
  • arg0 – 
  • arg1 – 
  • arg2 – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/psetex">psetex</a>.
   * @param arg0 
   * @param arg1 
   * @param arg2 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI psetex(String arg0, String arg1, String arg2) {
    return 
psetex(arg0, arg1, arg2, ar -> { });
  }

    
Redis command psetex.

Params:
  • arg0 – 
  • arg1 – 
  • arg2 – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/psetex">psetex</a>.
   * @param arg0 
   * @param arg1 
   * @param arg2 
   * @return fluent self
   */
  public Single<io.vertx.rxjava.redis.client.Response> rxPsetex(String arg0, String arg1, String arg2) { 
    return Single.create(new SingleOnSubscribeAdapter<>(fut -> {
      psetex(arg0, arg1, arg2, fut);
    }));
  }

  
Redis command psubscribe.

Params:
  • args – 
  • handler – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/psubscribe">psubscribe</a>.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI psubscribe(List<String> args, Handler<AsyncResult<io.vertx.rxjava.redis.client.Response>> handler) { 
    delegate.psubscribe(args, new Handler<AsyncResult<io.vertx.redis.client.Response>>() {
      public void handle(AsyncResult<io.vertx.redis.client.Response> ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

  
Redis command psubscribe.

Params:
  • args – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/psubscribe">psubscribe</a>.
   * @param args 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI psubscribe(List<String> args) {
    return 
psubscribe(args, ar -> { });
  }

    
Redis command psubscribe.

Params:
  • args – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/psubscribe">psubscribe</a>.
   * @param args 
   * @return fluent self
   */
  public Single<io.vertx.rxjava.redis.client.Response> rxPsubscribe(List<String> args) { 
    return Single.create(new SingleOnSubscribeAdapter<>(fut -> {
      psubscribe(args, fut);
    }));
  }

  
Redis command psync.

Params:
  • arg0 – 
  • arg1 – 
  • handler – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/psync">psync</a>.
   * @param arg0 
   * @param arg1 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI psync(String arg0, String arg1, Handler<AsyncResult<io.vertx.rxjava.redis.client.Response>> handler) { 
    delegate.psync(arg0, arg1, new Handler<AsyncResult<io.vertx.redis.client.Response>>() {
      public void handle(AsyncResult<io.vertx.redis.client.Response> ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

  
Redis command psync.

Params:
  • arg0 – 
  • arg1 – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/psync">psync</a>.
   * @param arg0 
   * @param arg1 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI psync(String arg0, String arg1) {
    return 
psync(arg0, arg1, ar -> { });
  }

    
Redis command psync.

Params:
  • arg0 – 
  • arg1 – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/psync">psync</a>.
   * @param arg0 
   * @param arg1 
   * @return fluent self
   */
  public Single<io.vertx.rxjava.redis.client.Response> rxPsync(String arg0, String arg1) { 
    return Single.create(new SingleOnSubscribeAdapter<>(fut -> {
      psync(arg0, arg1, fut);
    }));
  }

  
Redis command pttl.

Params:
  • arg0 – 
  • handler – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/pttl">pttl</a>.
   * @param arg0 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI pttl(String arg0, Handler<AsyncResult<io.vertx.rxjava.redis.client.Response>> handler) { 
    delegate.pttl(arg0, new Handler<AsyncResult<io.vertx.redis.client.Response>>() {
      public void handle(AsyncResult<io.vertx.redis.client.Response> ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

  
Redis command pttl.

Params:
  • arg0 – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/pttl">pttl</a>.
   * @param arg0 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI pttl(String arg0) {
    return 
pttl(arg0, ar -> { });
  }

    
Redis command pttl.

Params:
  • arg0 – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/pttl">pttl</a>.
   * @param arg0 
   * @return fluent self
   */
  public Single<io.vertx.rxjava.redis.client.Response> rxPttl(String arg0) { 
    return Single.create(new SingleOnSubscribeAdapter<>(fut -> {
      pttl(arg0, fut);
    }));
  }

  
Redis command publish.

Params:
  • arg0 – 
  • arg1 – 
  • handler – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/publish">publish</a>.
   * @param arg0 
   * @param arg1 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI publish(String arg0, String arg1, Handler<AsyncResult<io.vertx.rxjava.redis.client.Response>> handler) { 
    delegate.publish(arg0, arg1, new Handler<AsyncResult<io.vertx.redis.client.Response>>() {
      public void handle(AsyncResult<io.vertx.redis.client.Response> ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

  
Redis command publish.

Params:
  • arg0 – 
  • arg1 – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/publish">publish</a>.
   * @param arg0 
   * @param arg1 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI publish(String arg0, String arg1) {
    return 
publish(arg0, arg1, ar -> { });
  }

    
Redis command publish.

Params:
  • arg0 – 
  • arg1 – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/publish">publish</a>.
   * @param arg0 
   * @param arg1 
   * @return fluent self
   */
  public Single<io.vertx.rxjava.redis.client.Response> rxPublish(String arg0, String arg1) { 
    return Single.create(new SingleOnSubscribeAdapter<>(fut -> {
      publish(arg0, arg1, fut);
    }));
  }

  
Redis command pubsub.

Params:
  • args – 
  • handler – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/pubsub">pubsub</a>.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI pubsub(List<String> args, Handler<AsyncResult<io.vertx.rxjava.redis.client.Response>> handler) { 
    delegate.pubsub(args, new Handler<AsyncResult<io.vertx.redis.client.Response>>() {
      public void handle(AsyncResult<io.vertx.redis.client.Response> ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

  
Redis command pubsub.

Params:
  • args – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/pubsub">pubsub</a>.
   * @param args 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI pubsub(List<String> args) {
    return 
pubsub(args, ar -> { });
  }

    
Redis command pubsub.

Params:
  • args – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/pubsub">pubsub</a>.
   * @param args 
   * @return fluent self
   */
  public Single<io.vertx.rxjava.redis.client.Response> rxPubsub(List<String> args) { 
    return Single.create(new SingleOnSubscribeAdapter<>(fut -> {
      pubsub(args, fut);
    }));
  }

  
Redis command punsubscribe.

Params:
  • args – 
  • handler – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/punsubscribe">punsubscribe</a>.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI punsubscribe(List<String> args, Handler<AsyncResult<io.vertx.rxjava.redis.client.Response>> handler) { 
    delegate.punsubscribe(args, new Handler<AsyncResult<io.vertx.redis.client.Response>>() {
      public void handle(AsyncResult<io.vertx.redis.client.Response> ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

  
Redis command punsubscribe.

Params:
  • args – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/punsubscribe">punsubscribe</a>.
   * @param args 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI punsubscribe(List<String> args) {
    return 
punsubscribe(args, ar -> { });
  }

    
Redis command punsubscribe.

Params:
  • args – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/punsubscribe">punsubscribe</a>.
   * @param args 
   * @return fluent self
   */
  public Single<io.vertx.rxjava.redis.client.Response> rxPunsubscribe(List<String> args) { 
    return Single.create(new SingleOnSubscribeAdapter<>(fut -> {
      punsubscribe(args, fut);
    }));
  }

  
Redis command randomkey.

Params:
  • handler – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/randomkey">randomkey</a>.
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI randomkey(Handler<AsyncResult<io.vertx.rxjava.redis.client.Response>> handler) { 
    delegate.randomkey(new Handler<AsyncResult<io.vertx.redis.client.Response>>() {
      public void handle(AsyncResult<io.vertx.redis.client.Response> ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

  
Redis command randomkey.

Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/randomkey">randomkey</a>.
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI randomkey() {
    return 
randomkey(ar -> { });
  }

    
Redis command randomkey.

Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/randomkey">randomkey</a>.
   * @return fluent self
   */
  public Single<io.vertx.rxjava.redis.client.Response> rxRandomkey() { 
    return Single.create(new SingleOnSubscribeAdapter<>(fut -> {
      randomkey(fut);
    }));
  }

  
Redis command readonly.

Params:
  • handler – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/readonly">readonly</a>.
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI readonly(Handler<AsyncResult<io.vertx.rxjava.redis.client.Response>> handler) { 
    delegate.readonly(new Handler<AsyncResult<io.vertx.redis.client.Response>>() {
      public void handle(AsyncResult<io.vertx.redis.client.Response> ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

  
Redis command readonly.

Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/readonly">readonly</a>.
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI readonly() {
    return 
readonly(ar -> { });
  }

    
Redis command readonly.

Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/readonly">readonly</a>.
   * @return fluent self
   */
  public Single<io.vertx.rxjava.redis.client.Response> rxReadonly() { 
    return Single.create(new SingleOnSubscribeAdapter<>(fut -> {
      readonly(fut);
    }));
  }

  
Redis command readwrite.

Params:
  • handler – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/readwrite">readwrite</a>.
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI readwrite(Handler<AsyncResult<io.vertx.rxjava.redis.client.Response>> handler) { 
    delegate.readwrite(new Handler<AsyncResult<io.vertx.redis.client.Response>>() {
      public void handle(AsyncResult<io.vertx.redis.client.Response> ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

  
Redis command readwrite.

Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/readwrite">readwrite</a>.
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI readwrite() {
    return 
readwrite(ar -> { });
  }

    
Redis command readwrite.

Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/readwrite">readwrite</a>.
   * @return fluent self
   */
  public Single<io.vertx.rxjava.redis.client.Response> rxReadwrite() { 
    return Single.create(new SingleOnSubscribeAdapter<>(fut -> {
      readwrite(fut);
    }));
  }

  
Redis command rename.

Params:
  • arg0 – 
  • arg1 – 
  • handler – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/rename">rename</a>.
   * @param arg0 
   * @param arg1 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI rename(String arg0, String arg1, Handler<AsyncResult<io.vertx.rxjava.redis.client.Response>> handler) { 
    delegate.rename(arg0, arg1, new Handler<AsyncResult<io.vertx.redis.client.Response>>() {
      public void handle(AsyncResult<io.vertx.redis.client.Response> ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

  
Redis command rename.

Params:
  • arg0 – 
  • arg1 – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/rename">rename</a>.
   * @param arg0 
   * @param arg1 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI rename(String arg0, String arg1) {
    return 
rename(arg0, arg1, ar -> { });
  }

    
Redis command rename.

Params:
  • arg0 – 
  • arg1 – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/rename">rename</a>.
   * @param arg0 
   * @param arg1 
   * @return fluent self
   */
  public Single<io.vertx.rxjava.redis.client.Response> rxRename(String arg0, String arg1) { 
    return Single.create(new SingleOnSubscribeAdapter<>(fut -> {
      rename(arg0, arg1, fut);
    }));
  }

  
Redis command renamenx.

Params:
  • arg0 – 
  • arg1 – 
  • handler – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/renamenx">renamenx</a>.
   * @param arg0 
   * @param arg1 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI renamenx(String arg0, String arg1, Handler<AsyncResult<io.vertx.rxjava.redis.client.Response>> handler) { 
    delegate.renamenx(arg0, arg1, new Handler<AsyncResult<io.vertx.redis.client.Response>>() {
      public void handle(AsyncResult<io.vertx.redis.client.Response> ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

  
Redis command renamenx.

Params:
  • arg0 – 
  • arg1 – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/renamenx">renamenx</a>.
   * @param arg0 
   * @param arg1 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI renamenx(String arg0, String arg1) {
    return 
renamenx(arg0, arg1, ar -> { });
  }

    
Redis command renamenx.

Params:
  • arg0 – 
  • arg1 – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/renamenx">renamenx</a>.
   * @param arg0 
   * @param arg1 
   * @return fluent self
   */
  public Single<io.vertx.rxjava.redis.client.Response> rxRenamenx(String arg0, String arg1) { 
    return Single.create(new SingleOnSubscribeAdapter<>(fut -> {
      renamenx(arg0, arg1, fut);
    }));
  }

  
Redis command replconf.

Params:
  • args – 
  • handler – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/replconf">replconf</a>.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI replconf(List<String> args, Handler<AsyncResult<io.vertx.rxjava.redis.client.Response>> handler) { 
    delegate.replconf(args, new Handler<AsyncResult<io.vertx.redis.client.Response>>() {
      public void handle(AsyncResult<io.vertx.redis.client.Response> ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

  
Redis command replconf.

Params:
  • args – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/replconf">replconf</a>.
   * @param args 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI replconf(List<String> args) {
    return 
replconf(args, ar -> { });
  }

    
Redis command replconf.

Params:
  • args – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/replconf">replconf</a>.
   * @param args 
   * @return fluent self
   */
  public Single<io.vertx.rxjava.redis.client.Response> rxReplconf(List<String> args) { 
    return Single.create(new SingleOnSubscribeAdapter<>(fut -> {
      replconf(args, fut);
    }));
  }

  
Redis command replicaof.

Params:
  • arg0 – 
  • arg1 – 
  • handler – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/replicaof">replicaof</a>.
   * @param arg0 
   * @param arg1 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI replicaof(String arg0, String arg1, Handler<AsyncResult<io.vertx.rxjava.redis.client.Response>> handler) { 
    delegate.replicaof(arg0, arg1, new Handler<AsyncResult<io.vertx.redis.client.Response>>() {
      public void handle(AsyncResult<io.vertx.redis.client.Response> ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

  
Redis command replicaof.

Params:
  • arg0 – 
  • arg1 – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/replicaof">replicaof</a>.
   * @param arg0 
   * @param arg1 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI replicaof(String arg0, String arg1) {
    return 
replicaof(arg0, arg1, ar -> { });
  }

    
Redis command replicaof.

Params:
  • arg0 – 
  • arg1 – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/replicaof">replicaof</a>.
   * @param arg0 
   * @param arg1 
   * @return fluent self
   */
  public Single<io.vertx.rxjava.redis.client.Response> rxReplicaof(String arg0, String arg1) { 
    return Single.create(new SingleOnSubscribeAdapter<>(fut -> {
      replicaof(arg0, arg1, fut);
    }));
  }

  
Redis command restore.

Params:
  • args – 
  • handler – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/restore">restore</a>.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI restore(List<String> args, Handler<AsyncResult<io.vertx.rxjava.redis.client.Response>> handler) { 
    delegate.restore(args, new Handler<AsyncResult<io.vertx.redis.client.Response>>() {
      public void handle(AsyncResult<io.vertx.redis.client.Response> ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

  
Redis command restore.

Params:
  • args – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/restore">restore</a>.
   * @param args 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI restore(List<String> args) {
    return 
restore(args, ar -> { });
  }

    
Redis command restore.

Params:
  • args – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/restore">restore</a>.
   * @param args 
   * @return fluent self
   */
  public Single<io.vertx.rxjava.redis.client.Response> rxRestore(List<String> args) { 
    return Single.create(new SingleOnSubscribeAdapter<>(fut -> {
      restore(args, fut);
    }));
  }

  
Redis command restoreAsking.

Params:
  • args – 
  • handler – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/restore-asking">restoreAsking</a>.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI restoreAsking(List<String> args, Handler<AsyncResult<io.vertx.rxjava.redis.client.Response>> handler) { 
    delegate.restoreAsking(args, new Handler<AsyncResult<io.vertx.redis.client.Response>>() {
      public void handle(AsyncResult<io.vertx.redis.client.Response> ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

  
Redis command restoreAsking.

Params:
  • args – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/restore-asking">restoreAsking</a>.
   * @param args 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI restoreAsking(List<String> args) {
    return 
restoreAsking(args, ar -> { });
  }

    
Redis command restoreAsking.

Params:
  • args – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/restore-asking">restoreAsking</a>.
   * @param args 
   * @return fluent self
   */
  public Single<io.vertx.rxjava.redis.client.Response> rxRestoreAsking(List<String> args) { 
    return Single.create(new SingleOnSubscribeAdapter<>(fut -> {
      restoreAsking(args, fut);
    }));
  }

  
Redis command role.

Params:
  • handler – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/role">role</a>.
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI role(Handler<AsyncResult<io.vertx.rxjava.redis.client.Response>> handler) { 
    delegate.role(new Handler<AsyncResult<io.vertx.redis.client.Response>>() {
      public void handle(AsyncResult<io.vertx.redis.client.Response> ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

  
Redis command role.

Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/role">role</a>.
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI role() {
    return 
role(ar -> { });
  }

    
Redis command role.

Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/role">role</a>.
   * @return fluent self
   */
  public Single<io.vertx.rxjava.redis.client.Response> rxRole() { 
    return Single.create(new SingleOnSubscribeAdapter<>(fut -> {
      role(fut);
    }));
  }

  
Redis command rpop.

Params:
  • arg0 – 
  • handler – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/rpop">rpop</a>.
   * @param arg0 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI rpop(String arg0, Handler<AsyncResult<io.vertx.rxjava.redis.client.Response>> handler) { 
    delegate.rpop(arg0, new Handler<AsyncResult<io.vertx.redis.client.Response>>() {
      public void handle(AsyncResult<io.vertx.redis.client.Response> ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

  
Redis command rpop.

Params:
  • arg0 – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/rpop">rpop</a>.
   * @param arg0 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI rpop(String arg0) {
    return 
rpop(arg0, ar -> { });
  }

    
Redis command rpop.

Params:
  • arg0 – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/rpop">rpop</a>.
   * @param arg0 
   * @return fluent self
   */
  public Single<io.vertx.rxjava.redis.client.Response> rxRpop(String arg0) { 
    return Single.create(new SingleOnSubscribeAdapter<>(fut -> {
      rpop(arg0, fut);
    }));
  }

  
Redis command rpoplpush.

Params:
  • arg0 – 
  • arg1 – 
  • handler – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/rpoplpush">rpoplpush</a>.
   * @param arg0 
   * @param arg1 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI rpoplpush(String arg0, String arg1, Handler<AsyncResult<io.vertx.rxjava.redis.client.Response>> handler) { 
    delegate.rpoplpush(arg0, arg1, new Handler<AsyncResult<io.vertx.redis.client.Response>>() {
      public void handle(AsyncResult<io.vertx.redis.client.Response> ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

  
Redis command rpoplpush.

Params:
  • arg0 – 
  • arg1 – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/rpoplpush">rpoplpush</a>.
   * @param arg0 
   * @param arg1 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI rpoplpush(String arg0, String arg1) {
    return 
rpoplpush(arg0, arg1, ar -> { });
  }

    
Redis command rpoplpush.

Params:
  • arg0 – 
  • arg1 – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/rpoplpush">rpoplpush</a>.
   * @param arg0 
   * @param arg1 
   * @return fluent self
   */
  public Single<io.vertx.rxjava.redis.client.Response> rxRpoplpush(String arg0, String arg1) { 
    return Single.create(new SingleOnSubscribeAdapter<>(fut -> {
      rpoplpush(arg0, arg1, fut);
    }));
  }

  
Redis command rpush.

Params:
  • args – 
  • handler – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/rpush">rpush</a>.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI rpush(List<String> args, Handler<AsyncResult<io.vertx.rxjava.redis.client.Response>> handler) { 
    delegate.rpush(args, new Handler<AsyncResult<io.vertx.redis.client.Response>>() {
      public void handle(AsyncResult<io.vertx.redis.client.Response> ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

  
Redis command rpush.

Params:
  • args – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/rpush">rpush</a>.
   * @param args 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI rpush(List<String> args) {
    return 
rpush(args, ar -> { });
  }

    
Redis command rpush.

Params:
  • args – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/rpush">rpush</a>.
   * @param args 
   * @return fluent self
   */
  public Single<io.vertx.rxjava.redis.client.Response> rxRpush(List<String> args) { 
    return Single.create(new SingleOnSubscribeAdapter<>(fut -> {
      rpush(args, fut);
    }));
  }

  
Redis command rpushx.

Params:
  • args – 
  • handler – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/rpushx">rpushx</a>.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI rpushx(List<String> args, Handler<AsyncResult<io.vertx.rxjava.redis.client.Response>> handler) { 
    delegate.rpushx(args, new Handler<AsyncResult<io.vertx.redis.client.Response>>() {
      public void handle(AsyncResult<io.vertx.redis.client.Response> ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

  
Redis command rpushx.

Params:
  • args – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/rpushx">rpushx</a>.
   * @param args 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI rpushx(List<String> args) {
    return 
rpushx(args, ar -> { });
  }

    
Redis command rpushx.

Params:
  • args – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/rpushx">rpushx</a>.
   * @param args 
   * @return fluent self
   */
  public Single<io.vertx.rxjava.redis.client.Response> rxRpushx(List<String> args) { 
    return Single.create(new SingleOnSubscribeAdapter<>(fut -> {
      rpushx(args, fut);
    }));
  }

  
Redis command sadd.

Params:
  • args – 
  • handler – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/sadd">sadd</a>.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI sadd(List<String> args, Handler<AsyncResult<io.vertx.rxjava.redis.client.Response>> handler) { 
    delegate.sadd(args, new Handler<AsyncResult<io.vertx.redis.client.Response>>() {
      public void handle(AsyncResult<io.vertx.redis.client.Response> ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

  
Redis command sadd.

Params:
  • args – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/sadd">sadd</a>.
   * @param args 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI sadd(List<String> args) {
    return 
sadd(args, ar -> { });
  }

    
Redis command sadd.

Params:
  • args – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/sadd">sadd</a>.
   * @param args 
   * @return fluent self
   */
  public Single<io.vertx.rxjava.redis.client.Response> rxSadd(List<String> args) { 
    return Single.create(new SingleOnSubscribeAdapter<>(fut -> {
      sadd(args, fut);
    }));
  }

  
Redis command save.

Params:
  • handler – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/save">save</a>.
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI save(Handler<AsyncResult<io.vertx.rxjava.redis.client.Response>> handler) { 
    delegate.save(new Handler<AsyncResult<io.vertx.redis.client.Response>>() {
      public void handle(AsyncResult<io.vertx.redis.client.Response> ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

  
Redis command save.

Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/save">save</a>.
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI save() {
    return 
save(ar -> { });
  }

    
Redis command save.

Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/save">save</a>.
   * @return fluent self
   */
  public Single<io.vertx.rxjava.redis.client.Response> rxSave() { 
    return Single.create(new SingleOnSubscribeAdapter<>(fut -> {
      save(fut);
    }));
  }

  
Redis command scan.

Params:
  • args – 
  • handler – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/scan">scan</a>.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI scan(List<String> args, Handler<AsyncResult<io.vertx.rxjava.redis.client.Response>> handler) { 
    delegate.scan(args, new Handler<AsyncResult<io.vertx.redis.client.Response>>() {
      public void handle(AsyncResult<io.vertx.redis.client.Response> ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

  
Redis command scan.

Params:
  • args – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/scan">scan</a>.
   * @param args 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI scan(List<String> args) {
    return 
scan(args, ar -> { });
  }

    
Redis command scan.

Params:
  • args – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/scan">scan</a>.
   * @param args 
   * @return fluent self
   */
  public Single<io.vertx.rxjava.redis.client.Response> rxScan(List<String> args) { 
    return Single.create(new SingleOnSubscribeAdapter<>(fut -> {
      scan(args, fut);
    }));
  }

  
Redis command scard.

Params:
  • arg0 – 
  • handler – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/scard">scard</a>.
   * @param arg0 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI scard(String arg0, Handler<AsyncResult<io.vertx.rxjava.redis.client.Response>> handler) { 
    delegate.scard(arg0, new Handler<AsyncResult<io.vertx.redis.client.Response>>() {
      public void handle(AsyncResult<io.vertx.redis.client.Response> ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

  
Redis command scard.

Params:
  • arg0 – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/scard">scard</a>.
   * @param arg0 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI scard(String arg0) {
    return 
scard(arg0, ar -> { });
  }

    
Redis command scard.

Params:
  • arg0 – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/scard">scard</a>.
   * @param arg0 
   * @return fluent self
   */
  public Single<io.vertx.rxjava.redis.client.Response> rxScard(String arg0) { 
    return Single.create(new SingleOnSubscribeAdapter<>(fut -> {
      scard(arg0, fut);
    }));
  }

  
Redis command script.

Params:
  • args – 
  • handler – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/script">script</a>.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI script(List<String> args, Handler<AsyncResult<io.vertx.rxjava.redis.client.Response>> handler) { 
    delegate.script(args, new Handler<AsyncResult<io.vertx.redis.client.Response>>() {
      public void handle(AsyncResult<io.vertx.redis.client.Response> ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

  
Redis command script.

Params:
  • args – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/script">script</a>.
   * @param args 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI script(List<String> args) {
    return 
script(args, ar -> { });
  }

    
Redis command script.

Params:
  • args – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/script">script</a>.
   * @param args 
   * @return fluent self
   */
  public Single<io.vertx.rxjava.redis.client.Response> rxScript(List<String> args) { 
    return Single.create(new SingleOnSubscribeAdapter<>(fut -> {
      script(args, fut);
    }));
  }

  
Redis command sdiff.

Params:
  • args – 
  • handler – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/sdiff">sdiff</a>.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI sdiff(List<String> args, Handler<AsyncResult<io.vertx.rxjava.redis.client.Response>> handler) { 
    delegate.sdiff(args, new Handler<AsyncResult<io.vertx.redis.client.Response>>() {
      public void handle(AsyncResult<io.vertx.redis.client.Response> ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

  
Redis command sdiff.

Params:
  • args – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/sdiff">sdiff</a>.
   * @param args 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI sdiff(List<String> args) {
    return 
sdiff(args, ar -> { });
  }

    
Redis command sdiff.

Params:
  • args – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/sdiff">sdiff</a>.
   * @param args 
   * @return fluent self
   */
  public Single<io.vertx.rxjava.redis.client.Response> rxSdiff(List<String> args) { 
    return Single.create(new SingleOnSubscribeAdapter<>(fut -> {
      sdiff(args, fut);
    }));
  }

  
Redis command sdiffstore.

Params:
  • args – 
  • handler – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/sdiffstore">sdiffstore</a>.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI sdiffstore(List<String> args, Handler<AsyncResult<io.vertx.rxjava.redis.client.Response>> handler) { 
    delegate.sdiffstore(args, new Handler<AsyncResult<io.vertx.redis.client.Response>>() {
      public void handle(AsyncResult<io.vertx.redis.client.Response> ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

  
Redis command sdiffstore.

Params:
  • args – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/sdiffstore">sdiffstore</a>.
   * @param args 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI sdiffstore(List<String> args) {
    return 
sdiffstore(args, ar -> { });
  }

    
Redis command sdiffstore.

Params:
  • args – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/sdiffstore">sdiffstore</a>.
   * @param args 
   * @return fluent self
   */
  public Single<io.vertx.rxjava.redis.client.Response> rxSdiffstore(List<String> args) { 
    return Single.create(new SingleOnSubscribeAdapter<>(fut -> {
      sdiffstore(args, fut);
    }));
  }

  
Redis command select.

Params:
  • arg0 – 
  • handler – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/select">select</a>.
   * @param arg0 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI select(String arg0, Handler<AsyncResult<io.vertx.rxjava.redis.client.Response>> handler) { 
    delegate.select(arg0, new Handler<AsyncResult<io.vertx.redis.client.Response>>() {
      public void handle(AsyncResult<io.vertx.redis.client.Response> ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

  
Redis command select.

Params:
  • arg0 – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/select">select</a>.
   * @param arg0 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI select(String arg0) {
    return 
select(arg0, ar -> { });
  }

    
Redis command select.

Params:
  • arg0 – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/select">select</a>.
   * @param arg0 
   * @return fluent self
   */
  public Single<io.vertx.rxjava.redis.client.Response> rxSelect(String arg0) { 
    return Single.create(new SingleOnSubscribeAdapter<>(fut -> {
      select(arg0, fut);
    }));
  }

  
Redis command set.

Params:
  • args – 
  • handler – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/set">set</a>.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI set(List<String> args, Handler<AsyncResult<io.vertx.rxjava.redis.client.Response>> handler) { 
    delegate.set(args, new Handler<AsyncResult<io.vertx.redis.client.Response>>() {
      public void handle(AsyncResult<io.vertx.redis.client.Response> ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

  
Redis command set.

Params:
  • args – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/set">set</a>.
   * @param args 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI set(List<String> args) {
    return 
set(args, ar -> { });
  }

    
Redis command set.

Params:
  • args – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/set">set</a>.
   * @param args 
   * @return fluent self
   */
  public Single<io.vertx.rxjava.redis.client.Response> rxSet(List<String> args) { 
    return Single.create(new SingleOnSubscribeAdapter<>(fut -> {
      set(args, fut);
    }));
  }

  
Redis command setbit.

Params:
  • arg0 – 
  • arg1 – 
  • arg2 – 
  • handler – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/setbit">setbit</a>.
   * @param arg0 
   * @param arg1 
   * @param arg2 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI setbit(String arg0, String arg1, String arg2, Handler<AsyncResult<io.vertx.rxjava.redis.client.Response>> handler) { 
    delegate.setbit(arg0, arg1, arg2, new Handler<AsyncResult<io.vertx.redis.client.Response>>() {
      public void handle(AsyncResult<io.vertx.redis.client.Response> ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

  
Redis command setbit.

Params:
  • arg0 – 
  • arg1 – 
  • arg2 – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/setbit">setbit</a>.
   * @param arg0 
   * @param arg1 
   * @param arg2 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI setbit(String arg0, String arg1, String arg2) {
    return 
setbit(arg0, arg1, arg2, ar -> { });
  }

    
Redis command setbit.

Params:
  • arg0 – 
  • arg1 – 
  • arg2 – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/setbit">setbit</a>.
   * @param arg0 
   * @param arg1 
   * @param arg2 
   * @return fluent self
   */
  public Single<io.vertx.rxjava.redis.client.Response> rxSetbit(String arg0, String arg1, String arg2) { 
    return Single.create(new SingleOnSubscribeAdapter<>(fut -> {
      setbit(arg0, arg1, arg2, fut);
    }));
  }

  
Redis command setex.

Params:
  • arg0 – 
  • arg1 – 
  • arg2 – 
  • handler – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/setex">setex</a>.
   * @param arg0 
   * @param arg1 
   * @param arg2 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI setex(String arg0, String arg1, String arg2, Handler<AsyncResult<io.vertx.rxjava.redis.client.Response>> handler) { 
    delegate.setex(arg0, arg1, arg2, new Handler<AsyncResult<io.vertx.redis.client.Response>>() {
      public void handle(AsyncResult<io.vertx.redis.client.Response> ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

  
Redis command setex.

Params:
  • arg0 – 
  • arg1 – 
  • arg2 – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/setex">setex</a>.
   * @param arg0 
   * @param arg1 
   * @param arg2 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI setex(String arg0, String arg1, String arg2) {
    return 
setex(arg0, arg1, arg2, ar -> { });
  }

    
Redis command setex.

Params:
  • arg0 – 
  • arg1 – 
  • arg2 – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/setex">setex</a>.
   * @param arg0 
   * @param arg1 
   * @param arg2 
   * @return fluent self
   */
  public Single<io.vertx.rxjava.redis.client.Response> rxSetex(String arg0, String arg1, String arg2) { 
    return Single.create(new SingleOnSubscribeAdapter<>(fut -> {
      setex(arg0, arg1, arg2, fut);
    }));
  }

  
Redis command setnx.

Params:
  • arg0 – 
  • arg1 – 
  • handler – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/setnx">setnx</a>.
   * @param arg0 
   * @param arg1 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI setnx(String arg0, String arg1, Handler<AsyncResult<io.vertx.rxjava.redis.client.Response>> handler) { 
    delegate.setnx(arg0, arg1, new Handler<AsyncResult<io.vertx.redis.client.Response>>() {
      public void handle(AsyncResult<io.vertx.redis.client.Response> ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

  
Redis command setnx.

Params:
  • arg0 – 
  • arg1 – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/setnx">setnx</a>.
   * @param arg0 
   * @param arg1 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI setnx(String arg0, String arg1) {
    return 
setnx(arg0, arg1, ar -> { });
  }

    
Redis command setnx.

Params:
  • arg0 – 
  • arg1 – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/setnx">setnx</a>.
   * @param arg0 
   * @param arg1 
   * @return fluent self
   */
  public Single<io.vertx.rxjava.redis.client.Response> rxSetnx(String arg0, String arg1) { 
    return Single.create(new SingleOnSubscribeAdapter<>(fut -> {
      setnx(arg0, arg1, fut);
    }));
  }

  
Redis command setrange.

Params:
  • arg0 – 
  • arg1 – 
  • arg2 – 
  • handler – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/setrange">setrange</a>.
   * @param arg0 
   * @param arg1 
   * @param arg2 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI setrange(String arg0, String arg1, String arg2, Handler<AsyncResult<io.vertx.rxjava.redis.client.Response>> handler) { 
    delegate.setrange(arg0, arg1, arg2, new Handler<AsyncResult<io.vertx.redis.client.Response>>() {
      public void handle(AsyncResult<io.vertx.redis.client.Response> ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

  
Redis command setrange.

Params:
  • arg0 – 
  • arg1 – 
  • arg2 – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/setrange">setrange</a>.
   * @param arg0 
   * @param arg1 
   * @param arg2 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI setrange(String arg0, String arg1, String arg2) {
    return 
setrange(arg0, arg1, arg2, ar -> { });
  }

    
Redis command setrange.

Params:
  • arg0 – 
  • arg1 – 
  • arg2 – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/setrange">setrange</a>.
   * @param arg0 
   * @param arg1 
   * @param arg2 
   * @return fluent self
   */
  public Single<io.vertx.rxjava.redis.client.Response> rxSetrange(String arg0, String arg1, String arg2) { 
    return Single.create(new SingleOnSubscribeAdapter<>(fut -> {
      setrange(arg0, arg1, arg2, fut);
    }));
  }

  
Redis command shutdown.

Params:
  • args – 
  • handler – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/shutdown">shutdown</a>.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI shutdown(List<String> args, Handler<AsyncResult<io.vertx.rxjava.redis.client.Response>> handler) { 
    delegate.shutdown(args, new Handler<AsyncResult<io.vertx.redis.client.Response>>() {
      public void handle(AsyncResult<io.vertx.redis.client.Response> ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

  
Redis command shutdown.

Params:
  • args – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/shutdown">shutdown</a>.
   * @param args 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI shutdown(List<String> args) {
    return 
shutdown(args, ar -> { });
  }

    
Redis command shutdown.

Params:
  • args – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/shutdown">shutdown</a>.
   * @param args 
   * @return fluent self
   */
  public Single<io.vertx.rxjava.redis.client.Response> rxShutdown(List<String> args) { 
    return Single.create(new SingleOnSubscribeAdapter<>(fut -> {
      shutdown(args, fut);
    }));
  }

  
Redis command sinter.

Params:
  • args – 
  • handler – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/sinter">sinter</a>.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI sinter(List<String> args, Handler<AsyncResult<io.vertx.rxjava.redis.client.Response>> handler) { 
    delegate.sinter(args, new Handler<AsyncResult<io.vertx.redis.client.Response>>() {
      public void handle(AsyncResult<io.vertx.redis.client.Response> ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

  
Redis command sinter.

Params:
  • args – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/sinter">sinter</a>.
   * @param args 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI sinter(List<String> args) {
    return 
sinter(args, ar -> { });
  }

    
Redis command sinter.

Params:
  • args – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/sinter">sinter</a>.
   * @param args 
   * @return fluent self
   */
  public Single<io.vertx.rxjava.redis.client.Response> rxSinter(List<String> args) { 
    return Single.create(new SingleOnSubscribeAdapter<>(fut -> {
      sinter(args, fut);
    }));
  }

  
Redis command sinterstore.

Params:
  • args – 
  • handler – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/sinterstore">sinterstore</a>.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI sinterstore(List<String> args, Handler<AsyncResult<io.vertx.rxjava.redis.client.Response>> handler) { 
    delegate.sinterstore(args, new Handler<AsyncResult<io.vertx.redis.client.Response>>() {
      public void handle(AsyncResult<io.vertx.redis.client.Response> ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

  
Redis command sinterstore.

Params:
  • args – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/sinterstore">sinterstore</a>.
   * @param args 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI sinterstore(List<String> args) {
    return 
sinterstore(args, ar -> { });
  }

    
Redis command sinterstore.

Params:
  • args – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/sinterstore">sinterstore</a>.
   * @param args 
   * @return fluent self
   */
  public Single<io.vertx.rxjava.redis.client.Response> rxSinterstore(List<String> args) { 
    return Single.create(new SingleOnSubscribeAdapter<>(fut -> {
      sinterstore(args, fut);
    }));
  }

  
Redis command sismember.

Params:
  • arg0 – 
  • arg1 – 
  • handler – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/sismember">sismember</a>.
   * @param arg0 
   * @param arg1 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI sismember(String arg0, String arg1, Handler<AsyncResult<io.vertx.rxjava.redis.client.Response>> handler) { 
    delegate.sismember(arg0, arg1, new Handler<AsyncResult<io.vertx.redis.client.Response>>() {
      public void handle(AsyncResult<io.vertx.redis.client.Response> ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

  
Redis command sismember.

Params:
  • arg0 – 
  • arg1 – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/sismember">sismember</a>.
   * @param arg0 
   * @param arg1 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI sismember(String arg0, String arg1) {
    return 
sismember(arg0, arg1, ar -> { });
  }

    
Redis command sismember.

Params:
  • arg0 – 
  • arg1 – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/sismember">sismember</a>.
   * @param arg0 
   * @param arg1 
   * @return fluent self
   */
  public Single<io.vertx.rxjava.redis.client.Response> rxSismember(String arg0, String arg1) { 
    return Single.create(new SingleOnSubscribeAdapter<>(fut -> {
      sismember(arg0, arg1, fut);
    }));
  }

  
Redis command slaveof.

Params:
  • arg0 – 
  • arg1 – 
  • handler – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/slaveof">slaveof</a>.
   * @param arg0 
   * @param arg1 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI slaveof(String arg0, String arg1, Handler<AsyncResult<io.vertx.rxjava.redis.client.Response>> handler) { 
    delegate.slaveof(arg0, arg1, new Handler<AsyncResult<io.vertx.redis.client.Response>>() {
      public void handle(AsyncResult<io.vertx.redis.client.Response> ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

  
Redis command slaveof.

Params:
  • arg0 – 
  • arg1 – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/slaveof">slaveof</a>.
   * @param arg0 
   * @param arg1 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI slaveof(String arg0, String arg1) {
    return 
slaveof(arg0, arg1, ar -> { });
  }

    
Redis command slaveof.

Params:
  • arg0 – 
  • arg1 – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/slaveof">slaveof</a>.
   * @param arg0 
   * @param arg1 
   * @return fluent self
   */
  public Single<io.vertx.rxjava.redis.client.Response> rxSlaveof(String arg0, String arg1) { 
    return Single.create(new SingleOnSubscribeAdapter<>(fut -> {
      slaveof(arg0, arg1, fut);
    }));
  }

  
Redis command slowlog.

Params:
  • args – 
  • handler – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/slowlog">slowlog</a>.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI slowlog(List<String> args, Handler<AsyncResult<io.vertx.rxjava.redis.client.Response>> handler) { 
    delegate.slowlog(args, new Handler<AsyncResult<io.vertx.redis.client.Response>>() {
      public void handle(AsyncResult<io.vertx.redis.client.Response> ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

  
Redis command slowlog.

Params:
  • args – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/slowlog">slowlog</a>.
   * @param args 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI slowlog(List<String> args) {
    return 
slowlog(args, ar -> { });
  }

    
Redis command slowlog.

Params:
  • args – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/slowlog">slowlog</a>.
   * @param args 
   * @return fluent self
   */
  public Single<io.vertx.rxjava.redis.client.Response> rxSlowlog(List<String> args) { 
    return Single.create(new SingleOnSubscribeAdapter<>(fut -> {
      slowlog(args, fut);
    }));
  }

  
Redis command smembers.

Params:
  • arg0 – 
  • handler – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/smembers">smembers</a>.
   * @param arg0 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI smembers(String arg0, Handler<AsyncResult<io.vertx.rxjava.redis.client.Response>> handler) { 
    delegate.smembers(arg0, new Handler<AsyncResult<io.vertx.redis.client.Response>>() {
      public void handle(AsyncResult<io.vertx.redis.client.Response> ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

  
Redis command smembers.

Params:
  • arg0 – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/smembers">smembers</a>.
   * @param arg0 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI smembers(String arg0) {
    return 
smembers(arg0, ar -> { });
  }

    
Redis command smembers.

Params:
  • arg0 – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/smembers">smembers</a>.
   * @param arg0 
   * @return fluent self
   */
  public Single<io.vertx.rxjava.redis.client.Response> rxSmembers(String arg0) { 
    return Single.create(new SingleOnSubscribeAdapter<>(fut -> {
      smembers(arg0, fut);
    }));
  }

  
Redis command smove.

Params:
  • arg0 – 
  • arg1 – 
  • arg2 – 
  • handler – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/smove">smove</a>.
   * @param arg0 
   * @param arg1 
   * @param arg2 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI smove(String arg0, String arg1, String arg2, Handler<AsyncResult<io.vertx.rxjava.redis.client.Response>> handler) { 
    delegate.smove(arg0, arg1, arg2, new Handler<AsyncResult<io.vertx.redis.client.Response>>() {
      public void handle(AsyncResult<io.vertx.redis.client.Response> ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

  
Redis command smove.

Params:
  • arg0 – 
  • arg1 – 
  • arg2 – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/smove">smove</a>.
   * @param arg0 
   * @param arg1 
   * @param arg2 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI smove(String arg0, String arg1, String arg2) {
    return 
smove(arg0, arg1, arg2, ar -> { });
  }

    
Redis command smove.

Params:
  • arg0 – 
  • arg1 – 
  • arg2 – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/smove">smove</a>.
   * @param arg0 
   * @param arg1 
   * @param arg2 
   * @return fluent self
   */
  public Single<io.vertx.rxjava.redis.client.Response> rxSmove(String arg0, String arg1, String arg2) { 
    return Single.create(new SingleOnSubscribeAdapter<>(fut -> {
      smove(arg0, arg1, arg2, fut);
    }));
  }

  
Redis command sort.

Params:
  • args – 
  • handler – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/sort">sort</a>.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI sort(List<String> args, Handler<AsyncResult<io.vertx.rxjava.redis.client.Response>> handler) { 
    delegate.sort(args, new Handler<AsyncResult<io.vertx.redis.client.Response>>() {
      public void handle(AsyncResult<io.vertx.redis.client.Response> ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

  
Redis command sort.

Params:
  • args – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/sort">sort</a>.
   * @param args 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI sort(List<String> args) {
    return 
sort(args, ar -> { });
  }

    
Redis command sort.

Params:
  • args – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/sort">sort</a>.
   * @param args 
   * @return fluent self
   */
  public Single<io.vertx.rxjava.redis.client.Response> rxSort(List<String> args) { 
    return Single.create(new SingleOnSubscribeAdapter<>(fut -> {
      sort(args, fut);
    }));
  }

  
Redis command spop.

Params:
  • args – 
  • handler – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/spop">spop</a>.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI spop(List<String> args, Handler<AsyncResult<io.vertx.rxjava.redis.client.Response>> handler) { 
    delegate.spop(args, new Handler<AsyncResult<io.vertx.redis.client.Response>>() {
      public void handle(AsyncResult<io.vertx.redis.client.Response> ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

  
Redis command spop.

Params:
  • args – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/spop">spop</a>.
   * @param args 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI spop(List<String> args) {
    return 
spop(args, ar -> { });
  }

    
Redis command spop.

Params:
  • args – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/spop">spop</a>.
   * @param args 
   * @return fluent self
   */
  public Single<io.vertx.rxjava.redis.client.Response> rxSpop(List<String> args) { 
    return Single.create(new SingleOnSubscribeAdapter<>(fut -> {
      spop(args, fut);
    }));
  }

  
Redis command srandmember.

Params:
  • args – 
  • handler – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/srandmember">srandmember</a>.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI srandmember(List<String> args, Handler<AsyncResult<io.vertx.rxjava.redis.client.Response>> handler) { 
    delegate.srandmember(args, new Handler<AsyncResult<io.vertx.redis.client.Response>>() {
      public void handle(AsyncResult<io.vertx.redis.client.Response> ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

  
Redis command srandmember.

Params:
  • args – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/srandmember">srandmember</a>.
   * @param args 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI srandmember(List<String> args) {
    return 
srandmember(args, ar -> { });
  }

    
Redis command srandmember.

Params:
  • args – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/srandmember">srandmember</a>.
   * @param args 
   * @return fluent self
   */
  public Single<io.vertx.rxjava.redis.client.Response> rxSrandmember(List<String> args) { 
    return Single.create(new SingleOnSubscribeAdapter<>(fut -> {
      srandmember(args, fut);
    }));
  }

  
Redis command srem.

Params:
  • args – 
  • handler – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/srem">srem</a>.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI srem(List<String> args, Handler<AsyncResult<io.vertx.rxjava.redis.client.Response>> handler) { 
    delegate.srem(args, new Handler<AsyncResult<io.vertx.redis.client.Response>>() {
      public void handle(AsyncResult<io.vertx.redis.client.Response> ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

  
Redis command srem.

Params:
  • args – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/srem">srem</a>.
   * @param args 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI srem(List<String> args) {
    return 
srem(args, ar -> { });
  }

    
Redis command srem.

Params:
  • args – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/srem">srem</a>.
   * @param args 
   * @return fluent self
   */
  public Single<io.vertx.rxjava.redis.client.Response> rxSrem(List<String> args) { 
    return Single.create(new SingleOnSubscribeAdapter<>(fut -> {
      srem(args, fut);
    }));
  }

  
Redis command sscan.

Params:
  • args – 
  • handler – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/sscan">sscan</a>.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI sscan(List<String> args, Handler<AsyncResult<io.vertx.rxjava.redis.client.Response>> handler) { 
    delegate.sscan(args, new Handler<AsyncResult<io.vertx.redis.client.Response>>() {
      public void handle(AsyncResult<io.vertx.redis.client.Response> ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

  
Redis command sscan.

Params:
  • args – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/sscan">sscan</a>.
   * @param args 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI sscan(List<String> args) {
    return 
sscan(args, ar -> { });
  }

    
Redis command sscan.

Params:
  • args – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/sscan">sscan</a>.
   * @param args 
   * @return fluent self
   */
  public Single<io.vertx.rxjava.redis.client.Response> rxSscan(List<String> args) { 
    return Single.create(new SingleOnSubscribeAdapter<>(fut -> {
      sscan(args, fut);
    }));
  }

  
Redis command stralgo.

Params:
  • args – 
  • handler – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/stralgo">stralgo</a>.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI stralgo(List<String> args, Handler<AsyncResult<io.vertx.rxjava.redis.client.Response>> handler) { 
    delegate.stralgo(args, new Handler<AsyncResult<io.vertx.redis.client.Response>>() {
      public void handle(AsyncResult<io.vertx.redis.client.Response> ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

  
Redis command stralgo.

Params:
  • args – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/stralgo">stralgo</a>.
   * @param args 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI stralgo(List<String> args) {
    return 
stralgo(args, ar -> { });
  }

    
Redis command stralgo.

Params:
  • args – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/stralgo">stralgo</a>.
   * @param args 
   * @return fluent self
   */
  public Single<io.vertx.rxjava.redis.client.Response> rxStralgo(List<String> args) { 
    return Single.create(new SingleOnSubscribeAdapter<>(fut -> {
      stralgo(args, fut);
    }));
  }

  
Redis command strlen.

Params:
  • arg0 – 
  • handler – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/strlen">strlen</a>.
   * @param arg0 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI strlen(String arg0, Handler<AsyncResult<io.vertx.rxjava.redis.client.Response>> handler) { 
    delegate.strlen(arg0, new Handler<AsyncResult<io.vertx.redis.client.Response>>() {
      public void handle(AsyncResult<io.vertx.redis.client.Response> ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

  
Redis command strlen.

Params:
  • arg0 – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/strlen">strlen</a>.
   * @param arg0 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI strlen(String arg0) {
    return 
strlen(arg0, ar -> { });
  }

    
Redis command strlen.

Params:
  • arg0 – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/strlen">strlen</a>.
   * @param arg0 
   * @return fluent self
   */
  public Single<io.vertx.rxjava.redis.client.Response> rxStrlen(String arg0) { 
    return Single.create(new SingleOnSubscribeAdapter<>(fut -> {
      strlen(arg0, fut);
    }));
  }

  
Redis command subscribe.

Params:
  • args – 
  • handler – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/subscribe">subscribe</a>.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI subscribe(List<String> args, Handler<AsyncResult<io.vertx.rxjava.redis.client.Response>> handler) { 
    delegate.subscribe(args, new Handler<AsyncResult<io.vertx.redis.client.Response>>() {
      public void handle(AsyncResult<io.vertx.redis.client.Response> ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

  
Redis command subscribe.

Params:
  • args – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/subscribe">subscribe</a>.
   * @param args 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI subscribe(List<String> args) {
    return 
subscribe(args, ar -> { });
  }

    
Redis command subscribe.

Params:
  • args – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/subscribe">subscribe</a>.
   * @param args 
   * @return fluent self
   */
  public Single<io.vertx.rxjava.redis.client.Response> rxSubscribe(List<String> args) { 
    return Single.create(new SingleOnSubscribeAdapter<>(fut -> {
      subscribe(args, fut);
    }));
  }

  
Redis command substr.

Params:
  • arg0 – 
  • arg1 – 
  • arg2 – 
  • handler – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/substr">substr</a>.
   * @param arg0 
   * @param arg1 
   * @param arg2 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI substr(String arg0, String arg1, String arg2, Handler<AsyncResult<io.vertx.rxjava.redis.client.Response>> handler) { 
    delegate.substr(arg0, arg1, arg2, new Handler<AsyncResult<io.vertx.redis.client.Response>>() {
      public void handle(AsyncResult<io.vertx.redis.client.Response> ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

  
Redis command substr.

Params:
  • arg0 – 
  • arg1 – 
  • arg2 – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/substr">substr</a>.
   * @param arg0 
   * @param arg1 
   * @param arg2 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI substr(String arg0, String arg1, String arg2) {
    return 
substr(arg0, arg1, arg2, ar -> { });
  }

    
Redis command substr.

Params:
  • arg0 – 
  • arg1 – 
  • arg2 – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/substr">substr</a>.
   * @param arg0 
   * @param arg1 
   * @param arg2 
   * @return fluent self
   */
  public Single<io.vertx.rxjava.redis.client.Response> rxSubstr(String arg0, String arg1, String arg2) { 
    return Single.create(new SingleOnSubscribeAdapter<>(fut -> {
      substr(arg0, arg1, arg2, fut);
    }));
  }

  
Redis command sunion.

Params:
  • args – 
  • handler – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/sunion">sunion</a>.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI sunion(List<String> args, Handler<AsyncResult<io.vertx.rxjava.redis.client.Response>> handler) { 
    delegate.sunion(args, new Handler<AsyncResult<io.vertx.redis.client.Response>>() {
      public void handle(AsyncResult<io.vertx.redis.client.Response> ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

  
Redis command sunion.

Params:
  • args – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/sunion">sunion</a>.
   * @param args 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI sunion(List<String> args) {
    return 
sunion(args, ar -> { });
  }

    
Redis command sunion.

Params:
  • args – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/sunion">sunion</a>.
   * @param args 
   * @return fluent self
   */
  public Single<io.vertx.rxjava.redis.client.Response> rxSunion(List<String> args) { 
    return Single.create(new SingleOnSubscribeAdapter<>(fut -> {
      sunion(args, fut);
    }));
  }

  
Redis command sunionstore.

Params:
  • args – 
  • handler – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/sunionstore">sunionstore</a>.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI sunionstore(List<String> args, Handler<AsyncResult<io.vertx.rxjava.redis.client.Response>> handler) { 
    delegate.sunionstore(args, new Handler<AsyncResult<io.vertx.redis.client.Response>>() {
      public void handle(AsyncResult<io.vertx.redis.client.Response> ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

  
Redis command sunionstore.

Params:
  • args – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/sunionstore">sunionstore</a>.
   * @param args 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI sunionstore(List<String> args) {
    return 
sunionstore(args, ar -> { });
  }

    
Redis command sunionstore.

Params:
  • args – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/sunionstore">sunionstore</a>.
   * @param args 
   * @return fluent self
   */
  public Single<io.vertx.rxjava.redis.client.Response> rxSunionstore(List<String> args) { 
    return Single.create(new SingleOnSubscribeAdapter<>(fut -> {
      sunionstore(args, fut);
    }));
  }

  
Redis command swapdb.

Params:
  • arg0 – 
  • arg1 – 
  • handler – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/swapdb">swapdb</a>.
   * @param arg0 
   * @param arg1 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI swapdb(String arg0, String arg1, Handler<AsyncResult<io.vertx.rxjava.redis.client.Response>> handler) { 
    delegate.swapdb(arg0, arg1, new Handler<AsyncResult<io.vertx.redis.client.Response>>() {
      public void handle(AsyncResult<io.vertx.redis.client.Response> ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

  
Redis command swapdb.

Params:
  • arg0 – 
  • arg1 – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/swapdb">swapdb</a>.
   * @param arg0 
   * @param arg1 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI swapdb(String arg0, String arg1) {
    return 
swapdb(arg0, arg1, ar -> { });
  }

    
Redis command swapdb.

Params:
  • arg0 – 
  • arg1 – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/swapdb">swapdb</a>.
   * @param arg0 
   * @param arg1 
   * @return fluent self
   */
  public Single<io.vertx.rxjava.redis.client.Response> rxSwapdb(String arg0, String arg1) { 
    return Single.create(new SingleOnSubscribeAdapter<>(fut -> {
      swapdb(arg0, arg1, fut);
    }));
  }

  
Redis command sync.

Params:
  • handler – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/sync">sync</a>.
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI sync(Handler<AsyncResult<io.vertx.rxjava.redis.client.Response>> handler) { 
    delegate.sync(new Handler<AsyncResult<io.vertx.redis.client.Response>>() {
      public void handle(AsyncResult<io.vertx.redis.client.Response> ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

  
Redis command sync.

Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/sync">sync</a>.
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI sync() {
    return 
sync(ar -> { });
  }

    
Redis command sync.

Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/sync">sync</a>.
   * @return fluent self
   */
  public Single<io.vertx.rxjava.redis.client.Response> rxSync() { 
    return Single.create(new SingleOnSubscribeAdapter<>(fut -> {
      sync(fut);
    }));
  }

  
Redis command time.

Params:
  • handler – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/time">time</a>.
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI time(Handler<AsyncResult<io.vertx.rxjava.redis.client.Response>> handler) { 
    delegate.time(new Handler<AsyncResult<io.vertx.redis.client.Response>>() {
      public void handle(AsyncResult<io.vertx.redis.client.Response> ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

  
Redis command time.

Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/time">time</a>.
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI time() {
    return 
time(ar -> { });
  }

    
Redis command time.

Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/time">time</a>.
   * @return fluent self
   */
  public Single<io.vertx.rxjava.redis.client.Response> rxTime() { 
    return Single.create(new SingleOnSubscribeAdapter<>(fut -> {
      time(fut);
    }));
  }

  
Redis command touch.

Params:
  • args – 
  • handler – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/touch">touch</a>.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI touch(List<String> args, Handler<AsyncResult<io.vertx.rxjava.redis.client.Response>> handler) { 
    delegate.touch(args, new Handler<AsyncResult<io.vertx.redis.client.Response>>() {
      public void handle(AsyncResult<io.vertx.redis.client.Response> ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

  
Redis command touch.

Params:
  • args – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/touch">touch</a>.
   * @param args 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI touch(List<String> args) {
    return 
touch(args, ar -> { });
  }

    
Redis command touch.

Params:
  • args – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/touch">touch</a>.
   * @param args 
   * @return fluent self
   */
  public Single<io.vertx.rxjava.redis.client.Response> rxTouch(List<String> args) { 
    return Single.create(new SingleOnSubscribeAdapter<>(fut -> {
      touch(args, fut);
    }));
  }

  
Redis command ttl.

Params:
  • arg0 – 
  • handler – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/ttl">ttl</a>.
   * @param arg0 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI ttl(String arg0, Handler<AsyncResult<io.vertx.rxjava.redis.client.Response>> handler) { 
    delegate.ttl(arg0, new Handler<AsyncResult<io.vertx.redis.client.Response>>() {
      public void handle(AsyncResult<io.vertx.redis.client.Response> ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

  
Redis command ttl.

Params:
  • arg0 – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/ttl">ttl</a>.
   * @param arg0 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI ttl(String arg0) {
    return 
ttl(arg0, ar -> { });
  }

    
Redis command ttl.

Params:
  • arg0 – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/ttl">ttl</a>.
   * @param arg0 
   * @return fluent self
   */
  public Single<io.vertx.rxjava.redis.client.Response> rxTtl(String arg0) { 
    return Single.create(new SingleOnSubscribeAdapter<>(fut -> {
      ttl(arg0, fut);
    }));
  }

  
Redis command type.

Params:
  • arg0 – 
  • handler – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/type">type</a>.
   * @param arg0 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI type(String arg0, Handler<AsyncResult<io.vertx.rxjava.redis.client.Response>> handler) { 
    delegate.type(arg0, new Handler<AsyncResult<io.vertx.redis.client.Response>>() {
      public void handle(AsyncResult<io.vertx.redis.client.Response> ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

  
Redis command type.

Params:
  • arg0 – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/type">type</a>.
   * @param arg0 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI type(String arg0) {
    return 
type(arg0, ar -> { });
  }

    
Redis command type.

Params:
  • arg0 – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/type">type</a>.
   * @param arg0 
   * @return fluent self
   */
  public Single<io.vertx.rxjava.redis.client.Response> rxType(String arg0) { 
    return Single.create(new SingleOnSubscribeAdapter<>(fut -> {
      type(arg0, fut);
    }));
  }

  
Redis command unlink.

Params:
  • args – 
  • handler – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/unlink">unlink</a>.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI unlink(List<String> args, Handler<AsyncResult<io.vertx.rxjava.redis.client.Response>> handler) { 
    delegate.unlink(args, new Handler<AsyncResult<io.vertx.redis.client.Response>>() {
      public void handle(AsyncResult<io.vertx.redis.client.Response> ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

  
Redis command unlink.

Params:
  • args – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/unlink">unlink</a>.
   * @param args 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI unlink(List<String> args) {
    return 
unlink(args, ar -> { });
  }

    
Redis command unlink.

Params:
  • args – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/unlink">unlink</a>.
   * @param args 
   * @return fluent self
   */
  public Single<io.vertx.rxjava.redis.client.Response> rxUnlink(List<String> args) { 
    return Single.create(new SingleOnSubscribeAdapter<>(fut -> {
      unlink(args, fut);
    }));
  }

  
Redis command unsubscribe.

Params:
  • args – 
  • handler – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/unsubscribe">unsubscribe</a>.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI unsubscribe(List<String> args, Handler<AsyncResult<io.vertx.rxjava.redis.client.Response>> handler) { 
    delegate.unsubscribe(args, new Handler<AsyncResult<io.vertx.redis.client.Response>>() {
      public void handle(AsyncResult<io.vertx.redis.client.Response> ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

  
Redis command unsubscribe.

Params:
  • args – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/unsubscribe">unsubscribe</a>.
   * @param args 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI unsubscribe(List<String> args) {
    return 
unsubscribe(args, ar -> { });
  }

    
Redis command unsubscribe.

Params:
  • args – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/unsubscribe">unsubscribe</a>.
   * @param args 
   * @return fluent self
   */
  public Single<io.vertx.rxjava.redis.client.Response> rxUnsubscribe(List<String> args) { 
    return Single.create(new SingleOnSubscribeAdapter<>(fut -> {
      unsubscribe(args, fut);
    }));
  }

  
Redis command unwatch.

Params:
  • handler – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/unwatch">unwatch</a>.
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI unwatch(Handler<AsyncResult<io.vertx.rxjava.redis.client.Response>> handler) { 
    delegate.unwatch(new Handler<AsyncResult<io.vertx.redis.client.Response>>() {
      public void handle(AsyncResult<io.vertx.redis.client.Response> ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

  
Redis command unwatch.

Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/unwatch">unwatch</a>.
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI unwatch() {
    return 
unwatch(ar -> { });
  }

    
Redis command unwatch.

Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/unwatch">unwatch</a>.
   * @return fluent self
   */
  public Single<io.vertx.rxjava.redis.client.Response> rxUnwatch() { 
    return Single.create(new SingleOnSubscribeAdapter<>(fut -> {
      unwatch(fut);
    }));
  }

  
Redis command wait.

Params:
  • arg0 – 
  • arg1 – 
  • handler – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/wait">wait</a>.
   * @param arg0 
   * @param arg1 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI wait(String arg0, String arg1, Handler<AsyncResult<io.vertx.rxjava.redis.client.Response>> handler) { 
    delegate.wait(arg0, arg1, new Handler<AsyncResult<io.vertx.redis.client.Response>>() {
      public void handle(AsyncResult<io.vertx.redis.client.Response> ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

  
Redis command wait.

Params:
  • arg0 – 
  • arg1 – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/wait">wait</a>.
   * @param arg0 
   * @param arg1 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI wait(String arg0, String arg1) {
    return 
wait(arg0, arg1, ar -> { });
  }

    
Redis command wait.

Params:
  • arg0 – 
  • arg1 – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/wait">wait</a>.
   * @param arg0 
   * @param arg1 
   * @return fluent self
   */
  public Single<io.vertx.rxjava.redis.client.Response> rxWait(String arg0, String arg1) { 
    return Single.create(new SingleOnSubscribeAdapter<>(fut -> {
      wait(arg0, arg1, fut);
    }));
  }

  
Redis command watch.

Params:
  • args – 
  • handler – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/watch">watch</a>.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI watch(List<String> args, Handler<AsyncResult<io.vertx.rxjava.redis.client.Response>> handler) { 
    delegate.watch(args, new Handler<AsyncResult<io.vertx.redis.client.Response>>() {
      public void handle(AsyncResult<io.vertx.redis.client.Response> ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

  
Redis command watch.

Params:
  • args – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/watch">watch</a>.
   * @param args 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI watch(List<String> args) {
    return 
watch(args, ar -> { });
  }

    
Redis command watch.

Params:
  • args – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/watch">watch</a>.
   * @param args 
   * @return fluent self
   */
  public Single<io.vertx.rxjava.redis.client.Response> rxWatch(List<String> args) { 
    return Single.create(new SingleOnSubscribeAdapter<>(fut -> {
      watch(args, fut);
    }));
  }

  
Redis command xack.

Params:
  • args – 
  • handler – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/xack">xack</a>.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI xack(List<String> args, Handler<AsyncResult<io.vertx.rxjava.redis.client.Response>> handler) { 
    delegate.xack(args, new Handler<AsyncResult<io.vertx.redis.client.Response>>() {
      public void handle(AsyncResult<io.vertx.redis.client.Response> ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

  
Redis command xack.

Params:
  • args – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/xack">xack</a>.
   * @param args 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI xack(List<String> args) {
    return 
xack(args, ar -> { });
  }

    
Redis command xack.

Params:
  • args – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/xack">xack</a>.
   * @param args 
   * @return fluent self
   */
  public Single<io.vertx.rxjava.redis.client.Response> rxXack(List<String> args) { 
    return Single.create(new SingleOnSubscribeAdapter<>(fut -> {
      xack(args, fut);
    }));
  }

  
Redis command xadd.

Params:
  • args – 
  • handler – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/xadd">xadd</a>.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI xadd(List<String> args, Handler<AsyncResult<io.vertx.rxjava.redis.client.Response>> handler) { 
    delegate.xadd(args, new Handler<AsyncResult<io.vertx.redis.client.Response>>() {
      public void handle(AsyncResult<io.vertx.redis.client.Response> ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

  
Redis command xadd.

Params:
  • args – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/xadd">xadd</a>.
   * @param args 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI xadd(List<String> args) {
    return 
xadd(args, ar -> { });
  }

    
Redis command xadd.

Params:
  • args – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/xadd">xadd</a>.
   * @param args 
   * @return fluent self
   */
  public Single<io.vertx.rxjava.redis.client.Response> rxXadd(List<String> args) { 
    return Single.create(new SingleOnSubscribeAdapter<>(fut -> {
      xadd(args, fut);
    }));
  }

  
Redis command xclaim.

Params:
  • args – 
  • handler – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/xclaim">xclaim</a>.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI xclaim(List<String> args, Handler<AsyncResult<io.vertx.rxjava.redis.client.Response>> handler) { 
    delegate.xclaim(args, new Handler<AsyncResult<io.vertx.redis.client.Response>>() {
      public void handle(AsyncResult<io.vertx.redis.client.Response> ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

  
Redis command xclaim.

Params:
  • args – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/xclaim">xclaim</a>.
   * @param args 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI xclaim(List<String> args) {
    return 
xclaim(args, ar -> { });
  }

    
Redis command xclaim.

Params:
  • args – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/xclaim">xclaim</a>.
   * @param args 
   * @return fluent self
   */
  public Single<io.vertx.rxjava.redis.client.Response> rxXclaim(List<String> args) { 
    return Single.create(new SingleOnSubscribeAdapter<>(fut -> {
      xclaim(args, fut);
    }));
  }

  
Redis command xdel.

Params:
  • args – 
  • handler – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/xdel">xdel</a>.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI xdel(List<String> args, Handler<AsyncResult<io.vertx.rxjava.redis.client.Response>> handler) { 
    delegate.xdel(args, new Handler<AsyncResult<io.vertx.redis.client.Response>>() {
      public void handle(AsyncResult<io.vertx.redis.client.Response> ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

  
Redis command xdel.

Params:
  • args – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/xdel">xdel</a>.
   * @param args 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI xdel(List<String> args) {
    return 
xdel(args, ar -> { });
  }

    
Redis command xdel.

Params:
  • args – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/xdel">xdel</a>.
   * @param args 
   * @return fluent self
   */
  public Single<io.vertx.rxjava.redis.client.Response> rxXdel(List<String> args) { 
    return Single.create(new SingleOnSubscribeAdapter<>(fut -> {
      xdel(args, fut);
    }));
  }

  
Redis command xgroup.

Params:
  • args – 
  • handler – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/xgroup">xgroup</a>.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI xgroup(List<String> args, Handler<AsyncResult<io.vertx.rxjava.redis.client.Response>> handler) { 
    delegate.xgroup(args, new Handler<AsyncResult<io.vertx.redis.client.Response>>() {
      public void handle(AsyncResult<io.vertx.redis.client.Response> ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

  
Redis command xgroup.

Params:
  • args – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/xgroup">xgroup</a>.
   * @param args 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI xgroup(List<String> args) {
    return 
xgroup(args, ar -> { });
  }

    
Redis command xgroup.

Params:
  • args – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/xgroup">xgroup</a>.
   * @param args 
   * @return fluent self
   */
  public Single<io.vertx.rxjava.redis.client.Response> rxXgroup(List<String> args) { 
    return Single.create(new SingleOnSubscribeAdapter<>(fut -> {
      xgroup(args, fut);
    }));
  }

  
Redis command xinfo.

Params:
  • args – 
  • handler – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/xinfo">xinfo</a>.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI xinfo(List<String> args, Handler<AsyncResult<io.vertx.rxjava.redis.client.Response>> handler) { 
    delegate.xinfo(args, new Handler<AsyncResult<io.vertx.redis.client.Response>>() {
      public void handle(AsyncResult<io.vertx.redis.client.Response> ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

  
Redis command xinfo.

Params:
  • args – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/xinfo">xinfo</a>.
   * @param args 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI xinfo(List<String> args) {
    return 
xinfo(args, ar -> { });
  }

    
Redis command xinfo.

Params:
  • args – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/xinfo">xinfo</a>.
   * @param args 
   * @return fluent self
   */
  public Single<io.vertx.rxjava.redis.client.Response> rxXinfo(List<String> args) { 
    return Single.create(new SingleOnSubscribeAdapter<>(fut -> {
      xinfo(args, fut);
    }));
  }

  
Redis command xlen.

Params:
  • arg0 – 
  • handler – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/xlen">xlen</a>.
   * @param arg0 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI xlen(String arg0, Handler<AsyncResult<io.vertx.rxjava.redis.client.Response>> handler) { 
    delegate.xlen(arg0, new Handler<AsyncResult<io.vertx.redis.client.Response>>() {
      public void handle(AsyncResult<io.vertx.redis.client.Response> ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

  
Redis command xlen.

Params:
  • arg0 – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/xlen">xlen</a>.
   * @param arg0 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI xlen(String arg0) {
    return 
xlen(arg0, ar -> { });
  }

    
Redis command xlen.

Params:
  • arg0 – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/xlen">xlen</a>.
   * @param arg0 
   * @return fluent self
   */
  public Single<io.vertx.rxjava.redis.client.Response> rxXlen(String arg0) { 
    return Single.create(new SingleOnSubscribeAdapter<>(fut -> {
      xlen(arg0, fut);
    }));
  }

  
Redis command xpending.

Params:
  • args – 
  • handler – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/xpending">xpending</a>.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI xpending(List<String> args, Handler<AsyncResult<io.vertx.rxjava.redis.client.Response>> handler) { 
    delegate.xpending(args, new Handler<AsyncResult<io.vertx.redis.client.Response>>() {
      public void handle(AsyncResult<io.vertx.redis.client.Response> ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

  
Redis command xpending.

Params:
  • args – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/xpending">xpending</a>.
   * @param args 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI xpending(List<String> args) {
    return 
xpending(args, ar -> { });
  }

    
Redis command xpending.

Params:
  • args – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/xpending">xpending</a>.
   * @param args 
   * @return fluent self
   */
  public Single<io.vertx.rxjava.redis.client.Response> rxXpending(List<String> args) { 
    return Single.create(new SingleOnSubscribeAdapter<>(fut -> {
      xpending(args, fut);
    }));
  }

  
Redis command xrange.

Params:
  • args – 
  • handler – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/xrange">xrange</a>.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI xrange(List<String> args, Handler<AsyncResult<io.vertx.rxjava.redis.client.Response>> handler) { 
    delegate.xrange(args, new Handler<AsyncResult<io.vertx.redis.client.Response>>() {
      public void handle(AsyncResult<io.vertx.redis.client.Response> ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

  
Redis command xrange.

Params:
  • args – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/xrange">xrange</a>.
   * @param args 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI xrange(List<String> args) {
    return 
xrange(args, ar -> { });
  }

    
Redis command xrange.

Params:
  • args – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/xrange">xrange</a>.
   * @param args 
   * @return fluent self
   */
  public Single<io.vertx.rxjava.redis.client.Response> rxXrange(List<String> args) { 
    return Single.create(new SingleOnSubscribeAdapter<>(fut -> {
      xrange(args, fut);
    }));
  }

  
Redis command xread.

Params:
  • args – 
  • handler – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/xread">xread</a>.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI xread(List<String> args, Handler<AsyncResult<io.vertx.rxjava.redis.client.Response>> handler) { 
    delegate.xread(args, new Handler<AsyncResult<io.vertx.redis.client.Response>>() {
      public void handle(AsyncResult<io.vertx.redis.client.Response> ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

  
Redis command xread.

Params:
  • args – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/xread">xread</a>.
   * @param args 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI xread(List<String> args) {
    return 
xread(args, ar -> { });
  }

    
Redis command xread.

Params:
  • args – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/xread">xread</a>.
   * @param args 
   * @return fluent self
   */
  public Single<io.vertx.rxjava.redis.client.Response> rxXread(List<String> args) { 
    return Single.create(new SingleOnSubscribeAdapter<>(fut -> {
      xread(args, fut);
    }));
  }

  
Redis command xreadgroup.

Params:
  • args – 
  • handler – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/xreadgroup">xreadgroup</a>.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI xreadgroup(List<String> args, Handler<AsyncResult<io.vertx.rxjava.redis.client.Response>> handler) { 
    delegate.xreadgroup(args, new Handler<AsyncResult<io.vertx.redis.client.Response>>() {
      public void handle(AsyncResult<io.vertx.redis.client.Response> ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

  
Redis command xreadgroup.

Params:
  • args – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/xreadgroup">xreadgroup</a>.
   * @param args 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI xreadgroup(List<String> args) {
    return 
xreadgroup(args, ar -> { });
  }

    
Redis command xreadgroup.

Params:
  • args – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/xreadgroup">xreadgroup</a>.
   * @param args 
   * @return fluent self
   */
  public Single<io.vertx.rxjava.redis.client.Response> rxXreadgroup(List<String> args) { 
    return Single.create(new SingleOnSubscribeAdapter<>(fut -> {
      xreadgroup(args, fut);
    }));
  }

  
Redis command xrevrange.

Params:
  • args – 
  • handler – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/xrevrange">xrevrange</a>.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI xrevrange(List<String> args, Handler<AsyncResult<io.vertx.rxjava.redis.client.Response>> handler) { 
    delegate.xrevrange(args, new Handler<AsyncResult<io.vertx.redis.client.Response>>() {
      public void handle(AsyncResult<io.vertx.redis.client.Response> ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

  
Redis command xrevrange.

Params:
  • args – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/xrevrange">xrevrange</a>.
   * @param args 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI xrevrange(List<String> args) {
    return 
xrevrange(args, ar -> { });
  }

    
Redis command xrevrange.

Params:
  • args – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/xrevrange">xrevrange</a>.
   * @param args 
   * @return fluent self
   */
  public Single<io.vertx.rxjava.redis.client.Response> rxXrevrange(List<String> args) { 
    return Single.create(new SingleOnSubscribeAdapter<>(fut -> {
      xrevrange(args, fut);
    }));
  }

  
Redis command xsetid.

Params:
  • arg0 – 
  • arg1 – 
  • handler – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/xsetid">xsetid</a>.
   * @param arg0 
   * @param arg1 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI xsetid(String arg0, String arg1, Handler<AsyncResult<io.vertx.rxjava.redis.client.Response>> handler) { 
    delegate.xsetid(arg0, arg1, new Handler<AsyncResult<io.vertx.redis.client.Response>>() {
      public void handle(AsyncResult<io.vertx.redis.client.Response> ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

  
Redis command xsetid.

Params:
  • arg0 – 
  • arg1 – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/xsetid">xsetid</a>.
   * @param arg0 
   * @param arg1 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI xsetid(String arg0, String arg1) {
    return 
xsetid(arg0, arg1, ar -> { });
  }

    
Redis command xsetid.

Params:
  • arg0 – 
  • arg1 – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/xsetid">xsetid</a>.
   * @param arg0 
   * @param arg1 
   * @return fluent self
   */
  public Single<io.vertx.rxjava.redis.client.Response> rxXsetid(String arg0, String arg1) { 
    return Single.create(new SingleOnSubscribeAdapter<>(fut -> {
      xsetid(arg0, arg1, fut);
    }));
  }

  
Redis command xtrim.

Params:
  • args – 
  • handler – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/xtrim">xtrim</a>.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI xtrim(List<String> args, Handler<AsyncResult<io.vertx.rxjava.redis.client.Response>> handler) { 
    delegate.xtrim(args, new Handler<AsyncResult<io.vertx.redis.client.Response>>() {
      public void handle(AsyncResult<io.vertx.redis.client.Response> ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

  
Redis command xtrim.

Params:
  • args – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/xtrim">xtrim</a>.
   * @param args 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI xtrim(List<String> args) {
    return 
xtrim(args, ar -> { });
  }

    
Redis command xtrim.

Params:
  • args – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/xtrim">xtrim</a>.
   * @param args 
   * @return fluent self
   */
  public Single<io.vertx.rxjava.redis.client.Response> rxXtrim(List<String> args) { 
    return Single.create(new SingleOnSubscribeAdapter<>(fut -> {
      xtrim(args, fut);
    }));
  }

  
Redis command zadd.

Params:
  • args – 
  • handler – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/zadd">zadd</a>.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI zadd(List<String> args, Handler<AsyncResult<io.vertx.rxjava.redis.client.Response>> handler) { 
    delegate.zadd(args, new Handler<AsyncResult<io.vertx.redis.client.Response>>() {
      public void handle(AsyncResult<io.vertx.redis.client.Response> ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

  
Redis command zadd.

Params:
  • args – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/zadd">zadd</a>.
   * @param args 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI zadd(List<String> args) {
    return 
zadd(args, ar -> { });
  }

    
Redis command zadd.

Params:
  • args – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/zadd">zadd</a>.
   * @param args 
   * @return fluent self
   */
  public Single<io.vertx.rxjava.redis.client.Response> rxZadd(List<String> args) { 
    return Single.create(new SingleOnSubscribeAdapter<>(fut -> {
      zadd(args, fut);
    }));
  }

  
Redis command zcard.

Params:
  • arg0 – 
  • handler – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/zcard">zcard</a>.
   * @param arg0 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI zcard(String arg0, Handler<AsyncResult<io.vertx.rxjava.redis.client.Response>> handler) { 
    delegate.zcard(arg0, new Handler<AsyncResult<io.vertx.redis.client.Response>>() {
      public void handle(AsyncResult<io.vertx.redis.client.Response> ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

  
Redis command zcard.

Params:
  • arg0 – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/zcard">zcard</a>.
   * @param arg0 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI zcard(String arg0) {
    return 
zcard(arg0, ar -> { });
  }

    
Redis command zcard.

Params:
  • arg0 – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/zcard">zcard</a>.
   * @param arg0 
   * @return fluent self
   */
  public Single<io.vertx.rxjava.redis.client.Response> rxZcard(String arg0) { 
    return Single.create(new SingleOnSubscribeAdapter<>(fut -> {
      zcard(arg0, fut);
    }));
  }

  
Redis command zcount.

Params:
  • arg0 – 
  • arg1 – 
  • arg2 – 
  • handler – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/zcount">zcount</a>.
   * @param arg0 
   * @param arg1 
   * @param arg2 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI zcount(String arg0, String arg1, String arg2, Handler<AsyncResult<io.vertx.rxjava.redis.client.Response>> handler) { 
    delegate.zcount(arg0, arg1, arg2, new Handler<AsyncResult<io.vertx.redis.client.Response>>() {
      public void handle(AsyncResult<io.vertx.redis.client.Response> ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

  
Redis command zcount.

Params:
  • arg0 – 
  • arg1 – 
  • arg2 – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/zcount">zcount</a>.
   * @param arg0 
   * @param arg1 
   * @param arg2 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI zcount(String arg0, String arg1, String arg2) {
    return 
zcount(arg0, arg1, arg2, ar -> { });
  }

    
Redis command zcount.

Params:
  • arg0 – 
  • arg1 – 
  • arg2 – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/zcount">zcount</a>.
   * @param arg0 
   * @param arg1 
   * @param arg2 
   * @return fluent self
   */
  public Single<io.vertx.rxjava.redis.client.Response> rxZcount(String arg0, String arg1, String arg2) { 
    return Single.create(new SingleOnSubscribeAdapter<>(fut -> {
      zcount(arg0, arg1, arg2, fut);
    }));
  }

  
Redis command zincrby.

Params:
  • arg0 – 
  • arg1 – 
  • arg2 – 
  • handler – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/zincrby">zincrby</a>.
   * @param arg0 
   * @param arg1 
   * @param arg2 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI zincrby(String arg0, String arg1, String arg2, Handler<AsyncResult<io.vertx.rxjava.redis.client.Response>> handler) { 
    delegate.zincrby(arg0, arg1, arg2, new Handler<AsyncResult<io.vertx.redis.client.Response>>() {
      public void handle(AsyncResult<io.vertx.redis.client.Response> ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

  
Redis command zincrby.

Params:
  • arg0 – 
  • arg1 – 
  • arg2 – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/zincrby">zincrby</a>.
   * @param arg0 
   * @param arg1 
   * @param arg2 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI zincrby(String arg0, String arg1, String arg2) {
    return 
zincrby(arg0, arg1, arg2, ar -> { });
  }

    
Redis command zincrby.

Params:
  • arg0 – 
  • arg1 – 
  • arg2 – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/zincrby">zincrby</a>.
   * @param arg0 
   * @param arg1 
   * @param arg2 
   * @return fluent self
   */
  public Single<io.vertx.rxjava.redis.client.Response> rxZincrby(String arg0, String arg1, String arg2) { 
    return Single.create(new SingleOnSubscribeAdapter<>(fut -> {
      zincrby(arg0, arg1, arg2, fut);
    }));
  }

  
Redis command zinterstore.

Params:
  • args – 
  • handler – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/zinterstore">zinterstore</a>.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI zinterstore(List<String> args, Handler<AsyncResult<io.vertx.rxjava.redis.client.Response>> handler) { 
    delegate.zinterstore(args, new Handler<AsyncResult<io.vertx.redis.client.Response>>() {
      public void handle(AsyncResult<io.vertx.redis.client.Response> ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

  
Redis command zinterstore.

Params:
  • args – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/zinterstore">zinterstore</a>.
   * @param args 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI zinterstore(List<String> args) {
    return 
zinterstore(args, ar -> { });
  }

    
Redis command zinterstore.

Params:
  • args – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/zinterstore">zinterstore</a>.
   * @param args 
   * @return fluent self
   */
  public Single<io.vertx.rxjava.redis.client.Response> rxZinterstore(List<String> args) { 
    return Single.create(new SingleOnSubscribeAdapter<>(fut -> {
      zinterstore(args, fut);
    }));
  }

  
Redis command zlexcount.

Params:
  • arg0 – 
  • arg1 – 
  • arg2 – 
  • handler – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/zlexcount">zlexcount</a>.
   * @param arg0 
   * @param arg1 
   * @param arg2 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI zlexcount(String arg0, String arg1, String arg2, Handler<AsyncResult<io.vertx.rxjava.redis.client.Response>> handler) { 
    delegate.zlexcount(arg0, arg1, arg2, new Handler<AsyncResult<io.vertx.redis.client.Response>>() {
      public void handle(AsyncResult<io.vertx.redis.client.Response> ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

  
Redis command zlexcount.

Params:
  • arg0 – 
  • arg1 – 
  • arg2 – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/zlexcount">zlexcount</a>.
   * @param arg0 
   * @param arg1 
   * @param arg2 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI zlexcount(String arg0, String arg1, String arg2) {
    return 
zlexcount(arg0, arg1, arg2, ar -> { });
  }

    
Redis command zlexcount.

Params:
  • arg0 – 
  • arg1 – 
  • arg2 – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/zlexcount">zlexcount</a>.
   * @param arg0 
   * @param arg1 
   * @param arg2 
   * @return fluent self
   */
  public Single<io.vertx.rxjava.redis.client.Response> rxZlexcount(String arg0, String arg1, String arg2) { 
    return Single.create(new SingleOnSubscribeAdapter<>(fut -> {
      zlexcount(arg0, arg1, arg2, fut);
    }));
  }

  
Redis command zpopmax.

Params:
  • args – 
  • handler – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/zpopmax">zpopmax</a>.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI zpopmax(List<String> args, Handler<AsyncResult<io.vertx.rxjava.redis.client.Response>> handler) { 
    delegate.zpopmax(args, new Handler<AsyncResult<io.vertx.redis.client.Response>>() {
      public void handle(AsyncResult<io.vertx.redis.client.Response> ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

  
Redis command zpopmax.

Params:
  • args – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/zpopmax">zpopmax</a>.
   * @param args 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI zpopmax(List<String> args) {
    return 
zpopmax(args, ar -> { });
  }

    
Redis command zpopmax.

Params:
  • args – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/zpopmax">zpopmax</a>.
   * @param args 
   * @return fluent self
   */
  public Single<io.vertx.rxjava.redis.client.Response> rxZpopmax(List<String> args) { 
    return Single.create(new SingleOnSubscribeAdapter<>(fut -> {
      zpopmax(args, fut);
    }));
  }

  
Redis command zpopmin.

Params:
  • args – 
  • handler – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/zpopmin">zpopmin</a>.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI zpopmin(List<String> args, Handler<AsyncResult<io.vertx.rxjava.redis.client.Response>> handler) { 
    delegate.zpopmin(args, new Handler<AsyncResult<io.vertx.redis.client.Response>>() {
      public void handle(AsyncResult<io.vertx.redis.client.Response> ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

  
Redis command zpopmin.

Params:
  • args – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/zpopmin">zpopmin</a>.
   * @param args 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI zpopmin(List<String> args) {
    return 
zpopmin(args, ar -> { });
  }

    
Redis command zpopmin.

Params:
  • args – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/zpopmin">zpopmin</a>.
   * @param args 
   * @return fluent self
   */
  public Single<io.vertx.rxjava.redis.client.Response> rxZpopmin(List<String> args) { 
    return Single.create(new SingleOnSubscribeAdapter<>(fut -> {
      zpopmin(args, fut);
    }));
  }

  
Redis command zrange.

Params:
  • args – 
  • handler – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/zrange">zrange</a>.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI zrange(List<String> args, Handler<AsyncResult<io.vertx.rxjava.redis.client.Response>> handler) { 
    delegate.zrange(args, new Handler<AsyncResult<io.vertx.redis.client.Response>>() {
      public void handle(AsyncResult<io.vertx.redis.client.Response> ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

  
Redis command zrange.

Params:
  • args – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/zrange">zrange</a>.
   * @param args 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI zrange(List<String> args) {
    return 
zrange(args, ar -> { });
  }

    
Redis command zrange.

Params:
  • args – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/zrange">zrange</a>.
   * @param args 
   * @return fluent self
   */
  public Single<io.vertx.rxjava.redis.client.Response> rxZrange(List<String> args) { 
    return Single.create(new SingleOnSubscribeAdapter<>(fut -> {
      zrange(args, fut);
    }));
  }

  
Redis command zrangebylex.

Params:
  • args – 
  • handler – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/zrangebylex">zrangebylex</a>.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI zrangebylex(List<String> args, Handler<AsyncResult<io.vertx.rxjava.redis.client.Response>> handler) { 
    delegate.zrangebylex(args, new Handler<AsyncResult<io.vertx.redis.client.Response>>() {
      public void handle(AsyncResult<io.vertx.redis.client.Response> ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

  
Redis command zrangebylex.

Params:
  • args – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/zrangebylex">zrangebylex</a>.
   * @param args 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI zrangebylex(List<String> args) {
    return 
zrangebylex(args, ar -> { });
  }

    
Redis command zrangebylex.

Params:
  • args – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/zrangebylex">zrangebylex</a>.
   * @param args 
   * @return fluent self
   */
  public Single<io.vertx.rxjava.redis.client.Response> rxZrangebylex(List<String> args) { 
    return Single.create(new SingleOnSubscribeAdapter<>(fut -> {
      zrangebylex(args, fut);
    }));
  }

  
Redis command zrangebyscore.

Params:
  • args – 
  • handler – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/zrangebyscore">zrangebyscore</a>.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI zrangebyscore(List<String> args, Handler<AsyncResult<io.vertx.rxjava.redis.client.Response>> handler) { 
    delegate.zrangebyscore(args, new Handler<AsyncResult<io.vertx.redis.client.Response>>() {
      public void handle(AsyncResult<io.vertx.redis.client.Response> ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

  
Redis command zrangebyscore.

Params:
  • args – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/zrangebyscore">zrangebyscore</a>.
   * @param args 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI zrangebyscore(List<String> args) {
    return 
zrangebyscore(args, ar -> { });
  }

    
Redis command zrangebyscore.

Params:
  • args – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/zrangebyscore">zrangebyscore</a>.
   * @param args 
   * @return fluent self
   */
  public Single<io.vertx.rxjava.redis.client.Response> rxZrangebyscore(List<String> args) { 
    return Single.create(new SingleOnSubscribeAdapter<>(fut -> {
      zrangebyscore(args, fut);
    }));
  }

  
Redis command zrank.

Params:
  • arg0 – 
  • arg1 – 
  • handler – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/zrank">zrank</a>.
   * @param arg0 
   * @param arg1 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI zrank(String arg0, String arg1, Handler<AsyncResult<io.vertx.rxjava.redis.client.Response>> handler) { 
    delegate.zrank(arg0, arg1, new Handler<AsyncResult<io.vertx.redis.client.Response>>() {
      public void handle(AsyncResult<io.vertx.redis.client.Response> ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

  
Redis command zrank.

Params:
  • arg0 – 
  • arg1 – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/zrank">zrank</a>.
   * @param arg0 
   * @param arg1 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI zrank(String arg0, String arg1) {
    return 
zrank(arg0, arg1, ar -> { });
  }

    
Redis command zrank.

Params:
  • arg0 – 
  • arg1 – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/zrank">zrank</a>.
   * @param arg0 
   * @param arg1 
   * @return fluent self
   */
  public Single<io.vertx.rxjava.redis.client.Response> rxZrank(String arg0, String arg1) { 
    return Single.create(new SingleOnSubscribeAdapter<>(fut -> {
      zrank(arg0, arg1, fut);
    }));
  }

  
Redis command zrem.

Params:
  • args – 
  • handler – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/zrem">zrem</a>.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI zrem(List<String> args, Handler<AsyncResult<io.vertx.rxjava.redis.client.Response>> handler) { 
    delegate.zrem(args, new Handler<AsyncResult<io.vertx.redis.client.Response>>() {
      public void handle(AsyncResult<io.vertx.redis.client.Response> ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

  
Redis command zrem.

Params:
  • args – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/zrem">zrem</a>.
   * @param args 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI zrem(List<String> args) {
    return 
zrem(args, ar -> { });
  }

    
Redis command zrem.

Params:
  • args – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/zrem">zrem</a>.
   * @param args 
   * @return fluent self
   */
  public Single<io.vertx.rxjava.redis.client.Response> rxZrem(List<String> args) { 
    return Single.create(new SingleOnSubscribeAdapter<>(fut -> {
      zrem(args, fut);
    }));
  }

  
Redis command zremrangebylex.

Params:
  • arg0 – 
  • arg1 – 
  • arg2 – 
  • handler – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/zremrangebylex">zremrangebylex</a>.
   * @param arg0 
   * @param arg1 
   * @param arg2 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI zremrangebylex(String arg0, String arg1, String arg2, Handler<AsyncResult<io.vertx.rxjava.redis.client.Response>> handler) { 
    delegate.zremrangebylex(arg0, arg1, arg2, new Handler<AsyncResult<io.vertx.redis.client.Response>>() {
      public void handle(AsyncResult<io.vertx.redis.client.Response> ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

  
Redis command zremrangebylex.

Params:
  • arg0 – 
  • arg1 – 
  • arg2 – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/zremrangebylex">zremrangebylex</a>.
   * @param arg0 
   * @param arg1 
   * @param arg2 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI zremrangebylex(String arg0, String arg1, String arg2) {
    return 
zremrangebylex(arg0, arg1, arg2, ar -> { });
  }

    
Redis command zremrangebylex.

Params:
  • arg0 – 
  • arg1 – 
  • arg2 – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/zremrangebylex">zremrangebylex</a>.
   * @param arg0 
   * @param arg1 
   * @param arg2 
   * @return fluent self
   */
  public Single<io.vertx.rxjava.redis.client.Response> rxZremrangebylex(String arg0, String arg1, String arg2) { 
    return Single.create(new SingleOnSubscribeAdapter<>(fut -> {
      zremrangebylex(arg0, arg1, arg2, fut);
    }));
  }

  
Redis command zremrangebyrank.

Params:
  • arg0 – 
  • arg1 – 
  • arg2 – 
  • handler – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/zremrangebyrank">zremrangebyrank</a>.
   * @param arg0 
   * @param arg1 
   * @param arg2 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI zremrangebyrank(String arg0, String arg1, String arg2, Handler<AsyncResult<io.vertx.rxjava.redis.client.Response>> handler) { 
    delegate.zremrangebyrank(arg0, arg1, arg2, new Handler<AsyncResult<io.vertx.redis.client.Response>>() {
      public void handle(AsyncResult<io.vertx.redis.client.Response> ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

  
Redis command zremrangebyrank.

Params:
  • arg0 – 
  • arg1 – 
  • arg2 – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/zremrangebyrank">zremrangebyrank</a>.
   * @param arg0 
   * @param arg1 
   * @param arg2 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI zremrangebyrank(String arg0, String arg1, String arg2) {
    return 
zremrangebyrank(arg0, arg1, arg2, ar -> { });
  }

    
Redis command zremrangebyrank.

Params:
  • arg0 – 
  • arg1 – 
  • arg2 – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/zremrangebyrank">zremrangebyrank</a>.
   * @param arg0 
   * @param arg1 
   * @param arg2 
   * @return fluent self
   */
  public Single<io.vertx.rxjava.redis.client.Response> rxZremrangebyrank(String arg0, String arg1, String arg2) { 
    return Single.create(new SingleOnSubscribeAdapter<>(fut -> {
      zremrangebyrank(arg0, arg1, arg2, fut);
    }));
  }

  
Redis command zremrangebyscore.

Params:
  • arg0 – 
  • arg1 – 
  • arg2 – 
  • handler – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/zremrangebyscore">zremrangebyscore</a>.
   * @param arg0 
   * @param arg1 
   * @param arg2 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI zremrangebyscore(String arg0, String arg1, String arg2, Handler<AsyncResult<io.vertx.rxjava.redis.client.Response>> handler) { 
    delegate.zremrangebyscore(arg0, arg1, arg2, new Handler<AsyncResult<io.vertx.redis.client.Response>>() {
      public void handle(AsyncResult<io.vertx.redis.client.Response> ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

  
Redis command zremrangebyscore.

Params:
  • arg0 – 
  • arg1 – 
  • arg2 – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/zremrangebyscore">zremrangebyscore</a>.
   * @param arg0 
   * @param arg1 
   * @param arg2 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI zremrangebyscore(String arg0, String arg1, String arg2) {
    return 
zremrangebyscore(arg0, arg1, arg2, ar -> { });
  }

    
Redis command zremrangebyscore.

Params:
  • arg0 – 
  • arg1 – 
  • arg2 – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/zremrangebyscore">zremrangebyscore</a>.
   * @param arg0 
   * @param arg1 
   * @param arg2 
   * @return fluent self
   */
  public Single<io.vertx.rxjava.redis.client.Response> rxZremrangebyscore(String arg0, String arg1, String arg2) { 
    return Single.create(new SingleOnSubscribeAdapter<>(fut -> {
      zremrangebyscore(arg0, arg1, arg2, fut);
    }));
  }

  
Redis command zrevrange.

Params:
  • args – 
  • handler – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/zrevrange">zrevrange</a>.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI zrevrange(List<String> args, Handler<AsyncResult<io.vertx.rxjava.redis.client.Response>> handler) { 
    delegate.zrevrange(args, new Handler<AsyncResult<io.vertx.redis.client.Response>>() {
      public void handle(AsyncResult<io.vertx.redis.client.Response> ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

  
Redis command zrevrange.

Params:
  • args – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/zrevrange">zrevrange</a>.
   * @param args 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI zrevrange(List<String> args) {
    return 
zrevrange(args, ar -> { });
  }

    
Redis command zrevrange.

Params:
  • args – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/zrevrange">zrevrange</a>.
   * @param args 
   * @return fluent self
   */
  public Single<io.vertx.rxjava.redis.client.Response> rxZrevrange(List<String> args) { 
    return Single.create(new SingleOnSubscribeAdapter<>(fut -> {
      zrevrange(args, fut);
    }));
  }

  
Redis command zrevrangebylex.

Params:
  • args – 
  • handler – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/zrevrangebylex">zrevrangebylex</a>.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI zrevrangebylex(List<String> args, Handler<AsyncResult<io.vertx.rxjava.redis.client.Response>> handler) { 
    delegate.zrevrangebylex(args, new Handler<AsyncResult<io.vertx.redis.client.Response>>() {
      public void handle(AsyncResult<io.vertx.redis.client.Response> ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

  
Redis command zrevrangebylex.

Params:
  • args – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/zrevrangebylex">zrevrangebylex</a>.
   * @param args 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI zrevrangebylex(List<String> args) {
    return 
zrevrangebylex(args, ar -> { });
  }

    
Redis command zrevrangebylex.

Params:
  • args – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/zrevrangebylex">zrevrangebylex</a>.
   * @param args 
   * @return fluent self
   */
  public Single<io.vertx.rxjava.redis.client.Response> rxZrevrangebylex(List<String> args) { 
    return Single.create(new SingleOnSubscribeAdapter<>(fut -> {
      zrevrangebylex(args, fut);
    }));
  }

  
Redis command zrevrangebyscore.

Params:
  • args – 
  • handler – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/zrevrangebyscore">zrevrangebyscore</a>.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI zrevrangebyscore(List<String> args, Handler<AsyncResult<io.vertx.rxjava.redis.client.Response>> handler) { 
    delegate.zrevrangebyscore(args, new Handler<AsyncResult<io.vertx.redis.client.Response>>() {
      public void handle(AsyncResult<io.vertx.redis.client.Response> ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

  
Redis command zrevrangebyscore.

Params:
  • args – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/zrevrangebyscore">zrevrangebyscore</a>.
   * @param args 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI zrevrangebyscore(List<String> args) {
    return 
zrevrangebyscore(args, ar -> { });
  }

    
Redis command zrevrangebyscore.

Params:
  • args – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/zrevrangebyscore">zrevrangebyscore</a>.
   * @param args 
   * @return fluent self
   */
  public Single<io.vertx.rxjava.redis.client.Response> rxZrevrangebyscore(List<String> args) { 
    return Single.create(new SingleOnSubscribeAdapter<>(fut -> {
      zrevrangebyscore(args, fut);
    }));
  }

  
Redis command zrevrank.

Params:
  • arg0 – 
  • arg1 – 
  • handler – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/zrevrank">zrevrank</a>.
   * @param arg0 
   * @param arg1 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI zrevrank(String arg0, String arg1, Handler<AsyncResult<io.vertx.rxjava.redis.client.Response>> handler) { 
    delegate.zrevrank(arg0, arg1, new Handler<AsyncResult<io.vertx.redis.client.Response>>() {
      public void handle(AsyncResult<io.vertx.redis.client.Response> ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

  
Redis command zrevrank.

Params:
  • arg0 – 
  • arg1 – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/zrevrank">zrevrank</a>.
   * @param arg0 
   * @param arg1 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI zrevrank(String arg0, String arg1) {
    return 
zrevrank(arg0, arg1, ar -> { });
  }

    
Redis command zrevrank.

Params:
  • arg0 – 
  • arg1 – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/zrevrank">zrevrank</a>.
   * @param arg0 
   * @param arg1 
   * @return fluent self
   */
  public Single<io.vertx.rxjava.redis.client.Response> rxZrevrank(String arg0, String arg1) { 
    return Single.create(new SingleOnSubscribeAdapter<>(fut -> {
      zrevrank(arg0, arg1, fut);
    }));
  }

  
Redis command zscan.

Params:
  • args – 
  • handler – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/zscan">zscan</a>.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI zscan(List<String> args, Handler<AsyncResult<io.vertx.rxjava.redis.client.Response>> handler) { 
    delegate.zscan(args, new Handler<AsyncResult<io.vertx.redis.client.Response>>() {
      public void handle(AsyncResult<io.vertx.redis.client.Response> ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

  
Redis command zscan.

Params:
  • args – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/zscan">zscan</a>.
   * @param args 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI zscan(List<String> args) {
    return 
zscan(args, ar -> { });
  }

    
Redis command zscan.

Params:
  • args – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/zscan">zscan</a>.
   * @param args 
   * @return fluent self
   */
  public Single<io.vertx.rxjava.redis.client.Response> rxZscan(List<String> args) { 
    return Single.create(new SingleOnSubscribeAdapter<>(fut -> {
      zscan(args, fut);
    }));
  }

  
Redis command zscore.

Params:
  • arg0 – 
  • arg1 – 
  • handler – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/zscore">zscore</a>.
   * @param arg0 
   * @param arg1 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI zscore(String arg0, String arg1, Handler<AsyncResult<io.vertx.rxjava.redis.client.Response>> handler) { 
    delegate.zscore(arg0, arg1, new Handler<AsyncResult<io.vertx.redis.client.Response>>() {
      public void handle(AsyncResult<io.vertx.redis.client.Response> ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

  
Redis command zscore.

Params:
  • arg0 – 
  • arg1 – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/zscore">zscore</a>.
   * @param arg0 
   * @param arg1 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI zscore(String arg0, String arg1) {
    return 
zscore(arg0, arg1, ar -> { });
  }

    
Redis command zscore.

Params:
  • arg0 – 
  • arg1 – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/zscore">zscore</a>.
   * @param arg0 
   * @param arg1 
   * @return fluent self
   */
  public Single<io.vertx.rxjava.redis.client.Response> rxZscore(String arg0, String arg1) { 
    return Single.create(new SingleOnSubscribeAdapter<>(fut -> {
      zscore(arg0, arg1, fut);
    }));
  }

  
Redis command zunionstore.

Params:
  • args – 
  • handler – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/zunionstore">zunionstore</a>.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI zunionstore(List<String> args, Handler<AsyncResult<io.vertx.rxjava.redis.client.Response>> handler) { 
    delegate.zunionstore(args, new Handler<AsyncResult<io.vertx.redis.client.Response>>() {
      public void handle(AsyncResult<io.vertx.redis.client.Response> ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

  
Redis command zunionstore.

Params:
  • args – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/zunionstore">zunionstore</a>.
   * @param args 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI zunionstore(List<String> args) {
    return 
zunionstore(args, ar -> { });
  }

    
Redis command zunionstore.

Params:
  • args – 
Returns:fluent self
/**
   * Redis command <a href="https://redis.io/commands/zunionstore">zunionstore</a>.
   * @param args 
   * @return fluent self
   */
  public Single<io.vertx.rxjava.redis.client.Response> rxZunionstore(List<String> args) { 
    return Single.create(new SingleOnSubscribeAdapter<>(fut -> {
      zunionstore(args, fut);
    }));
  }

  public static io.vertx.rxjava.redis.client.RedisAPI api(io.vertx.rxjava.redis.client.Redis client) { 
    io.vertx.rxjava.redis.client.RedisAPI ret = io.vertx.rxjava.redis.client.RedisAPI.newInstance((io.vertx.redis.client.RedisAPI)io.vertx.redis.client.RedisAPI.api(client.getDelegate()));
    return ret;
  }

  public static io.vertx.rxjava.redis.client.RedisAPI api(io.vertx.rxjava.redis.client.RedisConnection connection) { 
    io.vertx.rxjava.redis.client.RedisAPI ret = io.vertx.rxjava.redis.client.RedisAPI.newInstance((io.vertx.redis.client.RedisAPI)io.vertx.redis.client.RedisAPI.api(connection.getDelegate()));
    return ret;
  }

  public static RedisAPI newInstance(io.vertx.redis.client.RedisAPI arg) {
    return arg != null ? new RedisAPI(arg) : null;
  }

}