io.vertx.rxjava.rabbitmq

## Class RabbitMQClient

- java.lang.Object
- - io.vertx.rxjava.rabbitmq.RabbitMQClient

-     public class RabbitMQClient
      extends Object

  NOTE: This class has been automatically generated from the `original` non RX-ified interface using Vert.x codegen.

- - ### Field Summary

    Fields
    Modifier and Type | Field and Description
    --- | ---
    `static io.vertx.lang.rx.TypeArg<RabbitMQClient>` | `__TYPE_ARG`

  - ### Constructor Summary

    Constructors
    Constructor and Description
    `RabbitMQClient(RabbitMQClient delegate)`

  - ### Method Summary

    All Methods Static Methods Instance Methods Concrete Methods Deprecated Methods
    Modifier and Type | Method and Description
    --- | ---
    `void` | `basicAck(long deliveryTag, boolean multiple, Handler<AsyncResult<JsonObject>> resultHandler)` Acknowledge one or several received messages.
    `Observable<JsonObject>` | `basicAckObservable(long deliveryTag, boolean multiple)` Deprecated. use `rxBasicAck(long, boolean)` instead
    `void` | `basicCancel(String consumerTag)` Deprecated.
    `void` | `basicCancel(String consumerTag, Handler<AsyncResult<Void>> resultHandler)` Deprecated.
    `Observable<Void>` | `basicCancelObservable(String consumerTag)` Deprecated. use `rxBasicCancel(java.lang.String)` instead
    `void` | `basicConsume(String queue, String address, boolean autoAck, Handler<AsyncResult<String>> resultHandler)` Deprecated.
    `void` | `basicConsume(String queue, String address, boolean autoAck, Handler<AsyncResult<String>> resultHandler, Handler<Throwable> errorHandler)` Deprecated.
    `void` | `basicConsume(String queue, String address, Handler<AsyncResult<String>> resultHandler)` Deprecated.
    `Observable<String>` | `basicConsumeObservable(String queue, String address)` Deprecated. use `rxBasicConsume(java.lang.String, java.lang.String)` instead
    `Observable<String>` | `basicConsumeObservable(String queue, String address, boolean autoAck)` Deprecated. use `rxBasicConsume(java.lang.String, java.lang.String)` instead
    `void` | `basicConsumer(String queue, Handler<AsyncResult<RabbitMQConsumer>> resultHandler)`
    `void` | `basicConsumer(String queue, QueueOptions options, Handler<AsyncResult<RabbitMQConsumer>> resultHandler)` Create a consumer with the given `options`.
    `Observable<RabbitMQConsumer>` | `basicConsumerObservable(String queue)` Deprecated. use `rxBasicConsumer(java.lang.String)` instead
    `Observable<RabbitMQConsumer>` | `basicConsumerObservable(String queue, QueueOptions options)` Deprecated. use `rxBasicConsumer(java.lang.String)` instead
    `void` | `basicGet(String queue, boolean autoAck, Handler<AsyncResult<JsonObject>> resultHandler)` Retrieve a message from a queue using AMQP.Basic.Get
    `Observable<JsonObject>` | `basicGetObservable(String queue, boolean autoAck)` Deprecated. use `rxBasicGet(java.lang.String, boolean)` instead
    `void` | `basicNack(long deliveryTag, boolean multiple, boolean requeue, Handler<AsyncResult<JsonObject>> resultHandler)` Reject one or several received messages.
    `Observable<JsonObject>` | `basicNackObservable(long deliveryTag, boolean multiple, boolean requeue)` Deprecated. use `rxBasicNack(long, boolean, boolean)` instead
    `void` | `basicPublish(String exchange, String routingKey, JsonObject message, Handler<AsyncResult<Void>> resultHandler)` Publish a message.
    `Observable<Void>` | `basicPublishObservable(String exchange, String routingKey, JsonObject message)` Deprecated. use `rxBasicPublish(java.lang.String, java.lang.String, io.vertx.core.json.JsonObject)` instead
    `void` | `basicQos(int prefetchCount, boolean global, Handler<AsyncResult<Void>> resultHandler)` Request a specific prefetchCount "quality of service" settings for this channel.
    `void` | `basicQos(int prefetchCount, Handler<AsyncResult<Void>> resultHandler)` Request a specific prefetchCount "quality of service" settings for this channel.
    `void` | `basicQos(int prefetchSize, int prefetchCount, boolean global, Handler<AsyncResult<Void>> resultHandler)` Request specific "quality of service" settings.
    `Observable<Void>` | `basicQosObservable(int prefetchCount)` Deprecated. use `rxBasicQos(int)` instead
    `Observable<Void>` | `basicQosObservable(int prefetchCount, boolean global)` Deprecated. use `rxBasicQos(int)` instead
    `Observable<Void>` | `basicQosObservable(int prefetchSize, int prefetchCount, boolean global)` Deprecated. use `rxBasicQos(int)` instead
    `void` | `confirmSelect(Handler<AsyncResult<Void>> resultHandler)` Enables publisher acknowledgements on this channel.
    `Observable<Void>` | `confirmSelectObservable()` Deprecated. use `rxConfirmSelect()` instead
    `static RabbitMQClient` | `create(Vertx vertx)` Create and return a client configured with the default options.
    `static RabbitMQClient` | `create(Vertx vertx, RabbitMQOptions config)` Create and return a client.
    `boolean` | `equals(Object o)`
    `void` | `exchangeBind(String destination, String source, String routingKey, Handler<AsyncResult<Void>> resultHandler)` Bind an exchange to an exchange.
    `Observable<Void>` | `exchangeBindObservable(String destination, String source, String routingKey)` Deprecated. use `rxExchangeBind(java.lang.String, java.lang.String, java.lang.String)` instead
    `void` | `exchangeDeclare(String exchange, String type, boolean durable, boolean autoDelete, Handler<AsyncResult<Void>> resultHandler)` Declare an exchange.
    `void` | `exchangeDeclare(String exchange, String type, boolean durable, boolean autoDelete, JsonObject config, Handler<AsyncResult<Void>> resultHandler)` Declare an exchange with additional parameters such as dead lettering, an alternate exchange or TTL.
    `Observable<Void>` | `exchangeDeclareObservable(String exchange, String type, boolean durable, boolean autoDelete)` Deprecated. use `rxExchangeDeclare(java.lang.String, java.lang.String, boolean, boolean)` instead
    `Observable<Void>` | `exchangeDeclareObservable(String exchange, String type, boolean durable, boolean autoDelete, JsonObject config)` Deprecated. use `rxExchangeDeclare(java.lang.String, java.lang.String, boolean, boolean)` instead
    `void` | `exchangeDelete(String exchange, Handler<AsyncResult<Void>> resultHandler)` Delete an exchange, without regard for whether it is in use or not.
    `Observable<Void>` | `exchangeDeleteObservable(String exchange)` Deprecated. use `rxExchangeDelete(java.lang.String)` instead
    `void` | `exchangeUnbind(String destination, String source, String routingKey, Handler<AsyncResult<Void>> resultHandler)` Unbind an exchange from an exchange.
    `Observable<Void>` | `exchangeUnbindObservable(String destination, String source, String routingKey)` Deprecated. use `rxExchangeUnbind(java.lang.String, java.lang.String, java.lang.String)` instead
    `RabbitMQClient` | `getDelegate()`
    `int` | `hashCode()`
    `boolean` | `isConnected()` Check if a connection is open
    `boolean` | `isOpenChannel()` Check if a channel is open
    `void` | `messageCount(String queue, Handler<AsyncResult<Long>> resultHandler)` Returns the number of messages in a queue ready to be delivered.
    `Observable<Long>` | `messageCountObservable(String queue)` Deprecated. use `rxMessageCount(java.lang.String)` instead
    `static RabbitMQClient` | `newInstance(RabbitMQClient arg)`
    `void` | `queueBind(String queue, String exchange, String routingKey, Handler<AsyncResult<Void>> resultHandler)` Bind a queue to an exchange
    `Observable<Void>` | `queueBindObservable(String queue, String exchange, String routingKey)` Deprecated. use `rxQueueBind(java.lang.String, java.lang.String, java.lang.String)` instead
    `void` | `queueDeclare(String queue, boolean durable, boolean exclusive, boolean autoDelete, Handler<AsyncResult<JsonObject>> resultHandler)` Declare a queue
    `void` | `queueDeclare(String queue, boolean durable, boolean exclusive, boolean autoDelete, JsonObject config, Handler<AsyncResult<JsonObject>> resultHandler)` Declare a queue with config options
    `void` | `queueDeclareAuto(Handler<AsyncResult<JsonObject>> resultHandler)` Actively declare a server-named exclusive, autodelete, non-durable queue.
    `Observable<JsonObject>` | `queueDeclareAutoObservable()` Deprecated. use `rxQueueDeclareAuto()` instead
    `Observable<JsonObject>` | `queueDeclareObservable(String queue, boolean durable, boolean exclusive, boolean autoDelete)` Deprecated. use `rxQueueDeclare(java.lang.String, boolean, boolean, boolean)` instead
    `Observable<JsonObject>` | `queueDeclareObservable(String queue, boolean durable, boolean exclusive, boolean autoDelete, JsonObject config)` Deprecated. use `rxQueueDeclare(java.lang.String, boolean, boolean, boolean)` instead
    `void` | `queueDelete(String queue, Handler<AsyncResult<JsonObject>> resultHandler)` Delete a queue, without regard for whether it is in use or has messages on it
    `void` | `queueDeleteIf(String queue, boolean ifUnused, boolean ifEmpty, Handler<AsyncResult<JsonObject>> resultHandler)` Delete a queue
    `Observable<JsonObject>` | `queueDeleteIfObservable(String queue, boolean ifUnused, boolean ifEmpty)` Deprecated. use `rxQueueDeleteIf(java.lang.String, boolean, boolean)` instead
    `Observable<JsonObject>` | `queueDeleteObservable(String queue)` Deprecated. use `rxQueueDelete(java.lang.String)` instead
    `Single<JsonObject>` | `rxBasicAck(long deliveryTag, boolean multiple)` Acknowledge one or several received messages.
    `Single<Void>` | `rxBasicCancel(String consumerTag)` Deprecated.
    `Single<String>` | `rxBasicConsume(String queue, String address)` Deprecated.
    `Single<String>` | `rxBasicConsume(String queue, String address, boolean autoAck)` Deprecated.
    `Single<RabbitMQConsumer>` | `rxBasicConsumer(String queue)`
    `Single<RabbitMQConsumer>` | `rxBasicConsumer(String queue, QueueOptions options)` Create a consumer with the given `options`.
    `Single<JsonObject>` | `rxBasicGet(String queue, boolean autoAck)` Retrieve a message from a queue using AMQP.Basic.Get
    `Single<JsonObject>` | `rxBasicNack(long deliveryTag, boolean multiple, boolean requeue)` Reject one or several received messages.
    `Single<Void>` | `rxBasicPublish(String exchange, String routingKey, JsonObject message)` Publish a message.
    `Single<Void>` | `rxBasicQos(int prefetchCount)` Request a specific prefetchCount "quality of service" settings for this channel.
    `Single<Void>` | `rxBasicQos(int prefetchCount, boolean global)` Request a specific prefetchCount "quality of service" settings for this channel.
    `Single<Void>` | `rxBasicQos(int prefetchSize, int prefetchCount, boolean global)` Request specific "quality of service" settings.
    `Single<Void>` | `rxConfirmSelect()` Enables publisher acknowledgements on this channel.
    `Single<Void>` | `rxExchangeBind(String destination, String source, String routingKey)` Bind an exchange to an exchange.
    `Single<Void>` | `rxExchangeDeclare(String exchange, String type, boolean durable, boolean autoDelete)` Declare an exchange.
    `Single<Void>` | `rxExchangeDeclare(String exchange, String type, boolean durable, boolean autoDelete, JsonObject config)` Declare an exchange with additional parameters such as dead lettering, an alternate exchange or TTL.
    `Single<Void>` | `rxExchangeDelete(String exchange)` Delete an exchange, without regard for whether it is in use or not.
    `Single<Void>` | `rxExchangeUnbind(String destination, String source, String routingKey)` Unbind an exchange from an exchange.
    `Single<Long>` | `rxMessageCount(String queue)` Returns the number of messages in a queue ready to be delivered.
    `Single<Void>` | `rxQueueBind(String queue, String exchange, String routingKey)` Bind a queue to an exchange
    `Single<JsonObject>` | `rxQueueDeclare(String queue, boolean durable, boolean exclusive, boolean autoDelete)` Declare a queue
    `Single<JsonObject>` | `rxQueueDeclare(String queue, boolean durable, boolean exclusive, boolean autoDelete, JsonObject config)` Declare a queue with config options
    `Single<JsonObject>` | `rxQueueDeclareAuto()` Actively declare a server-named exclusive, autodelete, non-durable queue.
    `Single<JsonObject>` | `rxQueueDelete(String queue)` Delete a queue, without regard for whether it is in use or has messages on it
    `Single<JsonObject>` | `rxQueueDeleteIf(String queue, boolean ifUnused, boolean ifEmpty)` Delete a queue
    `Single<Void>` | `rxStart()` Start the rabbitMQ client.
    `Single<Void>` | `rxStop()` Stop the rabbitMQ client.
    `Single<Void>` | `rxWaitForConfirms()` Wait until all messages published since the last call have been either ack'd or nack'd by the broker.
    `Single<Void>` | `rxWaitForConfirms(long timeout)` Wait until all messages published since the last call have been either ack'd or nack'd by the broker; or until timeout elapses.
    `void` | `start(Handler<AsyncResult<Void>> resultHandler)` Start the rabbitMQ client.
    `Observable<Void>` | `startObservable()` Deprecated. use `rxStart()` instead
    `void` | `stop(Handler<AsyncResult<Void>> resultHandler)` Stop the rabbitMQ client.
    `Observable<Void>` | `stopObservable()` Deprecated. use `rxStop()` instead
    `String` | `toString()`
    `void` | `waitForConfirms(Handler<AsyncResult<Void>> resultHandler)` Wait until all messages published since the last call have been either ack'd or nack'd by the broker.
    `void` | `waitForConfirms(long timeout, Handler<AsyncResult<Void>> 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.
    `Observable<Void>` | `waitForConfirmsObservable()` Deprecated. use `rxWaitForConfirms()` instead
    `Observable<Void>` | `waitForConfirmsObservable(long timeout)` Deprecated. use `rxWaitForConfirms()` instead

    - ### Methods inherited from class java.lang.Object

      `clone, finalize, getClass, notify, notifyAll, wait, wait, wait`

- - ### Field Detail

    - #### __TYPE_ARG

          public static final io.vertx.lang.rx.TypeArg<RabbitMQClient> __TYPE_ARG

  - ### Constructor Detail

    - #### RabbitMQClient

          public RabbitMQClient(RabbitMQClient delegate)

  - ### Method Detail

    - #### toString

          public String toString()

      Overrides:
        `toString` in class `Object`

    - #### equals

          public boolean equals(Object o)

      Overrides:
        `equals` in class `Object`

    - #### hashCode

          public int hashCode()

      Overrides:
        `hashCode` in class `Object`

    - #### getDelegate

          public RabbitMQClient getDelegate()

    - #### create

          public static RabbitMQClient create(Vertx vertx)

      Create and return a client configured with the default options.
      Parameters:
        `vertx` - the vertx instance
      Returns:
        the client

    - #### create

          public static RabbitMQClient create(Vertx vertx,
                                              RabbitMQOptions config)

      Create and return a client.
      Parameters:
        `vertx` - the vertx instance
        `config` - the client config
      Returns:
        the client

    - #### basicAck

          public void basicAck(long deliveryTag,
                               boolean multiple,
                               Handler<AsyncResult<JsonObject>> 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.
      Parameters:
        `deliveryTag` -
        `multiple` -
        `resultHandler` -

    - #### basicAckObservable

          @Deprecated
          public Observable<JsonObject> basicAckObservable(long deliveryTag,
                                                                       boolean multiple)

      Deprecated. use `rxBasicAck(long, boolean)` 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.
      Parameters:
        `deliveryTag` -
        `multiple` -
      Returns:

    - #### rxBasicAck

          public Single<JsonObject> rxBasicAck(long deliveryTag,
                                               boolean multiple)

      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.
      Parameters:
        `deliveryTag` -
        `multiple` -
      Returns:

    - #### basicNack

          public void basicNack(long deliveryTag,
                                boolean multiple,
                                boolean requeue,
                                Handler<AsyncResult<JsonObject>> resultHandler)

      Reject one or several received messages.
      Parameters:
        `deliveryTag` -
        `multiple` -
        `requeue` -
        `resultHandler` -

    - #### basicNackObservable

          @Deprecated
          public Observable<JsonObject> basicNackObservable(long deliveryTag,
                                                                        boolean multiple,
                                                                        boolean requeue)

      Deprecated. use `rxBasicNack(long, boolean, boolean)` instead
      Reject one or several received messages.
      Parameters:
        `deliveryTag` -
        `multiple` -
        `requeue` -
      Returns:

    - #### rxBasicNack

          public Single<JsonObject> rxBasicNack(long deliveryTag,
                                                boolean multiple,
                                                boolean requeue)

      Reject one or several received messages.
      Parameters:
        `deliveryTag` -
        `multiple` -
        `requeue` -
      Returns:

    - #### basicGet

          public void basicGet(String queue,
                               boolean autoAck,
                               Handler<AsyncResult<JsonObject>> resultHandler)

      Retrieve a message from a queue using AMQP.Basic.Get
      Parameters:
        `queue` -
        `autoAck` -
        `resultHandler` -

    - #### basicGetObservable

          @Deprecated
          public Observable<JsonObject> basicGetObservable(String queue,
                                                                       boolean autoAck)

      Deprecated. use `rxBasicGet(java.lang.String, boolean)` instead
      Retrieve a message from a queue using AMQP.Basic.Get
      Parameters:
        `queue` -
        `autoAck` -
      Returns:

    - #### rxBasicGet

          public Single<JsonObject> rxBasicGet(String queue,
                                               boolean autoAck)

      Retrieve a message from a queue using AMQP.Basic.Get
      Parameters:
        `queue` -
        `autoAck` -
      Returns:

    - #### basicConsume

          @Deprecated
          public void basicConsume(String queue,
                                               String address,
                                               Handler<AsyncResult<String>> resultHandler)

      Deprecated.
      Use `basicConsumer(java.lang.String, io.vertx.core.Handler<io.vertx.core.AsyncResult<io.vertx.rxjava.rabbitmq.RabbitMQConsumer>>)` instead

      Start a non-nolocal, non-exclusive consumer, with auto acknowledgement and a server-generated consumerTag.

      Parameters:
        `queue` -
        `address` -
        `resultHandler` -

    - #### basicConsumeObservable

          @Deprecated
          public Observable<String> basicConsumeObservable(String queue,
                                                                       String address)

      Deprecated. use `rxBasicConsume(java.lang.String, java.lang.String)` instead
      Use `basicConsumer(java.lang.String, io.vertx.core.Handler<io.vertx.core.AsyncResult<io.vertx.rxjava.rabbitmq.RabbitMQConsumer>>)` instead

      Start a non-nolocal, non-exclusive consumer, with auto acknowledgement and a server-generated consumerTag.

      Parameters:
        `queue` -
        `address` -
      Returns:

    - #### rxBasicConsume

          @Deprecated
          public Single<String> rxBasicConsume(String queue,
                                                           String address)

      Deprecated.
      Use `basicConsumer(java.lang.String, io.vertx.core.Handler<io.vertx.core.AsyncResult<io.vertx.rxjava.rabbitmq.RabbitMQConsumer>>)` instead

      Start a non-nolocal, non-exclusive consumer, with auto acknowledgement and a server-generated consumerTag.

      Parameters:
        `queue` -
        `address` -
      Returns:

    - #### basicConsume

          @Deprecated
          public void basicConsume(String queue,
                                               String address,
                                               boolean autoAck,
                                               Handler<AsyncResult<String>> resultHandler)

      Deprecated.
      Use `basicConsumer(java.lang.String, io.vertx.core.Handler<io.vertx.core.AsyncResult<io.vertx.rxjava.rabbitmq.RabbitMQConsumer>>)` instead

      Start a non-nolocal, non-exclusive consumer, with a server-generated consumerTag.

      Parameters:
        `queue` -
        `address` -
        `autoAck` -
        `resultHandler` -

    - #### basicConsumeObservable

          @Deprecated
          public Observable<String> basicConsumeObservable(String queue,
                                                                       String address,
                                                                       boolean autoAck)

      Deprecated. use `rxBasicConsume(java.lang.String, java.lang.String)` instead
      Use `basicConsumer(java.lang.String, io.vertx.core.Handler<io.vertx.core.AsyncResult<io.vertx.rxjava.rabbitmq.RabbitMQConsumer>>)` instead

      Start a non-nolocal, non-exclusive consumer, with a server-generated consumerTag.

      Parameters:
        `queue` -
        `address` -
        `autoAck` -
      Returns:

    - #### rxBasicConsume

          @Deprecated
          public Single<String> rxBasicConsume(String queue,
                                                           String address,
                                                           boolean autoAck)

      Deprecated.
      Use `basicConsumer(java.lang.String, io.vertx.core.Handler<io.vertx.core.AsyncResult<io.vertx.rxjava.rabbitmq.RabbitMQConsumer>>)` instead

      Start a non-nolocal, non-exclusive consumer, with a server-generated consumerTag.

      Parameters:
        `queue` -
        `address` -
        `autoAck` -
      Returns:

    - #### basicConsume

          @Deprecated
          public void basicConsume(String queue,
                                               String address,
                                               boolean autoAck,
                                               Handler<AsyncResult<String>> resultHandler,
                                               Handler<Throwable> errorHandler)

      Deprecated.
      Use `basicConsumer(java.lang.String, io.vertx.core.Handler<io.vertx.core.AsyncResult<io.vertx.rxjava.rabbitmq.RabbitMQConsumer>>)` instead

      Start a non-nolocal, non-exclusive consumer, with a server-generated consumerTag and error handler

      Parameters:
        `queue` -
        `address` -
        `autoAck` -
        `resultHandler` -
        `errorHandler` -

    - #### basicCancel

          @Deprecated
          public void basicCancel(String consumerTag)

      Deprecated.
      Instead of using this and `basicConsume(java.lang.String, java.lang.String, io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.String>>)` method, `basicConsumer(java.lang.String, io.vertx.core.Handler<io.vertx.core.AsyncResult<io.vertx.rxjava.rabbitmq.RabbitMQConsumer>>)` and `RabbitMQConsumer.cancel()` instead

      This method should be called when you want to cancel consumption from a queue, started by calling `basicConsume(java.lang.String, java.lang.String, io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.String>>)`.

      Parameters:
        `consumerTag` -

    - #### basicCancel

          @Deprecated
          public void basicCancel(String consumerTag,
                                              Handler<AsyncResult<Void>> resultHandler)

      Deprecated.
      Instead of using this and `basicConsume(java.lang.String, java.lang.String, io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.String>>)` method, `basicConsumer(java.lang.String, io.vertx.core.Handler<io.vertx.core.AsyncResult<io.vertx.rxjava.rabbitmq.RabbitMQConsumer>>)` and `RabbitMQConsumer.cancel()` instead

      This method should be called when you want to cancel consumption from a queue, started by calling `basicConsume(java.lang.String, java.lang.String, io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.String>>)`.

      Parameters:
        `consumerTag` -
        `resultHandler` -

    - #### basicCancelObservable

          @Deprecated
          public Observable<Void> basicCancelObservable(String consumerTag)

      Deprecated. use `rxBasicCancel(java.lang.String)` instead
      Instead of using this and `basicConsume(java.lang.String, java.lang.String, io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.String>>)` method, `basicConsumer(java.lang.String, io.vertx.core.Handler<io.vertx.core.AsyncResult<io.vertx.rxjava.rabbitmq.RabbitMQConsumer>>)` and `RabbitMQConsumer.cancel()` instead

      This method should be called when you want to cancel consumption from a queue, started by calling `basicConsume(java.lang.String, java.lang.String, io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.String>>)`.

      Parameters:
        `consumerTag` -
      Returns:

    - #### rxBasicCancel

          @Deprecated
          public Single<Void> rxBasicCancel(String consumerTag)

      Deprecated.
      Instead of using this and `basicConsume(java.lang.String, java.lang.String, io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.String>>)` method, `basicConsumer(java.lang.String, io.vertx.core.Handler<io.vertx.core.AsyncResult<io.vertx.rxjava.rabbitmq.RabbitMQConsumer>>)` and `RabbitMQConsumer.cancel()` instead

      This method should be called when you want to cancel consumption from a queue, started by calling `basicConsume(java.lang.String, java.lang.String, io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.String>>)`.

      Parameters:
        `consumerTag` -
      Returns:

    - #### basicConsumer

          public void basicConsumer(String queue,
                                    Handler<AsyncResult<RabbitMQConsumer>> resultHandler)

      Parameters:
        `queue` -
        `resultHandler` -

    - #### basicConsumerObservable

          @Deprecated
          public Observable<RabbitMQConsumer> basicConsumerObservable(String queue)

      Deprecated. use `rxBasicConsumer(java.lang.String)` instead
      Parameters:
        `queue` -
      Returns:

    - #### rxBasicConsumer

          public Single<RabbitMQConsumer> rxBasicConsumer(String queue)

      Parameters:
        `queue` -
      Returns:

    - #### basicConsumer

          public void basicConsumer(String queue,
                                    QueueOptions options,
                                    Handler<AsyncResult<RabbitMQConsumer>> resultHandler)

      Create a consumer with the given `options`.
      Parameters:
        `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`

    - #### basicConsumerObservable

          @Deprecated
          public Observable<RabbitMQConsumer> basicConsumerObservable(String queue,
                                                                                  QueueOptions options)

      Deprecated. use `rxBasicConsumer(java.lang.String)` instead
      Create a consumer with the given `options`.
      Parameters:
        `queue` - the name of a queue
        `options` - options for queue
      Returns:

    - #### rxBasicConsumer

          public Single<RabbitMQConsumer> rxBasicConsumer(String queue,
                                                          QueueOptions options)

      Create a consumer with the given `options`.
      Parameters:
        `queue` - the name of a queue
        `options` - options for queue
      Returns:

    - #### basicPublish

          public void basicPublish(String exchange,
                                   String routingKey,
                                   JsonObject message,
                                   Handler<AsyncResult<Void>> 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.
      Parameters:
        `exchange` -
        `routingKey` -
        `message` -
        `resultHandler` -

    - #### basicPublishObservable

          @Deprecated
          public Observable<Void> basicPublishObservable(String exchange,
                                                                     String routingKey,
                                                                     JsonObject message)

      Deprecated. use `rxBasicPublish(java.lang.String, java.lang.String, io.vertx.core.json.JsonObject)` 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.
      Parameters:
        `exchange` -
        `routingKey` -
        `message` -
      Returns:

    - #### rxBasicPublish

          public Single<Void> rxBasicPublish(String exchange,
                                             String routingKey,
                                             JsonObject message)

      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.
      Parameters:
        `exchange` -
        `routingKey` -
        `message` -
      Returns:

    - #### confirmSelect

          public void confirmSelect(Handler<AsyncResult<Void>> resultHandler)

      Enables publisher acknowledgements on this channel. Can be called once during client initialisation. Calls to basicPublish() will have to be confirmed.
      Parameters:
        `resultHandler` -

    - #### confirmSelectObservable

          @Deprecated
          public Observable<Void> confirmSelectObservable()

      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.
      Returns:

    - #### rxConfirmSelect

          public Single<Void> rxConfirmSelect()

      Enables publisher acknowledgements on this channel. Can be called once during client initialisation. Calls to basicPublish() will have to be confirmed.
      Returns:

    - #### waitForConfirms

          public void waitForConfirms(Handler<AsyncResult<Void>> 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.
      Parameters:
        `resultHandler` -

    - #### waitForConfirmsObservable

          @Deprecated
          public Observable<Void> waitForConfirmsObservable()

      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.
      Returns:

    - #### rxWaitForConfirms

          public Single<Void> rxWaitForConfirms()

      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:

    - #### waitForConfirms

          public void waitForConfirms(long timeout,
                                      Handler<AsyncResult<Void>> 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.
      Parameters:
        `timeout` -
        `resultHandler` -

    - #### waitForConfirmsObservable

          @Deprecated
          public Observable<Void> waitForConfirmsObservable(long timeout)

      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.
      Parameters:
        `timeout` -
      Returns:

    - #### rxWaitForConfirms

          public Single<Void> rxWaitForConfirms(long timeout)

      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.
      Parameters:
        `timeout` -
      Returns:

    - #### basicQos

          public void basicQos(int prefetchCount,
                               Handler<AsyncResult<Void>> resultHandler)

      Request a specific prefetchCount "quality of service" settings for this channel.
      Parameters:
        `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

    - #### basicQosObservable

          @Deprecated
          public Observable<Void> basicQosObservable(int prefetchCount)

      Deprecated. use `rxBasicQos(int)` instead
      Request a specific prefetchCount "quality of service" settings for this channel.
      Parameters:
        `prefetchCount` - maximum number of messages that the server will deliver, 0 if unlimited
      Returns:

    - #### rxBasicQos

          public Single<Void> rxBasicQos(int prefetchCount)

      Request a specific prefetchCount "quality of service" settings for this channel.
      Parameters:
        `prefetchCount` - maximum number of messages that the server will deliver, 0 if unlimited
      Returns:

    - #### basicQos

          public void basicQos(int prefetchCount,
                               boolean global,
                               Handler<AsyncResult<Void>> resultHandler)

      Request a specific prefetchCount "quality of service" settings for this channel.
      Parameters:
        `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

    - #### basicQosObservable

          @Deprecated
          public Observable<Void> basicQosObservable(int prefetchCount,
                                                                 boolean global)

      Deprecated. use `rxBasicQos(int)` instead
      Request a specific prefetchCount "quality of service" settings for this channel.
      Parameters:
        `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:

    - #### rxBasicQos

          public Single<Void> rxBasicQos(int prefetchCount,
                                         boolean global)

      Request a specific prefetchCount "quality of service" settings for this channel.
      Parameters:
        `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:

    - #### basicQos

          public void basicQos(int prefetchSize,
                               int prefetchCount,
                               boolean global,
                               Handler<AsyncResult<Void>> 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.
      Parameters:
        `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

    - #### basicQosObservable

          @Deprecated
          public Observable<Void> basicQosObservable(int prefetchSize,
                                                                 int prefetchCount,
                                                                 boolean global)

      Deprecated. use `rxBasicQos(int)` 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.
      Parameters:
        `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:

    - #### rxBasicQos

          public Single<Void> rxBasicQos(int prefetchSize,
                                         int prefetchCount,
                                         boolean global)

      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.
      Parameters:
        `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:

    - #### exchangeDeclare

          public void exchangeDeclare(String exchange,
                                      String type,
                                      boolean durable,
                                      boolean autoDelete,
                                      Handler<AsyncResult<Void>> resultHandler)

      Declare an exchange.
      Parameters:
        `exchange` -
        `type` -
        `durable` -
        `autoDelete` -
        `resultHandler` -

    - #### exchangeDeclareObservable

          @Deprecated
          public Observable<Void> exchangeDeclareObservable(String exchange,
                                                                        String type,
                                                                        boolean durable,
                                                                        boolean autoDelete)

      Deprecated. use `rxExchangeDeclare(java.lang.String, java.lang.String, boolean, boolean)` instead
      Declare an exchange.
      Parameters:
        `exchange` -
        `type` -
        `durable` -
        `autoDelete` -
      Returns:

    - #### rxExchangeDeclare

          public Single<Void> rxExchangeDeclare(String exchange,
                                                String type,
                                                boolean durable,
                                                boolean autoDelete)

      Declare an exchange.
      Parameters:
        `exchange` -
        `type` -
        `durable` -
        `autoDelete` -
      Returns:

    - #### exchangeDeclare

          public void exchangeDeclare(String exchange,
                                      String type,
                                      boolean durable,
                                      boolean autoDelete,
                                      JsonObject config,
                                      Handler<AsyncResult<Void>> resultHandler)

      Declare an exchange with additional parameters such as dead lettering, an alternate exchange or TTL.
      Parameters:
        `exchange` -
        `type` -
        `durable` -
        `autoDelete` -
        `config` -
        `resultHandler` -

    - #### exchangeDeclareObservable

          @Deprecated
          public Observable<Void> exchangeDeclareObservable(String exchange,
                                                                        String type,
                                                                        boolean durable,
                                                                        boolean autoDelete,
                                                                        JsonObject config)

      Deprecated. use `rxExchangeDeclare(java.lang.String, java.lang.String, boolean, boolean)` instead
      Declare an exchange with additional parameters such as dead lettering, an alternate exchange or TTL.
      Parameters:
        `exchange` -
        `type` -
        `durable` -
        `autoDelete` -
        `config` -
      Returns:

    - #### rxExchangeDeclare

          public Single<Void> rxExchangeDeclare(String exchange,
                                                String type,
                                                boolean durable,
                                                boolean autoDelete,
                                                JsonObject config)

      Declare an exchange with additional parameters such as dead lettering, an alternate exchange or TTL.
      Parameters:
        `exchange` -
        `type` -
        `durable` -
        `autoDelete` -
        `config` -
      Returns:

    - #### exchangeDelete

          public void exchangeDelete(String exchange,
                                     Handler<AsyncResult<Void>> resultHandler)

      Delete an exchange, without regard for whether it is in use or not.
      Parameters:
        `exchange` -
        `resultHandler` -

    - #### exchangeDeleteObservable

          @Deprecated
          public Observable<Void> exchangeDeleteObservable(String exchange)

      Deprecated. use `rxExchangeDelete(java.lang.String)` instead
      Delete an exchange, without regard for whether it is in use or not.
      Parameters:
        `exchange` -
      Returns:

    - #### rxExchangeDelete

          public Single<Void> rxExchangeDelete(String exchange)

      Delete an exchange, without regard for whether it is in use or not.
      Parameters:
        `exchange` -
      Returns:

    - #### exchangeBind

          public void exchangeBind(String destination,
                                   String source,
                                   String routingKey,
                                   Handler<AsyncResult<Void>> resultHandler)

      Bind an exchange to an exchange.
      Parameters:
        `destination` -
        `source` -
        `routingKey` -
        `resultHandler` -

    - #### exchangeBindObservable

          @Deprecated
          public Observable<Void> exchangeBindObservable(String destination,
                                                                     String source,
                                                                     String routingKey)

      Deprecated. use `rxExchangeBind(java.lang.String, java.lang.String, java.lang.String)` instead
      Bind an exchange to an exchange.
      Parameters:
        `destination` -
        `source` -
        `routingKey` -
      Returns:

    - #### rxExchangeBind

          public Single<Void> rxExchangeBind(String destination,
                                             String source,
                                             String routingKey)

      Bind an exchange to an exchange.
      Parameters:
        `destination` -
        `source` -
        `routingKey` -
      Returns:

    - #### exchangeUnbind

          public void exchangeUnbind(String destination,
                                     String source,
                                     String routingKey,
                                     Handler<AsyncResult<Void>> resultHandler)

      Unbind an exchange from an exchange.
      Parameters:
        `destination` -
        `source` -
        `routingKey` -
        `resultHandler` -

    - #### exchangeUnbindObservable

          @Deprecated
          public Observable<Void> exchangeUnbindObservable(String destination,
                                                                       String source,
                                                                       String routingKey)

      Deprecated. use `rxExchangeUnbind(java.lang.String, java.lang.String, java.lang.String)` instead
      Unbind an exchange from an exchange.
      Parameters:
        `destination` -
        `source` -
        `routingKey` -
      Returns:

    - #### rxExchangeUnbind

          public Single<Void> rxExchangeUnbind(String destination,
                                               String source,
                                               String routingKey)

      Unbind an exchange from an exchange.
      Parameters:
        `destination` -
        `source` -
        `routingKey` -
      Returns:

    - #### queueDeclareAuto

          public void queueDeclareAuto(Handler<AsyncResult<JsonObject>> resultHandler)

      Actively declare a server-named exclusive, autodelete, non-durable queue.
      Parameters:
        `resultHandler` -

    - #### queueDeclareAutoObservable

          @Deprecated
          public Observable<JsonObject> queueDeclareAutoObservable()

      Deprecated. use `rxQueueDeclareAuto()` instead
      Actively declare a server-named exclusive, autodelete, non-durable queue.
      Returns:

    - #### rxQueueDeclareAuto

          public Single<JsonObject> rxQueueDeclareAuto()

      Actively declare a server-named exclusive, autodelete, non-durable queue.
      Returns:

    - #### queueDeclare

          public void queueDeclare(String queue,
                                   boolean durable,
                                   boolean exclusive,
                                   boolean autoDelete,
                                   Handler<AsyncResult<JsonObject>> resultHandler)

      Declare a queue
      Parameters:
        `queue` -
        `durable` -
        `exclusive` -
        `autoDelete` -
        `resultHandler` -

    - #### queueDeclareObservable

          @Deprecated
          public Observable<JsonObject> queueDeclareObservable(String queue,
                                                                           boolean durable,
                                                                           boolean exclusive,
                                                                           boolean autoDelete)

      Deprecated. use `rxQueueDeclare(java.lang.String, boolean, boolean, boolean)` instead
      Declare a queue
      Parameters:
        `queue` -
        `durable` -
        `exclusive` -
        `autoDelete` -
      Returns:

    - #### rxQueueDeclare

          public Single<JsonObject> rxQueueDeclare(String queue,
                                                   boolean durable,
                                                   boolean exclusive,
                                                   boolean autoDelete)

      Declare a queue
      Parameters:
        `queue` -
        `durable` -
        `exclusive` -
        `autoDelete` -
      Returns:

    - #### queueDeclare

          public void queueDeclare(String queue,
                                   boolean durable,
                                   boolean exclusive,
                                   boolean autoDelete,
                                   JsonObject config,
                                   Handler<AsyncResult<JsonObject>> resultHandler)

      Declare a queue with config options
      Parameters:
        `queue` -
        `durable` -
        `exclusive` -
        `autoDelete` -
        `config` -
        `resultHandler` -

    - #### queueDeclareObservable

          @Deprecated
          public Observable<JsonObject> queueDeclareObservable(String queue,
                                                                           boolean durable,
                                                                           boolean exclusive,
                                                                           boolean autoDelete,
                                                                           JsonObject config)

      Deprecated. use `rxQueueDeclare(java.lang.String, boolean, boolean, boolean)` instead
      Declare a queue with config options
      Parameters:
        `queue` -
        `durable` -
        `exclusive` -
        `autoDelete` -
        `config` -
      Returns:

    - #### rxQueueDeclare

          public Single<JsonObject> rxQueueDeclare(String queue,
                                                   boolean durable,
                                                   boolean exclusive,
                                                   boolean autoDelete,
                                                   JsonObject config)

      Declare a queue with config options
      Parameters:
        `queue` -
        `durable` -
        `exclusive` -
        `autoDelete` -
        `config` -
      Returns:

    - #### queueDelete

          public void queueDelete(String queue,
                                  Handler<AsyncResult<JsonObject>> resultHandler)

      Delete a queue, without regard for whether it is in use or has messages on it
      Parameters:
        `queue` -
        `resultHandler` -

    - #### queueDeleteObservable

          @Deprecated
          public Observable<JsonObject> queueDeleteObservable(String queue)

      Deprecated. use `rxQueueDelete(java.lang.String)` instead
      Delete a queue, without regard for whether it is in use or has messages on it
      Parameters:
        `queue` -
      Returns:

    - #### rxQueueDelete

          public Single<JsonObject> rxQueueDelete(String queue)

      Delete a queue, without regard for whether it is in use or has messages on it
      Parameters:
        `queue` -
      Returns:

    - #### queueDeleteIf

          public void queueDeleteIf(String queue,
                                    boolean ifUnused,
                                    boolean ifEmpty,
                                    Handler<AsyncResult<JsonObject>> resultHandler)

      Delete a queue
      Parameters:
        `queue` -
        `ifUnused` -
        `ifEmpty` -
        `resultHandler` -

    - #### queueDeleteIfObservable

          @Deprecated
          public Observable<JsonObject> queueDeleteIfObservable(String queue,
                                                                            boolean ifUnused,
                                                                            boolean ifEmpty)

      Deprecated. use `rxQueueDeleteIf(java.lang.String, boolean, boolean)` instead
      Delete a queue
      Parameters:
        `queue` -
        `ifUnused` -
        `ifEmpty` -
      Returns:

    - #### rxQueueDeleteIf

          public Single<JsonObject> rxQueueDeleteIf(String queue,
                                                    boolean ifUnused,
                                                    boolean ifEmpty)

      Delete a queue
      Parameters:
        `queue` -
        `ifUnused` -
        `ifEmpty` -
      Returns:

    - #### queueBind

          public void queueBind(String queue,
                                String exchange,
                                String routingKey,
                                Handler<AsyncResult<Void>> resultHandler)

      Bind a queue to an exchange
      Parameters:
        `queue` -
        `exchange` -
        `routingKey` -
        `resultHandler` -

    - #### queueBindObservable

          @Deprecated
          public Observable<Void> queueBindObservable(String queue,
                                                                  String exchange,
                                                                  String routingKey)

      Deprecated. use `rxQueueBind(java.lang.String, java.lang.String, java.lang.String)` instead
      Bind a queue to an exchange
      Parameters:
        `queue` -
        `exchange` -
        `routingKey` -
      Returns:

    - #### rxQueueBind

          public Single<Void> rxQueueBind(String queue,
                                          String exchange,
                                          String routingKey)

      Bind a queue to an exchange
      Parameters:
        `queue` -
        `exchange` -
        `routingKey` -
      Returns:

    - #### messageCount

          public void messageCount(String queue,
                                   Handler<AsyncResult<Long>> resultHandler)

      Returns the number of messages in a queue ready to be delivered.
      Parameters:
        `queue` -
        `resultHandler` -

    - #### messageCountObservable

          @Deprecated
          public Observable<Long> messageCountObservable(String queue)

      Deprecated. use `rxMessageCount(java.lang.String)` instead
      Returns the number of messages in a queue ready to be delivered.
      Parameters:
        `queue` -
      Returns:

    - #### rxMessageCount

          public Single<Long> rxMessageCount(String queue)

      Returns the number of messages in a queue ready to be delivered.
      Parameters:
        `queue` -
      Returns:

    - #### start

          public void start(Handler<AsyncResult<Void>> resultHandler)

      Start the rabbitMQ client. Create the connection and the chanel.
      Parameters:
        `resultHandler` -

    - #### startObservable

          @Deprecated
          public Observable<Void> startObservable()

      Deprecated. use `rxStart()` instead
      Start the rabbitMQ client. Create the connection and the chanel.
      Returns:

    - #### rxStart

          public Single<Void> rxStart()

      Start the rabbitMQ client. Create the connection and the chanel.
      Returns:

    - #### stop

          public void stop(Handler<AsyncResult<Void>> resultHandler)

      Stop the rabbitMQ client. Close the connection and its chanel.
      Parameters:
        `resultHandler` -

    - #### stopObservable

          @Deprecated
          public Observable<Void> stopObservable()

      Deprecated. use `rxStop()` instead
      Stop the rabbitMQ client. Close the connection and its chanel.
      Returns:

    - #### rxStop

          public Single<Void> rxStop()

      Stop the rabbitMQ client. Close the connection and its chanel.
      Returns:

    - #### isConnected

          public boolean isConnected()

      Check if a connection is open
      Returns:
        true when the connection is open, false otherwise

    - #### isOpenChannel

          public boolean isOpenChannel()

      Check if a channel is open
      Returns:
        true when the connection is open, false otherwise

    - #### newInstance

          public static RabbitMQClient newInstance(RabbitMQClient arg)

Copyright © 2019 Eclipse. All rights reserved.