io.vertx.reactivex.core.streams

## Interface WriteStream<T>

- All Superinterfaces:
    io.vertx.lang.rx.RxDelegate, StreamBase
  All Known Subinterfaces:
    WebSocketBase
  All Known Implementing Classes:
    AmqpSender, AsyncFile, ClientWebSocket, GrpcClientRequest, GrpcServerResponse, GrpcWriteStream, HttpClientRequest, HttpServerResponse, KafkaProducer, NetSocket, ServerWebSocket, SockJSSocket, WebSocket

      public interface WriteStream<T>
      extends io.vertx.lang.rx.RxDelegate, StreamBase

  Represents a stream of data that can be written to.

  Any class that implements this interface can be used by a `Pipe` to pipe data from a `ReadStream` to it.

  NOTE: This class has been automatically generated from the `original` non RX-ified interface using Vert.x codegen.

- - ### Method Summary

    All Methods Static Methods Instance Methods Abstract Methods Default Methods
    Modifier and Type | Method and Description
    --- | ---
    `WriteStream<T>` | `drainHandler(Handler<Void> handler)` Set a drain handler on the stream.
    `void` | `end()` Same as `end(io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>)` but with an `handler` called when the operation completes
    `void` | `end(Handler<AsyncResult<Void>> handler)` Same as `end(io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>)` but with an `handler` called when the operation completes
    `void` | `end(T data)` Same as but with an `handler` called when the operation completes
    `void` | `end(T data, Handler<AsyncResult<Void>> handler)` Same as but with an `handler` called when the operation completes
    `WriteStream<T>` | `exceptionHandler(Handler<Throwable> handler)` Set an exception handler on the write stream.
    `WriteStream` | `getDelegate()`
    `static <T> WriteStream<T>` | `newInstance(WriteStream arg)`
    `static <T> WriteStream<T>` | `newInstance(WriteStream arg, io.vertx.lang.rx.TypeArg<T> __typeArg_T)`
    `Completable` | `rxEnd()` Same as `end(io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>)` but with an `handler` called when the operation completes
    `Completable` | `rxEnd(T data)` Same as but with an `handler` called when the operation completes
    `Completable` | `rxWrite(T data)` Same as but with an `handler` called when the operation completes
    `WriteStream<T>` | `setWriteQueueMaxSize(int maxSize)` Set the maximum size of the write queue to `maxSize`.
    `WriteStreamObserver<T>` | `toObserver()`
    `WriteStreamSubscriber<T>` | `toSubscriber()`
    `void` | `write(T data)` Same as but with an `handler` called when the operation completes
    `void` | `write(T data, Handler<AsyncResult<Void>> handler)` Same as but with an `handler` called when the operation completes
    `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 interface io.vertx.reactivex.core.streams.StreamBase

      `newInstance`

- - ### Method Detail

    - #### getDelegate

          WriteStream getDelegate()

      Specified by:
        `getDelegate` in interface `io.vertx.lang.rx.RxDelegate`
      Specified by:
        `getDelegate` in interface `StreamBase`

    - #### exceptionHandler

          WriteStream<T> exceptionHandler(Handler<Throwable> handler)

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

    - #### write

          void write(T data,
                     Handler<AsyncResult<Void>> handler)

      Same as but with an `handler` called when the operation completes
      Parameters:
        `data` -
        `handler` -

    - #### write

          void write(T data)

      Same as but with an `handler` called when the operation completes
      Parameters:
        `data` -

    - #### rxWrite

          Completable rxWrite(T data)

      Same as but with an `handler` called when the operation completes
      Parameters:
        `data` -
      Returns:

    - #### end

          void end(Handler<AsyncResult<Void>> handler)

      Same as `end(io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>)` but with an `handler` called when the operation completes
      Parameters:
        `handler` -

    - #### end

          void end()

      Same as `end(io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>)` but with an `handler` called when the operation completes

    - #### rxEnd

          Completable rxEnd()

      Same as `end(io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>)` but with an `handler` called when the operation completes
      Returns:

    - #### end

          void end(T data,
                   Handler<AsyncResult<Void>> handler)

      Same as but with an `handler` called when the operation completes
      Parameters:
        `data` -
        `handler` -

    - #### end

          void end(T data)

      Same as but with an `handler` called when the operation completes
      Parameters:
        `data` -

    - #### rxEnd

          Completable rxEnd(T data)

      Same as but with an `handler` called when the operation completes
      Parameters:
        `data` -
      Returns:

    - #### setWriteQueueMaxSize

          WriteStream<T> setWriteQueueMaxSize(int maxSize)

      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...
      Parameters:
        `maxSize` - the max size of the write stream
      Returns:
        a reference to this, so the API can be used fluently

    - #### writeQueueFull

          boolean writeQueueFull()

      This will return `true` if there are more bytes in the write queue than the value set using `setWriteQueueMaxSize(int)`
      Returns:
        `true` if write queue is full

    - #### drainHandler

          WriteStream<T> 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 `Pipe` 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`.

      Parameters:
        `handler` - the handler
      Returns:
        a reference to this, so the API can be used fluently

    - #### toObserver

          WriteStreamObserver<T> toObserver()

    - #### toSubscriber

          WriteStreamSubscriber<T> toSubscriber()

    - #### newInstance

          static <T> WriteStream<T> newInstance(WriteStream arg)

    - #### newInstance

          static <T> WriteStream<T> newInstance(WriteStream arg,
                                                io.vertx.lang.rx.TypeArg<T> __typeArg_T)

Copyright © 2025 Eclipse. All rights reserved.