io.vertx.rxjava.grpc.client

## Class GrpcClientRequest<Req,Resp>

- java.lang.Object
- - io.vertx.rxjava.grpc.common.GrpcWriteStream<Req>
  - - io.vertx.rxjava.grpc.client.GrpcClientRequest<Req,Resp>

- All Implemented Interfaces:
    StreamBase, WriteStream<Req>

      public class GrpcClientRequest<Req,Resp>
      extends GrpcWriteStream<Req>

  A request to a gRPC server.

  You interact with the remote service with gRPC generated messages or protobuf encoded messages.

  Before sending a request you need to set `#serviceName)` and `#methodName)` or alternatively the service `fullMethodName(java.lang.String)`.

  Writing a request message will send the request to the service:

  - To send a unary request, just call
  - To send a streaming request, call any time you need and then `WriteStream.end(io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>)`

  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 and Description
    --- | ---
    `static io.vertx.lang.rx.TypeArg<GrpcClientRequest>` | `__TYPE_ARG`
    `io.vertx.lang.rx.TypeArg<Req>` | `__typeArg_0`
    `io.vertx.lang.rx.TypeArg<Resp>` | `__typeArg_1`

  - ### Constructor Summary

    Constructors
    Constructor and Description
    `GrpcClientRequest(GrpcClientRequest delegate)`
    `GrpcClientRequest(Object delegate, io.vertx.lang.rx.TypeArg<Req> typeArg_0, io.vertx.lang.rx.TypeArg<Resp> typeArg_1)`

  - ### Method Summary

    All Methods Static Methods Instance Methods Concrete Methods
    Modifier and Type | Method and Description
    --- | ---
    `HttpConnection` | `connection()`
    `GrpcClientRequest<Req,Resp>` | `drainHandler(Handler<Void> handler)` Set a drain handler on the stream.
    `GrpcClientRequest<Req,Resp>` | `encoding(String encoding)` Set the stream encoding, e.g `identity` or `gzip`.
    `void` | `end()` Same as `WriteStream.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 `WriteStream.end(io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>)` but with an `handler` called when the operation completes
    `void` | `end(Req data)` Same as but with an `handler` called when the operation completes
    `void` | `end(Req data, Handler<AsyncResult<Void>> handler)` Same as but with an `handler` called when the operation completes
    `boolean` | `equals(Object o)`
    `GrpcClientRequest<Req,Resp>` | `exceptionHandler(Handler<Throwable> handler)` Set an exception handler on the write stream.
    `GrpcClientRequest<Req,Resp>` | `fullMethodName(String fullMethodName)` Set the full method name to call, it must follow the format `package-name + '.' + service-name + '/' + method-name` or an `IllegalArgumentException` is thrown.
    `GrpcClientRequest` | `getDelegate()`
    `int` | `hashCode()`
    `GrpcClientRequest<Req,Resp>` | `methodName(String methodName)` Set the method name to call.
    `static <Req,Resp> GrpcClientRequest<Req,Resp>` | `newInstance(GrpcClientRequest arg)`
    `static <Req,Resp> GrpcClientRequest<Req,Resp>` | `newInstance(GrpcClientRequest arg, io.vertx.lang.rx.TypeArg<Req> __typeArg_Req, io.vertx.lang.rx.TypeArg<Resp> __typeArg_Resp)`
    `Future<GrpcClientResponse<Req,Resp>>` | `response()`
    `Single<Void>` | `rxEnd()` Same as `WriteStream.end(io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>)` but with an `handler` called when the operation completes
    `Single<Void>` | `rxEnd(Req data)` Same as but with an `handler` called when the operation completes
    `Single<GrpcClientResponse<Req,Resp>>` | `rxResponse()`
    `Single<GrpcClientResponse<Req,Resp>>` | `rxSend(Observable<Req> body)`
    `Single<GrpcClientResponse<Req,Resp>>` | `rxSend(ReadStream<Req> body)`
    `Single<GrpcClientResponse<Req,Resp>>` | `rxSend(Req item)`
    `Single<Void>` | `rxWrite(Req data)` Same as but with an `handler` called when the operation completes
    `Future<GrpcClientResponse<Req,Resp>>` | `send(Observable<Req> body)`
    `Future<GrpcClientResponse<Req,Resp>>` | `send(ReadStream<Req> body)`
    `Future<GrpcClientResponse<Req,Resp>>` | `send(Req item)`
    `GrpcClientRequest<Req,Resp>` | `serviceName(ServiceName serviceName)` Set the service name to call.
    `GrpcClientRequest<Req,Resp>` | `setWriteQueueMaxSize(int maxSize)` Set the maximum size of the write queue to `maxSize`.
    `String` | `toString()`
    `WriteStreamSubscriber<Req>` | `toSubscriber()`
    `void` | `write(Req data)` Same as but with an `handler` called when the operation completes
    `void` | `write(Req 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 class io.vertx.rxjava.grpc.common.GrpcWriteStream

      `cancel, endMessage, headers, newInstance, newInstance, rxEndMessage, rxWriteMessage, writeMessage`

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

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

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

      `newInstance, newInstance`

    - ### Methods inherited from interface io.vertx.rxjava.core.streams.StreamBase

      `newInstance`

- - ### Field Detail

    - #### __TYPE_ARG

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

    - #### __typeArg_0

          public final io.vertx.lang.rx.TypeArg<Req> __typeArg_0

    - #### __typeArg_1

          public final io.vertx.lang.rx.TypeArg<Resp> __typeArg_1

  - ### Constructor Detail

    - #### GrpcClientRequest

          public GrpcClientRequest(GrpcClientRequest delegate)

    - #### GrpcClientRequest

          public GrpcClientRequest(Object delegate,
                                   io.vertx.lang.rx.TypeArg<Req> typeArg_0,
                                   io.vertx.lang.rx.TypeArg<Resp> typeArg_1)

  - ### Method Detail

    - #### toString

          public String toString()

      Overrides:
        `toString` in class `GrpcWriteStream<Req>`

    - #### equals

          public boolean equals(Object o)

      Overrides:
        `equals` in class `GrpcWriteStream<Req>`

    - #### hashCode

          public int hashCode()

      Overrides:
        `hashCode` in class `GrpcWriteStream<Req>`

    - #### getDelegate

          public GrpcClientRequest getDelegate()

      Specified by:
        `getDelegate` in interface `StreamBase`
      Specified by:
        `getDelegate` in interface `WriteStream<Req>`
      Overrides:
        `getDelegate` in class `GrpcWriteStream<Req>`

    - #### toSubscriber

          public WriteStreamSubscriber<Req> toSubscriber()

      Overrides:
        `toSubscriber` in class `GrpcWriteStream<Req>`

    - #### write

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

      Same as but with an `handler` called when the operation completes
      Specified by:
        `write` in interface `WriteStream<Req>`
      Overrides:
        `write` in class `GrpcWriteStream<Req>`
      Parameters:
        `data` -
        `handler` -

    - #### write

          public void write(Req data)

      Same as but with an `handler` called when the operation completes
      Specified by:
        `write` in interface `WriteStream<Req>`
      Overrides:
        `write` in class `GrpcWriteStream<Req>`
      Parameters:
        `data` -

    - #### rxWrite

          public Single<Void> rxWrite(Req data)

      Same as but with an `handler` called when the operation completes
      Specified by:
        `rxWrite` in interface `WriteStream<Req>`
      Overrides:
        `rxWrite` in class `GrpcWriteStream<Req>`
      Parameters:
        `data` -
      Returns:

    - #### end

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

      Same as `WriteStream.end(io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>)` but with an `handler` called when the operation completes
      Specified by:
        `end` in interface `WriteStream<Req>`
      Overrides:
        `end` in class `GrpcWriteStream<Req>`
      Parameters:
        `handler` -

    - #### end

          public void end()

      Same as `WriteStream.end(io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>)` but with an `handler` called when the operation completes
      Specified by:
        `end` in interface `WriteStream<Req>`
      Overrides:
        `end` in class `GrpcWriteStream<Req>`

    - #### rxEnd

          public Single<Void> rxEnd()

      Same as `WriteStream.end(io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>)` but with an `handler` called when the operation completes
      Specified by:
        `rxEnd` in interface `WriteStream<Req>`
      Overrides:
        `rxEnd` in class `GrpcWriteStream<Req>`
      Returns:

    - #### end

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

      Same as but with an `handler` called when the operation completes
      Specified by:
        `end` in interface `WriteStream<Req>`
      Overrides:
        `end` in class `GrpcWriteStream<Req>`
      Parameters:
        `data` -
        `handler` -

    - #### end

          public void end(Req data)

      Same as but with an `handler` called when the operation completes
      Specified by:
        `end` in interface `WriteStream<Req>`
      Overrides:
        `end` in class `GrpcWriteStream<Req>`
      Parameters:
        `data` -

    - #### rxEnd

          public Single<Void> rxEnd(Req data)

      Same as but with an `handler` called when the operation completes
      Specified by:
        `rxEnd` in interface `WriteStream<Req>`
      Overrides:
        `rxEnd` in class `GrpcWriteStream<Req>`
      Parameters:
        `data` -
      Returns:

    - #### 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<Req>`
      Overrides:
        `writeQueueFull` in class `GrpcWriteStream<Req>`
      Returns:
        `true` if write queue is full

    - #### encoding

          public GrpcClientRequest<Req,Resp> encoding(String encoding)

      Description copied from class: `GrpcWriteStream`
      Set the stream encoding, e.g `identity` or `gzip`. It must be called before sending any message, otherwise {@code identity will be used.
      Overrides:
        `encoding` in class `GrpcWriteStream<Req>`
      Parameters:
        `encoding` - the target message encoding
      Returns:
        a reference to this, so the API can be used fluently

    - #### fullMethodName

          public GrpcClientRequest<Req,Resp> fullMethodName(String fullMethodName)

      Set the full method name to call, it must follow the format `package-name + '.' + service-name + '/' + method-name` or an `IllegalArgumentException` is thrown.

      It must be called before sending the request otherwise an `IllegalStateException` is thrown.

      Parameters:
        `fullMethodName` - the full method name to call
      Returns:
        a reference to this, so the API can be used fluently

    - #### serviceName

          public GrpcClientRequest<Req,Resp> serviceName(ServiceName serviceName)

      Set the service name to call.

      It must be called before sending the request otherwise an `IllegalStateException` is thrown.

      Parameters:
        `serviceName` - the service name to call
      Returns:
        a reference to this, so the API can be used fluently

    - #### methodName

          public GrpcClientRequest<Req,Resp> methodName(String methodName)

      Set the method name to call.

      It must be called before sending the request otherwise an `IllegalStateException` is thrown.

      Parameters:
        `methodName` - the method name to call
      Returns:
        a reference to this, so the API can be used fluently

    - #### response

          public Future<GrpcClientResponse<Req,Resp>> response()

      Returns:
        the gRPC response

    - #### rxResponse

          public Single<GrpcClientResponse<Req,Resp>> rxResponse()

      Returns:
        the gRPC response

    - #### exceptionHandler

          public GrpcClientRequest<Req,Resp> 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<Req>`
      Overrides:
        `exceptionHandler` in class `GrpcWriteStream<Req>`
      Parameters:
        `handler` - the exception handler
      Returns:
        a reference to this, so the API can be used fluently

    - #### setWriteQueueMaxSize

          public GrpcClientRequest<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 `WriteStream<Req>`
      Overrides:
        `setWriteQueueMaxSize` in class `GrpcWriteStream<Req>`
      Parameters:
        `maxSize` - the max size of the write stream
      Returns:
        a reference to this, so the API can be used fluently

    - #### drainHandler

          public GrpcClientRequest<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 `WriteStream<Req>`
      Overrides:
        `drainHandler` in class `GrpcWriteStream<Req>`
      Parameters:
        `handler` - the handler
      Returns:
        a reference to this, so the API can be used fluently

    - #### connection

          public HttpConnection connection()

      Returns:
        the underlying HTTP connection

    - #### send

          public Future<GrpcClientResponse<Req,Resp>> send(Req item)

    - #### rxSend

          public Single<GrpcClientResponse<Req,Resp>> rxSend(Req item)

    - #### send

          public Future<GrpcClientResponse<Req,Resp>> send(ReadStream<Req> body)

    - #### rxSend

          public Single<GrpcClientResponse<Req,Resp>> rxSend(ReadStream<Req> body)

    - #### send

          public Future<GrpcClientResponse<Req,Resp>> send(Observable<Req> body)

    - #### rxSend

          public Single<GrpcClientResponse<Req,Resp>> rxSend(Observable<Req> body)

    - #### newInstance

          public static <Req,Resp> GrpcClientRequest<Req,Resp> newInstance(GrpcClientRequest arg)

    - #### newInstance

          public static <Req,Resp> GrpcClientRequest<Req,Resp> newInstance(GrpcClientRequest arg,
                                                                           io.vertx.lang.rx.TypeArg<Req> __typeArg_Req,
                                                                           io.vertx.lang.rx.TypeArg<Resp> __typeArg_Resp)

Copyright © 2024 Eclipse. All rights reserved.