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 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.
    `rx.Observable<JsonObject>` | `basicAckObservable(long deliveryTag, boolean multiple)` Deprecated. use `rxBasicAck(long, boolean)` instead
    `void` | `basicConsume(String queue, String address, boolean autoAck, Handler<AsyncResult<Void>> resultHandler)` Start a non-nolocal, non-exclusive consumer, with a server-generated consumerTag.
    `void` | `basicConsume(String queue, String address, Handler<AsyncResult<Void>> resultHandler)` Start a non-nolocal, non-exclusive consumer, with auto acknowledgement and a server-generated consumerTag.
    `rx.Observable<Void>` | `basicConsumeObservable(String queue, String address)` Deprecated. use `rxBasicConsume(java.lang.String, java.lang.String)` instead
    `rx.Observable<Void>` | `basicConsumeObservable(String queue, String address, boolean autoAck)` Deprecated. use `rxBasicConsume(java.lang.String, java.lang.String)` instead
    `void` | `basicGet(String queue, boolean autoAck, Handler<AsyncResult<JsonObject>> resultHandler)` Retrieve a message from a queue using AMQP.Basic.Get
    `rx.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.
    `rx.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.
    `rx.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, Handler<AsyncResult<Void>> resultHandler)` Request specific "quality of service" settings, Limiting the number of unacknowledged messages on a channel (or connection).
    `rx.Observable<Void>` | `basicQosObservable(int prefetchCount)` Deprecated. use `rxBasicQos(int)` instead
    `static RabbitMQClient` | `create(Vertx vertx, JsonObject config)`
    `void` | `exchangeBind(String destination, String source, String routingKey, Handler<AsyncResult<Void>> resultHandler)` Bind an exchange to an exchange.
    `rx.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, Map<String,String> config, Handler<AsyncResult<Void>> resultHandler)` Declare an exchange with additional parameters such as dead lettering or an alternate exchnage.
    `rx.Observable<Void>` | `exchangeDeclareObservable(String exchange, String type, boolean durable, boolean autoDelete)` Deprecated. use `rxExchangeDeclare(java.lang.String, java.lang.String, boolean, boolean)` instead
    `rx.Observable<Void>` | `exchangeDeclareObservable(String exchange, String type, boolean durable, boolean autoDelete, Map<String,String> 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.
    `rx.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.
    `rx.Observable<Void>` | `exchangeUnbindObservable(String destination, String source, String routingKey)` Deprecated. use `rxExchangeUnbind(java.lang.String, java.lang.String, java.lang.String)` instead
    `RabbitMQClient` | `getDelegate()`
    `boolean` | `isConnected()` Check if a connection is open
    `boolean` | `isOpenChannel()` Check if a channel is open
    `void` | `messageCount(String queue, Handler<AsyncResult<JsonObject>> resultHandler)` Returns the number of messages in a queue ready to be delivered.
    `rx.Observable<JsonObject>` | `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
    `rx.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` | `queueDeclareAuto(Handler<AsyncResult<JsonObject>> resultHandler)` Actively declare a server-named exclusive, autodelete, non-durable queue.
    `rx.Observable<JsonObject>` | `queueDeclareAutoObservable()` Deprecated. use `rxQueueDeclareAuto()` instead
    `rx.Observable<JsonObject>` | `queueDeclareObservable(String queue, boolean durable, boolean exclusive, boolean autoDelete)` 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
    `rx.Observable<JsonObject>` | `queueDeleteIfObservable(String queue, boolean ifUnused, boolean ifEmpty)` Deprecated. use `rxQueueDeleteIf(java.lang.String, boolean, boolean)` instead
    `rx.Observable<JsonObject>` | `queueDeleteObservable(String queue)` Deprecated. use `rxQueueDelete(java.lang.String)` instead
    `rx.Single<JsonObject>` | `rxBasicAck(long deliveryTag, boolean multiple)` Acknowledge one or several received messages.
    `rx.Single<Void>` | `rxBasicConsume(String queue, String address)` Start a non-nolocal, non-exclusive consumer, with auto acknowledgement and a server-generated consumerTag.
    `rx.Single<Void>` | `rxBasicConsume(String queue, String address, boolean autoAck)` Start a non-nolocal, non-exclusive consumer, with a server-generated consumerTag.
    `rx.Single<JsonObject>` | `rxBasicGet(String queue, boolean autoAck)` Retrieve a message from a queue using AMQP.Basic.Get
    `rx.Single<JsonObject>` | `rxBasicNack(long deliveryTag, boolean multiple, boolean requeue)` Reject one or several received messages.
    `rx.Single<Void>` | `rxBasicPublish(String exchange, String routingKey, JsonObject message)` Publish a message.
    `rx.Single<Void>` | `rxBasicQos(int prefetchCount)` Request specific "quality of service" settings, Limiting the number of unacknowledged messages on a channel (or connection).
    `rx.Single<Void>` | `rxExchangeBind(String destination, String source, String routingKey)` Bind an exchange to an exchange.
    `rx.Single<Void>` | `rxExchangeDeclare(String exchange, String type, boolean durable, boolean autoDelete)` Declare an exchange.
    `rx.Single<Void>` | `rxExchangeDeclare(String exchange, String type, boolean durable, boolean autoDelete, Map<String,String> config)` Declare an exchange with additional parameters such as dead lettering or an alternate exchnage.
    `rx.Single<Void>` | `rxExchangeDelete(String exchange)` Delete an exchange, without regard for whether it is in use or not.
    `rx.Single<Void>` | `rxExchangeUnbind(String destination, String source, String routingKey)` Unbind an exchange from an exchange.
    `rx.Single<JsonObject>` | `rxMessageCount(String queue)` Returns the number of messages in a queue ready to be delivered.
    `rx.Single<Void>` | `rxQueueBind(String queue, String exchange, String routingKey)` Bind a queue to an exchange
    `rx.Single<JsonObject>` | `rxQueueDeclare(String queue, boolean durable, boolean exclusive, boolean autoDelete)` Declare a queue
    `rx.Single<JsonObject>` | `rxQueueDeclareAuto()` Actively declare a server-named exclusive, autodelete, non-durable queue.
    `rx.Single<JsonObject>` | `rxQueueDelete(String queue)` Delete a queue, without regard for whether it is in use or has messages on it
    `rx.Single<JsonObject>` | `rxQueueDeleteIf(String queue, boolean ifUnused, boolean ifEmpty)` Delete a queue
    `rx.Single<Void>` | `rxStart()` Start the rabbitMQ client.
    `rx.Single<Void>` | `rxStop()` Stop the rabbitMQ client.
    `void` | `start(Handler<AsyncResult<Void>> resultHandler)` Start the rabbitMQ client.
    `rx.Observable<Void>` | `startObservable()` Deprecated. use `rxStart()` instead
    `void` | `stop(Handler<AsyncResult<Void>> resultHandler)` Stop the rabbitMQ client.
    `rx.Observable<Void>` | `stopObservable()` Deprecated. use `rxStop()` instead

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

      `clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

- - ### Field Detail

    - #### __TYPE_ARG

          public static final TypeArg<RabbitMQClient> __TYPE_ARG

  - ### Constructor Detail

    - #### RabbitMQClient

          public RabbitMQClient(RabbitMQClient delegate)

  - ### Method Detail

    - #### getDelegate

          public RabbitMQClient getDelegate()

    - #### create

          public static RabbitMQClient create(Vertx vertx,
                                              JsonObject config)

    - #### 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 rx.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 rx.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 rx.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 rx.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 rx.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 rx.Single<JsonObject> rxBasicGet(String queue,
                                                  boolean autoAck)

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

    - #### basicConsume

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

      Start a non-nolocal, non-exclusive consumer, with auto acknowledgement and a server-generated consumerTag.
      Parameters:
        `queue` -
        `address` -
        `resultHandler` -

    - #### basicConsumeObservable

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

      Deprecated. use `rxBasicConsume(java.lang.String, java.lang.String)` instead
      Start a non-nolocal, non-exclusive consumer, with auto acknowledgement and a server-generated consumerTag.
      Parameters:
        `queue` -
        `address` -
      Returns:

    - #### rxBasicConsume

          public rx.Single<Void> rxBasicConsume(String queue,
                                                String address)

      Start a non-nolocal, non-exclusive consumer, with auto acknowledgement and a server-generated consumerTag.
      Parameters:
        `queue` -
        `address` -
      Returns:

    - #### basicConsume

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

      Start a non-nolocal, non-exclusive consumer, with a server-generated consumerTag.
      Parameters:
        `queue` -
        `address` -
        `autoAck` -
        `resultHandler` -

    - #### basicConsumeObservable

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

      Deprecated. use `rxBasicConsume(java.lang.String, java.lang.String)` instead
      Start a non-nolocal, non-exclusive consumer, with a server-generated consumerTag.
      Parameters:
        `queue` -
        `address` -
        `autoAck` -
      Returns:

    - #### rxBasicConsume

          public rx.Single<Void> rxBasicConsume(String queue,
                                                String address,
                                                boolean autoAck)

      Start a non-nolocal, non-exclusive consumer, with a server-generated consumerTag.
      Parameters:
        `queue` -
        `address` -
        `autoAck` -
      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 rx.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 rx.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:

    - #### basicQos

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

      Request specific "quality of service" settings, Limiting the number of unacknowledged messages on a channel (or connection). This limit is applied separately to each new consumer on the channel.
      Parameters:
        `prefetchCount` -
        `resultHandler` -

    - #### basicQosObservable

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

      Deprecated. use `rxBasicQos(int)` instead
      Request specific "quality of service" settings, Limiting the number of unacknowledged messages on a channel (or connection). This limit is applied separately to each new consumer on the channel.
      Parameters:
        `prefetchCount` -
      Returns:

    - #### rxBasicQos

          public rx.Single<Void> rxBasicQos(int prefetchCount)

      Request specific "quality of service" settings, Limiting the number of unacknowledged messages on a channel (or connection). This limit is applied separately to each new consumer on the channel.
      Parameters:
        `prefetchCount` -
      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 rx.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 rx.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,
                                      Map<String,String> config,
                                      Handler<AsyncResult<Void>> resultHandler)

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

    - #### exchangeDeclareObservable

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

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

    - #### rxExchangeDeclare

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

      Declare an exchange with additional parameters such as dead lettering or an alternate exchnage.
      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 rx.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 rx.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 rx.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 rx.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 rx.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 rx.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 rx.Observable<JsonObject> queueDeclareAutoObservable()

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

    - #### rxQueueDeclareAuto

          public rx.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 rx.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 rx.Single<JsonObject> rxQueueDeclare(String queue,
                                                      boolean durable,
                                                      boolean exclusive,
                                                      boolean autoDelete)

      Declare a queue
      Parameters:
        `queue` -
        `durable` -
        `exclusive` -
        `autoDelete` -
      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 rx.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 rx.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 rx.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 rx.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 rx.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 rx.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<JsonObject>> resultHandler)

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

    - #### messageCountObservable

          @Deprecated
          public rx.Observable<JsonObject> 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 rx.Single<JsonObject> 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 rx.Observable<Void> startObservable()

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

    - #### rxStart

          public rx.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 rx.Observable<Void> stopObservable()

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

    - #### rxStop

          public rx.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 © 2017. All rights reserved.