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, boolean autoAck, Handler<AsyncResult<Void>> resultHandler, Handler<Throwable> errorHandler)` Start a non-nolocal, non-exclusive consumer, with a server-generated consumerTag and error handler
    `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
    `void` | `confirmSelect(Handler<AsyncResult<Void>> resultHandler)` Enables publisher acknowledgements on this channel.
    `rx.Observable<Void>` | `confirmSelectObservable()` Deprecated. use `rxConfirmSelect()` 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` | `queueDeclare(String queue, boolean durable, boolean exclusive, boolean autoDelete, Map<String,String> 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.
    `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
    `rx.Observable<JsonObject>` | `queueDeclareObservable(String queue, boolean durable, boolean exclusive, boolean autoDelete, Map<String,String> 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
    `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>` | `rxConfirmSelect()` Enables publisher acknowledgements on this channel.
    `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>` | `rxQueueDeclare(String queue, boolean durable, boolean exclusive, boolean autoDelete, Map<String,String> config)` Declare a queue with config options
    `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.
    `rx.Single<Void>` | `rxWaitForConfirms()` Wait until all messages published since the last call have been either ack'd or nack'd by the broker.
    `rx.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.
    `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
    `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.
    `rx.Observable<Void>` | `waitForConfirmsObservable()` Deprecated. use `rxWaitForConfirms()` instead
    `rx.Observable<Void>` | `waitForConfirmsObservable(long timeout)` Deprecated. use `rxWaitForConfirms()` 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:

    - #### basicConsume

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

      Start a non-nolocal, non-exclusive consumer, with a server-generated consumerTag and error handler
      Parameters:
        `queue` -
        `address` -
        `autoAck` -
        `resultHandler` -
        `errorHandler` -

    - #### 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:

    - #### 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 rx.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 rx.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 rx.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 rx.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 rx.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 rx.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 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:

    - #### queueDeclare

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

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

    - #### queueDeclareObservable

          @Deprecated
          public rx.Observable<JsonObject> queueDeclareObservable(String queue,
                                                                              boolean durable,
                                                                              boolean exclusive,
                                                                              boolean autoDelete,
                                                                              Map<String,String> 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 rx.Single<JsonObject> rxQueueDeclare(String queue,
                                                      boolean durable,
                                                      boolean exclusive,
                                                      boolean autoDelete,
                                                      Map<String,String> 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 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.