Value Members

1.  final def !=(arg0: Any): Boolean

   Definition Classes

   AnyRef → Any

2.  final def ##(): Int

   Definition Classes

   AnyRef → Any

3.  final def ==(arg0: Any): Boolean

   Definition Classes

   AnyRef → Any

4.  final def asInstanceOf[T0]: T0

   Definition Classes

   Any

5.  def asJava: AnyRef
6.  def basicAck(deliveryTag: Long, multiple: Boolean, resultHandler: Handler[AsyncResult[JsonObject]]): Unit

   Acknowledge one or several received messages.

   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.

7.  def basicAckFuture(deliveryTag: Long, multiple: Boolean): Future[JsonObject]

   Like basicAck but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

8.  def basicCancel(consumerTag: String, resultHandler: Handler[AsyncResult[Unit]]): Unit

   Instead of using this and io.vertx.scala.rabbitmq.RabbitMQClient#basicConsume method, io.vertx.scala.rabbitmq.RabbitMQClient#basicConsumer and io.vertx.scala.rabbitmq.RabbitMQConsumer#cancel instead

   Instead of using this and io.vertx.scala.rabbitmq.RabbitMQClient#basicConsume method, io.vertx.scala.rabbitmq.RabbitMQClient#basicConsumer and io.vertx.scala.rabbitmq.RabbitMQConsumer#cancel instead

   This method should be called when you want to cancel consumption from a queue, started by calling io.vertx.scala.rabbitmq.RabbitMQClient#basicConsume.

9.  def basicCancel(consumerTag: String): Unit

   Instead of using this and io.vertx.scala.rabbitmq.RabbitMQClient#basicConsume method, io.vertx.scala.rabbitmq.RabbitMQClient#basicConsumer and io.vertx.scala.rabbitmq.RabbitMQConsumer#cancel instead

   Instead of using this and io.vertx.scala.rabbitmq.RabbitMQClient#basicConsume method, io.vertx.scala.rabbitmq.RabbitMQClient#basicConsumer and io.vertx.scala.rabbitmq.RabbitMQConsumer#cancel instead

   This method should be called when you want to cancel consumption from a queue, started by calling io.vertx.scala.rabbitmq.RabbitMQClient#basicConsume.

10.  def basicCancelFuture(consumerTag: String): Future[Unit]

    Like basicCancel but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

11.  def basicConsume(queue: String, address: String, autoAck: Boolean, resultHandler: Handler[AsyncResult[String]], errorHandler: Handler[Throwable]): Unit

    Use io.vertx.scala.rabbitmq.RabbitMQClient#basicConsumer instead

    Use io.vertx.scala.rabbitmq.RabbitMQClient#basicConsumer instead

    Start a non-nolocal, non-exclusive consumer, with a server-generated consumerTag and error handler

12.  def basicConsume(queue: String, address: String, autoAck: Boolean, resultHandler: Handler[AsyncResult[String]]): Unit

    Use io.vertx.scala.rabbitmq.RabbitMQClient#basicConsumer instead

    Use io.vertx.scala.rabbitmq.RabbitMQClient#basicConsumer instead

    Start a non-nolocal, non-exclusive consumer, with a server-generated consumerTag.

13.  def basicConsume(queue: String, address: String, resultHandler: Handler[AsyncResult[String]]): Unit

    Use io.vertx.scala.rabbitmq.RabbitMQClient#basicConsumer instead

    Use io.vertx.scala.rabbitmq.RabbitMQClient#basicConsumer instead

    Start a non-nolocal, non-exclusive consumer, with auto acknowledgement and a server-generated consumerTag.

14.  def basicConsumeFuture(queue: String, address: String, autoAck: Boolean): Future[String]

    Like basicConsume but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

15.  def basicConsumeFuture(queue: String, address: String): Future[String]

    Like basicConsume but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

16.  def basicConsumer(queue: String, options: QueueOptions, resultHandler: Handler[AsyncResult[RabbitMQConsumer]]): Unit

    Create a consumer with the given options.

    Create a consumer with the given options. * @param queue the name of a queue

    options

    options for queue see QueueOptions

    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

17.  def basicConsumer(queue: String, resultHandler: Handler[AsyncResult[RabbitMQConsumer]]): Unit

18.  def basicConsumerFuture(queue: String, options: QueueOptions): Future[RabbitMQConsumer]

    Like basicConsumer but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

19.  def basicConsumerFuture(queue: String): Future[RabbitMQConsumer]

    Like basicConsumer but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

20.  def basicGet(queue: String, autoAck: Boolean, resultHandler: Handler[AsyncResult[JsonObject]]): Unit

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

21.  def basicGetFuture(queue: String, autoAck: Boolean): Future[JsonObject]

    Like basicGet but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

22.  def basicNack(deliveryTag: Long, multiple: Boolean, requeue: Boolean, resultHandler: Handler[AsyncResult[JsonObject]]): Unit

    Reject one or several received messages.

23.  def basicNackFuture(deliveryTag: Long, multiple: Boolean, requeue: Boolean): Future[JsonObject]

    Like basicNack but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

24.  def basicPublish(exchange: String, routingKey: String, message: JsonObject, resultHandler: Handler[AsyncResult[Unit]]): Unit

    Publish a 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.

25.  def basicPublishFuture(exchange: String, routingKey: String, message: JsonObject): Future[Unit]

    Like basicPublish but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

26.  def basicQos(prefetchSize: Int, prefetchCount: Int, global: Boolean, resultHandler: Handler[AsyncResult[Unit]]): Unit

    Request specific "quality of service" settings.

    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. * @param 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

27.  def basicQos(prefetchCount: Int, global: Boolean, resultHandler: Handler[AsyncResult[Unit]]): Unit

    Request a specific prefetchCount "quality of service" settings for this channel.

    Request a specific prefetchCount "quality of service" settings for this channel. * @param 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

28.  def basicQos(prefetchCount: Int, resultHandler: Handler[AsyncResult[Unit]]): Unit

    Request a specific prefetchCount "quality of service" settings for this channel.

    Request a specific prefetchCount "quality of service" settings for this channel. * @param 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

29.  def basicQosFuture(prefetchSize: Int, prefetchCount: Int, global: Boolean): Future[Unit]

    Like basicQos but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

30.  def basicQosFuture(prefetchCount: Int, global: Boolean): Future[Unit]

    Like basicQos but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

31.  def basicQosFuture(prefetchCount: Int): Future[Unit]

    Like basicQos but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

32.  def clone(): AnyRef

    Attributes

    protected[java.lang]

    Definition Classes

    AnyRef

    Annotations

    @native() @throws( ... )

33.  def confirmSelect(resultHandler: Handler[AsyncResult[Unit]]): Unit

    Enables publisher acknowledgements on this channel.

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

34.  def confirmSelectFuture(): Future[Unit]

    Like confirmSelect but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

35.  final def eq(arg0: AnyRef): Boolean

    Definition Classes

    AnyRef

36.  def equals(arg0: Any): Boolean

    Definition Classes

    AnyRef → Any

37.  def exchangeBind(destination: String, source: String, routingKey: String, resultHandler: Handler[AsyncResult[Unit]]): Unit

    Bind an exchange to an exchange.

38.  def exchangeBindFuture(destination: String, source: String, routingKey: String): Future[Unit]

    Like exchangeBind but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

39.  def exchangeDeclare(exchange: String, type: String, durable: Boolean, autoDelete: Boolean, config: JsonObject, resultHandler: Handler[AsyncResult[Unit]]): Unit

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

40.  def exchangeDeclare(exchange: String, type: String, durable: Boolean, autoDelete: Boolean, resultHandler: Handler[AsyncResult[Unit]]): Unit

    Declare an exchange.

41.  def exchangeDeclareFuture(exchange: String, type: String, durable: Boolean, autoDelete: Boolean, config: JsonObject): Future[Unit]

    Like exchangeDeclare but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

42.  def exchangeDeclareFuture(exchange: String, type: String, durable: Boolean, autoDelete: Boolean): Future[Unit]

    Like exchangeDeclare but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

43.  def exchangeDelete(exchange: String, resultHandler: Handler[AsyncResult[Unit]]): Unit

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

44.  def exchangeDeleteFuture(exchange: String): Future[Unit]

    Like exchangeDelete but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

45.  def exchangeUnbind(destination: String, source: String, routingKey: String, resultHandler: Handler[AsyncResult[Unit]]): Unit

    Unbind an exchange from an exchange.

46.  def exchangeUnbindFuture(destination: String, source: String, routingKey: String): Future[Unit]

    Like exchangeUnbind but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

47.  def finalize(): Unit

    Attributes

    protected[java.lang]

    Definition Classes

    AnyRef

    Annotations

    @throws( classOf[java.lang.Throwable] )

48.  final def getClass(): Class[_]

    Definition Classes

    AnyRef → Any

    Annotations

    @native()

49.  def hashCode(): Int

    Definition Classes

    AnyRef → Any

    Annotations

    @native()

50.  def isConnected(): Boolean

    Check if a connection is open * @return true when the connection is open, false otherwise

51.  final def isInstanceOf[T0]: Boolean

    Definition Classes

    Any

52.  def isOpenChannel(): Boolean

    Check if a channel is open * @return true when the connection is open, false otherwise

53.  def messageCount(queue: String, resultHandler: Handler[AsyncResult[Long]]): Unit

    Returns the number of messages in a queue ready to be delivered.

54.  def messageCountFuture(queue: String): Future[Long]

    Like messageCount but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

55.  final def ne(arg0: AnyRef): Boolean

    Definition Classes

    AnyRef

56.  final def notify(): Unit

    Definition Classes

    AnyRef

    Annotations

    @native()

57.  final def notifyAll(): Unit

    Definition Classes

    AnyRef

    Annotations

    @native()

58.  def queueBind(queue: String, exchange: String, routingKey: String, resultHandler: Handler[AsyncResult[Unit]]): Unit

    Bind a queue to an exchange

59.  def queueBindFuture(queue: String, exchange: String, routingKey: String): Future[Unit]

    Like queueBind but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

60.  def queueDeclare(queue: String, durable: Boolean, exclusive: Boolean, autoDelete: Boolean, config: JsonObject, resultHandler: Handler[AsyncResult[JsonObject]]): Unit

    Declare a queue with config options

61.  def queueDeclare(queue: String, durable: Boolean, exclusive: Boolean, autoDelete: Boolean, resultHandler: Handler[AsyncResult[JsonObject]]): Unit

    Declare a queue

62.  def queueDeclareAuto(resultHandler: Handler[AsyncResult[JsonObject]]): Unit

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

63.  def queueDeclareAutoFuture(): Future[JsonObject]

    Like queueDeclareAuto but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

64.  def queueDeclareFuture(queue: String, durable: Boolean, exclusive: Boolean, autoDelete: Boolean, config: JsonObject): Future[JsonObject]

    Like queueDeclare but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

65.  def queueDeclareFuture(queue: String, durable: Boolean, exclusive: Boolean, autoDelete: Boolean): Future[JsonObject]

    Like queueDeclare but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

66.  def queueDelete(queue: String, resultHandler: Handler[AsyncResult[JsonObject]]): Unit

    Delete a queue, without regard for whether it is in use or has messages on it

67.  def queueDeleteFuture(queue: String): Future[JsonObject]

    Like queueDelete but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

68.  def queueDeleteIf(queue: String, ifUnused: Boolean, ifEmpty: Boolean, resultHandler: Handler[AsyncResult[JsonObject]]): Unit

    Delete a queue

69.  def queueDeleteIfFuture(queue: String, ifUnused: Boolean, ifEmpty: Boolean): Future[JsonObject]

    Like queueDeleteIf but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

70.  def start(resultHandler: Handler[AsyncResult[Unit]]): Unit

    Start the rabbitMQ client.

    Start the rabbitMQ client. Create the connection and the chanel.

71.  def startFuture(): Future[Unit]

    Like start but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

72.  def stop(resultHandler: Handler[AsyncResult[Unit]]): Unit

    Stop the rabbitMQ client.

    Stop the rabbitMQ client. Close the connection and its chanel.

73.  def stopFuture(): Future[Unit]

    Like stop but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

74.  final def synchronized[T0](arg0: ⇒ T0): T0

    Definition Classes

    AnyRef

75.  def toString(): String

    Definition Classes

    AnyRef → Any

76.  final def wait(): Unit

    Definition Classes

    AnyRef

    Annotations

    @throws( ... )

77.  final def wait(arg0: Long, arg1: Int): Unit

    Definition Classes

    AnyRef

    Annotations

    @throws( ... )

78.  final def wait(arg0: Long): Unit

    Definition Classes

    AnyRef

    Annotations

    @native() @throws( ... )

79.  def waitForConfirms(timeout: Long, resultHandler: Handler[AsyncResult[Unit]]): Unit

    Wait until all messages published since the last call have been either ack'd or nack'd by the broker; or until timeout elapses.

    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.

80.  def waitForConfirms(resultHandler: Handler[AsyncResult[Unit]]): Unit

    Wait until all messages published since the last call have been either ack'd or nack'd by the broker.

    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.

81.  def waitForConfirmsFuture(timeout: Long): Future[Unit]

    Like waitForConfirms but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

82.  def waitForConfirmsFuture(): Future[Unit]

    Like waitForConfirms but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.