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 Description

static TypeArg<RabbitMQClient> __TYPE_ARG

Constructor Summary

Constructors
Constructor Description

RabbitMQClient(RabbitMQClient delegate)

RabbitMQClient(Object delegate)

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method	Description
`void`	`addConfirmListener(int maxQueueSize)`	Add a Confirm Listener to the channel.
`void`	`addConfirmListener(int maxQueueSize, io.vertx.core.Handler<io.vertx.core.AsyncResult<ReadStream<RabbitMQConfirmation>>> resultHandler)`	Add a Confirm Listener to the channel.
`void`	`basicAck(long deliveryTag, boolean multiple)`	Acknowledge one or several received messages.
`void`	`basicAck(long deliveryTag, boolean multiple, io.vertx.core.Handler<io.vertx.core.AsyncResult<Void>> resultHandler)`	Acknowledge one or several received messages.
`void`	`basicConsumer(String queue)`
`void`	`basicConsumer(String queue, io.vertx.core.Handler<io.vertx.core.AsyncResult<RabbitMQConsumer>> resultHandler)`
`void`	`basicConsumer(String queue, QueueOptions options)`	Create a consumer with the given `options`.
`void`	`basicConsumer(String queue, QueueOptions options, io.vertx.core.Handler<io.vertx.core.AsyncResult<RabbitMQConsumer>> resultHandler)`	Create a consumer with the given `options`.
`void`	`basicGet(String queue, boolean autoAck)`	Retrieve a message from a queue using AMQP.Basic.Get
`void`	`basicGet(String queue, boolean autoAck, io.vertx.core.Handler<io.vertx.core.AsyncResult<RabbitMQMessage>> resultHandler)`	Retrieve a message from a queue using AMQP.Basic.Get
`void`	`basicNack(long deliveryTag, boolean multiple, boolean requeue)`	Reject one or several received messages.
`void`	`basicNack(long deliveryTag, boolean multiple, boolean requeue, io.vertx.core.Handler<io.vertx.core.AsyncResult<Void>> resultHandler)`	Reject one or several received messages.
`void`	`basicPublish(String exchange, String routingKey, com.rabbitmq.client.BasicProperties properties, Buffer body)`	Publish a message.
`void`	`basicPublish(String exchange, String routingKey, com.rabbitmq.client.BasicProperties properties, Buffer body, io.vertx.core.Handler<io.vertx.core.AsyncResult<Void>> resultHandler)`	Publish a message.
`void`	`basicPublish(String exchange, String routingKey, Buffer body)`	Publish a message.
`void`	`basicPublish(String exchange, String routingKey, Buffer body, io.vertx.core.Handler<io.vertx.core.AsyncResult<Void>> resultHandler)`	Publish a message.
`void`	`basicPublishWithDeliveryTag(String exchange, String routingKey, com.rabbitmq.client.BasicProperties properties, Buffer body, io.vertx.core.Handler<Long> deliveryTagHandler)`	Publish a message.
`void`	`basicPublishWithDeliveryTag(String exchange, String routingKey, com.rabbitmq.client.BasicProperties properties, Buffer body, io.vertx.core.Handler<Long> deliveryTagHandler, io.vertx.core.Handler<io.vertx.core.AsyncResult<Void>> resultHandler)`	Publish a message.
`void`	`basicQos(int prefetchCount)`	Request a specific prefetchCount "quality of service" settings for this channel.
`void`	`basicQos(int prefetchCount, boolean global)`	Request a specific prefetchCount "quality of service" settings for this channel.
`void`	`basicQos(int prefetchCount, boolean global, io.vertx.core.Handler<io.vertx.core.AsyncResult<Void>> resultHandler)`	Request a specific prefetchCount "quality of service" settings for this channel.
`void`	`basicQos(int prefetchSize, int prefetchCount, boolean global)`	Request specific "quality of service" settings.
`void`	`basicQos(int prefetchSize, int prefetchCount, boolean global, io.vertx.core.Handler<io.vertx.core.AsyncResult<Void>> resultHandler)`	Request specific "quality of service" settings.
`void`	`basicQos(int prefetchCount, io.vertx.core.Handler<io.vertx.core.AsyncResult<Void>> resultHandler)`	Request a specific prefetchCount "quality of service" settings for this channel.
`void`	`confirmSelect()`	Enables publisher acknowledgements on this channel.
`void`	`confirmSelect(io.vertx.core.Handler<io.vertx.core.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, RabbitMQOptions config)`	Create and return a client.
`boolean`	`equals(Object o)`
`void`	`exchangeBind(String destination, String source, String routingKey)`	Bind an exchange to an exchange.
`void`	`exchangeBind(String destination, String source, String routingKey, io.vertx.core.Handler<io.vertx.core.AsyncResult<Void>> resultHandler)`	Bind an exchange to an exchange.
`void`	`exchangeBind(String destination, String source, String routingKey, Map<String,Object> arguments)`	Bind an exchange to an exchange.
`void`	`exchangeBind(String destination, String source, String routingKey, Map<String,Object> arguments, io.vertx.core.Handler<io.vertx.core.AsyncResult<Void>> resultHandler)`	Bind an exchange to an exchange.
`void`	`exchangeDeclare(String exchange, String type, boolean durable, boolean autoDelete)`	Declare an exchange.
`void`	`exchangeDeclare(String exchange, String type, boolean durable, boolean autoDelete, io.vertx.core.Handler<io.vertx.core.AsyncResult<Void>> resultHandler)`	Declare an exchange.
`void`	`exchangeDeclare(String exchange, String type, boolean durable, boolean autoDelete, io.vertx.core.json.JsonObject config)`	Declare an exchange with additional parameters such as dead lettering, an alternate exchange or TTL.
`void`	`exchangeDeclare(String exchange, String type, boolean durable, boolean autoDelete, io.vertx.core.json.JsonObject config, io.vertx.core.Handler<io.vertx.core.AsyncResult<Void>> resultHandler)`	Declare an exchange with additional parameters such as dead lettering, an alternate exchange or TTL.
`void`	`exchangeDelete(String exchange)`	Delete an exchange, without regard for whether it is in use or not.
`void`	`exchangeDelete(String exchange, io.vertx.core.Handler<io.vertx.core.AsyncResult<Void>> resultHandler)`	Delete an exchange, without regard for whether it is in use or not.
`void`	`exchangeUnbind(String destination, String source, String routingKey)`	Unbind an exchange from an exchange.
`void`	`exchangeUnbind(String destination, String source, String routingKey, io.vertx.core.Handler<io.vertx.core.AsyncResult<Void>> resultHandler)`	Unbind an exchange from an exchange.
`void`	`exchangeUnbind(String destination, String source, String routingKey, Map<String,Object> arguments)`	Unbind an exchange from an exchange.
`void`	`exchangeUnbind(String destination, String source, String routingKey, Map<String,Object> arguments, io.vertx.core.Handler<io.vertx.core.AsyncResult<Void>> resultHandler)`	Unbind an exchange from an exchange.
`RabbitMQClient`	`getDelegate()`
`int`	`hashCode()`
`boolean`	`isConnected()`	Check if a connection is open
`boolean`	`isOpenChannel()`	Check if a channel is open
`void`	`messageCount(String queue)`	Returns the number of messages in a queue ready to be delivered.
`void`	`messageCount(String queue, io.vertx.core.Handler<io.vertx.core.AsyncResult<Long>> resultHandler)`	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)`	Bind a queue to an exchange
`void`	`queueBind(String queue, String exchange, String routingKey, io.vertx.core.Handler<io.vertx.core.AsyncResult<Void>> resultHandler)`	Bind a queue to an exchange
`void`	`queueBind(String queue, String exchange, String routingKey, Map<String,Object> arguments)`	Bind a queue to an exchange
`void`	`queueBind(String queue, String exchange, String routingKey, Map<String,Object> arguments, io.vertx.core.Handler<io.vertx.core.AsyncResult<Void>> resultHandler)`	Bind a queue to an exchange
`void`	`queueDeclare(String queue, boolean durable, boolean exclusive, boolean autoDelete)`	Declare a queue
`void`	`queueDeclare(String queue, boolean durable, boolean exclusive, boolean autoDelete, io.vertx.core.Handler<io.vertx.core.AsyncResult<com.rabbitmq.client.AMQP.Queue.DeclareOk>> resultHandler)`	Declare a queue
`void`	`queueDeclare(String queue, boolean durable, boolean exclusive, boolean autoDelete, io.vertx.core.json.JsonObject config)`	Declare a queue with config options
`void`	`queueDeclare(String queue, boolean durable, boolean exclusive, boolean autoDelete, io.vertx.core.json.JsonObject config, io.vertx.core.Handler<io.vertx.core.AsyncResult<com.rabbitmq.client.AMQP.Queue.DeclareOk>> resultHandler)`	Declare a queue with config options
`void`	`queueDeclareAuto()`	Actively declare a server-named exclusive, autodelete, non-durable queue.
`void`	`queueDeclareAuto(io.vertx.core.Handler<io.vertx.core.AsyncResult<io.vertx.core.json.JsonObject>> resultHandler)`	Actively declare a server-named exclusive, autodelete, non-durable queue.
`void`	`queueDelete(String queue)`	Delete a queue, without regard for whether it is in use or has messages on it
`void`	`queueDelete(String queue, io.vertx.core.Handler<io.vertx.core.AsyncResult<com.rabbitmq.client.AMQP.Queue.DeleteOk>> 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)`	Delete a queue
`void`	`queueDeleteIf(String queue, boolean ifUnused, boolean ifEmpty, io.vertx.core.Handler<io.vertx.core.AsyncResult<com.rabbitmq.client.AMQP.Queue.DeleteOk>> resultHandler)`	Delete a queue
`void`	`queueUnbind(String queue, String exchange, String routingKey)`	Unbind a queue from an exchange
`void`	`queueUnbind(String queue, String exchange, String routingKey, io.vertx.core.Handler<io.vertx.core.AsyncResult<Void>> resultHandler)`	Unbind a queue from an exchange
`void`	`queueUnbind(String queue, String exchange, String routingKey, Map<String,Object> arguments)`	Unbind a queue from an exchange
`void`	`queueUnbind(String queue, String exchange, String routingKey, Map<String,Object> arguments, io.vertx.core.Handler<io.vertx.core.AsyncResult<Void>> resultHandler)`	Unbind a queue from an exchange
`void`	`restartConnect(int attempts)`	restart the rabbitMQ connect.
`void`	`restartConnect(int attempts, io.vertx.core.Handler<io.vertx.core.AsyncResult<Void>> resultHandler)`	restart the rabbitMQ connect.
`rx.Single<ReadStream<RabbitMQConfirmation>>`	`rxAddConfirmListener(int maxQueueSize)`	Add a Confirm Listener to the channel.
`rx.Single<Void>`	`rxBasicAck(long deliveryTag, boolean multiple)`	Acknowledge one or several received messages.
`rx.Single<RabbitMQConsumer>`	`rxBasicConsumer(String queue)`
`rx.Single<RabbitMQConsumer>`	`rxBasicConsumer(String queue, QueueOptions options)`	Create a consumer with the given `options`.
`rx.Single<RabbitMQMessage>`	`rxBasicGet(String queue, boolean autoAck)`	Retrieve a message from a queue using AMQP.Basic.Get
`rx.Single<Void>`	`rxBasicNack(long deliveryTag, boolean multiple, boolean requeue)`	Reject one or several received messages.
`rx.Single<Void>`	`rxBasicPublish(String exchange, String routingKey, com.rabbitmq.client.BasicProperties properties, Buffer body)`	Publish a message.
`rx.Single<Void>`	`rxBasicPublish(String exchange, String routingKey, Buffer body)`	Publish a message.
`rx.Single<Void>`	`rxBasicPublishWithDeliveryTag(String exchange, String routingKey, com.rabbitmq.client.BasicProperties properties, Buffer body, io.vertx.core.Handler<Long> deliveryTagHandler)`	Publish a message.
`rx.Single<Void>`	`rxBasicQos(int prefetchCount)`	Request a specific prefetchCount "quality of service" settings for this channel.
`rx.Single<Void>`	`rxBasicQos(int prefetchCount, boolean global)`	Request a specific prefetchCount "quality of service" settings for this channel.
`rx.Single<Void>`	`rxBasicQos(int prefetchSize, int prefetchCount, boolean global)`	Request specific "quality of service" settings.
`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>`	`rxExchangeBind(String destination, String source, String routingKey, Map<String,Object> arguments)`	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, io.vertx.core.json.JsonObject config)`	Declare an exchange with additional parameters such as dead lettering, an alternate exchange or TTL.
`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<Void>`	`rxExchangeUnbind(String destination, String source, String routingKey, Map<String,Object> arguments)`	Unbind an exchange from an exchange.
`rx.Single<Long>`	`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<Void>`	`rxQueueBind(String queue, String exchange, String routingKey, Map<String,Object> arguments)`	Bind a queue to an exchange
`rx.Single<com.rabbitmq.client.AMQP.Queue.DeclareOk>`	`rxQueueDeclare(String queue, boolean durable, boolean exclusive, boolean autoDelete)`	Declare a queue
`rx.Single<com.rabbitmq.client.AMQP.Queue.DeclareOk>`	`rxQueueDeclare(String queue, boolean durable, boolean exclusive, boolean autoDelete, io.vertx.core.json.JsonObject config)`	Declare a queue with config options
`rx.Single<io.vertx.core.json.JsonObject>`	`rxQueueDeclareAuto()`	Actively declare a server-named exclusive, autodelete, non-durable queue.
`rx.Single<com.rabbitmq.client.AMQP.Queue.DeleteOk>`	`rxQueueDelete(String queue)`	Delete a queue, without regard for whether it is in use or has messages on it
`rx.Single<com.rabbitmq.client.AMQP.Queue.DeleteOk>`	`rxQueueDeleteIf(String queue, boolean ifUnused, boolean ifEmpty)`	Delete a queue
`rx.Single<Void>`	`rxQueueUnbind(String queue, String exchange, String routingKey)`	Unbind a queue from an exchange
`rx.Single<Void>`	`rxQueueUnbind(String queue, String exchange, String routingKey, Map<String,Object> arguments)`	Unbind a queue from an exchange
`rx.Single<Void>`	`rxRestartConnect(int attempts)`	restart the rabbitMQ connect.
`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()`	Start the rabbitMQ client.
`void`	`start(io.vertx.core.Handler<io.vertx.core.AsyncResult<Void>> resultHandler)`	Start the rabbitMQ client.
`void`	`stop()`	Stop the rabbitMQ client.
`void`	`stop(io.vertx.core.Handler<io.vertx.core.AsyncResult<Void>> resultHandler)`	Stop the rabbitMQ client.
`String`	`toString()`
`void`	`waitForConfirms()`	Wait until all messages published since the last call have been either ack'd or nack'd by the broker.
`void`	`waitForConfirms(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`	`waitForConfirms(long timeout, io.vertx.core.Handler<io.vertx.core.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.
`void`	`waitForConfirms(io.vertx.core.Handler<io.vertx.core.AsyncResult<Void>> resultHandler)`	Wait until all messages published since the last call have been either ack'd or nack'd by the broker.

Methods inherited from class java.lang.Object
clone, finalize, getClass, notify, notifyAll, wait, wait, wait

Field Detail

__TYPE_ARG

public static final TypeArg<RabbitMQClient> __TYPE_ARG

Constructor Detail

RabbitMQClient

public RabbitMQClient(RabbitMQClient delegate)

RabbitMQClient

public RabbitMQClient(Object delegate)

Method Detail

toString
```
public String toString()
```
Overrides:

toString in class Object

equals
```
public boolean equals(Object o)
```
Overrides:

equals in class Object

hashCode
```
public int hashCode()
```
Overrides:

hashCode in class Object

getDelegate
```
public RabbitMQClient getDelegate()
```

create
```
public static RabbitMQClient create(Vertx vertx)
```
Create and return a client configured with the default options.

Parameters:

vertx - the vertx instance

Returns:

the client

create

public static RabbitMQClient create(Vertx vertx,
                                    RabbitMQOptions config)

Create and return a client.

Parameters:: vertx - the vertx instance; config - the client config
Returns:: the client

basicAck
```
public void basicAck(long deliveryTag,
                     boolean multiple,
                     io.vertx.core.Handler<io.vertx.core.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.

Parameters:

deliveryTag -

multiple -

resultHandler -

basicAck
```
public void basicAck(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 -

rxBasicAck
```
public rx.Single<Void> 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,
                      io.vertx.core.Handler<io.vertx.core.AsyncResult<Void>> resultHandler)

Reject one or several received messages.

Parameters:: deliveryTag -; multiple -; requeue -; resultHandler -

basicNack

public void basicNack(long deliveryTag,
                      boolean multiple,
                      boolean requeue)

Reject one or several received messages.

Parameters:: deliveryTag -; multiple -; requeue -

rxBasicNack

public rx.Single<Void> 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,
                     io.vertx.core.Handler<io.vertx.core.AsyncResult<RabbitMQMessage>> resultHandler)

Retrieve a message from a queue using AMQP.Basic.Get

Parameters:: queue -; autoAck -; resultHandler -

basicGet
```
public void basicGet(String queue,
                     boolean autoAck)
```
Retrieve a message from a queue using AMQP.Basic.Get

Parameters:

queue -

autoAck -

rxBasicGet

public rx.Single<RabbitMQMessage> rxBasicGet(String queue,
                                             boolean autoAck)

Retrieve a message from a queue using AMQP.Basic.Get

Parameters:: queue -; autoAck -
Returns:

basicConsumer

public void basicConsumer(String queue,
                          io.vertx.core.Handler<io.vertx.core.AsyncResult<RabbitMQConsumer>> resultHandler)

Parameters:: queue -; resultHandler -

basicConsumer

public void basicConsumer(String queue)

Parameters:: queue -

rxBasicConsumer

public rx.Single<RabbitMQConsumer> rxBasicConsumer(String queue)

Parameters:: queue -
Returns:

basicConsumer
```
public void basicConsumer(String queue,
                          QueueOptions options,
                          io.vertx.core.Handler<io.vertx.core.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

basicConsumer

public void basicConsumer(String queue,
                          QueueOptions options)

Create a consumer with the given options.

Parameters:: queue - the name of a queue; options - options for queue

rxBasicConsumer

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

Create a consumer with the given options.

Parameters:: queue - the name of a queue; options - options for queue
Returns:

basicPublish
```
public void basicPublish(String exchange,
                         String routingKey,
                         Buffer body,
                         io.vertx.core.Handler<io.vertx.core.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 -

body -

resultHandler -

basicPublish
```
public void basicPublish(String exchange,
                         String routingKey,
                         Buffer body)
```
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 -

body -

rxBasicPublish
```
public rx.Single<Void> rxBasicPublish(String exchange,
                                      String routingKey,
                                      Buffer body)
```
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 -

body -

Returns:

addConfirmListener
```
public void addConfirmListener(int maxQueueSize,
                               io.vertx.core.Handler<io.vertx.core.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

addConfirmListener
```
public void addConfirmListener(int maxQueueSize)
```
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

rxAddConfirmListener
```
public rx.Single<ReadStream<RabbitMQConfirmation>> rxAddConfirmListener(int maxQueueSize)
```
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

Returns:

confirmSelect
```
public void confirmSelect(io.vertx.core.Handler<io.vertx.core.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 -

confirmSelect
```
public void confirmSelect()
```
Enables publisher acknowledgements on this channel. Can be called once during client initialisation. Calls to basicPublish() will have to be confirmed.

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(io.vertx.core.Handler<io.vertx.core.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 -

waitForConfirms
```
public void waitForConfirms()
```
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.

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,
                            io.vertx.core.Handler<io.vertx.core.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 -

waitForConfirms
```
public void waitForConfirms(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 -

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,
                     io.vertx.core.Handler<io.vertx.core.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

basicQos
```
public void basicQos(int prefetchCount)
```
Request a specific prefetchCount "quality of service" settings for this channel.

Parameters:

prefetchCount - maximum number of messages that the server will deliver, 0 if unlimited

rxBasicQos
```
public rx.Single<Void> rxBasicQos(int prefetchCount)
```
Request a specific prefetchCount "quality of service" settings for this channel.

Parameters:

prefetchCount - maximum number of messages that the server will deliver, 0 if unlimited

Returns:

basicQos
```
public void basicQos(int prefetchCount,
                     boolean global,
                     io.vertx.core.Handler<io.vertx.core.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

basicQos
```
public void basicQos(int prefetchCount,
                     boolean global)
```
Request a specific prefetchCount "quality of service" settings for this channel.

Parameters:

prefetchCount - maximum number of messages that the server will deliver, 0 if unlimited

global - true if the settings should be applied to the entire channel rather than each consumer

rxBasicQos
```
public rx.Single<Void> rxBasicQos(int prefetchCount,
                                  boolean global)
```
Request a specific prefetchCount "quality of service" settings for this channel.

Parameters:

prefetchCount - maximum number of messages that the server will deliver, 0 if unlimited

global - true if the settings should be applied to the entire channel rather than each consumer

Returns:

basicQos
```
public void basicQos(int prefetchSize,
                     int prefetchCount,
                     boolean global,
                     io.vertx.core.Handler<io.vertx.core.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

basicQos
```
public void basicQos(int prefetchSize,
                     int prefetchCount,
                     boolean global)
```
Request specific "quality of service" settings. These settings impose limits on the amount of data the server will deliver to consumers before requiring acknowledgements. Thus they provide a means of consumer-initiated flow control.

Parameters:

prefetchSize - maximum amount of content (measured in octets) that the server will deliver, 0 if unlimited

prefetchCount - maximum number of messages that the server will deliver, 0 if unlimited

global - true if the settings should be applied to the entire channel rather than each consumer

rxBasicQos
```
public rx.Single<Void> rxBasicQos(int prefetchSize,
                                  int prefetchCount,
                                  boolean global)
```
Request specific "quality of service" settings. These settings impose limits on the amount of data the server will deliver to consumers before requiring acknowledgements. Thus they provide a means of consumer-initiated flow control.

Parameters:

prefetchSize - maximum amount of content (measured in octets) that the server will deliver, 0 if unlimited

prefetchCount - maximum number of messages that the server will deliver, 0 if unlimited

global - true if the settings should be applied to the entire channel rather than each consumer

Returns:

exchangeDeclare

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

Declare an exchange.

Parameters:: exchange -; type -; durable -; autoDelete -; resultHandler -

exchangeDeclare

public void exchangeDeclare(String exchange,
                            String type,
                            boolean durable,
                            boolean autoDelete)

Declare an exchange.

Parameters:: exchange -; type -; durable -; autoDelete -

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,
                            io.vertx.core.json.JsonObject config,
                            io.vertx.core.Handler<io.vertx.core.AsyncResult<Void>> resultHandler)

Declare an exchange with additional parameters such as dead lettering, an alternate exchange or TTL.

Parameters:: exchange -; type -; durable -; autoDelete -; config -; resultHandler -

exchangeDeclare

public void exchangeDeclare(String exchange,
                            String type,
                            boolean durable,
                            boolean autoDelete,
                            io.vertx.core.json.JsonObject config)

Declare an exchange with additional parameters such as dead lettering, an alternate exchange or TTL.

Parameters:: exchange -; type -; durable -; autoDelete -; config -

rxExchangeDeclare

public rx.Single<Void> rxExchangeDeclare(String exchange,
                                         String type,
                                         boolean durable,
                                         boolean autoDelete,
                                         io.vertx.core.json.JsonObject config)

Declare an exchange with additional parameters such as dead lettering, an alternate exchange or TTL.

Parameters:: exchange -; type -; durable -; autoDelete -; config -
Returns:

exchangeDelete

public void exchangeDelete(String exchange,
                           io.vertx.core.Handler<io.vertx.core.AsyncResult<Void>> resultHandler)

Delete an exchange, without regard for whether it is in use or not.

Parameters:: exchange -; resultHandler -

exchangeDelete
```
public void exchangeDelete(String exchange)
```
Delete an exchange, without regard for whether it is in use or not.

Parameters:

exchange -

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,
                         io.vertx.core.Handler<io.vertx.core.AsyncResult<Void>> resultHandler)

Bind an exchange to an exchange.

Parameters:: destination -; source -; routingKey -; resultHandler -

exchangeBind

public void exchangeBind(String destination,
                         String source,
                         String routingKey)

Bind an exchange to an exchange.

Parameters:: destination -; source -; routingKey -

rxExchangeBind

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

Bind an exchange to an exchange.

Parameters:: destination -; source -; routingKey -
Returns:

exchangeBind

public void exchangeBind(String destination,
                         String source,
                         String routingKey,
                         Map<String,Object> arguments,
                         io.vertx.core.Handler<io.vertx.core.AsyncResult<Void>> resultHandler)

Bind an exchange to an exchange.

Parameters:: destination -; source -; routingKey -; arguments -; resultHandler -

exchangeBind

public void exchangeBind(String destination,
                         String source,
                         String routingKey,
                         Map<String,Object> arguments)

Bind an exchange to an exchange.

Parameters:: destination -; source -; routingKey -; arguments -

rxExchangeBind

public rx.Single<Void> rxExchangeBind(String destination,
                                      String source,
                                      String routingKey,
                                      Map<String,Object> arguments)

Bind an exchange to an exchange.

Parameters:: destination -; source -; routingKey -; arguments -
Returns:

exchangeUnbind

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

Unbind an exchange from an exchange.

Parameters:: destination -; source -; routingKey -; resultHandler -

exchangeUnbind

public void exchangeUnbind(String destination,
                           String source,
                           String routingKey)

Unbind an exchange from an exchange.

Parameters:: destination -; source -; routingKey -

rxExchangeUnbind

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

Unbind an exchange from an exchange.

Parameters:: destination -; source -; routingKey -
Returns:

exchangeUnbind

public void exchangeUnbind(String destination,
                           String source,
                           String routingKey,
                           Map<String,Object> arguments,
                           io.vertx.core.Handler<io.vertx.core.AsyncResult<Void>> resultHandler)

Unbind an exchange from an exchange.

Parameters:: destination -; source -; routingKey -; arguments -; resultHandler -

exchangeUnbind

public void exchangeUnbind(String destination,
                           String source,
                           String routingKey,
                           Map<String,Object> arguments)

Unbind an exchange from an exchange.

Parameters:: destination -; source -; routingKey -; arguments -

rxExchangeUnbind

public rx.Single<Void> rxExchangeUnbind(String destination,
                                        String source,
                                        String routingKey,
                                        Map<String,Object> arguments)

Unbind an exchange from an exchange.

Parameters:: destination -; source -; routingKey -; arguments -
Returns:

queueDeclareAuto

public void queueDeclareAuto(io.vertx.core.Handler<io.vertx.core.AsyncResult<io.vertx.core.json.JsonObject>> resultHandler)

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

Parameters:: resultHandler -

queueDeclareAuto
```
public void queueDeclareAuto()
```
Actively declare a server-named exclusive, autodelete, non-durable queue.

rxQueueDeclareAuto
```
public rx.Single<io.vertx.core.json.JsonObject> rxQueueDeclareAuto()
```
Actively declare a server-named exclusive, autodelete, non-durable queue.

Returns:

queueBind

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

Bind a queue to an exchange

Parameters:: queue -; exchange -; routingKey -; resultHandler -

queueBind

public void queueBind(String queue,
                      String exchange,
                      String routingKey)

Bind a queue to an exchange

Parameters:: queue -; exchange -; routingKey -

rxQueueBind

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

Bind a queue to an exchange

Parameters:: queue -; exchange -; routingKey -
Returns:

queueBind

public void queueBind(String queue,
                      String exchange,
                      String routingKey,
                      Map<String,Object> arguments,
                      io.vertx.core.Handler<io.vertx.core.AsyncResult<Void>> resultHandler)

Bind a queue to an exchange

Parameters:: queue -; exchange -; routingKey -; arguments -; resultHandler -

queueBind

public void queueBind(String queue,
                      String exchange,
                      String routingKey,
                      Map<String,Object> arguments)

Bind a queue to an exchange

Parameters:: queue -; exchange -; routingKey -; arguments -

rxQueueBind

public rx.Single<Void> rxQueueBind(String queue,
                                   String exchange,
                                   String routingKey,
                                   Map<String,Object> arguments)

Bind a queue to an exchange

Parameters:: queue -; exchange -; routingKey -; arguments -
Returns: