vertx / io.vertx.reactivex.core.eventbus / MessageProducer

# MessageProducer

`open class MessageProducer<T : Any> : WriteStream<T>`

Represents a stream of message that can be written to.

NOTE: This class has been automatically generated from the io.vertx.core.eventbus.MessageProducer non RX-ified interface using Vert.x codegen.

### Constructors

<init> | `MessageProducer(delegate: MessageProducer<Any>)` `MessageProducer(delegate: MessageProducer<Any>, typeArg_0: TypeArg<T>)`

### Properties

__TYPE_ARG | `static val __TYPE_ARG: TypeArg<MessageProducer<Any>>`
__typeArg_0 | `val __typeArg_0: TypeArg<T>`

### Functions

address | `open fun address(): String`
close | `open fun close(): Unit` Closes the producer, this method should be called when the message producer is not used anymore.
deliveryOptions | `open fun deliveryOptions(options: DeliveryOptions): MessageProducer<T>` Update the delivery options of this producer.
drainHandler | `open fun drainHandler(handler: Handler<Void>): MessageProducer<T>`
end | `open fun end(t: T): Unit` Same as `io.vertx.reactivex.core.eventbus.MessageProducer#end` but writes some data to the stream before ending. `open fun end(): Unit` Closes the producer, calls `io.vertx.reactivex.core.eventbus.MessageProducer#close`
equals | `open fun equals(other: Any?): Boolean`
exceptionHandler | `open fun exceptionHandler(handler: Handler<Throwable>): MessageProducer<T>`
getDelegate | `open fun getDelegate(): MessageProducer<Any>`
hashCode | `open fun hashCode(): Int`
newInstance | `open static fun <T : Any> newInstance(arg: MessageProducer<Any>): MessageProducer<T>` `open static fun <T : Any> newInstance(arg: MessageProducer<Any>, __typeArg_T: TypeArg<T>): MessageProducer<T>`
send | `open fun send(message: T): MessageProducer<T>` This method actually sends a message using the send semantic regardless this producer is a sender or a publisher. `open fun <R : Any> send(message: T, replyHandler: Handler<AsyncResult<Message<R>>>): MessageProducer<T>` Like `io.vertx.reactivex.core.eventbus.MessageProducer#send` but specifying a `replyHandler` that will be called if the recipient subsequently replies to the message.
setWriteQueueMaxSize | `open fun setWriteQueueMaxSize(maxSize: Int): MessageProducer<T>`
toString | `open fun toString(): String`
write | `open fun write(data: T): MessageProducer<T>`
writeQueueFull | `open fun writeQueueFull(): Boolean` This will return `true` if there are more bytes in the write queue than the value set using `io.vertx.reactivex.core.eventbus.MessageProducer#setWriteQueueMaxSize`