Package io.vertx.mutiny.core.http

Class HttpClientRequest

java.lang.Object
io.vertx.mutiny.core.http.HttpClientRequest
All Implemented Interfaces:
MutinyDelegate, StreamBase, WriteStream<io.vertx.core.buffer.Buffer>
public class HttpClientRequest extends Object implements WriteStream<io.vertx.core.buffer.Buffer>, MutinyDelegate
Represents a client-side HTTP request.

Instances are created by an HttpClient instance, via one of the methods corresponding to the specific HTTP methods, or the generic request methods. On creation the request will not have been written to the wire.

Once a request has been obtained, headers can be set on it, and data can be written to its body if required. Once you are ready to send the request, one of the end() methods should be called.

Nothing is actually sent until the request has been internally assigned an HTTP connection.

The HttpClient instance will return an instance of this class immediately, even if there are no HTTP connections available in the pool. Any requests sent before a connection is assigned will be queued internally and actually sent when an HTTP connection becomes available from the pool.

The headers of the request are queued for writing either when the end() method is called, or, when the first part of the body is written, whichever occurs first.

This class supports both chunked and non-chunked HTTP.

It implements WriteStream so it can be used with Pipe to pipe data with flow control.

An example of using this class is as follows:

NOTE: This class has been automatically generated from the original non Mutiny-ified interface.

Author:
Tim Fox
See Also:
  • HttpClientRequest

  • Field Details

  • Constructor Details

    • HttpClientRequest

      public HttpClientRequest(io.vertx.core.http.HttpClientRequest delegate)
      Create a new instance of HttpClientRequest delegating to the given (non-null) instance of HttpClientRequest.

    • HttpClientRequest

      public HttpClientRequest(Object delegate)

  • Method Details

    • getDelegate

      public io.vertx.core.http.HttpClientRequest getDelegate()
      Get the delegate instance.

      This method returns the instance on which this shim is delegating the calls. And so, give you access to the bare API.

      Specified by:
      getDelegate in interface MutinyDelegate
      Specified by:
      getDelegate in interface StreamBase
      Specified by:
      getDelegate in interface WriteStream<io.vertx.core.buffer.Buffer>
      Returns:
      the delegate instance

    • write

      @CheckReturnValue public io.smallrye.mutiny.Uni<Void> write(String chunk)
      Write a String to the request body, encoded as UTF-8.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Parameters:
      chunk - the data chunk
      Returns:
      A Uni representing the asynchronous result of this operation.
      Throws:
      when - no response handler is set
      See Also:
      • HttpClientRequest.write(String)

    • writeAndAwait

      public void writeAndAwait(String chunk)
      Write a String to the request body, encoded as UTF-8.

      Unlike the bare Vert.x variant, this method returns a Void. This method awaits indefinitely for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

      Parameters:
      chunk - the data chunk
      Throws:
      when - no response handler is set
      See Also:
      • HttpClientRequest.write(String)

    • writeAndForget

      public HttpClientRequest writeAndForget(String chunk)
      Write a String to the request body, encoded as UTF-8.

      Unlike the bare Vert.x variant, this method ignores the Void result or any failure.

      Parameters:
      chunk - the data chunk
      Returns:
      The current instance to chain operations if needed.
      Throws:
      when - no response handler is set
      See Also:
      • HttpClientRequest.write(String)

    • write

      @CheckReturnValue public io.smallrye.mutiny.Uni<Void> write(String chunk, String enc)
      Write a String to the request body, encoded using the encoding enc.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Parameters:
      chunk - the data chunk
      enc - the encoding
      Returns:
      A Uni representing the asynchronous result of this operation.
      Throws:
      when - no response handler is set
      See Also:
      • HttpClientRequest.write(String, String)

    • writeAndAwait

      public void writeAndAwait(String chunk, String enc)
      Write a String to the request body, encoded using the encoding enc.

      Unlike the bare Vert.x variant, this method returns a Void. This method awaits indefinitely for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

      Parameters:
      chunk - the data chunk
      enc - the encoding
      Throws:
      when - no response handler is set
      See Also:
      • HttpClientRequest.write(String, String)

    • writeAndForget

      public HttpClientRequest writeAndForget(String chunk, String enc)
      Write a String to the request body, encoded using the encoding enc.

      Unlike the bare Vert.x variant, this method ignores the Void result or any failure.

      Parameters:
      chunk - the data chunk
      enc - the encoding
      Returns:
      The current instance to chain operations if needed.
      Throws:
      when - no response handler is set
      See Also:
      • HttpClientRequest.write(String, String)

    • sendHead

      @Deprecated @CheckReturnValue public io.smallrye.mutiny.Uni<Void> sendHead()
      Deprecated.
      instead use writeHead(), this is scheduled for removal in Vert.x 6
      Forces the head of the request to be written before end() is called on the request or any data is written to it.

      This is normally used to implement HTTP 100-continue handling, see #continueHandler(io.vertx.core.Handler) for more information.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      See Also:
      • HttpClientRequest.sendHead()

    • sendHeadAndAwait

      public void sendHeadAndAwait()
      Deprecated.
      instead use writeHead(), this is scheduled for removal in Vert.x 6
      Forces the head of the request to be written before end() is called on the request or any data is written to it.

      This is normally used to implement HTTP 100-continue handling, see #continueHandler(io.vertx.core.Handler) for more information.

      Unlike the bare Vert.x variant, this method returns a Void. This method awaits indefinitely for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

      See Also:
      • HttpClientRequest.sendHead()

    • sendHeadAndForget

      public HttpClientRequest sendHeadAndForget()
      Deprecated.
      instead use writeHead(), this is scheduled for removal in Vert.x 6
      Forces the head of the request to be written before end() is called on the request or any data is written to it.

      This is normally used to implement HTTP 100-continue handling, see #continueHandler(io.vertx.core.Handler) for more information.

      Unlike the bare Vert.x variant, this method ignores the Void result or any failure.

      Returns:
      The current instance to chain operations if needed.
      See Also:
      • HttpClientRequest.sendHead()

    • writeHead

      @CheckReturnValue public io.smallrye.mutiny.Uni<Void> writeHead()
      Write the head of the request.

      This can be used to implement HTTP 100-continue handling, see #continueHandler(io.vertx.core.Handler) for more information.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      See Also:
      • HttpClientRequest.writeHead()

    • writeHeadAndAwait

      public void writeHeadAndAwait()
      Write the head of the request.

      This can be used to implement HTTP 100-continue handling, see #continueHandler(io.vertx.core.Handler) for more information.

      Unlike the bare Vert.x variant, this method returns a Void. This method awaits indefinitely for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

      See Also:
      • HttpClientRequest.writeHead()

    • writeHeadAndForget

      public HttpClientRequest writeHeadAndForget()
      Write the head of the request.

      This can be used to implement HTTP 100-continue handling, see #continueHandler(io.vertx.core.Handler) for more information.

      Unlike the bare Vert.x variant, this method ignores the Void result or any failure.

      Returns:
      The current instance to chain operations if needed.
      See Also:
      • HttpClientRequest.writeHead()

    • connect

      @CheckReturnValue public io.smallrye.mutiny.Uni<HttpClientResponse> connect()
      Create an HTTP tunnel to the server.

      Send HTTP request headers to the server, then configures the transport to exchange raw buffers when the server replies with an appropriate response:

      • 200 for HTTP CONNECT method
      • 101 for HTTP/1.1 GET with Upgrade connection header

      The handler is called after response headers are received.

      Use HttpClientResponse.netSocket() to get a NetSocket for interacting more conveniently with the server.

      HTTP/1.1 pipe-lined requests are not supported.f

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      See Also:
      • HttpClientRequest.connect()

    • connectAndAwait

      public HttpClientResponse connectAndAwait()
      Create an HTTP tunnel to the server.

      Send HTTP request headers to the server, then configures the transport to exchange raw buffers when the server replies with an appropriate response:

      • 200 for HTTP CONNECT method
      • 101 for HTTP/1.1 GET with Upgrade connection header

      The handler is called after response headers are received.

      Use HttpClientResponse.netSocket() to get a NetSocket for interacting more conveniently with the server.

      HTTP/1.1 pipe-lined requests are not supported.f

      Unlike the bare Vert.x variant, this method returns a HttpClientResponse. This method awaits indefinitely for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

      Returns:
      The operation result
      See Also:
      • HttpClientRequest.connect()

    • connectAndForget

      public HttpClientRequest connectAndForget()
      Create an HTTP tunnel to the server.

      Send HTTP request headers to the server, then configures the transport to exchange raw buffers when the server replies with an appropriate response:

      • 200 for HTTP CONNECT method
      • 101 for HTTP/1.1 GET with Upgrade connection header

      The handler is called after response headers are received.

      Use HttpClientResponse.netSocket() to get a NetSocket for interacting more conveniently with the server.

      HTTP/1.1 pipe-lined requests are not supported.f

      Unlike the bare Vert.x variant, this method ignores the HttpClientResponse result or any failure.

      Returns:
      The current instance to chain operations if needed.
      See Also:
      • HttpClientRequest.connect()

    • response

      @CheckReturnValue public io.smallrye.mutiny.Uni<HttpClientResponse> response()

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      See Also:
      • HttpClientRequest.response()

    • responseAndAwait

      public HttpClientResponse responseAndAwait()

      Unlike the bare Vert.x variant, this method returns a HttpClientResponse. This method awaits indefinitely for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

      Returns:
      The operation result
      See Also:
      • HttpClientRequest.response()

    • responseAndForget

      public HttpClientRequest responseAndForget()

      Unlike the bare Vert.x variant, this method ignores the HttpClientResponse result or any failure.

      Returns:
      The current instance to chain operations if needed.
      See Also:
      • HttpClientRequest.response()

    • send

      @CheckReturnValue public io.smallrye.mutiny.Uni<HttpClientResponse> send()
      Send the request with an empty body.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      See Also:
      • HttpClientRequest.send()

    • sendAndAwait

      public HttpClientResponse sendAndAwait()
      Send the request with an empty body.

      Unlike the bare Vert.x variant, this method returns a HttpClientResponse. This method awaits indefinitely for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

      Returns:
      The operation result
      See Also:
      • HttpClientRequest.send()

    • sendAndForget

      public HttpClientRequest sendAndForget()
      Send the request with an empty body.

      Unlike the bare Vert.x variant, this method ignores the HttpClientResponse result or any failure.

      Returns:
      The current instance to chain operations if needed.
      See Also:
      • HttpClientRequest.send()

    • send

      @CheckReturnValue public io.smallrye.mutiny.Uni<HttpClientResponse> send(String body)
      Send the request with a string body.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      See Also:
      • HttpClientRequest.send(String)

    • sendAndAwait

      public HttpClientResponse sendAndAwait(String body)
      Send the request with a string body.

      Unlike the bare Vert.x variant, this method returns a HttpClientResponse. This method awaits indefinitely for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

      Returns:
      The operation result
      See Also:
      • HttpClientRequest.send(String)

    • sendAndForget

      public HttpClientRequest sendAndForget(String body)
      Send the request with a string body.

      Unlike the bare Vert.x variant, this method ignores the HttpClientResponse result or any failure.

      Returns:
      The current instance to chain operations if needed.
      See Also:
      • HttpClientRequest.send(String)

    • send

      @CheckReturnValue public io.smallrye.mutiny.Uni<HttpClientResponse> send(io.vertx.core.buffer.Buffer body)
      Send the request with a buffer body.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      See Also:
      • HttpClientRequest.send(Buffer)

    • sendAndAwait

      public HttpClientResponse sendAndAwait(io.vertx.core.buffer.Buffer body)
      Send the request with a buffer body.

      Unlike the bare Vert.x variant, this method returns a HttpClientResponse. This method awaits indefinitely for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

      Returns:
      The operation result
      See Also:
      • HttpClientRequest.send(Buffer)

    • sendAndForget

      public HttpClientRequest sendAndForget(io.vertx.core.buffer.Buffer body)
      Send the request with a buffer body.

      Unlike the bare Vert.x variant, this method ignores the HttpClientResponse result or any failure.

      Returns:
      The current instance to chain operations if needed.
      See Also:
      • HttpClientRequest.send(Buffer)

    • send

      @CheckReturnValue public io.smallrye.mutiny.Uni<HttpClientResponse> send(io.vertx.core.http.ClientForm form)
      Like send() but with a form. The content will be set to application/x-www-form-urlencoded or multipart/form-data according to the nature of the form.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Parameters:
      form - the form to send
      Returns:
      A Uni representing the asynchronous result of this operation.
      See Also:
      • HttpClientRequest.send(ClientForm)

    • sendAndAwait

      public HttpClientResponse sendAndAwait(io.vertx.core.http.ClientForm form)
      Like send() but with a form. The content will be set to application/x-www-form-urlencoded or multipart/form-data according to the nature of the form.

      Unlike the bare Vert.x variant, this method returns a HttpClientResponse. This method awaits indefinitely for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

      Parameters:
      form - the form to send
      Returns:
      The operation result
      See Also:
      • HttpClientRequest.send(ClientForm)

    • sendAndForget

      public HttpClientRequest sendAndForget(io.vertx.core.http.ClientForm form)
      Like send() but with a form. The content will be set to application/x-www-form-urlencoded or multipart/form-data according to the nature of the form.

      Unlike the bare Vert.x variant, this method ignores the HttpClientResponse result or any failure.

      Parameters:
      form - the form to send
      Returns:
      The current instance to chain operations if needed.
      See Also:
      • HttpClientRequest.send(ClientForm)

    • send

      @CheckReturnValue public io.smallrye.mutiny.Uni<HttpClientResponse> send(ReadStream<io.vertx.core.buffer.Buffer> body)
      Send the request with a stream body.

      If the HttpHeaders.CONTENT_LENGTH is set then the request assumes this is the length of the {stream}, otherwise the request will set a chunked HttpHeaders.CONTENT_ENCODING.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      See Also:
      • io.vertx.core.http.HttpClientRequest#send(ReadStream)

    • sendAndAwait

      public HttpClientResponse sendAndAwait(ReadStream<io.vertx.core.buffer.Buffer> body)
      Send the request with a stream body.

      If the HttpHeaders.CONTENT_LENGTH is set then the request assumes this is the length of the {stream}, otherwise the request will set a chunked HttpHeaders.CONTENT_ENCODING.

      Unlike the bare Vert.x variant, this method returns a HttpClientResponse. This method awaits indefinitely for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

      Returns:
      The operation result
      See Also:
      • io.vertx.core.http.HttpClientRequest#send(ReadStream)

    • sendAndForget

      public HttpClientRequest sendAndForget(ReadStream<io.vertx.core.buffer.Buffer> body)
      Send the request with a stream body.

      If the HttpHeaders.CONTENT_LENGTH is set then the request assumes this is the length of the {stream}, otherwise the request will set a chunked HttpHeaders.CONTENT_ENCODING.

      Unlike the bare Vert.x variant, this method ignores the HttpClientResponse result or any failure.

      Returns:
      The current instance to chain operations if needed.
      See Also:
      • io.vertx.core.http.HttpClientRequest#send(ReadStream)

    • send

      @CheckReturnValue public io.smallrye.mutiny.Uni<HttpClientResponse> send(Flow.Publisher<io.vertx.core.buffer.Buffer> body)
      Send the request with a stream body.

      If the HttpHeaders.CONTENT_LENGTH is set then the request assumes this is the length of the {stream}, otherwise the request will set a chunked HttpHeaders.CONTENT_ENCODING.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      See Also:
      • io.vertx.core.http.HttpClientRequest#send(ReadStream)

    • sendAndAwait

      public HttpClientResponse sendAndAwait(Flow.Publisher<io.vertx.core.buffer.Buffer> body)
      Send the request with a stream body.

      If the HttpHeaders.CONTENT_LENGTH is set then the request assumes this is the length of the {stream}, otherwise the request will set a chunked HttpHeaders.CONTENT_ENCODING.

      Unlike the bare Vert.x variant, this method returns a HttpClientResponse. This method awaits indefinitely for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

      Returns:
      The operation result
      See Also:
      • io.vertx.core.http.HttpClientRequest#send(ReadStream)

    • sendAndForget

      public HttpClientRequest sendAndForget(Flow.Publisher<io.vertx.core.buffer.Buffer> body)
      Send the request with a stream body.

      If the HttpHeaders.CONTENT_LENGTH is set then the request assumes this is the length of the {stream}, otherwise the request will set a chunked HttpHeaders.CONTENT_ENCODING.

      Unlike the bare Vert.x variant, this method ignores the HttpClientResponse result or any failure.

      Returns:
      The current instance to chain operations if needed.
      See Also:
      • io.vertx.core.http.HttpClientRequest#send(ReadStream)

    • end

      @CheckReturnValue public io.smallrye.mutiny.Uni<Void> end(String chunk)
      Same as end(Buffer) but writes a String in UTF-8 encoding

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Parameters:
      chunk - the data chunk
      Returns:
      A Uni representing the asynchronous result of this operation.
      Throws:
      when - no response handler is set
      See Also:
      • HttpClientRequest.end(String)

    • endAndAwait

      public void endAndAwait(String chunk)
      Same as end(Buffer) but writes a String in UTF-8 encoding

      Unlike the bare Vert.x variant, this method returns a Void. This method awaits indefinitely for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

      Parameters:
      chunk - the data chunk
      Throws:
      when - no response handler is set
      See Also:
      • HttpClientRequest.end(String)

    • endAndForget

      public HttpClientRequest endAndForget(String chunk)
      Same as end(Buffer) but writes a String in UTF-8 encoding

      Unlike the bare Vert.x variant, this method ignores the Void result or any failure.

      Parameters:
      chunk - the data chunk
      Returns:
      The current instance to chain operations if needed.
      Throws:
      when - no response handler is set
      See Also:
      • HttpClientRequest.end(String)

    • end

      @CheckReturnValue public io.smallrye.mutiny.Uni<Void> end(String chunk, String enc)
      Same as end(Buffer) but writes a String with the specified encoding

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Parameters:
      chunk - the data chunk
      enc - the encoding
      Returns:
      A Uni representing the asynchronous result of this operation.
      Throws:
      when - no response handler is set
      See Also:
      • HttpClientRequest.end(String, String)

    • endAndAwait

      public void endAndAwait(String chunk, String enc)
      Same as end(Buffer) but writes a String with the specified encoding

      Unlike the bare Vert.x variant, this method returns a Void. This method awaits indefinitely for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

      Parameters:
      chunk - the data chunk
      enc - the encoding
      Throws:
      when - no response handler is set
      See Also:
      • HttpClientRequest.end(String, String)

    • endAndForget

      public HttpClientRequest endAndForget(String chunk, String enc)
      Same as end(Buffer) but writes a String with the specified encoding

      Unlike the bare Vert.x variant, this method ignores the Void result or any failure.

      Parameters:
      chunk - the data chunk
      enc - the encoding
      Returns:
      The current instance to chain operations if needed.
      Throws:
      when - no response handler is set
      See Also:
      • HttpClientRequest.end(String, String)

    • end

      @CheckReturnValue public io.smallrye.mutiny.Uni<Void> end(io.vertx.core.buffer.Buffer chunk)
      Same as end() but writes some data to the request body before ending. If the request is not chunked and no other data has been written then the Content-Length header will be automatically set

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Specified by:
      end in interface WriteStream<io.vertx.core.buffer.Buffer>
      Parameters:
      chunk - the data to write
      Returns:
      A Uni representing the asynchronous result of this operation.
      Throws:
      when - no response handler is set
      See Also:
      • HttpClientRequest.end(Buffer)

    • endAndAwait

      public void endAndAwait(io.vertx.core.buffer.Buffer chunk)
      Same as end() but writes some data to the request body before ending. If the request is not chunked and no other data has been written then the Content-Length header will be automatically set

      Unlike the bare Vert.x variant, this method returns a Void. This method awaits indefinitely for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

      Throws:
      when - no response handler is set
      See Also:
      • HttpClientRequest.end(Buffer)

    • endAndForget

      public HttpClientRequest endAndForget(io.vertx.core.buffer.Buffer chunk)
      Same as end() but writes some data to the request body before ending. If the request is not chunked and no other data has been written then the Content-Length header will be automatically set

      Unlike the bare Vert.x variant, this method ignores the Void result or any failure.

      Returns:
      The current instance to chain operations if needed.
      Throws:
      when - no response handler is set
      See Also:
      • HttpClientRequest.end(Buffer)

    • end

      @CheckReturnValue public io.smallrye.mutiny.Uni<Void> end()
      Ends the request. If no data has been written to the request body, and writeHead() has not been called then the actual request won't get written until this method gets called.

      Once the request has ended, it cannot be used any more,

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Specified by:
      end in interface WriteStream<io.vertx.core.buffer.Buffer>
      Returns:
      A Uni representing the asynchronous result of this operation.
      Throws:
      when - no response handler is set
      See Also:
      • HttpClientRequest.end()

    • endAndAwait

      public void endAndAwait()
      Ends the request. If no data has been written to the request body, and writeHead() has not been called then the actual request won't get written until this method gets called.

      Once the request has ended, it cannot be used any more,

      Unlike the bare Vert.x variant, this method returns a Void. This method awaits indefinitely for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

      Throws:
      when - no response handler is set
      See Also:
      • HttpClientRequest.end()

    • endAndForget

      public HttpClientRequest endAndForget()
      Ends the request. If no data has been written to the request body, and writeHead() has not been called then the actual request won't get written until this method gets called.

      Once the request has ended, it cannot be used any more,

      Unlike the bare Vert.x variant, this method ignores the Void result or any failure.

      Returns:
      The current instance to chain operations if needed.
      Throws:
      when - no response handler is set
      See Also:
      • HttpClientRequest.end()

    • reset

      @CheckReturnValue public io.smallrye.mutiny.Uni<Void> reset()
      Reset this stream with the error code 0.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      See Also:

    • resetAndAwait

      public void resetAndAwait()
      Reset this stream with the error code 0.

      Unlike the bare Vert.x variant, this method returns a Void. This method awaits indefinitely for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

      See Also:

    • resetAndForget

      public HttpClientRequest resetAndForget()
      Reset this stream with the error code 0.

      Unlike the bare Vert.x variant, this method ignores the Void result or any failure.

      Returns:
      The current instance to chain operations if needed.
      See Also:

    • reset

      @CheckReturnValue public io.smallrye.mutiny.Uni<Void> reset(long code)
      Reset this request:

      • for HTTP/1.x, this closes the connection when the current request is inflight
      • for HTTP/2, this performs send an HTTP/2 reset frame with the specified error code
      • for HTTP/3, this is only effective if the stream has not been fully sent

      When the request has not yet been sent, the request will be aborted and false is returned as indicator.

      Stream reset should be avoided because the implementation works partially for HTTP/3 and reset error codes depends on the version of the protocol, cancel() should be used instead.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Parameters:
      code - the error code
      Returns:
      A Uni representing the asynchronous result of this operation.
      See Also:
      • HttpClientRequest.reset(long)

    • resetAndAwait

      public void resetAndAwait(long code)
      Reset this request:

      • for HTTP/1.x, this closes the connection when the current request is inflight
      • for HTTP/2, this performs send an HTTP/2 reset frame with the specified error code
      • for HTTP/3, this is only effective if the stream has not been fully sent

      When the request has not yet been sent, the request will be aborted and false is returned as indicator.

      Stream reset should be avoided because the implementation works partially for HTTP/3 and reset error codes depends on the version of the protocol, cancel() should be used instead.

      Unlike the bare Vert.x variant, this method returns a Void. This method awaits indefinitely for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

      Parameters:
      code - the error code
      See Also:
      • HttpClientRequest.reset(long)

    • resetAndForget

      public HttpClientRequest resetAndForget(long code)
      Reset this request:

      • for HTTP/1.x, this closes the connection when the current request is inflight
      • for HTTP/2, this performs send an HTTP/2 reset frame with the specified error code
      • for HTTP/3, this is only effective if the stream has not been fully sent

      When the request has not yet been sent, the request will be aborted and false is returned as indicator.

      Stream reset should be avoided because the implementation works partially for HTTP/3 and reset error codes depends on the version of the protocol, cancel() should be used instead.

      Unlike the bare Vert.x variant, this method ignores the Void result or any failure.

      Parameters:
      code - the error code
      Returns:
      The current instance to chain operations if needed.
      See Also:
      • HttpClientRequest.reset(long)

    • cancel

      @CheckReturnValue public io.smallrye.mutiny.Uni<Boolean> cancel()
      Attempt to cancel the request according to the semantics of the underlying HTTP implementation.
      • for HTTP/1.x, this closes the connection when the current request is inflight
      • for HTTP/2, this performs send an HTTP/2 reset frame with the error 0x08
      • for HTTP/3, this resets or abort reading the underlying QUIC stream with code 0x10c

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      See Also:
      • HttpClientRequest.cancel()

    • cancelAndAwait

      public Boolean cancelAndAwait()
      Attempt to cancel the request according to the semantics of the underlying HTTP implementation.
      • for HTTP/1.x, this closes the connection when the current request is inflight
      • for HTTP/2, this performs send an HTTP/2 reset frame with the error 0x08
      • for HTTP/3, this resets or abort reading the underlying QUIC stream with code 0x10c

      Unlike the bare Vert.x variant, this method returns a Boolean. This method awaits indefinitely for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

      Returns:
      The operation result
      See Also:
      • HttpClientRequest.cancel()

    • cancelAndForget

      public HttpClientRequest cancelAndForget()
      Attempt to cancel the request according to the semantics of the underlying HTTP implementation.
      • for HTTP/1.x, this closes the connection when the current request is inflight
      • for HTTP/2, this performs send an HTTP/2 reset frame with the error 0x08
      • for HTTP/3, this resets or abort reading the underlying QUIC stream with code 0x10c

      Unlike the bare Vert.x variant, this method ignores the Boolean result or any failure.

      Returns:
      The current instance to chain operations if needed.
      See Also:
      • HttpClientRequest.cancel()

    • reset

      @CheckReturnValue public io.smallrye.mutiny.Uni<Void> reset(long code, Throwable cause)
      Reset this request:

      • for HTTP/2, send an HTTP/2 reset frame with the specified error code
      • for HTTP/1.x, close the connection when the current request is inflight

      When the request has not yet been sent, the request will be aborted and false is returned as indicator.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Parameters:
      code - the error code
      cause - an optional cause that can be attached to the error code
      Returns:
      A Uni representing the asynchronous result of this operation.
      See Also:
      • HttpClientRequest.reset(long, Throwable)

    • resetAndAwait

      public void resetAndAwait(long code, Throwable cause)
      Reset this request:

      • for HTTP/2, send an HTTP/2 reset frame with the specified error code
      • for HTTP/1.x, close the connection when the current request is inflight

      When the request has not yet been sent, the request will be aborted and false is returned as indicator.

      Unlike the bare Vert.x variant, this method returns a Void. This method awaits indefinitely for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

      Parameters:
      code - the error code
      cause - an optional cause that can be attached to the error code
      See Also:
      • HttpClientRequest.reset(long, Throwable)

    • resetAndForget

      public HttpClientRequest resetAndForget(long code, Throwable cause)
      Reset this request:

      • for HTTP/2, send an HTTP/2 reset frame with the specified error code
      • for HTTP/1.x, close the connection when the current request is inflight

      When the request has not yet been sent, the request will be aborted and false is returned as indicator.

      Unlike the bare Vert.x variant, this method ignores the Void result or any failure.

      Parameters:
      code - the error code
      cause - an optional cause that can be attached to the error code
      Returns:
      The current instance to chain operations if needed.
      See Also:
      • HttpClientRequest.reset(long, Throwable)

    • writeCustomFrame

      @CheckReturnValue public io.smallrye.mutiny.Uni<Void> writeCustomFrame(int type, int flags, io.vertx.core.buffer.Buffer payload)
      Write an HTTP/2 frame to the request, allowing to extend the HTTP/2 protocol.

      The frame is sent immediatly and is not subject to flow control.

      This method must be called after the request headers have been sent and only for the protocol HTTP/2. The writeHead() should be used for this purpose.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Parameters:
      type - the 8-bit frame type
      flags - the 8-bit frame flags
      payload - the frame payload
      Returns:
      A Uni representing the asynchronous result of this operation.
      See Also:
      • HttpClientRequest.writeCustomFrame(int, int, Buffer)

    • writeCustomFrameAndAwait

      public void writeCustomFrameAndAwait(int type, int flags, io.vertx.core.buffer.Buffer payload)
      Write an HTTP/2 frame to the request, allowing to extend the HTTP/2 protocol.

      The frame is sent immediatly and is not subject to flow control.

      This method must be called after the request headers have been sent and only for the protocol HTTP/2. The writeHead() should be used for this purpose.

      Unlike the bare Vert.x variant, this method returns a Void. This method awaits indefinitely for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

      Parameters:
      type - the 8-bit frame type
      flags - the 8-bit frame flags
      payload - the frame payload
      See Also:
      • HttpClientRequest.writeCustomFrame(int, int, Buffer)

    • writeCustomFrameAndForget

      public HttpClientRequest writeCustomFrameAndForget(int type, int flags, io.vertx.core.buffer.Buffer payload)
      Write an HTTP/2 frame to the request, allowing to extend the HTTP/2 protocol.

      The frame is sent immediatly and is not subject to flow control.

      This method must be called after the request headers have been sent and only for the protocol HTTP/2. The writeHead() should be used for this purpose.

      Unlike the bare Vert.x variant, this method ignores the Void result or any failure.

      Parameters:
      type - the 8-bit frame type
      flags - the 8-bit frame flags
      payload - the frame payload
      Returns:
      The current instance to chain operations if needed.
      See Also:
      • HttpClientRequest.writeCustomFrame(int, int, Buffer)

    • writeCustomFrame

      @CheckReturnValue public io.smallrye.mutiny.Uni<Void> writeCustomFrame(io.vertx.core.http.HttpFrame frame)
      Like writeCustomFrame(int, int, Buffer) but with an HttpFrame.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Parameters:
      frame - the frame to write
      Returns:
      A Uni representing the asynchronous result of this operation.
      See Also:
      • HttpClientRequest.writeCustomFrame(HttpFrame)

    • writeCustomFrameAndAwait

      public void writeCustomFrameAndAwait(io.vertx.core.http.HttpFrame frame)
      Like writeCustomFrame(int, int, Buffer) but with an HttpFrame.

      Unlike the bare Vert.x variant, this method returns a Void. This method awaits indefinitely for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

      Parameters:
      frame - the frame to write
      See Also:
      • HttpClientRequest.writeCustomFrame(HttpFrame)

    • writeCustomFrameAndForget

      public HttpClientRequest writeCustomFrameAndForget(io.vertx.core.http.HttpFrame frame)
      Like writeCustomFrame(int, int, Buffer) but with an HttpFrame.

      Unlike the bare Vert.x variant, this method ignores the Void result or any failure.

      Parameters:
      frame - the frame to write
      Returns:
      The current instance to chain operations if needed.
      See Also:
      • HttpClientRequest.writeCustomFrame(HttpFrame)

    • write

      @CheckReturnValue public io.smallrye.mutiny.Uni<Void> write(io.vertx.core.buffer.Buffer arg0)
      Write some data to the stream.

      The data is usually put on an internal write queue, and the write actually happens asynchronously. To avoid running out of memory by putting too much on the write queue, check the writeQueueFull() method before writing. This is done automatically if using a Pipe.

      When the data is moved from the queue to the actual medium, the returned Future will be completed with the write result, e.g the uni is succeeded when a server HTTP response buffer is written to the socket and failed if the remote client has closed the socket while the data was still pending for write.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Specified by:
      write in interface WriteStream<io.vertx.core.buffer.Buffer>
      Parameters:
      data - the data to write
      Returns:
      A Uni representing the asynchronous result of this operation.
      See Also:
      • HttpClientRequest.write(T)

    • writeAndAwait

      public void writeAndAwait(io.vertx.core.buffer.Buffer arg0)
      Write some data to the stream.

      The data is usually put on an internal write queue, and the write actually happens asynchronously. To avoid running out of memory by putting too much on the write queue, check the writeQueueFull() method before writing. This is done automatically if using a Pipe.

      When the data is moved from the queue to the actual medium, the returned Future will be completed with the write result, e.g the underlying uni is succeeded when a server HTTP response buffer is written to the socket and failed if the remote client has closed the socket while the data was still pending for write.

      Unlike the bare Vert.x variant, this method returns a Void. This method awaits indefinitely for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

      Parameters:
      data - the data to write
      See Also:
      • HttpClientRequest.write(T)

    • writeAndForget

      public HttpClientRequest writeAndForget(io.vertx.core.buffer.Buffer arg0)
      Write some data to the stream.

      The data is usually put on an internal write queue, and the write actually happens asynchronously. To avoid running out of memory by putting too much on the write queue, check the writeQueueFull() method before writing. This is done automatically if using a Pipe.

      When the data is moved from the queue to the actual medium, the returned Future will be completed with the write result, e.g the underlying uni is succeeded when a server HTTP response buffer is written to the socket and failed if the remote client has closed the socket while the data was still pending for write.

      Unlike the bare Vert.x variant, this method ignores the Void result or any failure.

      Parameters:
      data - the data to write
      Returns:
      The current instance to chain operations if needed.
      See Also:
      • HttpClientRequest.write(T)

    • exceptionHandler

      public HttpClientRequest exceptionHandler(Consumer<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<io.vertx.core.buffer.Buffer>
      Parameters:
      handler - the exception handler. Can be null.
      Returns:
      a reference to this, so the API can be used fluently

    • setWriteQueueMaxSize

      public HttpClientRequest 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<io.vertx.core.buffer.Buffer>
      Parameters:
      maxSize - the max size of the write stream
      Returns:
      a reference to this, so the API can be used fluently

    • drainHandler

      public HttpClientRequest drainHandler(Runnable 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<io.vertx.core.buffer.Buffer>
      Parameters:
      handler - the handler. Can be null.
      Returns:
      a reference to this, so the API can be used fluently

    • authority

      public HttpClientRequest authority(io.vertx.core.net.HostAndPort authority)
      Override the request authority initially set by the client.
      • when using HTTP/1.x this overrides the request host header
      • when using HTTP/2 this sets the authority pseudo header

        • When the port is a negative value, the default scheme port will be used.

        According to the protocol, it can set to null (although it is not common), e.g. an HTTP/2 request can have a null authority when it carries an host header.

      Parameters:
      authority - override the request authority
      Returns:
      a reference to this, so the API can be used fluently

    • authority

      public io.vertx.core.net.HostAndPort authority()
      Returns:
      the current request authority

    • setFollowRedirects

      public HttpClientRequest setFollowRedirects(boolean followRedirects)
      Set the request to follow HTTP redirects up to HttpClientOptions#getMaxRedirects().
      Parameters:
      followRedirects - true to follow HTTP redirects
      Returns:
      a reference to this, so the API can be used fluently

    • isFollowRedirects

      public boolean isFollowRedirects()
      Returns:
      whether HTTP redirections should be followed

    • setMaxRedirects

      public HttpClientRequest setMaxRedirects(int maxRedirects)
      Set the max number of HTTP redirects this request will follow. The default is 0 which means no redirects.
      Parameters:
      maxRedirects - the number of HTTP redirect to follow
      Returns:
      a reference to this, so the API can be used fluently

    • getMaxRedirects

      public int getMaxRedirects()
      Returns:
      the maximum number of HTTP redirections to follow

    • numberOfRedirections

      public int numberOfRedirections()
      Returns:
      the number of followed redirections for the current HTTP request

    • setChunked

      public HttpClientRequest setChunked(boolean chunked)
      If chunked is true then the request will be set into HTTP chunked mode
      Parameters:
      chunked - true if chunked encoding
      Returns:
      a reference to this, so the API can be used fluently

    • isChunked

      public boolean isChunked()
      Returns:
      Is the request chunked?

    • getMethod

      public io.vertx.core.http.HttpMethod getMethod()
      The HTTP method for the request.

    • setMethod

      public HttpClientRequest setMethod(io.vertx.core.http.HttpMethod method)
      Set the HTTP method for this request.
      Parameters:
      method - the HTTP method
      Returns:
      a reference to this, so the API can be used fluently

    • absoluteURI

      public String absoluteURI()
      Returns:
      the absolute URI corresponding to the HTTP request

    • getURI

      public String getURI()
      Returns:
      The URI of the request.

    • setURI

      public HttpClientRequest setURI(String uri)
      Set the request uri.
      Parameters:
      uri - the request uri
      Returns:
      a reference to this, so the API can be used fluently

    • path

      public String path()
      Returns:
      The path part of the uri. For example /somepath/somemorepath/someresource.foo

    • query

      public String query()
      Returns:
      the query part of the uri. For example someparam=32&someotherparam=x

    • headers

      public io.vertx.core.MultiMap headers()
      Returns:
      The HTTP headers

    • putHeader

      public HttpClientRequest putHeader(String name, String value)
      Put an HTTP header
      Parameters:
      name - The header name
      value - The header value
      Returns:
      a reference to this, so the API can be used fluently

    • putHeader

      public HttpClientRequest putHeader(CharSequence name, CharSequence value)
      Like putHeader(String, String) but using CharSequence

    • putHeader

      public HttpClientRequest putHeader(String name, Iterable<String> values)
      Put an HTTP header with multiple values
      Parameters:
      name - The header name
      values - The header values
      Returns:

    • putHeader

      public HttpClientRequest putHeader(CharSequence name, Iterable<CharSequence> values)
      Like putHeader(String, Iterable) but using CharSequence

    • traceOperation

      public HttpClientRequest traceOperation(String op)
      Set the trace operation of this request.
      Parameters:
      op - the operation
      Returns:

    • traceOperation

      public String traceOperation()
      Returns:
      the trace operation of this request

    • version

      public io.vertx.core.http.HttpVersion version()
      Returns:
      the HTTP version for this request

    • continueHandler

      public HttpClientRequest continueHandler(Runnable handler)
      If you send an HTTP request with the header Expect set to the value 100-continue and the server responds with an interim HTTP response with a status code of 100 and a Continue handler has been set using this method, then the handler will be called.

      You can then continue to write data to the request body and later end it. This is normally used in conjunction with the writeHead() method to force the request header to be written before the request has ended.

      Returns:
      a reference to this, so the API can be used fluently

    • earlyHintsHandler

      public HttpClientRequest earlyHintsHandler(Consumer<io.vertx.core.MultiMap> handler)
      If the server responds with an interim HTTP response with a status code of 103 and a Early Hints handler has been set using this method, then the handler will be called.
      Returns:
      a reference to this, so the API can be used fluently

    • redirectHandler

      public HttpClientRequest redirectHandler(Function<HttpClientResponse,io.smallrye.mutiny.Uni<HttpClientRequest>> handler)

    • idleTimeout

      public HttpClientRequest idleTimeout(long timeout)
      Sets the amount of time after which, if the request does not return any data within the timeout period, the request/response is closed and the related futures are failed with a TimeoutException, e.g. Future<HttpClientResponse> or Future<Buffer> response body.
      Parameters:
      timeout - the amount of time in milliseconds.
      Returns:
      a reference to this, so the API can be used fluently

    • pushHandler

      public HttpClientRequest pushHandler(Consumer<HttpClientRequest> handler)
      Set a push handler for this request.

      The handler is called when the client receives a push promise from the server. The handler can be called multiple times, for each push promise.

      The handler is called with a read-only HttpClientRequest, the following methods can be called:

      In addition the handler should call the response() method to set an handler to process the response.

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

    • connection

      public HttpConnection connection()
      Returns:
      the HttpConnection associated with this request

    • streamId

      public long streamId()
      Returns:
      the id of the stream of this response, -1 when it is not yet determined, i.e the request has not been yet sent or it is not supported HTTP/1.x

    • setStreamPriority

      public HttpClientRequest setStreamPriority(io.vertx.core.http.StreamPriority streamPriority)
      Sets the priority of the associated stream.

      This is not implemented for HTTP/1.x.

      Parameters:
      streamPriority - the priority of this request's stream

    • getStreamPriority

      public io.vertx.core.http.StreamPriority getStreamPriority()
      Returns:
      the priority of the associated HTTP/2 stream for HTTP/2 otherwise null

    • 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<io.vertx.core.buffer.Buffer>
      Returns:
      true if write queue is full

    • newInstance

      public static HttpClientRequest newInstance(io.vertx.core.http.HttpClientRequest delegate)
      Creates a new instance of the HttpClientRequest.

    • hashCode

      public int hashCode()
      Overrides:
      hashCode in class Object

    • equals

      public boolean equals(Object o)
      Overrides:
      equals in class Object

    • toString

      public String toString()
      Overrides:
      toString in class Object

    • toSubscriber

      @CheckReturnValue public Flow.Subscriber<io.vertx.core.buffer.Buffer> toSubscriber()
      Converts the current write stream to a subscriber.