Package io.vertx.reactivex.core.http

## Class HttpClientResponse

- java.lang.Object
- - io.vertx.reactivex.core.http.HttpClientResponse

- All Implemented Interfaces:
    `io.vertx.lang.rx.RxDelegate`, `HttpResponseHead`, `ReadStream<Buffer>`, `StreamBase`

      public class HttpClientResponse
      extends Object
      implements io.vertx.lang.rx.RxDelegate, ReadStream<Buffer>, HttpResponseHead

  Represents a client-side HTTP response.

  Vert.x provides you with one of these via the handler that was provided when creating the `HttpClientRequest` or that was set on the `HttpClientRequest` instance.

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

  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 | Description
    --- | --- | ---
    `static io.vertx.lang.rx.TypeArg<HttpClientResponse>` | `__TYPE_ARG` |

  - ### Constructor Summary

    Constructors
    Constructor | Description
    --- | ---
    `HttpClientResponse​(HttpClientResponse delegate)` |
    `HttpClientResponse​(Object delegate)` |

  - ### Method Summary

    All Methods Static Methods Instance Methods Concrete Methods
    Modifier and Type | Method | Description
    --- | --- | ---
    `Future<Buffer>` | `body()` | Convenience method for receiving the entire request body in one piece.
    `HttpClientResponse` | `bodyHandler​(Handler<Buffer> bodyHandler)` | Convenience method for receiving the entire request body in one piece.
    `List<String>` | `cookies()` |
    `HttpClientResponse` | `customFrameHandler​(Handler<HttpFrame> handler)` | Set an custom frame handler.
    `Future<Void>` | `end()` | Returns a future signaling when the response has been fully received successfully or failed.
    `HttpClientResponse` | `endHandler​(Handler<Void> endHandler)` | Set an end handler.
    `boolean` | `equals​(Object o)` |
    `HttpClientResponse` | `exceptionHandler​(Handler<Throwable> handler)` | Set an exception handler on the read stream.
    `HttpClientResponse` | `fetch​(long amount)` | Fetch the specified `amount` of elements.
    `HttpClientResponse` | `getDelegate()` |
    `String` | `getHeader​(CharSequence headerName)` | Return the first header value with the specified name
    `String` | `getHeader​(String headerName)` | Return the first header value with the specified name
    `String` | `getTrailer​(String trailerName)` | Return the first trailer value with the specified name
    `HttpClientResponse` | `handler​(Handler<Buffer> handler)` | Set a data handler.
    `int` | `hashCode()` |
    `MultiMap` | `headers()` |
    `NetSocket` | `netSocket()` |
    `static HttpClientResponse` | `newInstance​(HttpClientResponse arg)` |
    `HttpClientResponse` | `pause()` | Pause the `ReadStream`, it sets the buffer in `fetch` mode and clears the actual demand.
    `Pipe<Buffer>` | `pipe()` | Pause this stream and return a to transfer the elements of this stream to a destination .
    `Future<Void>` | `pipeTo​(WriteStream<Buffer> dst)` | Pipe this `ReadStream` to the `WriteStream`.
    `HttpClientRequest` | `request()` |
    `HttpClientResponse` | `resume()` | Resume reading, and sets the buffer in `flowing` mode.
    `Single<Buffer>` | `rxBody()` | Convenience method for receiving the entire request body in one piece.
    `Completable` | `rxEnd()` | Returns a future signaling when the response has been fully received successfully or failed.
    `Completable` | `rxPipeTo​(WriteStream<Buffer> dst)` | Pipe this `ReadStream` to the `WriteStream`.
    `int` | `statusCode()` |
    `String` | `statusMessage()` |
    `HttpClientResponse` | `streamPriorityHandler​(Handler<StreamPriority> handler)` | Set an handler for stream priority changes.
    `Flowable<Buffer>` | `toFlowable()` |
    `Observable<Buffer>` | `toObservable()` |
    `String` | `toString()` |
    `MultiMap` | `trailers()` |
    `HttpVersion` | `version()` |

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

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

- - ### Field Detail

    - #### __TYPE_ARG

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

  - ### Constructor Detail

    - #### HttpClientResponse

          public HttpClientResponse​(HttpClientResponse delegate)

    - #### HttpClientResponse

          public HttpClientResponse​(Object delegate)

  - ### Method Detail

    - #### toString

          public String toString()

      Overrides:
        `toString` in class `Object`

    - #### equals

          public boolean equals​(Object o)

      Overrides:
        `equals` in class `Object`

    - #### hashCode

          public int hashCode()

      Overrides:
        `hashCode` in class `Object`

    - #### getDelegate

          public HttpClientResponse getDelegate()

      Specified by:
        `getDelegate` in interface `HttpResponseHead`
      Specified by:
        `getDelegate` in interface `ReadStream<Buffer>`
      Specified by:
        `getDelegate` in interface `io.vertx.lang.rx.RxDelegate`
      Specified by:
        `getDelegate` in interface `StreamBase`

    - #### toObservable

          public Observable<Buffer> toObservable()

      Specified by:
        `toObservable` in interface `ReadStream<Buffer>`

    - #### toFlowable

          public Flowable<Buffer> toFlowable()

      Specified by:
        `toFlowable` in interface `ReadStream<Buffer>`

    - #### version

          public HttpVersion version()

      Specified by:
        `version` in interface `HttpResponseHead`
      Returns:
        the version of the response

    - #### statusCode

          public int statusCode()

      Specified by:
        `statusCode` in interface `HttpResponseHead`
      Returns:
        the status code of the response

    - #### statusMessage

          public String statusMessage()

      Specified by:
        `statusMessage` in interface `HttpResponseHead`
      Returns:
        the status message of the response

    - #### headers

          public MultiMap headers()

      Specified by:
        `headers` in interface `HttpResponseHead`
      Returns:
        the headers

    - #### getHeader

          public String getHeader​(String headerName)

      Return the first header value with the specified name
      Specified by:
        `getHeader` in interface `HttpResponseHead`
      Parameters:
        `headerName` - the header name
      Returns:
        the header value

    - #### cookies

          public List<String> cookies()

      Specified by:
        `cookies` in interface `HttpResponseHead`
      Returns:
        the Set-Cookie headers (including trailers)

    - #### pipe

          public Pipe<Buffer> pipe()

      Pause this stream and return a to transfer the elements of this stream to a destination .

      The stream will be resumed when the pipe will be wired to a `WriteStream`.
      Specified by:
        `pipe` in interface `ReadStream<Buffer>`
      Returns:
        a pipe

    - #### pipeTo

          public Future<Void> pipeTo​(WriteStream<Buffer> dst)

      Pipe this `ReadStream` to the `WriteStream`.

      Elements emitted by this stream will be written to the write stream until this stream ends or fails.

      Specified by:
        `pipeTo` in interface `ReadStream<Buffer>`
      Parameters:
        `dst` - the destination write stream
      Returns:
        a future notified when the write stream will be ended with the outcome

    - #### rxPipeTo

          public Completable rxPipeTo​(WriteStream<Buffer> dst)

      Pipe this `ReadStream` to the `WriteStream`.

      Elements emitted by this stream will be written to the write stream until this stream ends or fails.

      Specified by:
        `rxPipeTo` in interface `ReadStream<Buffer>`
      Parameters:
        `dst` - the destination write stream
      Returns:
        a future notified when the write stream will be ended with the outcome

    - #### fetch

          public HttpClientResponse fetch​(long amount)

      Description copied from interface: `ReadStream`
      Fetch the specified `amount` of elements. If the `ReadStream` has been paused, reading will recommence with the specified `amount` of items, otherwise the specified `amount` will be added to the current stream demand.
      Specified by:
        `fetch` in interface `ReadStream<Buffer>`
      Returns:
        a reference to this, so the API can be used fluently

    - #### resume

          public HttpClientResponse resume()

      Description copied from interface: `ReadStream`
      Resume reading, and sets the buffer in `flowing` mode.

      If the `ReadStream` has been paused, reading will recommence on it.
      Specified by:
        `resume` in interface `ReadStream<Buffer>`
      Returns:
        a reference to this, so the API can be used fluently

    - #### exceptionHandler

          public HttpClientResponse exceptionHandler​(Handler<Throwable> handler)

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

    - #### handler

          public HttpClientResponse handler​(Handler<Buffer> handler)

      Description copied from interface: `ReadStream`
      Set a data handler. As data is read, the handler will be called with the data.
      Specified by:
        `handler` in interface `ReadStream<Buffer>`
      Returns:
        a reference to this, so the API can be used fluently

    - #### pause

          public HttpClientResponse pause()

      Description copied from interface: `ReadStream`
      Pause the `ReadStream`, it sets the buffer in `fetch` mode and clears the actual demand.

      While it's paused, no data will be sent to the data `handler`.

      Specified by:
        `pause` in interface `ReadStream<Buffer>`
      Returns:
        a reference to this, so the API can be used fluently

    - #### endHandler

          public HttpClientResponse endHandler​(Handler<Void> endHandler)

      Description copied from interface: `ReadStream`
      Set an end handler. Once the stream has ended, and there is no more data to be read, this handler will be called.
      Specified by:
        `endHandler` in interface `ReadStream<Buffer>`
      Returns:
        a reference to this, so the API can be used fluently

    - #### netSocket

          public NetSocket netSocket()

      Returns:
        a `NetSocket` facade to interact with the HTTP client response.

    - #### getTrailer

          public String getTrailer​(String trailerName)

      Return the first trailer value with the specified name
      Parameters:
        `trailerName` - the trailer name
      Returns:
        the trailer value

    - #### trailers

          public MultiMap trailers()

      Returns:
        the trailers

    - #### bodyHandler

          public HttpClientResponse bodyHandler​(Handler<Buffer> bodyHandler)

      Convenience method for receiving the entire request body in one piece.

      This saves you having to manually set a dataHandler and an endHandler and append the chunks of the body until the whole body received. Don't use this if your request body is large - you could potentially run out of RAM.

      Parameters:
        `bodyHandler` - This handler will be called after all the body has been received
      Returns:

    - #### body

          public Future<Buffer> body()

      Convenience method for receiving the entire request body in one piece.

      This saves you having to manually set a dataHandler and an endHandler and append the chunks of the body until the whole body received. Don't use this if your request body is large - you could potentially run out of RAM.

      Returns:
        a future completed with the body result

    - #### rxBody

          public Single<Buffer> rxBody()

      Convenience method for receiving the entire request body in one piece.

      This saves you having to manually set a dataHandler and an endHandler and append the chunks of the body until the whole body received. Don't use this if your request body is large - you could potentially run out of RAM.

      Returns:
        a future completed with the body result

    - #### end

          public Future<Void> end()

      Returns a future signaling when the response has been fully received successfully or failed.
      Returns:
        a future completed with the body result

    - #### rxEnd

          public Completable rxEnd()

      Returns a future signaling when the response has been fully received successfully or failed.
      Returns:
        a future completed with the body result

    - #### customFrameHandler

          public HttpClientResponse customFrameHandler​(Handler<HttpFrame> handler)

      Set an custom frame handler. The handler will get notified when the http stream receives an custom HTTP/2 frame. HTTP/2 permits extension of the protocol.
      Parameters:
        `handler` -
      Returns:
        a reference to this, so the API can be used fluently

    - #### request

          public HttpClientRequest request()

      Returns:
        the corresponding request

    - #### streamPriorityHandler

          public HttpClientResponse streamPriorityHandler​(Handler<StreamPriority> handler)

      Set an handler for stream priority changes.

      This is not implemented for HTTP/1.x.
      Parameters:
        `handler` - the handler to be called when the stream priority changes
      Returns:

    - #### getHeader

          public String getHeader​(CharSequence headerName)

      Return the first header value with the specified name
      Parameters:
        `headerName` - the header name
      Returns:
        the header value

    - #### newInstance

          public static HttpClientResponse newInstance​(HttpClientResponse arg)