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.

- - ### Constructor Summary

    Constructors
    Constructor and Description
    `RabbitMQClient(RabbitMQClient delegate)`

  - ### Method Summary

    All Methods Static Methods Instance Methods Concrete 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)` Acknowledge one or several received messages.
    `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.
    `Observable<Void>` | `basicConsumeObservable(String queue, String address)` Start a non-nolocal, non-exclusive consumer, with auto acknowledgement and a server-generated consumerTag.
    `Observable<Void>` | `basicConsumeObservable(String queue, String address, boolean autoAck)` Start a non-nolocal, non-exclusive consumer, with a server-generated consumerTag.
    `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)` Retrieve a message from a queue using AMQP.Basic.Get
    `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)` Reject one or several received messages.
    `void` | `basicPublish(String exchange, String routingKey, JsonObject message, Handler<AsyncResult<Void>> resultHandler)` Publish a message.
    `Observable<Void>` | `basicPublishObservable(String exchange, String routingKey, JsonObject message)` Publish a message.
    `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).
    `Observable<Void>` | `basicQosObservable(int prefetchCount)` Request specific "quality of service" settings, Limiting the number of unacknowledged messages on a channel (or connection).
    `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.
    `Observable<Void>` | `exchangeBindObservable(String destination, String source, String routingKey)` Bind an exchange to an exchange.
    `void` | `exchangeDeclare(String exchange, String type, boolean durable, boolean autoDelete, Handler<AsyncResult<Void>> resultHandler)` Declare an exchange.
    `Observable<Void>` | `exchangeDeclareObservable(String exchange, String type, boolean durable, boolean autoDelete)` Declare an exchange.
    `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)` Delete an exchange, without regard for whether it is in use or not.
    `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)` Unbind an exchange from an exchange.
    `Object` | `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.
    `Observable<JsonObject>` | `messageCountObservable(String queue)` Returns the number of messages in a queue ready to be delivered.
    `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)` Bind a queue to an exchange
    `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.
    `Observable<JsonObject>` | `queueDeclareAutoObservable()` Actively declare a server-named exclusive, autodelete, non-durable queue.
    `Observable<JsonObject>` | `queueDeclareObservable(String queue, boolean durable, boolean exclusive, boolean autoDelete)` Declare a queue
    `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)` Delete a queue
    `Observable<JsonObject>` | `queueDeleteObservable(String queue)` Delete a queue, without regard for whether it is in use or has messages on it
    `void` | `start(Handler<AsyncResult<Void>> resultHandler)` Start the rabbitMQ client.
    `Observable<Void>` | `startObservable()` Start the rabbitMQ client.
    `void` | `stop(Handler<AsyncResult<Void>> resultHandler)` Stop the rabbitMQ client.
    `Observable<Void>` | `stopObservable()` Stop the rabbitMQ client.

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

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

- - ### Constructor Detail

    - #### RabbitMQClient

          public RabbitMQClient(RabbitMQClient delegate)

  - ### Method Detail

    - #### getDelegate

          public Object 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

          public Observable<JsonObject> basicAckObservable(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

          public Observable<JsonObject> basicNackObservable(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

          public Observable<JsonObject> basicGetObservable(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

          public Observable<Void> basicConsumeObservable(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

          public Observable<Void> basicConsumeObservable(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

          public Observable<Void> basicPublishObservable(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

          public Observable<Void> basicQosObservable(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

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

      Declare an exchange.
      Parameters:
        `exchange` -
        `type` -
        `durable` -
        `autoDelete` -
      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

          public Observable<Void> exchangeDeleteObservable(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

          public Observable<Void> exchangeBindObservable(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

          public Observable<Void> exchangeUnbindObservable(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

          public Observable<JsonObject> queueDeclareAutoObservable()

      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

          public Observable<JsonObject> queueDeclareObservable(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

          public Observable<JsonObject> queueDeleteObservable(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

          public Observable<JsonObject> queueDeleteIfObservable(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

          public Observable<Void> queueBindObservable(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

          public Observable<JsonObject> messageCountObservable(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

          public Observable<Void> startObservable()

      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

          public Observable<Void> stopObservable()

      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 © 2016. All rights reserved.