io.vertx.grpc.common

## Interface GrpcWriteStream<T>

- All Superinterfaces:
    StreamBase, WriteStream<T>
  All Known Subinterfaces:
    GrpcClientRequest<Req,Resp>, GrpcServerResponse<Req,Resp>

      public interface GrpcWriteStream<T>
      extends WriteStream<T>

- - ### Method Summary

    All Methods Instance Methods Abstract Methods Default Methods
    Modifier and Type | Method and Description
    --- | ---
    `boolean` | `cancel()` Cancel the stream.
    `GrpcWriteStream<T>` | `drainHandler(Handler<Void> handler)` Set a drain handler on the stream.
    `GrpcWriteStream<T>` | `encoding(String encoding)` Set the stream encoding, e.g `identity` or `gzip`.
    `void` | `end(Handler<AsyncResult<Void>> handler)` Same as `WriteStream.end()` but with an `handler` called when the operation completes
    `default void` | `end(T data, Handler<AsyncResult<Void>> handler)` Same as `#end(T)` but with an `handler` called when the operation completes
    `Future<Void>` | `endMessage(GrpcMessage message)` End the stream with an encoded gRPC message.
    `GrpcWriteStream<T>` | `exceptionHandler(Handler<Throwable> handler)` Set an exception handler on the write stream.
    `MultiMap` | `headers()`
    `GrpcWriteStream<T>` | `setWriteQueueMaxSize(int i)` Set the maximum size of the write queue to `maxSize`.
    `void` | `write(T t, Handler<AsyncResult<Void>> handler)` Same as `#write(T)` but with an `handler` called when the operation completes
    `Future<Void>` | `writeMessage(GrpcMessage message)` Write an encoded gRPC message.

    - ### Methods inherited from interface io.vertx.core.streams.WriteStream

      `end, end, write, writeQueueFull`

- - ### Method Detail

    - #### headers

          MultiMap headers()

      Returns:
        the `MultiMap` to reader metadata headers

    - #### encoding

          GrpcWriteStream<T> encoding(String encoding)

      Set the stream encoding, e.g `identity` or `gzip`. It must be called before sending any message, otherwise {@code identity will be used.
      Parameters:
        `encoding` - the target message encoding
      Returns:
        a reference to this, so the API can be used fluently

    - #### exceptionHandler

          GrpcWriteStream<T> 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<T>`
      Parameters:
        `handler` - the exception handler
      Returns:
        a reference to this, so the API can be used fluently

    - #### setWriteQueueMaxSize

          GrpcWriteStream<T> setWriteQueueMaxSize(int i)

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

    - #### drainHandler

          GrpcWriteStream<T> drainHandler(Handler<Void> handler)

      Description copied from interface: `WriteStream`
      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`.

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

    - #### writeMessage

          Future<Void> writeMessage(GrpcMessage message)

      Write an encoded gRPC message.
      Parameters:
        `message` - the message
      Returns:
        a future completed with the result

    - #### endMessage

          Future<Void> endMessage(GrpcMessage message)

      End the stream with an encoded gRPC message.
      Parameters:
        `message` - the message
      Returns:
        a future completed with the result

    - #### cancel

          boolean cancel()

      Cancel the stream.
      Returns:
        `true` if the stream was cancelled

    - #### write

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

      Description copied from interface: `WriteStream`
      Same as `#write(T)` but with an `handler` called when the operation completes
      Specified by:
        `write` in interface `WriteStream<T>`

    - #### end

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

      Description copied from interface: `WriteStream`
      Same as `WriteStream.end()` but with an `handler` called when the operation completes
      Specified by:
        `end` in interface `WriteStream<T>`

    - #### end

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

      Description copied from interface: `WriteStream`
      Same as `#end(T)` but with an `handler` called when the operation completes
      Specified by:
        `end` in interface `WriteStream<T>`

Copyright © 2022 Eclipse. All rights reserved.