Package io.vertx.reactivex.amqp

## Class AmqpSender

- java.lang.Object
- - io.vertx.reactivex.amqp.AmqpSender

- All Implemented Interfaces:
    `io.vertx.lang.rx.RxDelegate`, `StreamBase`, `WriteStream<AmqpMessage>`

      public class AmqpSender
      extends Object
      implements io.vertx.lang.rx.RxDelegate, WriteStream<AmqpMessage>

  AMQP Sender interface used to send messages.

  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 io.vertx.lang.rx.TypeArg<AmqpSender>` | `__TYPE_ARG` |

  - ### Constructor Summary

    Constructors
    Constructor | Description
    --- | ---
    `AmqpSender​(AmqpSender delegate)` |
    `AmqpSender​(Object delegate)` |

  - ### Method Summary

    All Methods Static Methods Instance Methods Concrete Methods
    Modifier and Type | Method | Description
    --- | --- | ---
    `String` | `address()` |
    `Future<Void>` | `close()` | Closes the sender.
    `AmqpConnection` | `connection()` | Gets the connection having created the sender.
    `WriteStream<AmqpMessage>` | `drainHandler​(Handler<Void> handler)` | Set a drain handler on the stream.
    `Future<Void>` | `end()` | Ends the stream.
    `Future<Void>` | `end​(AmqpMessage data)` | Same as `WriteStream.end()` but writes some data to the stream before ending.
    `boolean` | `equals​(Object o)` |
    `AmqpSender` | `exceptionHandler​(Handler<Throwable> handler)` | Set an exception handler on the write stream.
    `AmqpSender` | `getDelegate()` |
    `int` | `hashCode()` |
    `static AmqpSender` | `newInstance​(AmqpSender arg)` |
    `long` | `remainingCredits()` |
    `Completable` | `rxClose()` | Closes the sender.
    `Completable` | `rxEnd()` | Ends the stream.
    `Completable` | `rxEnd​(AmqpMessage data)` | Same as `WriteStream.end()` but writes some data to the stream before ending.
    `Completable` | `rxSendWithAck​(AmqpMessage message)` | Sends an AMQP message and waits for an acknowledgement.
    `Completable` | `rxWrite​(AmqpMessage data)` | Write some data to the stream.
    `AmqpSender` | `send​(AmqpMessage message)` | Sends an AMQP message.
    `Future<Void>` | `sendWithAck​(AmqpMessage message)` | Sends an AMQP message and waits for an acknowledgement.
    `AmqpSender` | `setWriteQueueMaxSize​(int maxSize)` | Set the maximum size of the write queue to `maxSize`.
    `WriteStreamObserver<AmqpMessage>` | `toObserver()` |
    `String` | `toString()` |
    `WriteStreamSubscriber<AmqpMessage>` | `toSubscriber()` |
    `io.vertx.proton.ProtonSender` | `unwrap()` |
    `Future<Void>` | `write​(AmqpMessage data)` | Write some data to the stream.
    `boolean` | `writeQueueFull()` | This will return `true` if there are more bytes in the write queue than the value set using `setWriteQueueMaxSize(int)`

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

      `clone, finalize, getClass, notify, notifyAll, wait, wait, wait`

- - ### Field Detail

    - #### __TYPE_ARG

          public static final io.vertx.lang.rx.TypeArg<AmqpSender> __TYPE_ARG

  - ### Constructor Detail

    - #### AmqpSender

          public AmqpSender​(AmqpSender delegate)

    - #### AmqpSender

          public AmqpSender​(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 AmqpSender getDelegate()

      Specified by:
        `getDelegate` in interface `io.vertx.lang.rx.RxDelegate`
      Specified by:
        `getDelegate` in interface `StreamBase`
      Specified by:
        `getDelegate` in interface `WriteStream<AmqpMessage>`

    - #### toObserver

          public WriteStreamObserver<AmqpMessage> toObserver()

      Specified by:
        `toObserver` in interface `WriteStream<AmqpMessage>`

    - #### toSubscriber

          public WriteStreamSubscriber<AmqpMessage> toSubscriber()

      Specified by:
        `toSubscriber` in interface `WriteStream<AmqpMessage>`

    - #### write

          public Future<Void> write​(AmqpMessage data)

      Write some data to the stream.

      The data is usually put on an internal write queue, and the write actually happens asynchronously. To avoid running out of memory by putting too much on the write queue, check the `WriteStream.writeQueueFull()` method before writing. This is done automatically if using a .

      When the `data` is moved from the queue to the actual medium, the returned will be completed with the write result, e.g the future is succeeded when a server HTTP response buffer is written to the socket and failed if the remote client has closed the socket while the data was still pending for write.

      Specified by:
        `write` in interface `WriteStream<AmqpMessage>`
      Parameters:
        `data` - the data to write
      Returns:
        a future completed with the write result

    - #### rxWrite

          public Completable rxWrite​(AmqpMessage data)

      Write some data to the stream.

      The data is usually put on an internal write queue, and the write actually happens asynchronously. To avoid running out of memory by putting too much on the write queue, check the `WriteStream.writeQueueFull()` method before writing. This is done automatically if using a .

      When the `data` is moved from the queue to the actual medium, the returned will be completed with the write result, e.g the future is succeeded when a server HTTP response buffer is written to the socket and failed if the remote client has closed the socket while the data was still pending for write.

      Specified by:
        `rxWrite` in interface `WriteStream<AmqpMessage>`
      Parameters:
        `data` - the data to write
      Returns:
        a future completed with the write result

    - #### end

          public Future<Void> end()

      Ends the stream.

      Once the stream has ended, it cannot be used any more.

      Specified by:
        `end` in interface `WriteStream<AmqpMessage>`
      Returns:
        a future completed with the result

    - #### rxEnd

          public Completable rxEnd()

      Ends the stream.

      Once the stream has ended, it cannot be used any more.

      Specified by:
        `rxEnd` in interface `WriteStream<AmqpMessage>`
      Returns:
        a future completed with the result

    - #### end

          public Future<Void> end​(AmqpMessage data)

      Same as `WriteStream.end()` but writes some data to the stream before ending.
      Specified by:
        `end` in interface `WriteStream<AmqpMessage>`
      Parameters:
        `data` - the data to write
      Returns:
        a future completed with the result

    - #### rxEnd

          public Completable rxEnd​(AmqpMessage data)

      Same as `WriteStream.end()` but writes some data to the stream before ending.
      Specified by:
        `rxEnd` in interface `WriteStream<AmqpMessage>`
      Parameters:
        `data` - the data to write
      Returns:
        a future completed with the result

    - #### writeQueueFull

          public boolean writeQueueFull()

      This will return `true` if there are more bytes in the write queue than the value set using `setWriteQueueMaxSize(int)`
      Specified by:
        `writeQueueFull` in interface `WriteStream<AmqpMessage>`
      Returns:
        `true` if write queue is full

    - #### drainHandler

          public WriteStream<AmqpMessage> drainHandler​(Handler<Void> handler)

      Set a drain handler on the stream. If the write queue is full, then the handler will be called when the write queue is ready to accept buffers again. See for an example of this being used.

      The stream implementation defines when the drain handler, for example it could be when the queue size has been reduced to `maxSize / 2`.

      Specified by:
        `drainHandler` in interface `WriteStream<AmqpMessage>`
      Parameters:
        `handler` - the handler
      Returns:
        a reference to this, so the API can be used fluently

    - #### exceptionHandler

          public AmqpSender exceptionHandler​(Handler<Throwable> handler)

      Description copied from interface: `WriteStream`
      Set an exception handler on the write stream.
      Specified by:
        `exceptionHandler` in interface `StreamBase`
      Specified by:
        `exceptionHandler` in interface `WriteStream<AmqpMessage>`
      Parameters:
        `handler` - the exception handler
      Returns:
        a reference to this, so the API can be used fluently

    - #### setWriteQueueMaxSize

          public AmqpSender setWriteQueueMaxSize​(int maxSize)

      Description copied from interface: `WriteStream`
      Set the maximum size of the write queue to `maxSize`. You will still be able to write to the stream even if there is more than `maxSize` items in the write queue. This is used as an indicator by classes such as `Pipe` to provide flow control.

      The value is defined by the implementation of the stream, e.g in bytes for a `NetSocket`, etc...
      Specified by:
        `setWriteQueueMaxSize` in interface `WriteStream<AmqpMessage>`
      Parameters:
        `maxSize` - the max size of the write stream
      Returns:
        a reference to this, so the API can be used fluently

    - #### send

          public AmqpSender send​(AmqpMessage message)

      Sends an AMQP message. The destination the configured sender address or the address configured in the message.
      Parameters:
        `message` - the message, must not be `null`
      Returns:
        the current sender

    - #### sendWithAck

          public Future<Void> sendWithAck​(AmqpMessage message)

      Sends an AMQP message and waits for an acknowledgement. It returns a future marked as failed if the message has been rejected or re-routed. If the message has been accepted, the handler is called with a success.
      Parameters:
        `message` - the message, must not be `null`
      Returns:
        a future notified with the acknowledgement

    - #### rxSendWithAck

          public Completable rxSendWithAck​(AmqpMessage message)

      Sends an AMQP message and waits for an acknowledgement. It returns a future marked as failed if the message has been rejected or re-routed. If the message has been accepted, the handler is called with a success.
      Parameters:
        `message` - the message, must not be `null`
      Returns:
        a future notified with the acknowledgement

    - #### close

          public Future<Void> close()

      Closes the sender.
      Returns:
        a future notified when the sender has been closed

    - #### rxClose

          public Completable rxClose()

      Closes the sender.
      Returns:
        a future notified when the sender has been closed

    - #### address

          public String address()

      Returns:
        the configured address.

    - #### connection

          public AmqpConnection connection()

      Gets the connection having created the sender. Cannot be `null`
      Returns:
        the connection having created the sender.

    - #### remainingCredits

          public long remainingCredits()

      Returns:
        the remaining credit, 0 is none.

    - #### unwrap

          public io.vertx.proton.ProtonSender unwrap()

      Returns:
        the underlying ProtonSender.

    - #### newInstance

          public static AmqpSender newInstance​(AmqpSender arg)