io.vertx.rabbitmq

## Interface RabbitMQClient

-     public interface RabbitMQClient

  Author:
    Nick Scavelli

- - ### Method Summary

    All Methods Static Methods Instance Methods Abstract Methods Default Methods
    Modifier and Type | Method and Description
    --- | ---
    `Future<ReadStream<RabbitMQConfirmation>>` | `addConfirmListener(int maxQueueSize)` Add a Confirm Listener to the channel.
    `void` | `addConfirmListener(int maxQueueSize, Handler<AsyncResult<ReadStream<RabbitMQConfirmation>>> resultHandler)` Add a Confirm Listener to the channel.
    `void` | `addConnectionEstablishedCallback(Handler<Promise<Void>> connectionEstablishedCallback)` Set a callback to be called whenever a new connection is established.
    `Future<Void>` | `basicAck(long deliveryTag, boolean multiple)` Like `basicAck(long, boolean, Handler)` but returns a `Future` of the asynchronous result
    `void` | `basicAck(long deliveryTag, boolean multiple, Handler<AsyncResult<Void>> resultHandler)` Acknowledge one or several received messages.
    `default Future<RabbitMQConsumer>` | `basicConsumer(String queue)` Like `basicConsumer(String, Handler)` but returns a `Future` of the asynchronous result
    `default void` | `basicConsumer(String queue, Handler<AsyncResult<RabbitMQConsumer>> resultHandler)`
    `Future<RabbitMQConsumer>` | `basicConsumer(String queue, QueueOptions options)` Like `basicConsumer(String, QueueOptions, Handler)` but returns a `Future` of the asynchronous result
    `void` | `basicConsumer(String queue, QueueOptions options, Handler<AsyncResult<RabbitMQConsumer>> resultHandler)` Create a consumer with the given `options`.
    `Future<RabbitMQMessage>` | `basicGet(String queue, boolean autoAck)` Like `basicGet(String, boolean, Handler)` but returns a `Future` of the asynchronous result
    `void` | `basicGet(String queue, boolean autoAck, Handler<AsyncResult<RabbitMQMessage>> resultHandler)` Retrieve a message from a queue using AMQP.Basic.Get
    `Future<Void>` | `basicNack(long deliveryTag, boolean multiple, boolean requeue)` Like `basicNack(long, boolean, boolean, Handler)` but returns a `Future` of the asynchronous result
    `void` | `basicNack(long deliveryTag, boolean multiple, boolean requeue, Handler<AsyncResult<Void>> resultHandler)` Reject one or several received messages.
    `Future<Void>` | `basicPublish(String exchange, String routingKey, com.rabbitmq.client.BasicProperties properties, Buffer body)` Like `basicPublish(String, String, BasicProperties, Buffer, Handler)` but returns a `Future` of the asynchronous result
    `void` | `basicPublish(String exchange, String routingKey, com.rabbitmq.client.BasicProperties properties, Buffer body, Handler<AsyncResult<Void>> resultHandler)` Publish a message.
    `Future<Void>` | `basicPublish(String exchange, String routingKey, Buffer body)` Like `basicPublish(String, String, Buffer, Handler)` but returns a `Future` of the asynchronous result
    `void` | `basicPublish(String exchange, String routingKey, Buffer body, Handler<AsyncResult<Void>> resultHandler)` Publish a message.
    `Future<Void>` | `basicPublishWithDeliveryTag(String exchange, String routingKey, com.rabbitmq.client.BasicProperties properties, Buffer body, Handler<Long> deliveryTagHandler)` Publish a message.
    `void` | `basicPublishWithDeliveryTag(String exchange, String routingKey, com.rabbitmq.client.BasicProperties properties, Buffer body, Handler<Long> deliveryTagHandler, Handler<AsyncResult<Void>> resultHandler)` Publish a message.
    `default Future<Void>` | `basicQos(int prefetchCount)` Like `basicQos(int, Handler)` but returns a `Future` of the asynchronous result
    `default Future<Void>` | `basicQos(int prefetchCount, boolean global)` Like `basicQos(int, boolean, Handler)` but returns a `Future` of the asynchronous result
    `default void` | `basicQos(int prefetchCount, boolean global, Handler<AsyncResult<Void>> resultHandler)` Request a specific prefetchCount "quality of service" settings for this channel.
    `default void` | `basicQos(int prefetchCount, Handler<AsyncResult<Void>> resultHandler)` Request a specific prefetchCount "quality of service" settings for this channel.
    `Future<Void>` | `basicQos(int prefetchSize, int prefetchCount, boolean global)` Like `basicQos(int, int, boolean, Handler)` but returns a `Future` of the asynchronous result
    `void` | `basicQos(int prefetchSize, int prefetchCount, boolean global, Handler<AsyncResult<Void>> resultHandler)` Request specific "quality of service" settings.
    `Future<Void>` | `confirmSelect()` Like `confirmSelect(Handler)` but returns a `Future` of the asynchronous result
    `void` | `confirmSelect(Handler<AsyncResult<Void>> resultHandler)` Enables publisher acknowledgements on this channel.
    `static RabbitMQClient` | `create(Vertx vertx)` Create and return a client configured with the default options.
    `static RabbitMQClient` | `create(Vertx vertx, JsonObject config)` Like `create(Vertx, RabbitMQOptions)` but with a `JsonObject` config object.
    `static RabbitMQClient` | `create(Vertx vertx, RabbitMQOptions config)` Create and return a client.
    `Future<Void>` | `exchangeBind(String destination, String source, String routingKey)` Like `exchangeBind(String, String, String, Handler)` but returns a `Future` of the asynchronous result
    `void` | `exchangeBind(String destination, String source, String routingKey, Handler<AsyncResult<Void>> resultHandler)` Bind an exchange to an exchange.
    `Future<Void>` | `exchangeBind(String destination, String source, String routingKey, Map<String,Object> arguments)` Like `exchangeBind(String, String, String, Map, Handler)` but returns a `Future` of the asynchronous result
    `void` | `exchangeBind(String destination, String source, String routingKey, Map<String,Object> arguments, Handler<AsyncResult<Void>> resultHandler)` Bind an exchange to an exchange.
    `Future<Void>` | `exchangeDeclare(String exchange, String type, boolean durable, boolean autoDelete)` Like `exchangeDeclare(String, String, boolean, boolean, Handler)` but returns a `Future` of the asynchronous result
    `void` | `exchangeDeclare(String exchange, String type, boolean durable, boolean autoDelete, Handler<AsyncResult<Void>> resultHandler)` Declare an exchange.
    `Future<Void>` | `exchangeDeclare(String exchange, String type, boolean durable, boolean autoDelete, JsonObject config)` Like `exchangeDeclare(String, String, boolean, boolean, JsonObject, Handler)` but returns a `Future` of the asynchronous result
    `void` | `exchangeDeclare(String exchange, String type, boolean durable, boolean autoDelete, JsonObject config, Handler<AsyncResult<Void>> resultHandler)` Declare an exchange with additional parameters such as dead lettering, an alternate exchange or TTL.
    `Future<Void>` | `exchangeDelete(String exchange)` Like `exchangeDelete(String, Handler)` but returns a `Future` of the asynchronous result
    `void` | `exchangeDelete(String exchange, Handler<AsyncResult<Void>> resultHandler)` Delete an exchange, without regard for whether it is in use or not.
    `Future<Void>` | `exchangeUnbind(String destination, String source, String routingKey)` Like `exchangeUnbind(String, String, String, Handler)` but returns a `Future` of the asynchronous result
    `void` | `exchangeUnbind(String destination, String source, String routingKey, Handler<AsyncResult<Void>> resultHandler)` Unbind an exchange from an exchange.
    `Future<Void>` | `exchangeUnbind(String destination, String source, String routingKey, Map<String,Object> arguments)` Like `exchangeUnbind(String, String, String, Map, Handler)` but returns a `Future` of the asynchronous result
    `void` | `exchangeUnbind(String destination, String source, String routingKey, Map<String,Object> arguments, Handler<AsyncResult<Void>> resultHandler)` Unbind an exchange from an exchange.
    `boolean` | `isConnected()` Check if a connection is open
    `boolean` | `isOpenChannel()` Check if a channel is open
    `Future<Long>` | `messageCount(String queue)` Like `messageCount(String, Handler)` but returns a `Future` of the asynchronous result
    `void` | `messageCount(String queue, Handler<AsyncResult<Long>> resultHandler)` Returns the number of messages in a queue ready to be delivered.
    `Future<Void>` | `queueBind(String queue, String exchange, String routingKey)` Like `queueBind(String, String, String, Handler)` but returns a `Future` of the asynchronous result
    `void` | `queueBind(String queue, String exchange, String routingKey, Handler<AsyncResult<Void>> resultHandler)` Bind a queue to an exchange
    `Future<Void>` | `queueBind(String queue, String exchange, String routingKey, Map<String,Object> arguments)` Like `queueBind(String, String, String, Map, Handler)` but returns a `Future` of the asynchronous result
    `void` | `queueBind(String queue, String exchange, String routingKey, Map<String,Object> arguments, Handler<AsyncResult<Void>> resultHandler)` Bind a queue to an exchange
    `Future<com.rabbitmq.client.AMQP.Queue.DeclareOk>` | `queueDeclare(String queue, boolean durable, boolean exclusive, boolean autoDelete)` Like `queueDeclare(String, boolean, boolean, boolean, Handler)` but returns a `Future` of the asynchronous result
    `void` | `queueDeclare(String queue, boolean durable, boolean exclusive, boolean autoDelete, Handler<AsyncResult<com.rabbitmq.client.AMQP.Queue.DeclareOk>> resultHandler)` Declare a queue
    `Future<com.rabbitmq.client.AMQP.Queue.DeclareOk>` | `queueDeclare(String queue, boolean durable, boolean exclusive, boolean autoDelete, JsonObject config)` Like `queueDeclare(String, boolean, boolean, boolean, JsonObject, Handler)` but returns a `Future` of the asynchronous result
    `void` | `queueDeclare(String queue, boolean durable, boolean exclusive, boolean autoDelete, JsonObject config, Handler<AsyncResult<com.rabbitmq.client.AMQP.Queue.DeclareOk>> resultHandler)` Declare a queue with config options
    `Future<JsonObject>` | `queueDeclareAuto()` Like `queueDeclareAuto(Handler)` but returns a `Future` of the asynchronous result
    `void` | `queueDeclareAuto(Handler<AsyncResult<JsonObject>> resultHandler)` Actively declare a server-named exclusive, autodelete, non-durable queue.
    `Future<com.rabbitmq.client.AMQP.Queue.DeleteOk>` | `queueDelete(String queue)` Like `queueDelete(String, Handler)` but returns a `Future` of the asynchronous result
    `void` | `queueDelete(String queue, Handler<AsyncResult<com.rabbitmq.client.AMQP.Queue.DeleteOk>> resultHandler)` Delete a queue, without regard for whether it is in use or has messages on it
    `Future<com.rabbitmq.client.AMQP.Queue.DeleteOk>` | `queueDeleteIf(String queue, boolean ifUnused, boolean ifEmpty)` Like `queueDeleteIf(String, boolean, boolean, Handler)` but returns a `Future` of the asynchronous result
    `void` | `queueDeleteIf(String queue, boolean ifUnused, boolean ifEmpty, Handler<AsyncResult<com.rabbitmq.client.AMQP.Queue.DeleteOk>> resultHandler)` Delete a queue
    `Future<Void>` | `queueUnbind(String queue, String exchange, String routingKey)` Like `queueUnbind(String, String, String, Handler)` but returns a `Future` of the asynchronous result
    `void` | `queueUnbind(String queue, String exchange, String routingKey, Handler<AsyncResult<Void>> resultHandler)` Unbind a queue from an exchange
    `Future<Void>` | `queueUnbind(String queue, String exchange, String routingKey, Map<String,Object> arguments)` Like `queueUnbind(String, String, String, Map, Handler)` but returns a `Future` of the asynchronous result
    `void` | `queueUnbind(String queue, String exchange, String routingKey, Map<String,Object> arguments, Handler<AsyncResult<Void>> resultHandler)` Unbind a queue from an exchange
    `Future<Void>` | `start()` Like `start(Handler)` but returns a `Future` of the asynchronous result
    `void` | `start(Handler<AsyncResult<Void>> resultHandler)` Start the rabbitMQ client.
    `Future<Void>` | `stop()` Like `stop(Handler)` but returns a `Future` of the asynchronous result
    `void` | `stop(Handler<AsyncResult<Void>> resultHandler)` Stop the rabbitMQ client.
    `Future<Void>` | `waitForConfirms()` Like `waitForConfirms(Handler)` but returns a `Future` of the asynchronous result
    `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.
    `Future<Void>` | `waitForConfirms(long timeout)` Like `waitForConfirms(long, Handler)` but returns a `Future` of the asynchronous result
    `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.

- - ### Method Detail

    - #### create

          static RabbitMQClient create(Vertx vertx)

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

    - #### create

          static RabbitMQClient create(Vertx vertx,
                                       RabbitMQOptions config)

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

    - #### addConnectionEstablishedCallback

          void addConnectionEstablishedCallback(Handler<Promise<Void>> connectionEstablishedCallback)

      Set a callback to be called whenever a new connection is established. This callback must be idempotent - it will be called each time a connection is established, which may be multiple times against the same instance. Callbacks will be added to a list and called in the order they were added, the only way to remove callbacks is to create a new client. These callbacks should be used to establish any Rabbit MQ server objects that are required - exchanges, queues, bindings, etc. Each callback will receive a Promise that it must complete in order to pass control to the next callback (or back to the RabbitMQClient). If the callback fails the promise the RabbitMQClient will be unable to make a connection (it will attempt to connect again according to its retry configuration). If the promise is not completed or failed by a callback the RabbitMQClient will not start (it will hang indefinitely). Other methods on the client may be used in the callback - it is specifically expected that RabbitMQ objects will be declared, but the publish and consume methods must not be used. The connection established callbacks are particularly important with the RabbitMQPublisher and RabbitMQConsumer when they are used with servers that may failover to another instance of the server that does not have the same exchanges/queues configured on it. In this situation these callbacks are the only opportunity to create exchanges, queues and bindings before the client will attempt to use them when it re-establishes connection. If your failover cluster is guaranteed to have the appropriate objects already configured then it is not necessary to use the callbacks.
      Parameters:
        `connectionEstablishedCallback` - callback to be called whenever a new connection is established.

    - #### create

          static RabbitMQClient create(Vertx vertx,
                                       JsonObject config)

      Like `create(Vertx, RabbitMQOptions)` but with a `JsonObject` config object.

    - #### basicAck

          void basicAck(long deliveryTag,
                        boolean multiple,
                        Handler<AsyncResult<Void>> 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.
      See Also:
        `Channel.basicAck(long, boolean)`

    - #### basicAck

          Future<Void> basicAck(long deliveryTag,
                                boolean multiple)

      Like `basicAck(long, boolean, Handler)` but returns a `Future` of the asynchronous result

    - #### basicNack

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

      Reject one or several received messages.
      See Also:
        `Channel.basicNack(long, boolean, boolean)`

    - #### basicNack

          Future<Void> basicNack(long deliveryTag,
                                 boolean multiple,
                                 boolean requeue)

      Like `basicNack(long, boolean, boolean, Handler)` but returns a `Future` of the asynchronous result

    - #### basicGet

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

      Retrieve a message from a queue using AMQP.Basic.Get
      See Also:
        `Channel.basicGet(String, boolean)`

    - #### basicGet

          Future<RabbitMQMessage> basicGet(String queue,
                                           boolean autoAck)

      Like `basicGet(String, boolean, Handler)` but returns a `Future` of the asynchronous result

    - #### basicConsumer

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

      See Also:
        `Channel.basicConsume(String, Consumer)`, `basicConsumer(String, Handler)`

    - #### basicConsumer

          default Future<RabbitMQConsumer> basicConsumer(String queue)

      Like `basicConsumer(String, Handler)` but returns a `Future` of the asynchronous result

    - #### basicConsumer

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

      Create a consumer with the given `options`.
      Parameters:
        `queue` - the name of a queue
        `options` - options for queue
        `resultHandler` - a handler through which you can find out the operation status; if the operation succeeds you can begin to receive messages through an instance of `RabbitMQConsumer`
      See Also:
        `Channel.basicConsume(String, boolean, String, Consumer)`

    - #### basicConsumer

          Future<RabbitMQConsumer> basicConsumer(String queue,
                                                 QueueOptions options)

      Like `basicConsumer(String, QueueOptions, Handler)` but returns a `Future` of the asynchronous result

    - #### basicPublish

          void basicPublish(String exchange,
                            String routingKey,
                            Buffer body,
                            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.
      See Also:
        `Channel.basicPublish(String, String, AMQP.BasicProperties, byte[])`

    - #### basicPublish

          Future<Void> basicPublish(String exchange,
                                    String routingKey,
                                    Buffer body)

      Like `basicPublish(String, String, Buffer, Handler)` but returns a `Future` of the asynchronous result

    - #### basicPublish

          void basicPublish(String exchange,
                            String routingKey,
                            com.rabbitmq.client.BasicProperties properties,
                            Buffer body,
                            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.
      See Also:
        `Channel.basicPublish(String, String, AMQP.BasicProperties, byte[])`

    - #### basicPublish

          Future<Void> basicPublish(String exchange,
                                    String routingKey,
                                    com.rabbitmq.client.BasicProperties properties,
                                    Buffer body)

      Like `basicPublish(String, String, BasicProperties, Buffer, Handler)` but returns a `Future` of the asynchronous result

    - #### basicPublishWithDeliveryTag

          void basicPublishWithDeliveryTag(String exchange,
                                           String routingKey,
                                           com.rabbitmq.client.BasicProperties properties,
                                           Buffer body,
                                           Handler<Long> deliveryTagHandler,
                                           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. The deliveryTagHandler will be called before the message is sent, which is necessary because the confirmation may arrive asynchronously before the resultHandler is called.
      Parameters:
        `deliveryTagHandler` - callback to capture the deliveryTag for this message. Note that this will be called synchronously in the context of the client before the result is known.
      See Also:
        `Channel.basicPublish(String, String, AMQP.BasicProperties, byte[])`

    - #### basicPublishWithDeliveryTag

          Future<Void> basicPublishWithDeliveryTag(String exchange,
                                                   String routingKey,
                                                   com.rabbitmq.client.BasicProperties properties,
                                                   Buffer body,
                                                   Handler<Long> deliveryTagHandler)

      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:
        `deliveryTagHandler` - callback to capture the deliveryTag for this message. Note that this will be called synchronously in the context of the client.
      See Also:
        `Channel.basicPublish(String, String, AMQP.BasicProperties, byte[])`

    - #### addConfirmListener

          void addConfirmListener(int maxQueueSize,
                                  Handler<AsyncResult<ReadStream<RabbitMQConfirmation>>> resultHandler)

      Add a Confirm Listener to the channel. Note that this will automatically call confirmSelect, it is not necessary to call that too.
      Parameters:
        `maxQueueSize` - maximum size of the queue of confirmations
        `resultHandler` - a handler through which you can find out the operation status; if the operation succeeds you can begin to receive confirmations through an instance of `RabbitMQConfirmListener`
      See Also:
        `Channel.addConfirmListener(ConfirmListener)`

    - #### addConfirmListener

          Future<ReadStream<RabbitMQConfirmation>> addConfirmListener(int maxQueueSize)

      Add a Confirm Listener to the channel. Like `#addConfirmListener(Handler)` but returns a `Future` of the asynchronous result Note that this will automatically call confirmSelect, it is not necessary to call that too.
      Parameters:
        `maxQueueSize` - maximum size of the queue of confirmations
      Returns:
        a future through which you can find out the operation status; if the operation succeeds you can begin to receive confirmations through an instance of `RabbitMQConfirmListener`
      See Also:
        `Channel.addConfirmListener(ConfirmListener)`

    - #### confirmSelect

          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.
      See Also:
        `Channel.confirmSelect()`

    - #### confirmSelect

          Future<Void> confirmSelect()

      Like `confirmSelect(Handler)` but returns a `Future` of the asynchronous result

    - #### waitForConfirms

          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.
      Throws:
        `IOException` - Throws an IOException if the message was not written to the queue.
      See Also:
        `Channel.waitForConfirms()`

    - #### waitForConfirms

          Future<Void> waitForConfirms()

      Like `waitForConfirms(Handler)` but returns a `Future` of the asynchronous result

    - #### waitForConfirms

          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` -
      Throws:
        `IOException` - Throws an IOException if the message was not written to the queue.
      See Also:
        `RabbitMQClientImpl.waitForConfirms(Handler)`

    - #### waitForConfirms

          Future<Void> waitForConfirms(long timeout)

      Like `waitForConfirms(long, Handler)` but returns a `Future` of the asynchronous result

    - #### basicQos

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

      Request a specific prefetchCount "quality of service" settings for this channel.
      Parameters:
        `prefetchCount` - maximum number of messages that the server will deliver, 0 if unlimited
        `resultHandler` - handler called when operation is done with a result of the operation
      See Also:
        `basicQos(int, int, boolean, Handler)`

    - #### basicQos

          default Future<Void> basicQos(int prefetchCount)

      Like `basicQos(int, Handler)` but returns a `Future` of the asynchronous result

    - #### basicQos

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

      Request a specific prefetchCount "quality of service" settings for this channel.
      Parameters:
        `prefetchCount` - maximum number of messages that the server will deliver, 0 if unlimited
        `global` - true if the settings should be applied to the entire channel rather than each consumer
        `resultHandler` - handler called when operation is done with a result of the operation
      See Also:
        `basicQos(int, int, boolean, Handler)`

    - #### basicQos

          default Future<Void> basicQos(int prefetchCount,
                                        boolean global)

      Like `basicQos(int, boolean, Handler)` but returns a `Future` of the asynchronous result

    - #### basicQos

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

      Request specific "quality of service" settings. These settings impose limits on the amount of data the server will deliver to consumers before requiring acknowledgements. Thus they provide a means of consumer-initiated flow control.
      Parameters:
        `prefetchSize` - maximum amount of content (measured in octets) that the server will deliver, 0 if unlimited
        `prefetchCount` - maximum number of messages that the server will deliver, 0 if unlimited
        `global` - true if the settings should be applied to the entire channel rather than each consumer
        `resultHandler` - handler called when operation is done with a result of the operation
      See Also:
        `AMQP.Basic.Qos`

    - #### basicQos

          Future<Void> basicQos(int prefetchSize,
                                int prefetchCount,
                                boolean global)

      Like `basicQos(int, int, boolean, Handler)` but returns a `Future` of the asynchronous result

    - #### exchangeDeclare

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

      Declare an exchange.
      See Also:
        `Channel.exchangeDeclare(String, String, boolean, boolean, Map)`

    - #### exchangeDeclare

          Future<Void> exchangeDeclare(String exchange,
                                       String type,
                                       boolean durable,
                                       boolean autoDelete)

      Like `exchangeDeclare(String, String, boolean, boolean, Handler)` but returns a `Future` of the asynchronous result

    - #### exchangeDeclare

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

      Declare an exchange with additional parameters such as dead lettering, an alternate exchange or TTL.
      See Also:
        `Channel.exchangeDeclare(String, String, boolean, boolean, Map)`

    - #### exchangeDeclare

          Future<Void> exchangeDeclare(String exchange,
                                       String type,
                                       boolean durable,
                                       boolean autoDelete,
                                       JsonObject config)

      Like `exchangeDeclare(String, String, boolean, boolean, JsonObject, Handler)` but returns a `Future` of the asynchronous result

    - #### exchangeDelete

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

      Delete an exchange, without regard for whether it is in use or not.
      See Also:
        `Channel.exchangeDelete(String)`

    - #### exchangeDelete

          Future<Void> exchangeDelete(String exchange)

      Like `exchangeDelete(String, Handler)` but returns a `Future` of the asynchronous result

    - #### exchangeBind

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

      Bind an exchange to an exchange.
      See Also:
        `Channel.exchangeBind(String, String, String)`

    - #### exchangeBind

          Future<Void> exchangeBind(String destination,
                                    String source,
                                    String routingKey)

      Like `exchangeBind(String, String, String, Handler)` but returns a `Future` of the asynchronous result

    - #### exchangeBind

          void exchangeBind(String destination,
                            String source,
                            String routingKey,
                            Map<String,Object> arguments,
                            Handler<AsyncResult<Void>> resultHandler)

      Bind an exchange to an exchange.
      See Also:
        `com.rabbitmq.client.Channel#exchangeBind(String, String, String, Map)`

    - #### exchangeBind

          Future<Void> exchangeBind(String destination,
                                    String source,
                                    String routingKey,
                                    Map<String,Object> arguments)

      Like `exchangeBind(String, String, String, Map, Handler)` but returns a `Future` of the asynchronous result

    - #### exchangeUnbind

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

      Unbind an exchange from an exchange.
      See Also:
        `Channel.exchangeUnbind(String, String, String)`

    - #### exchangeUnbind

          Future<Void> exchangeUnbind(String destination,
                                      String source,
                                      String routingKey)

      Like `exchangeUnbind(String, String, String, Handler)` but returns a `Future` of the asynchronous result

    - #### exchangeUnbind

          void exchangeUnbind(String destination,
                              String source,
                              String routingKey,
                              Map<String,Object> arguments,
                              Handler<AsyncResult<Void>> resultHandler)

      Unbind an exchange from an exchange.
      See Also:
        `com.rabbitmq.client.Channel#exchangeUnbind(String, String, String, Map)`

    - #### exchangeUnbind

          Future<Void> exchangeUnbind(String destination,
                                      String source,
                                      String routingKey,
                                      Map<String,Object> arguments)

      Like `exchangeUnbind(String, String, String, Map, Handler)` but returns a `Future` of the asynchronous result

    - #### queueDeclareAuto

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

      Actively declare a server-named exclusive, autodelete, non-durable queue.
      See Also:
        `Channel.queueDeclare()`

    - #### queueDeclareAuto

          Future<JsonObject> queueDeclareAuto()

      Like `queueDeclareAuto(Handler)` but returns a `Future` of the asynchronous result

    - #### queueDeclare

          void queueDeclare(String queue,
                            boolean durable,
                            boolean exclusive,
                            boolean autoDelete,
                            Handler<AsyncResult<com.rabbitmq.client.AMQP.Queue.DeclareOk>> resultHandler)

      Declare a queue
      See Also:
        `Channel.queueDeclare(String, boolean, boolean, boolean, java.util.Map)`

    - #### queueDeclare

          Future<com.rabbitmq.client.AMQP.Queue.DeclareOk> queueDeclare(String queue,
                                                                        boolean durable,
                                                                        boolean exclusive,
                                                                        boolean autoDelete)

      Like `queueDeclare(String, boolean, boolean, boolean, Handler)` but returns a `Future` of the asynchronous result

    - #### queueDeclare

          void queueDeclare(String queue,
                            boolean durable,
                            boolean exclusive,
                            boolean autoDelete,
                            JsonObject config,
                            Handler<AsyncResult<com.rabbitmq.client.AMQP.Queue.DeclareOk>> resultHandler)

      Declare a queue with config options
      See Also:
        `Channel.queueDeclare(String, boolean, boolean, boolean, java.util.Map)`

    - #### queueDeclare

          Future<com.rabbitmq.client.AMQP.Queue.DeclareOk> queueDeclare(String queue,
                                                                        boolean durable,
                                                                        boolean exclusive,
                                                                        boolean autoDelete,
                                                                        JsonObject config)

      Like `queueDeclare(String, boolean, boolean, boolean, JsonObject, Handler)` but returns a `Future` of the asynchronous result

    - #### queueDelete

          void queueDelete(String queue,
                           Handler<AsyncResult<com.rabbitmq.client.AMQP.Queue.DeleteOk>> resultHandler)

      Delete a queue, without regard for whether it is in use or has messages on it
      See Also:
        `Channel.queueDelete(String)`

    - #### queueDelete

          Future<com.rabbitmq.client.AMQP.Queue.DeleteOk> queueDelete(String queue)

      Like `queueDelete(String, Handler)` but returns a `Future` of the asynchronous result

    - #### queueDeleteIf

          void queueDeleteIf(String queue,
                             boolean ifUnused,
                             boolean ifEmpty,
                             Handler<AsyncResult<com.rabbitmq.client.AMQP.Queue.DeleteOk>> resultHandler)

      Delete a queue
      See Also:
        `Channel.queueDelete(String, boolean, boolean)`

    - #### queueDeleteIf

          Future<com.rabbitmq.client.AMQP.Queue.DeleteOk> queueDeleteIf(String queue,
                                                                        boolean ifUnused,
                                                                        boolean ifEmpty)

      Like `queueDeleteIf(String, boolean, boolean, Handler)` but returns a `Future` of the asynchronous result

    - #### queueBind

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

      Bind a queue to an exchange
      See Also:
        `Channel.queueBind(String, String, String)`

    - #### queueBind

          Future<Void> queueBind(String queue,
                                 String exchange,
                                 String routingKey)

      Like `queueBind(String, String, String, Handler)` but returns a `Future` of the asynchronous result

    - #### queueBind

          void queueBind(String queue,
                         String exchange,
                         String routingKey,
                         Map<String,Object> arguments,
                         Handler<AsyncResult<Void>> resultHandler)

      Bind a queue to an exchange
      See Also:
        `com.rabbitmq.client.Channel#queueBind(String, String, String, Map)`

    - #### queueBind

          Future<Void> queueBind(String queue,
                                 String exchange,
                                 String routingKey,
                                 Map<String,Object> arguments)

      Like `queueBind(String, String, String, Map, Handler)` but returns a `Future` of the asynchronous result

    - #### queueUnbind

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

      Unbind a queue from an exchange
      See Also:
        `Channel.queueUnbind(String, String, String)`

    - #### queueUnbind

          Future<Void> queueUnbind(String queue,
                                   String exchange,
                                   String routingKey)

      Like `queueUnbind(String, String, String, Handler)` but returns a `Future` of the asynchronous result

    - #### queueUnbind

          void queueUnbind(String queue,
                           String exchange,
                           String routingKey,
                           Map<String,Object> arguments,
                           Handler<AsyncResult<Void>> resultHandler)

      Unbind a queue from an exchange
      See Also:
        `com.rabbitmq.client.Channel#queueUnbind(String, String, String, Map)`

    - #### queueUnbind

          Future<Void> queueUnbind(String queue,
                                   String exchange,
                                   String routingKey,
                                   Map<String,Object> arguments)

      Like `queueUnbind(String, String, String, Map, Handler)` but returns a `Future` of the asynchronous result

    - #### messageCount

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

      Returns the number of messages in a queue ready to be delivered.
      See Also:
        `Channel.messageCount(String)`

    - #### messageCount

          Future<Long> messageCount(String queue)

      Like `messageCount(String, Handler)` but returns a `Future` of the asynchronous result

    - #### start

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

      Start the rabbitMQ client. Create the connection and the channel.
      See Also:
        `Connection.createChannel()`

    - #### start

          Future<Void> start()

      Like `start(Handler)` but returns a `Future` of the asynchronous result

    - #### stop

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

      Stop the rabbitMQ client. Close the connection and its channel.
      See Also:
        `Connection.close()`

    - #### stop

          Future<Void> stop()

      Like `stop(Handler)` but returns a `Future` of the asynchronous result

    - #### isConnected

          boolean isConnected()

      Check if a connection is open
      Returns:
        true when the connection is open, false otherwise
      See Also:
        `ShutdownNotifier.isOpen()`

    - #### isOpenChannel

          boolean isOpenChannel()

      Check if a channel is open
      Returns:
        true when the connection is open, false otherwise
      See Also:
        `ShutdownNotifier.isOpen()`

Copyright © 2021 Eclipse. All rights reserved.