Package io.vertx.grpc.server

## Interface GrpcServerResponse<Req,​Resp>

- All Superinterfaces:
    `GrpcWriteStream<Resp>`, `StreamBase`, `WriteStream<Resp>`

      public interface GrpcServerResponse<Req,​Resp>
      extends GrpcWriteStream<Resp>

- - ### Method Summary

    All Methods Instance Methods Abstract Methods Default Methods
    Modifier and Type | Method | Description
    --- | --- | ---
    `Set<String>` | `acceptedEncodings()` |
    `GrpcServerResponse<Req,​Resp>` | `drainHandler​(Handler<Void> handler)` | Set a drain handler on the stream.
    `GrpcServerResponse<Req,​Resp>` | `encoding​(String encoding)` | Set the stream encoding, e.g.
    `GrpcServerResponse<Req,​Resp>` | `exceptionHandler​(Handler<Throwable> handler)` | Set an exception handler on the write stream.
    `void` | `fail​(Throwable failure)` | End the stream with an appropriate status message, when `failure` is `StatusException`, set status to `StatusException.status()` and status message to `StatusException.message()` `UnsupportedOperationException` returns `GrpcStatus.UNIMPLEMENTED` otherwise returns `GrpcStatus.UNKNOWN`
    `GrpcServerResponse<Req,​Resp>` | `format​(WireFormat format)` | Set the stream format, e.g.
    `default Future<Void>` | `send​(ReadStream<Resp> body)` |
    `default Future<Void>` | `send​(Resp item)` |
    `GrpcServerResponse<Req,​Resp>` | `setWriteQueueMaxSize​(int maxSize)` | Set the maximum size of the write queue to `maxSize`.
    `GrpcServerResponse<Req,​Resp>` | `status​(GrpcStatus status)` | Set the grpc status response
    `GrpcServerResponse<Req,​Resp>` | `statusMessage​(String msg)` | Set the grpc status response message
    `MultiMap` | `trailers()` |
    `Future<Void>` | `writeHead()` | Send the response headers.

    - ### Methods inherited from interface io.vertx.grpc.common.GrpcWriteStream

      `cancel, endMessage, headers, writeMessage`

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

      `end, end, write, writeQueueFull`

- - ### Method Detail

    - #### status

          GrpcServerResponse<Req,​Resp> status​(GrpcStatus status)

      Set the grpc status response
      Parameters:
        `status` - the status
      Returns:
        a reference to this, so the API can be used fluently

    - #### statusMessage

          GrpcServerResponse<Req,​Resp> statusMessage​(String msg)

      Set the grpc status response message
      Parameters:
        `msg` - the message
      Returns:
        a reference to this, so the API can be used fluently

    - #### encoding

          GrpcServerResponse<Req,​Resp> encoding​(String encoding)

      Description copied from interface: `GrpcWriteStream`

      Set the stream encoding, e.g. `identity` or `gzip`,

      - The encoding must be set before sending any message, otherwise `identity` will be used.
      - The encoding should also match the opposite endpoint expectations.
      Specified by:
        `encoding` in interface `GrpcWriteStream<Req>`
      Parameters:
        `encoding` - the target message encoding
      Returns:
        a reference to this, so the API can be used fluently

    - #### format

          GrpcServerResponse<Req,​Resp> format​(WireFormat format)

      Description copied from interface: `GrpcWriteStream`
      Set the stream format, e.g. `proto` or `json`. It must be called before sending any message, otherwise `proto` will be used.
      Specified by:
        `format` in interface `GrpcWriteStream<Req>`
      Parameters:
        `format` - the message format
      Returns:
        a reference to this, so the API can be used fluently

    - #### acceptedEncodings

          Set<String> acceptedEncodings()

      Returns:
        the set of accepted encodings sent by the client, note that `identity` should not be part of this set. This can be used to set the response `encoding` to ensure the client will accept the encoding. This is a glorified wrapper for the `grpc-accept-encoding` header.

    - #### trailers

          MultiMap trailers()

      Returns:
        the `MultiMap` to write metadata trailers

    - #### exceptionHandler

          GrpcServerResponse<Req,​Resp> exceptionHandler​(Handler<Throwable> handler)

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

    - #### setWriteQueueMaxSize

          GrpcServerResponse<Req,​Resp> 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 `GrpcWriteStream<Req>`
      Specified by:
        `setWriteQueueMaxSize` in interface `WriteStream<Req>`
      Parameters:
        `maxSize` - the max size of the write stream
      Returns:
        a reference to this, so the API can be used fluently

    - #### drainHandler

          GrpcServerResponse<Req,​Resp> 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 `GrpcWriteStream<Req>`
      Specified by:
        `drainHandler` in interface `WriteStream<Req>`
      Parameters:
        `handler` - the handler
      Returns:
        a reference to this, so the API can be used fluently

    - #### writeHead

          Future<Void> writeHead()

      Send the response headers.
      Returns:
        a future notified by the success or failure of the write

    - #### send

          default Future<Void> send​(Resp item)

    - #### send

          default Future<Void> send​(ReadStream<Resp> body)

    - #### fail

          void fail​(Throwable failure)

      End the stream with an appropriate status message, when `failure` is
      - `StatusException`, set status to `StatusException.status()` and status message to `StatusException.message()`
      - `UnsupportedOperationException` returns `GrpcStatus.UNIMPLEMENTED`
      - otherwise returns `GrpcStatus.UNKNOWN`
      Parameters:
        `failure` - the failure