/*
 * 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.rabbitmq;

import java.util.Map;
import rx.Observable;
import rx.Single;
import io.vertx.rabbitmq.RabbitMQOptions;
import io.vertx.core.json.JsonObject;
import io.vertx.rabbitmq.QueueOptions;
import io.vertx.core.AsyncResult;
import io.vertx.core.Handler;

 NOTE: This class has been automatically generated from the original non RX-ified interface using Vert.x codegen. /**
 *
 * <p/>
 * NOTE: This class has been automatically generated from the {@link io.vertx.rabbitmq.RabbitMQClient original} non RX-ified interface using Vert.x codegen.
 */

@io.vertx.lang.rx.RxGen(io.vertx.rabbitmq.RabbitMQClient.class)
public class RabbitMQClient {

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

  public static final io.vertx.lang.rx.TypeArg<RabbitMQClient> __TYPE_ARG = new io.vertx.lang.rx.TypeArg<>(    obj -> new RabbitMQClient((io.vertx.rabbitmq.RabbitMQClient) obj),
    RabbitMQClient::getDelegate
  );

  private final io.vertx.rabbitmq.RabbitMQClient delegate;
  
  public RabbitMQClient(io.vertx.rabbitmq.RabbitMQClient delegate) {
    this.delegate = delegate;
  }

  public io.vertx.rabbitmq.RabbitMQClient getDelegate() {
    return delegate;
  }

  
Create and return a client configured with the default options.
Params:
vertx – the vertx instance
Returns:
the client/**
   * Create and return a client configured with the default options.
   * @param vertx the vertx instance
   * @return the client
   */
  public static io.vertx.rxjava.rabbitmq.RabbitMQClient create(io.vertx.rxjava.core.Vertx vertx) { 
    io.vertx.rxjava.rabbitmq.RabbitMQClient ret = io.vertx.rxjava.rabbitmq.RabbitMQClient.newInstance(io.vertx.rabbitmq.RabbitMQClient.create(vertx.getDelegate()));
    return ret;
  }

  
Create and return a client.
Params:
vertx – the vertx instance
config – the client config
Returns:
the client/**
   * Create and return a client.
   * @param vertx the vertx instance
   * @param config the client config
   * @return the client
   */
  public static io.vertx.rxjava.rabbitmq.RabbitMQClient create(io.vertx.rxjava.core.Vertx vertx, RabbitMQOptions config) { 
    io.vertx.rxjava.rabbitmq.RabbitMQClient ret = io.vertx.rxjava.rabbitmq.RabbitMQClient.newInstance(io.vertx.rabbitmq.RabbitMQClient.create(vertx.getDelegate(), config));
    return ret;
  }

  
Acknowledge one or several received messages. Supply the deliveryTag from the AMQP.Basic.GetOk or AMQP.Basic.Deliver
method containing the received message being acknowledged.
Params:
deliveryTag – 
multiple – 
resultHandler – /**
   * Acknowledge one or several received messages. Supply the deliveryTag from the AMQP.Basic.GetOk or AMQP.Basic.Deliver
   * method containing the received message being acknowledged.
   * @param deliveryTag 
   * @param multiple 
   * @param resultHandler 
   */
  public void basicAck(long deliveryTag, boolean multiple, Handler<AsyncResult<JsonObject>> resultHandler) { 
    delegate.basicAck(deliveryTag, multiple, resultHandler);
  }

    
Acknowledge one or several received messages. Supply the deliveryTag from the AMQP.Basic.GetOk or AMQP.Basic.Deliver
method containing the received message being acknowledged.
Params:
deliveryTag – 
multiple – 
Returns:
Deprecated:
use rxBasicAck instead/**
   * Acknowledge one or several received messages. Supply the deliveryTag from the AMQP.Basic.GetOk or AMQP.Basic.Deliver
   * method containing the received message being acknowledged.
   * @param deliveryTag 
   * @param multiple 
   * @return 
   * @deprecated use {@link #rxBasicAck} instead
   */
  @Deprecated()
  public Observable<JsonObject> basicAckObservable(long deliveryTag, boolean multiple) { 
    io.vertx.rx.java.ObservableFuture<JsonObject> resultHandler = io.vertx.rx.java.RxHelper.observableFuture();
    basicAck(deliveryTag, multiple, resultHandler.toHandler());
    return resultHandler;
  }

  
Acknowledge one or several received messages. Supply the deliveryTag from the AMQP.Basic.GetOk or AMQP.Basic.Deliver
method containing the received message being acknowledged.
Params:
deliveryTag – 
multiple – 
Returns:
/**
   * Acknowledge one or several received messages. Supply the deliveryTag from the AMQP.Basic.GetOk or AMQP.Basic.Deliver
   * method containing the received message being acknowledged.
   * @param deliveryTag 
   * @param multiple 
   * @return 
   */
  public Single<JsonObject> rxBasicAck(long deliveryTag, boolean multiple) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      basicAck(deliveryTag, multiple, fut);
    }));
  }

  
Reject one or several received messages.
Params:
deliveryTag – 
multiple – 
requeue – 
resultHandler – /**
   * Reject one or several received messages.
   * @param deliveryTag 
   * @param multiple 
   * @param requeue 
   * @param resultHandler 
   */
  public void basicNack(long deliveryTag, boolean multiple, boolean requeue, Handler<AsyncResult<JsonObject>> resultHandler) { 
    delegate.basicNack(deliveryTag, multiple, requeue, resultHandler);
  }

    
Reject one or several received messages.
Params:
deliveryTag – 
multiple – 
requeue – 
Returns:
Deprecated:
use rxBasicNack instead/**
   * Reject one or several received messages.
   * @param deliveryTag 
   * @param multiple 
   * @param requeue 
   * @return 
   * @deprecated use {@link #rxBasicNack} instead
   */
  @Deprecated()
  public Observable<JsonObject> basicNackObservable(long deliveryTag, boolean multiple, boolean requeue) { 
    io.vertx.rx.java.ObservableFuture<JsonObject> resultHandler = io.vertx.rx.java.RxHelper.observableFuture();
    basicNack(deliveryTag, multiple, requeue, resultHandler.toHandler());
    return resultHandler;
  }

  
Reject one or several received messages.
Params:
deliveryTag – 
multiple – 
requeue – 
Returns:
/**
   * Reject one or several received messages.
   * @param deliveryTag 
   * @param multiple 
   * @param requeue 
   * @return 
   */
  public Single<JsonObject> rxBasicNack(long deliveryTag, boolean multiple, boolean requeue) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      basicNack(deliveryTag, multiple, requeue, fut);
    }));
  }

  
Retrieve a message from a queue using AMQP.Basic.Get
Params:
queue – 
autoAck – 
resultHandler – /**
   * Retrieve a message from a queue using AMQP.Basic.Get
   * @param queue 
   * @param autoAck 
   * @param resultHandler 
   */
  public void basicGet(String queue, boolean autoAck, Handler<AsyncResult<JsonObject>> resultHandler) { 
    delegate.basicGet(queue, autoAck, resultHandler);
  }

    
Retrieve a message from a queue using AMQP.Basic.Get
Params:
queue – 
autoAck – 
Returns:
Deprecated:
use rxBasicGet instead/**
   * Retrieve a message from a queue using AMQP.Basic.Get
   * @param queue 
   * @param autoAck 
   * @return 
   * @deprecated use {@link #rxBasicGet} instead
   */
  @Deprecated()
  public Observable<JsonObject> basicGetObservable(String queue, boolean autoAck) { 
    io.vertx.rx.java.ObservableFuture<JsonObject> resultHandler = io.vertx.rx.java.RxHelper.observableFuture();
    basicGet(queue, autoAck, resultHandler.toHandler());
    return resultHandler;
  }

  
Retrieve a message from a queue using AMQP.Basic.Get
Params:
queue – 
autoAck – 
Returns:
/**
   * Retrieve a message from a queue using AMQP.Basic.Get
   * @param queue 
   * @param autoAck 
   * @return 
   */
  public Single<JsonObject> rxBasicGet(String queue, boolean autoAck) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      basicGet(queue, autoAck, fut);
    }));
  }

  
Use basicConsumer instead 

Start a non-nolocal, non-exclusive consumer, with auto acknowledgement and a server-generated consumerTag.
Params:
queue – 
address – 
resultHandler – /**
   * Use {@link io.vertx.rxjava.rabbitmq.RabbitMQClient#basicConsumer} instead
   * <p>
   * Start a non-nolocal, non-exclusive consumer, with auto acknowledgement and a server-generated consumerTag.
   * @param queue 
   * @param address 
   * @param resultHandler 
   */
  @Deprecated()
  public void basicConsume(String queue, String address, Handler<AsyncResult<String>> resultHandler) { 
    delegate.basicConsume(queue, address, resultHandler);
  }

    
Use basicConsumer instead 

Start a non-nolocal, non-exclusive consumer, with auto acknowledgement and a server-generated consumerTag.
Params:
queue – 
address – 
Returns:
Deprecated:
use rxBasicConsume instead/**
   * Use {@link io.vertx.rxjava.rabbitmq.RabbitMQClient#basicConsumer} instead
   * <p>
   * Start a non-nolocal, non-exclusive consumer, with auto acknowledgement and a server-generated consumerTag.
   * @param queue 
   * @param address 
   * @return 
   * @deprecated use {@link #rxBasicConsume} instead
   */
  @Deprecated()
  public Observable<String> basicConsumeObservable(String queue, String address) { 
    io.vertx.rx.java.ObservableFuture<String> resultHandler = io.vertx.rx.java.RxHelper.observableFuture();
    basicConsume(queue, address, resultHandler.toHandler());
    return resultHandler;
  }

  
Use basicConsumer instead 

Start a non-nolocal, non-exclusive consumer, with auto acknowledgement and a server-generated consumerTag.
Params:
queue – 
address – 
Returns:
/**
   * Use {@link io.vertx.rxjava.rabbitmq.RabbitMQClient#basicConsumer} instead
   * <p>
   * Start a non-nolocal, non-exclusive consumer, with auto acknowledgement and a server-generated consumerTag.
   * @param queue 
   * @param address 
   * @return 
   */
  @Deprecated()
  public Single<String> rxBasicConsume(String queue, String address) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      basicConsume(queue, address, fut);
    }));
  }

  
Use basicConsumer instead 

Start a non-nolocal, non-exclusive consumer, with a server-generated consumerTag.
Params:
queue – 
address – 
autoAck – 
resultHandler – /**
   * Use {@link io.vertx.rxjava.rabbitmq.RabbitMQClient#basicConsumer} instead
   * <p>
   * Start a non-nolocal, non-exclusive consumer, with a server-generated consumerTag.
   * @param queue 
   * @param address 
   * @param autoAck 
   * @param resultHandler 
   */
  @Deprecated()
  public void basicConsume(String queue, String address, boolean autoAck, Handler<AsyncResult<String>> resultHandler) { 
    delegate.basicConsume(queue, address, autoAck, resultHandler);
  }

    
Use basicConsumer instead 

Start a non-nolocal, non-exclusive consumer, with a server-generated consumerTag.
Params:
queue – 
address – 
autoAck – 
Returns:
Deprecated:
use rxBasicConsume instead/**
   * Use {@link io.vertx.rxjava.rabbitmq.RabbitMQClient#basicConsumer} instead
   * <p>
   * Start a non-nolocal, non-exclusive consumer, with a server-generated consumerTag.
   * @param queue 
   * @param address 
   * @param autoAck 
   * @return 
   * @deprecated use {@link #rxBasicConsume} instead
   */
  @Deprecated()
  public Observable<String> basicConsumeObservable(String queue, String address, boolean autoAck) { 
    io.vertx.rx.java.ObservableFuture<String> resultHandler = io.vertx.rx.java.RxHelper.observableFuture();
    basicConsume(queue, address, autoAck, resultHandler.toHandler());
    return resultHandler;
  }

  
Use basicConsumer instead 

Start a non-nolocal, non-exclusive consumer, with a server-generated consumerTag.
Params:
queue – 
address – 
autoAck – 
Returns:
/**
   * Use {@link io.vertx.rxjava.rabbitmq.RabbitMQClient#basicConsumer} instead
   * <p>
   * Start a non-nolocal, non-exclusive consumer, with a server-generated consumerTag.
   * @param queue 
   * @param address 
   * @param autoAck 
   * @return 
   */
  @Deprecated()
  public Single<String> rxBasicConsume(String queue, String address, boolean autoAck) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      basicConsume(queue, address, autoAck, fut);
    }));
  }

  
Use basicConsumer instead 

Start a non-nolocal, non-exclusive consumer, with a server-generated consumerTag and error handler
Params:
queue – 
address – 
autoAck – 
resultHandler – 
errorHandler – /**
   * Use {@link io.vertx.rxjava.rabbitmq.RabbitMQClient#basicConsumer} instead
   * <p>
   * Start a non-nolocal, non-exclusive consumer, with a server-generated consumerTag and error handler
   * @param queue 
   * @param address 
   * @param autoAck 
   * @param resultHandler 
   * @param errorHandler 
   */
  @Deprecated()
  public void basicConsume(String queue, String address, boolean autoAck, Handler<AsyncResult<String>> resultHandler, Handler<Throwable> errorHandler) { 
    delegate.basicConsume(queue, address, autoAck, resultHandler, errorHandler);
  }

  
Instead of using this and basicConsume method, basicConsumer and RabbitMQConsumer.cancel instead 
 This method should be called when you want to cancel consumption from a queue, started by calling basicConsume. 
Params:
consumerTag – /**
   * Instead of using this and {@link io.vertx.rxjava.rabbitmq.RabbitMQClient#basicConsume} method,
   * {@link io.vertx.rxjava.rabbitmq.RabbitMQClient#basicConsumer} and {@link io.vertx.rxjava.rabbitmq.RabbitMQConsumer#cancel} instead
   * <p>
   * This method should be called when you want to cancel consumption from a queue,
   * started by calling {@link io.vertx.rxjava.rabbitmq.RabbitMQClient#basicConsume}.
   * @param consumerTag 
   */
  @Deprecated()
  public void basicCancel(String consumerTag) { 
    delegate.basicCancel(consumerTag);
  }

  
Instead of using this and basicConsume method, basicConsumer and RabbitMQConsumer.cancel instead 
 This method should be called when you want to cancel consumption from a queue, started by calling basicConsume. 
Params:
consumerTag – 
resultHandler – /**
   * Instead of using this and {@link io.vertx.rxjava.rabbitmq.RabbitMQClient#basicConsume} method,
   * {@link io.vertx.rxjava.rabbitmq.RabbitMQClient#basicConsumer} and {@link io.vertx.rxjava.rabbitmq.RabbitMQConsumer#cancel} instead
   * <p>
   * This method should be called when you want to cancel consumption from a queue,
   * started by calling {@link io.vertx.rxjava.rabbitmq.RabbitMQClient#basicConsume}.
   * @param consumerTag 
   * @param resultHandler 
   */
  @Deprecated()
  public void basicCancel(String consumerTag, Handler<AsyncResult<Void>> resultHandler) { 
    delegate.basicCancel(consumerTag, resultHandler);
  }

    
Instead of using this and basicConsume method, basicConsumer and RabbitMQConsumer.cancel instead 
 This method should be called when you want to cancel consumption from a queue, started by calling basicConsume. 
Params:
consumerTag – 
Returns:
Deprecated:
use rxBasicCancel instead/**
   * Instead of using this and {@link io.vertx.rxjava.rabbitmq.RabbitMQClient#basicConsume} method,
   * {@link io.vertx.rxjava.rabbitmq.RabbitMQClient#basicConsumer} and {@link io.vertx.rxjava.rabbitmq.RabbitMQConsumer#cancel} instead
   * <p>
   * This method should be called when you want to cancel consumption from a queue,
   * started by calling {@link io.vertx.rxjava.rabbitmq.RabbitMQClient#basicConsume}.
   * @param consumerTag 
   * @return 
   * @deprecated use {@link #rxBasicCancel} instead
   */
  @Deprecated()
  public Observable<Void> basicCancelObservable(String consumerTag) { 
    io.vertx.rx.java.ObservableFuture<Void> resultHandler = io.vertx.rx.java.RxHelper.observableFuture();
    basicCancel(consumerTag, resultHandler.toHandler());
    return resultHandler;
  }

  
Instead of using this and basicConsume method, basicConsumer and RabbitMQConsumer.cancel instead 
 This method should be called when you want to cancel consumption from a queue, started by calling basicConsume. 
Params:
consumerTag – 
Returns:
/**
   * Instead of using this and {@link io.vertx.rxjava.rabbitmq.RabbitMQClient#basicConsume} method,
   * {@link io.vertx.rxjava.rabbitmq.RabbitMQClient#basicConsumer} and {@link io.vertx.rxjava.rabbitmq.RabbitMQConsumer#cancel} instead
   * <p>
   * This method should be called when you want to cancel consumption from a queue,
   * started by calling {@link io.vertx.rxjava.rabbitmq.RabbitMQClient#basicConsume}.
   * @param consumerTag 
   * @return 
   */
  @Deprecated()
  public Single<Void> rxBasicCancel(String consumerTag) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      basicCancel(consumerTag, fut);
    }));
  }

  
Params:
queue – 
resultHandler – /**
   * @param queue 
   * @param resultHandler 
   */
  public void basicConsumer(String queue, Handler<AsyncResult<io.vertx.rxjava.rabbitmq.RabbitMQConsumer>> resultHandler) { 
    delegate.basicConsumer(queue, new Handler<AsyncResult<io.vertx.rabbitmq.RabbitMQConsumer>>() {
      public void handle(AsyncResult<io.vertx.rabbitmq.RabbitMQConsumer> ar) {
        if (ar.succeeded()) {
          resultHandler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.rabbitmq.RabbitMQConsumer.newInstance(ar.result())));
        } else {
          resultHandler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
  }

    
Params:
queue – 
Returns:
Deprecated:
use rxBasicConsumer instead/**
   * @param queue 
   * @return 
   * @deprecated use {@link #rxBasicConsumer} instead
   */
  @Deprecated()
  public Observable<io.vertx.rxjava.rabbitmq.RabbitMQConsumer> basicConsumerObservable(String queue) { 
    io.vertx.rx.java.ObservableFuture<io.vertx.rxjava.rabbitmq.RabbitMQConsumer> resultHandler = io.vertx.rx.java.RxHelper.observableFuture();
    basicConsumer(queue, resultHandler.toHandler());
    return resultHandler;
  }

  
Params:
queue – 
Returns:
/**
   * @param queue 
   * @return 
   */
  public Single<io.vertx.rxjava.rabbitmq.RabbitMQConsumer> rxBasicConsumer(String queue) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      basicConsumer(queue, fut);
    }));
  }

  
Create a consumer with the given options.
Params:
queue – the name of a queue
options – options for queue
resultHandler – a handler through which you can find out the operation status; if the operation succeeds you can begin to receive messages through an instance of RabbitMQConsumer/**
   * Create a consumer with the given <code>options</code>.
   * @param queue the name of a queue
   * @param options options for queue
   * @param resultHandler a handler through which you can find out the operation status; if the operation succeeds you can begin to receive messages through an instance of {@link io.vertx.rxjava.rabbitmq.RabbitMQConsumer}
   */
  public void basicConsumer(String queue, QueueOptions options, Handler<AsyncResult<io.vertx.rxjava.rabbitmq.RabbitMQConsumer>> resultHandler) { 
    delegate.basicConsumer(queue, options, new Handler<AsyncResult<io.vertx.rabbitmq.RabbitMQConsumer>>() {
      public void handle(AsyncResult<io.vertx.rabbitmq.RabbitMQConsumer> ar) {
        if (ar.succeeded()) {
          resultHandler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.rabbitmq.RabbitMQConsumer.newInstance(ar.result())));
        } else {
          resultHandler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
  }

    
Create a consumer with the given options.
Params:
queue – the name of a queue
options – options for queue
Returns:
Deprecated:
use rxBasicConsumer instead/**
   * Create a consumer with the given <code>options</code>.
   * @param queue the name of a queue
   * @param options options for queue
   * @return 
   * @deprecated use {@link #rxBasicConsumer} instead
   */
  @Deprecated()
  public Observable<io.vertx.rxjava.rabbitmq.RabbitMQConsumer> basicConsumerObservable(String queue, QueueOptions options) { 
    io.vertx.rx.java.ObservableFuture<io.vertx.rxjava.rabbitmq.RabbitMQConsumer> resultHandler = io.vertx.rx.java.RxHelper.observableFuture();
    basicConsumer(queue, options, resultHandler.toHandler());
    return resultHandler;
  }

  
Create a consumer with the given options.
Params:
queue – the name of a queue
options – options for queue
Returns:
/**
   * Create a consumer with the given <code>options</code>.
   * @param queue the name of a queue
   * @param options options for queue
   * @return 
   */
  public Single<io.vertx.rxjava.rabbitmq.RabbitMQConsumer> rxBasicConsumer(String queue, QueueOptions options) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      basicConsumer(queue, options, fut);
    }));
  }

  
Publish a message. Publishing to a non-existent exchange will result in a channel-level protocol exception,
which closes the channel. Invocations of Channel#basicPublish will eventually block if a resource-driven alarm is in effect.
Params:
exchange – 
routingKey – 
message – 
resultHandler – /**
   * Publish a message. Publishing to a non-existent exchange will result in a channel-level protocol exception,
   * which closes the channel. Invocations of Channel#basicPublish will eventually block if a resource-driven alarm is in effect.
   * @param exchange 
   * @param routingKey 
   * @param message 
   * @param resultHandler 
   */
  public void basicPublish(String exchange, String routingKey, JsonObject message, Handler<AsyncResult<Void>> resultHandler) { 
    delegate.basicPublish(exchange, routingKey, message, resultHandler);
  }

    
Publish a message. Publishing to a non-existent exchange will result in a channel-level protocol exception,
which closes the channel. Invocations of Channel#basicPublish will eventually block if a resource-driven alarm is in effect.
Params:
exchange – 
routingKey – 
message – 
Returns:
Deprecated:
use rxBasicPublish instead/**
   * Publish a message. Publishing to a non-existent exchange will result in a channel-level protocol exception,
   * which closes the channel. Invocations of Channel#basicPublish will eventually block if a resource-driven alarm is in effect.
   * @param exchange 
   * @param routingKey 
   * @param message 
   * @return 
   * @deprecated use {@link #rxBasicPublish} instead
   */
  @Deprecated()
  public Observable<Void> basicPublishObservable(String exchange, String routingKey, JsonObject message) { 
    io.vertx.rx.java.ObservableFuture<Void> resultHandler = io.vertx.rx.java.RxHelper.observableFuture();
    basicPublish(exchange, routingKey, message, resultHandler.toHandler());
    return resultHandler;
  }

  
Publish a message. Publishing to a non-existent exchange will result in a channel-level protocol exception,
which closes the channel. Invocations of Channel#basicPublish will eventually block if a resource-driven alarm is in effect.
Params:
exchange – 
routingKey – 
message – 
Returns:
/**
   * Publish a message. Publishing to a non-existent exchange will result in a channel-level protocol exception,
   * which closes the channel. Invocations of Channel#basicPublish will eventually block if a resource-driven alarm is in effect.
   * @param exchange 
   * @param routingKey 
   * @param message 
   * @return 
   */
  public Single<Void> rxBasicPublish(String exchange, String routingKey, JsonObject message) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      basicPublish(exchange, routingKey, message, fut);
    }));
  }

  
Enables publisher acknowledgements on this channel. Can be called once during client initialisation. Calls to basicPublish()
will have to be confirmed.
Params:
resultHandler – /**
   * Enables publisher acknowledgements on this channel. Can be called once during client initialisation. Calls to basicPublish()
   * will have to be confirmed.
   * @param resultHandler 
   */
  public void confirmSelect(Handler<AsyncResult<Void>> resultHandler) { 
    delegate.confirmSelect(resultHandler);
  }

    
Enables publisher acknowledgements on this channel. Can be called once during client initialisation. Calls to basicPublish()
will have to be confirmed.
Returns:
Deprecated:
use rxConfirmSelect instead/**
   * Enables publisher acknowledgements on this channel. Can be called once during client initialisation. Calls to basicPublish()
   * will have to be confirmed.
   * @return 
   * @deprecated use {@link #rxConfirmSelect} instead
   */
  @Deprecated()
  public Observable<Void> confirmSelectObservable() { 
    io.vertx.rx.java.ObservableFuture<Void> resultHandler = io.vertx.rx.java.RxHelper.observableFuture();
    confirmSelect(resultHandler.toHandler());
    return resultHandler;
  }

  
Enables publisher acknowledgements on this channel. Can be called once during client initialisation. Calls to basicPublish()
will have to be confirmed.
Returns:
/**
   * Enables publisher acknowledgements on this channel. Can be called once during client initialisation. Calls to basicPublish()
   * will have to be confirmed.
   * @return 
   */
  public Single<Void> rxConfirmSelect() { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      confirmSelect(fut);
    }));
  }

  
Wait until all messages published since the last call have been either ack'd or nack'd by the broker.
This will incur slight performance loss at the expense of higher write consistency.
If desired, multiple calls to basicPublish() can be batched before confirming.
Params:
resultHandler – /**
   * Wait until all messages published since the last call have been either ack'd or nack'd by the broker.
   * This will incur slight performance loss at the expense of higher write consistency.
   * If desired, multiple calls to basicPublish() can be batched before confirming.
   * @param resultHandler 
   */
  public void waitForConfirms(Handler<AsyncResult<Void>> resultHandler) { 
    delegate.waitForConfirms(resultHandler);
  }

    
Wait until all messages published since the last call have been either ack'd or nack'd by the broker.
This will incur slight performance loss at the expense of higher write consistency.
If desired, multiple calls to basicPublish() can be batched before confirming.
Returns:
Deprecated:
use rxWaitForConfirms instead/**
   * Wait until all messages published since the last call have been either ack'd or nack'd by the broker.
   * This will incur slight performance loss at the expense of higher write consistency.
   * If desired, multiple calls to basicPublish() can be batched before confirming.
   * @return 
   * @deprecated use {@link #rxWaitForConfirms} instead
   */
  @Deprecated()
  public Observable<Void> waitForConfirmsObservable() { 
    io.vertx.rx.java.ObservableFuture<Void> resultHandler = io.vertx.rx.java.RxHelper.observableFuture();
    waitForConfirms(resultHandler.toHandler());
    return resultHandler;
  }

  
Wait until all messages published since the last call have been either ack'd or nack'd by the broker.
This will incur slight performance loss at the expense of higher write consistency.
If desired, multiple calls to basicPublish() can be batched before confirming.
Returns:
/**
   * Wait until all messages published since the last call have been either ack'd or nack'd by the broker.
   * This will incur slight performance loss at the expense of higher write consistency.
   * If desired, multiple calls to basicPublish() can be batched before confirming.
   * @return 
   */
  public Single<Void> rxWaitForConfirms() { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      waitForConfirms(fut);
    }));
  }

  
Wait until all messages published since the last call have been either ack'd or nack'd by the broker; or until timeout elapses. If the timeout expires a TimeoutException is thrown.
Params:
timeout – 
resultHandler – /**
   * Wait until all messages published since the last call have been either ack'd or nack'd by the broker; or until timeout elapses. If the timeout expires a TimeoutException is thrown.
   * @param timeout 
   * @param resultHandler 
   */
  public void waitForConfirms(long timeout, Handler<AsyncResult<Void>> resultHandler) { 
    delegate.waitForConfirms(timeout, resultHandler);
  }

    
Wait until all messages published since the last call have been either ack'd or nack'd by the broker; or until timeout elapses. If the timeout expires a TimeoutException is thrown.
Params:
timeout – 
Returns:
Deprecated:
use rxWaitForConfirms instead/**
   * Wait until all messages published since the last call have been either ack'd or nack'd by the broker; or until timeout elapses. If the timeout expires a TimeoutException is thrown.
   * @param timeout 
   * @return 
   * @deprecated use {@link #rxWaitForConfirms} instead
   */
  @Deprecated()
  public Observable<Void> waitForConfirmsObservable(long timeout) { 
    io.vertx.rx.java.ObservableFuture<Void> resultHandler = io.vertx.rx.java.RxHelper.observableFuture();
    waitForConfirms(timeout, resultHandler.toHandler());
    return resultHandler;
  }

  
Wait until all messages published since the last call have been either ack'd or nack'd by the broker; or until timeout elapses. If the timeout expires a TimeoutException is thrown.
Params:
timeout – 
Returns:
/**
   * Wait until all messages published since the last call have been either ack'd or nack'd by the broker; or until timeout elapses. If the timeout expires a TimeoutException is thrown.
   * @param timeout 
   * @return 
   */
  public Single<Void> rxWaitForConfirms(long timeout) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      waitForConfirms(timeout, fut);
    }));
  }

  
Request a specific prefetchCount "quality of service" settings
for this channel.
Params:
prefetchCount – maximum number of messages that the server will deliver, 0 if unlimited
resultHandler – handler called when operation is done with a result of the operation/**
   * Request a specific prefetchCount "quality of service" settings
   * for this channel.
   * @param prefetchCount maximum number of messages that the server will deliver, 0 if unlimited
   * @param resultHandler handler called when operation is done with a result of the operation
   */
  public void basicQos(int prefetchCount, Handler<AsyncResult<Void>> resultHandler) { 
    delegate.basicQos(prefetchCount, resultHandler);
  }

    
Request a specific prefetchCount "quality of service" settings
for this channel.
Params:
prefetchCount – maximum number of messages that the server will deliver, 0 if unlimited
Returns:
Deprecated:
use rxBasicQos instead/**
   * Request a specific prefetchCount "quality of service" settings
   * for this channel.
   * @param prefetchCount maximum number of messages that the server will deliver, 0 if unlimited
   * @return 
   * @deprecated use {@link #rxBasicQos} instead
   */
  @Deprecated()
  public Observable<Void> basicQosObservable(int prefetchCount) { 
    io.vertx.rx.java.ObservableFuture<Void> resultHandler = io.vertx.rx.java.RxHelper.observableFuture();
    basicQos(prefetchCount, resultHandler.toHandler());
    return resultHandler;
  }

  
Request a specific prefetchCount "quality of service" settings
for this channel.
Params:
prefetchCount – maximum number of messages that the server will deliver, 0 if unlimited
Returns:
/**
   * Request a specific prefetchCount "quality of service" settings
   * for this channel.
   * @param prefetchCount maximum number of messages that the server will deliver, 0 if unlimited
   * @return 
   */
  public Single<Void> rxBasicQos(int prefetchCount) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      basicQos(prefetchCount, fut);
    }));
  }

  
Request a specific prefetchCount "quality of service" settings
for this channel.
Params:
prefetchCount – maximum number of messages that the server will deliver, 0 if unlimited
global – true if the settings should be applied to the entire channel rather than each consumer
resultHandler – handler called when operation is done with a result of the operation/**
   * Request a specific prefetchCount "quality of service" settings
   * for this channel.
   * @param prefetchCount maximum number of messages that the server will deliver, 0 if unlimited
   * @param global true if the settings should be applied to the entire channel rather than each consumer
   * @param resultHandler handler called when operation is done with a result of the operation
   */
  public void basicQos(int prefetchCount, boolean global, Handler<AsyncResult<Void>> resultHandler) { 
    delegate.basicQos(prefetchCount, global, resultHandler);
  }

    
Request a specific prefetchCount "quality of service" settings
for this channel.
Params:
prefetchCount – maximum number of messages that the server will deliver, 0 if unlimited
global – true if the settings should be applied to the entire channel rather than each consumer
Returns:
Deprecated:
use rxBasicQos instead/**
   * Request a specific prefetchCount "quality of service" settings
   * for this channel.
   * @param prefetchCount maximum number of messages that the server will deliver, 0 if unlimited
   * @param global true if the settings should be applied to the entire channel rather than each consumer
   * @return 
   * @deprecated use {@link #rxBasicQos} instead
   */
  @Deprecated()
  public Observable<Void> basicQosObservable(int prefetchCount, boolean global) { 
    io.vertx.rx.java.ObservableFuture<Void> resultHandler = io.vertx.rx.java.RxHelper.observableFuture();
    basicQos(prefetchCount, global, resultHandler.toHandler());
    return resultHandler;
  }

  
Request a specific prefetchCount "quality of service" settings
for this channel.
Params:
prefetchCount – maximum number of messages that the server will deliver, 0 if unlimited
global – true if the settings should be applied to the entire channel rather than each consumer
Returns:
/**
   * Request a specific prefetchCount "quality of service" settings
   * for this channel.
   * @param prefetchCount maximum number of messages that the server will deliver, 0 if unlimited
   * @param global true if the settings should be applied to the entire channel rather than each consumer
   * @return 
   */
  public Single<Void> rxBasicQos(int prefetchCount, boolean global) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      basicQos(prefetchCount, global, fut);
    }));
  }

  
Request specific "quality of service" settings.
These settings impose limits on the amount of data the server
will deliver to consumers before requiring acknowledgements.
Thus they provide a means of consumer-initiated flow control.
Params:
prefetchSize – maximum amount of content (measured in octets) that the server will deliver, 0 if unlimited
prefetchCount – maximum number of messages that the server will deliver, 0 if unlimited
global – true if the settings should be applied to the entire channel rather than each consumer
resultHandler – handler called when operation is done with a result of the operation/**
   * Request specific "quality of service" settings.
   *
   * These settings impose limits on the amount of data the server
   * will deliver to consumers before requiring acknowledgements.
   * Thus they provide a means of consumer-initiated flow control.
   * @param prefetchSize maximum amount of content (measured in octets) that the server will deliver, 0 if unlimited
   * @param prefetchCount maximum number of messages that the server will deliver, 0 if unlimited
   * @param global true if the settings should be applied to the entire channel rather than each consumer
   * @param resultHandler handler called when operation is done with a result of the operation
   */
  public void basicQos(int prefetchSize, int prefetchCount, boolean global, Handler<AsyncResult<Void>> resultHandler) { 
    delegate.basicQos(prefetchSize, prefetchCount, global, resultHandler);
  }

    
Request specific "quality of service" settings.
These settings impose limits on the amount of data the server
will deliver to consumers before requiring acknowledgements.
Thus they provide a means of consumer-initiated flow control.
Params:
prefetchSize – maximum amount of content (measured in octets) that the server will deliver, 0 if unlimited
prefetchCount – maximum number of messages that the server will deliver, 0 if unlimited
global – true if the settings should be applied to the entire channel rather than each consumer
Returns:
Deprecated:
use rxBasicQos instead/**
   * Request specific "quality of service" settings.
   *
   * These settings impose limits on the amount of data the server
   * will deliver to consumers before requiring acknowledgements.
   * Thus they provide a means of consumer-initiated flow control.
   * @param prefetchSize maximum amount of content (measured in octets) that the server will deliver, 0 if unlimited
   * @param prefetchCount maximum number of messages that the server will deliver, 0 if unlimited
   * @param global true if the settings should be applied to the entire channel rather than each consumer
   * @return 
   * @deprecated use {@link #rxBasicQos} instead
   */
  @Deprecated()
  public Observable<Void> basicQosObservable(int prefetchSize, int prefetchCount, boolean global) { 
    io.vertx.rx.java.ObservableFuture<Void> resultHandler = io.vertx.rx.java.RxHelper.observableFuture();
    basicQos(prefetchSize, prefetchCount, global, resultHandler.toHandler());
    return resultHandler;
  }

  
Request specific "quality of service" settings.
These settings impose limits on the amount of data the server
will deliver to consumers before requiring acknowledgements.
Thus they provide a means of consumer-initiated flow control.
Params:
prefetchSize – maximum amount of content (measured in octets) that the server will deliver, 0 if unlimited
prefetchCount – maximum number of messages that the server will deliver, 0 if unlimited
global – true if the settings should be applied to the entire channel rather than each consumer
Returns:
/**
   * Request specific "quality of service" settings.
   *
   * These settings impose limits on the amount of data the server
   * will deliver to consumers before requiring acknowledgements.
   * Thus they provide a means of consumer-initiated flow control.
   * @param prefetchSize maximum amount of content (measured in octets) that the server will deliver, 0 if unlimited
   * @param prefetchCount maximum number of messages that the server will deliver, 0 if unlimited
   * @param global true if the settings should be applied to the entire channel rather than each consumer
   * @return 
   */
  public Single<Void> rxBasicQos(int prefetchSize, int prefetchCount, boolean global) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      basicQos(prefetchSize, prefetchCount, global, fut);
    }));
  }

  
Declare an exchange.
Params:
exchange – 
type – 
durable – 
autoDelete – 
resultHandler – /**
   * Declare an exchange.
   * @param exchange 
   * @param type 
   * @param durable 
   * @param autoDelete 
   * @param resultHandler 
   */
  public void exchangeDeclare(String exchange, String type, boolean durable, boolean autoDelete, Handler<AsyncResult<Void>> resultHandler) { 
    delegate.exchangeDeclare(exchange, type, durable, autoDelete, resultHandler);
  }

    
Declare an exchange.
Params:
exchange – 
type – 
durable – 
autoDelete – 
Returns:
Deprecated:
use rxExchangeDeclare instead/**
   * Declare an exchange.
   * @param exchange 
   * @param type 
   * @param durable 
   * @param autoDelete 
   * @return 
   * @deprecated use {@link #rxExchangeDeclare} instead
   */
  @Deprecated()
  public Observable<Void> exchangeDeclareObservable(String exchange, String type, boolean durable, boolean autoDelete) { 
    io.vertx.rx.java.ObservableFuture<Void> resultHandler = io.vertx.rx.java.RxHelper.observableFuture();
    exchangeDeclare(exchange, type, durable, autoDelete, resultHandler.toHandler());
    return resultHandler;
  }

  
Declare an exchange.
Params:
exchange – 
type – 
durable – 
autoDelete – 
Returns:
/**
   * Declare an exchange.
   * @param exchange 
   * @param type 
   * @param durable 
   * @param autoDelete 
   * @return 
   */
  public Single<Void> rxExchangeDeclare(String exchange, String type, boolean durable, boolean autoDelete) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      exchangeDeclare(exchange, type, durable, autoDelete, fut);
    }));
  }

  
Declare an exchange with additional parameters such as dead lettering, an alternate exchange or TTL.
Params:
exchange – 
type – 
durable – 
autoDelete – 
config – 
resultHandler – /**
   * Declare an exchange with additional parameters such as dead lettering, an alternate exchange or TTL.
   * @param exchange 
   * @param type 
   * @param durable 
   * @param autoDelete 
   * @param config 
   * @param resultHandler 
   */
  public void exchangeDeclare(String exchange, String type, boolean durable, boolean autoDelete, JsonObject config, Handler<AsyncResult<Void>> resultHandler) { 
    delegate.exchangeDeclare(exchange, type, durable, autoDelete, config, resultHandler);
  }

    
Declare an exchange with additional parameters such as dead lettering, an alternate exchange or TTL.
Params:
exchange – 
type – 
durable – 
autoDelete – 
config – 
Returns:
Deprecated:
use rxExchangeDeclare instead/**
   * Declare an exchange with additional parameters such as dead lettering, an alternate exchange or TTL.
   * @param exchange 
   * @param type 
   * @param durable 
   * @param autoDelete 
   * @param config 
   * @return 
   * @deprecated use {@link #rxExchangeDeclare} instead
   */
  @Deprecated()
  public Observable<Void> exchangeDeclareObservable(String exchange, String type, boolean durable, boolean autoDelete, JsonObject config) { 
    io.vertx.rx.java.ObservableFuture<Void> resultHandler = io.vertx.rx.java.RxHelper.observableFuture();
    exchangeDeclare(exchange, type, durable, autoDelete, config, resultHandler.toHandler());
    return resultHandler;
  }

  
Declare an exchange with additional parameters such as dead lettering, an alternate exchange or TTL.
Params:
exchange – 
type – 
durable – 
autoDelete – 
config – 
Returns:
/**
   * Declare an exchange with additional parameters such as dead lettering, an alternate exchange or TTL.
   * @param exchange 
   * @param type 
   * @param durable 
   * @param autoDelete 
   * @param config 
   * @return 
   */
  public Single<Void> rxExchangeDeclare(String exchange, String type, boolean durable, boolean autoDelete, JsonObject config) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      exchangeDeclare(exchange, type, durable, autoDelete, config, fut);
    }));
  }

  
Delete an exchange, without regard for whether it is in use or not.
Params:
exchange – 
resultHandler – /**
   * Delete an exchange, without regard for whether it is in use or not.
   * @param exchange 
   * @param resultHandler 
   */
  public void exchangeDelete(String exchange, Handler<AsyncResult<Void>> resultHandler) { 
    delegate.exchangeDelete(exchange, resultHandler);
  }

    
Delete an exchange, without regard for whether it is in use or not.
Params:
exchange – 
Returns:
Deprecated:
use rxExchangeDelete instead/**
   * Delete an exchange, without regard for whether it is in use or not.
   * @param exchange 
   * @return 
   * @deprecated use {@link #rxExchangeDelete} instead
   */
  @Deprecated()
  public Observable<Void> exchangeDeleteObservable(String exchange) { 
    io.vertx.rx.java.ObservableFuture<Void> resultHandler = io.vertx.rx.java.RxHelper.observableFuture();
    exchangeDelete(exchange, resultHandler.toHandler());
    return resultHandler;
  }

  
Delete an exchange, without regard for whether it is in use or not.
Params:
exchange – 
Returns:
/**
   * Delete an exchange, without regard for whether it is in use or not.
   * @param exchange 
   * @return 
   */
  public Single<Void> rxExchangeDelete(String exchange) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      exchangeDelete(exchange, fut);
    }));
  }

  
Bind an exchange to an exchange.
Params:
destination – 
source – 
routingKey – 
resultHandler – /**
   * Bind an exchange to an exchange.
   * @param destination 
   * @param source 
   * @param routingKey 
   * @param resultHandler 
   */
  public void exchangeBind(String destination, String source, String routingKey, Handler<AsyncResult<Void>> resultHandler) { 
    delegate.exchangeBind(destination, source, routingKey, resultHandler);
  }

    
Bind an exchange to an exchange.
Params:
destination – 
source – 
routingKey – 
Returns:
Deprecated:
use rxExchangeBind instead/**
   * Bind an exchange to an exchange.
   * @param destination 
   * @param source 
   * @param routingKey 
   * @return 
   * @deprecated use {@link #rxExchangeBind} instead
   */
  @Deprecated()
  public Observable<Void> exchangeBindObservable(String destination, String source, String routingKey) { 
    io.vertx.rx.java.ObservableFuture<Void> resultHandler = io.vertx.rx.java.RxHelper.observableFuture();
    exchangeBind(destination, source, routingKey, resultHandler.toHandler());
    return resultHandler;
  }

  
Bind an exchange to an exchange.
Params:
destination – 
source – 
routingKey – 
Returns:
/**
   * Bind an exchange to an exchange.
   * @param destination 
   * @param source 
   * @param routingKey 
   * @return 
   */
  public Single<Void> rxExchangeBind(String destination, String source, String routingKey) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      exchangeBind(destination, source, routingKey, fut);
    }));
  }

  
Unbind an exchange from an exchange.
Params:
destination – 
source – 
routingKey – 
resultHandler – /**
   * Unbind an exchange from an exchange.
   * @param destination 
   * @param source 
   * @param routingKey 
   * @param resultHandler 
   */
  public void exchangeUnbind(String destination, String source, String routingKey, Handler<AsyncResult<Void>> resultHandler) { 
    delegate.exchangeUnbind(destination, source, routingKey, resultHandler);
  }

    
Unbind an exchange from an exchange.
Params:
destination – 
source – 
routingKey – 
Returns:
Deprecated:
use rxExchangeUnbind instead/**
   * Unbind an exchange from an exchange.
   * @param destination 
   * @param source 
   * @param routingKey 
   * @return 
   * @deprecated use {@link #rxExchangeUnbind} instead
   */
  @Deprecated()
  public Observable<Void> exchangeUnbindObservable(String destination, String source, String routingKey) { 
    io.vertx.rx.java.ObservableFuture<Void> resultHandler = io.vertx.rx.java.RxHelper.observableFuture();
    exchangeUnbind(destination, source, routingKey, resultHandler.toHandler());
    return resultHandler;
  }

  
Unbind an exchange from an exchange.
Params:
destination – 
source – 
routingKey – 
Returns:
/**
   * Unbind an exchange from an exchange.
   * @param destination 
   * @param source 
   * @param routingKey 
   * @return 
   */
  public Single<Void> rxExchangeUnbind(String destination, String source, String routingKey) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      exchangeUnbind(destination, source, routingKey, fut);
    }));
  }

  
Actively declare a server-named exclusive, autodelete, non-durable queue.
Params:
resultHandler – /**
   * Actively declare a server-named exclusive, autodelete, non-durable queue.
   * @param resultHandler 
   */
  public void queueDeclareAuto(Handler<AsyncResult<JsonObject>> resultHandler) { 
    delegate.queueDeclareAuto(resultHandler);
  }

    
Actively declare a server-named exclusive, autodelete, non-durable queue.
Returns:
Deprecated:
use rxQueueDeclareAuto instead/**
   * Actively declare a server-named exclusive, autodelete, non-durable queue.
   * @return 
   * @deprecated use {@link #rxQueueDeclareAuto} instead
   */
  @Deprecated()
  public Observable<JsonObject> queueDeclareAutoObservable() { 
    io.vertx.rx.java.ObservableFuture<JsonObject> resultHandler = io.vertx.rx.java.RxHelper.observableFuture();
    queueDeclareAuto(resultHandler.toHandler());
    return resultHandler;
  }

  
Actively declare a server-named exclusive, autodelete, non-durable queue.
Returns:
/**
   * Actively declare a server-named exclusive, autodelete, non-durable queue.
   * @return 
   */
  public Single<JsonObject> rxQueueDeclareAuto() { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      queueDeclareAuto(fut);
    }));
  }

  
Declare a queue
Params:
queue – 
durable – 
exclusive – 
autoDelete – 
resultHandler – /**
   * Declare a queue
   * @param queue 
   * @param durable 
   * @param exclusive 
   * @param autoDelete 
   * @param resultHandler 
   */
  public void queueDeclare(String queue, boolean durable, boolean exclusive, boolean autoDelete, Handler<AsyncResult<JsonObject>> resultHandler) { 
    delegate.queueDeclare(queue, durable, exclusive, autoDelete, resultHandler);
  }

    
Declare a queue
Params:
queue – 
durable – 
exclusive – 
autoDelete – 
Returns:
Deprecated:
use rxQueueDeclare instead/**
   * Declare a queue
   * @param queue 
   * @param durable 
   * @param exclusive 
   * @param autoDelete 
   * @return 
   * @deprecated use {@link #rxQueueDeclare} instead
   */
  @Deprecated()
  public Observable<JsonObject> queueDeclareObservable(String queue, boolean durable, boolean exclusive, boolean autoDelete) { 
    io.vertx.rx.java.ObservableFuture<JsonObject> resultHandler = io.vertx.rx.java.RxHelper.observableFuture();
    queueDeclare(queue, durable, exclusive, autoDelete, resultHandler.toHandler());
    return resultHandler;
  }

  
Declare a queue
Params:
queue – 
durable – 
exclusive – 
autoDelete – 
Returns:
/**
   * Declare a queue
   * @param queue 
   * @param durable 
   * @param exclusive 
   * @param autoDelete 
   * @return 
   */
  public Single<JsonObject> rxQueueDeclare(String queue, boolean durable, boolean exclusive, boolean autoDelete) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      queueDeclare(queue, durable, exclusive, autoDelete, fut);
    }));
  }

  
Declare a queue with config options
Params:
queue – 
durable – 
exclusive – 
autoDelete – 
config – 
resultHandler – /**
   * Declare a queue with config options
   * @param queue 
   * @param durable 
   * @param exclusive 
   * @param autoDelete 
   * @param config 
   * @param resultHandler 
   */
  public void queueDeclare(String queue, boolean durable, boolean exclusive, boolean autoDelete, JsonObject config, Handler<AsyncResult<JsonObject>> resultHandler) { 
    delegate.queueDeclare(queue, durable, exclusive, autoDelete, config, resultHandler);
  }

    
Declare a queue with config options
Params:
queue – 
durable – 
exclusive – 
autoDelete – 
config – 
Returns:
Deprecated:
use rxQueueDeclare instead/**
   * Declare a queue with config options
   * @param queue 
   * @param durable 
   * @param exclusive 
   * @param autoDelete 
   * @param config 
   * @return 
   * @deprecated use {@link #rxQueueDeclare} instead
   */
  @Deprecated()
  public Observable<JsonObject> queueDeclareObservable(String queue, boolean durable, boolean exclusive, boolean autoDelete, JsonObject config) { 
    io.vertx.rx.java.ObservableFuture<JsonObject> resultHandler = io.vertx.rx.java.RxHelper.observableFuture();
    queueDeclare(queue, durable, exclusive, autoDelete, config, resultHandler.toHandler());
    return resultHandler;
  }

  
Declare a queue with config options
Params:
queue – 
durable – 
exclusive – 
autoDelete – 
config – 
Returns:
/**
   * Declare a queue with config options
   * @param queue 
   * @param durable 
   * @param exclusive 
   * @param autoDelete 
   * @param config 
   * @return 
   */
  public Single<JsonObject> rxQueueDeclare(String queue, boolean durable, boolean exclusive, boolean autoDelete, JsonObject config) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      queueDeclare(queue, durable, exclusive, autoDelete, config, fut);
    }));
  }

  
Delete a queue, without regard for whether it is in use or has messages on it
Params:
queue – 
resultHandler – /**
   * Delete a queue, without regard for whether it is in use or has messages on it
   * @param queue 
   * @param resultHandler 
   */
  public void queueDelete(String queue, Handler<AsyncResult<JsonObject>> resultHandler) { 
    delegate.queueDelete(queue, resultHandler);
  }

    
Delete a queue, without regard for whether it is in use or has messages on it
Params:
queue – 
Returns:
Deprecated:
use rxQueueDelete instead/**
   * Delete a queue, without regard for whether it is in use or has messages on it
   * @param queue 
   * @return 
   * @deprecated use {@link #rxQueueDelete} instead
   */
  @Deprecated()
  public Observable<JsonObject> queueDeleteObservable(String queue) { 
    io.vertx.rx.java.ObservableFuture<JsonObject> resultHandler = io.vertx.rx.java.RxHelper.observableFuture();
    queueDelete(queue, resultHandler.toHandler());
    return resultHandler;
  }

  
Delete a queue, without regard for whether it is in use or has messages on it
Params:
queue – 
Returns:
/**
   * Delete a queue, without regard for whether it is in use or has messages on it
   * @param queue 
   * @return 
   */
  public Single<JsonObject> rxQueueDelete(String queue) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      queueDelete(queue, fut);
    }));
  }

  
Delete a queue
Params:
queue – 
ifUnused – 
ifEmpty – 
resultHandler – /**
   * Delete a queue
   * @param queue 
   * @param ifUnused 
   * @param ifEmpty 
   * @param resultHandler 
   */
  public void queueDeleteIf(String queue, boolean ifUnused, boolean ifEmpty, Handler<AsyncResult<JsonObject>> resultHandler) { 
    delegate.queueDeleteIf(queue, ifUnused, ifEmpty, resultHandler);
  }

    
Delete a queue
Params:
queue – 
ifUnused – 
ifEmpty – 
Returns:
Deprecated:
use rxQueueDeleteIf instead/**
   * Delete a queue
   * @param queue 
   * @param ifUnused 
   * @param ifEmpty 
   * @return 
   * @deprecated use {@link #rxQueueDeleteIf} instead
   */
  @Deprecated()
  public Observable<JsonObject> queueDeleteIfObservable(String queue, boolean ifUnused, boolean ifEmpty) { 
    io.vertx.rx.java.ObservableFuture<JsonObject> resultHandler = io.vertx.rx.java.RxHelper.observableFuture();
    queueDeleteIf(queue, ifUnused, ifEmpty, resultHandler.toHandler());
    return resultHandler;
  }

  
Delete a queue
Params:
queue – 
ifUnused – 
ifEmpty – 
Returns:
/**
   * Delete a queue
   * @param queue 
   * @param ifUnused 
   * @param ifEmpty 
   * @return 
   */
  public Single<JsonObject> rxQueueDeleteIf(String queue, boolean ifUnused, boolean ifEmpty) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      queueDeleteIf(queue, ifUnused, ifEmpty, fut);
    }));
  }

  
Bind a queue to an exchange
Params:
queue – 
exchange – 
routingKey – 
resultHandler – /**
   * Bind a queue to an exchange
   * @param queue 
   * @param exchange 
   * @param routingKey 
   * @param resultHandler 
   */
  public void queueBind(String queue, String exchange, String routingKey, Handler<AsyncResult<Void>> resultHandler) { 
    delegate.queueBind(queue, exchange, routingKey, resultHandler);
  }

    
Bind a queue to an exchange
Params:
queue – 
exchange – 
routingKey – 
Returns:
Deprecated:
use rxQueueBind instead/**
   * Bind a queue to an exchange
   * @param queue 
   * @param exchange 
   * @param routingKey 
   * @return 
   * @deprecated use {@link #rxQueueBind} instead
   */
  @Deprecated()
  public Observable<Void> queueBindObservable(String queue, String exchange, String routingKey) { 
    io.vertx.rx.java.ObservableFuture<Void> resultHandler = io.vertx.rx.java.RxHelper.observableFuture();
    queueBind(queue, exchange, routingKey, resultHandler.toHandler());
    return resultHandler;
  }

  
Bind a queue to an exchange
Params:
queue – 
exchange – 
routingKey – 
Returns:
/**
   * Bind a queue to an exchange
   * @param queue 
   * @param exchange 
   * @param routingKey 
   * @return 
   */
  public Single<Void> rxQueueBind(String queue, String exchange, String routingKey) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      queueBind(queue, exchange, routingKey, fut);
    }));
  }

  
Returns the number of messages in a queue ready to be delivered.
Params:
queue – 
resultHandler – /**
   * Returns the number of messages in a queue ready to be delivered.
   * @param queue 
   * @param resultHandler 
   */
  public void messageCount(String queue, Handler<AsyncResult<Long>> resultHandler) { 
    delegate.messageCount(queue, resultHandler);
  }

    
Returns the number of messages in a queue ready to be delivered.
Params:
queue – 
Returns:
Deprecated:
use rxMessageCount instead/**
   * Returns the number of messages in a queue ready to be delivered.
   * @param queue 
   * @return 
   * @deprecated use {@link #rxMessageCount} instead
   */
  @Deprecated()
  public Observable<Long> messageCountObservable(String queue) { 
    io.vertx.rx.java.ObservableFuture<Long> resultHandler = io.vertx.rx.java.RxHelper.observableFuture();
    messageCount(queue, resultHandler.toHandler());
    return resultHandler;
  }

  
Returns the number of messages in a queue ready to be delivered.
Params:
queue – 
Returns:
/**
   * Returns the number of messages in a queue ready to be delivered.
   * @param queue 
   * @return 
   */
  public Single<Long> rxMessageCount(String queue) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      messageCount(queue, fut);
    }));
  }

  
Start the rabbitMQ client. Create the connection and the chanel.
Params:
resultHandler – /**
   * Start the rabbitMQ client. Create the connection and the chanel.
   * @param resultHandler 
   */
  public void start(Handler<AsyncResult<Void>> resultHandler) { 
    delegate.start(resultHandler);
  }

    
Start the rabbitMQ client. Create the connection and the chanel.
Returns:
Deprecated:
use rxStart instead/**
   * Start the rabbitMQ client. Create the connection and the chanel.
   * @return 
   * @deprecated use {@link #rxStart} instead
   */
  @Deprecated()
  public Observable<Void> startObservable() { 
    io.vertx.rx.java.ObservableFuture<Void> resultHandler = io.vertx.rx.java.RxHelper.observableFuture();
    start(resultHandler.toHandler());
    return resultHandler;
  }

  
Start the rabbitMQ client. Create the connection and the chanel.
Returns:
/**
   * Start the rabbitMQ client. Create the connection and the chanel.
   * @return 
   */
  public Single<Void> rxStart() { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      start(fut);
    }));
  }

  
Stop the rabbitMQ client. Close the connection and its chanel.
Params:
resultHandler – /**
   * Stop the rabbitMQ client. Close the connection and its chanel.
   * @param resultHandler 
   */
  public void stop(Handler<AsyncResult<Void>> resultHandler) { 
    delegate.stop(resultHandler);
  }

    
Stop the rabbitMQ client. Close the connection and its chanel.
Returns:
Deprecated:
use rxStop instead/**
   * Stop the rabbitMQ client. Close the connection and its chanel.
   * @return 
   * @deprecated use {@link #rxStop} instead
   */
  @Deprecated()
  public Observable<Void> stopObservable() { 
    io.vertx.rx.java.ObservableFuture<Void> resultHandler = io.vertx.rx.java.RxHelper.observableFuture();
    stop(resultHandler.toHandler());
    return resultHandler;
  }

  
Stop the rabbitMQ client. Close the connection and its chanel.
Returns:
/**
   * Stop the rabbitMQ client. Close the connection and its chanel.
   * @return 
   */
  public Single<Void> rxStop() { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      stop(fut);
    }));
  }

  
Check if a connection is open
Returns:
true when the connection is open, false otherwise/**
   * Check if a connection is open
   * @return true when the connection is open, false otherwise
   */
  public boolean isConnected() { 
    boolean ret = delegate.isConnected();
    return ret;
  }

  
Check if a channel is open
Returns:
true when the connection is open, false otherwise/**
   * Check if a channel is open
   * @return true when the connection is open, false otherwise
   */
  public boolean isOpenChannel() { 
    boolean ret = delegate.isOpenChannel();
    return ret;
  }


  public static  RabbitMQClient newInstance(io.vertx.rabbitmq.RabbitMQClient arg) {
    return arg != null ? new RabbitMQClient(arg) : null;
  }
}