HttpClientResponse (Vert.x Stack

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

All Implemented Interfaces:

ReadStream<Buffer>, StreamBase
```
public class HttpClientResponse
extends Object
implements ReadStream<Buffer>
```
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 and Description

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

Fields
Modifier and Type	Field and Description
`static io.vertx.lang.rx.TypeArg<HttpClientResponse>`	`__TYPE_ARG`

Constructor Summary

Constructors
Constructor and Description

HttpClientResponse(HttpClientResponse delegate)

HttpClientResponse(Object delegate)

Constructors
Constructor and Description
`HttpClientResponse(HttpClientResponse delegate)`
`HttpClientResponse(Object delegate)`

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`HttpClientResponse`	`body()` Same as `body(io.vertx.core.Handler<io.vertx.core.AsyncResult<io.vertx.reactivex.core.buffer.Buffer>>)` but with an `handler` called when the operation completes
`HttpClientResponse`	`body(Handler<AsyncResult<Buffer>> handler)` Same as `body(io.vertx.core.Handler<io.vertx.core.AsyncResult<io.vertx.reactivex.core.buffer.Buffer>>)` but with an `handler` called when the operation completes
`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.
`void`	`end()` Same as `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 `end(io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>)` but with an `handler` called when the operation completes
`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 .
`void`	`pipeTo(WriteStream<Buffer> dst)` Pipe this `ReadStream` to the `WriteStream`.
`void`	`pipeTo(WriteStream<Buffer> dst, Handler<AsyncResult<Void>> handler)` Pipe this `ReadStream` to the `WriteStream`.
`HttpClientRequest`	`request()`
`HttpClientResponse`	`resume()` Resume reading, and sets the buffer in `flowing` mode.
`Single<Buffer>`	`rxBody()` Same as `body(io.vertx.core.Handler<io.vertx.core.AsyncResult<io.vertx.reactivex.core.buffer.Buffer>>)` but with an `handler` called when the operation completes
`Completable`	`rxEnd()` Same as `end(io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>)` but with an `handler` called when the operation completes
`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

Methods inherited from interface io.vertx.reactivex.core.streams.ReadStream
newInstance, newInstance

Methods inherited from interface io.vertx.reactivex.core.streams.StreamBase
newInstance

- 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 ReadStream<Buffer>
    
    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>
  - 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 void pipeTo(WriteStream<Buffer> dst,
                   Handler<AsyncResult<Void>> handler)
```
    Pipe this ReadStream to the WriteStream.
    Elements emitted by this stream will be written to the write stream until this stream ends or fails.
    Once this stream has ended or failed, the write stream will be ended and the handler will be called with the result.
    
    Specified by:
    
    pipeTo in interface ReadStream<Buffer>
    
    Parameters:
    
    dst - the destination write stream
    
    handler -
  - pipeTo
```
public 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.
    Once this stream has ended or failed, the write stream will be ended and the handler will be called with the result.
    
    Specified by:
    
    pipeTo in interface ReadStream<Buffer>
    
    Parameters:
    
    dst - the destination write stream
  - 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.
    Once this stream has ended or failed, the write stream will be ended and the handler will be called with the result.
    
    Specified by:
    
    rxPipeTo in interface ReadStream<Buffer>
    
    Parameters:
    
    dst - the destination write stream
    
    Returns:
  - 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.
  - version
```
public HttpVersion version()
```
    Returns:
    
    the version of the response
  - statusCode
```
public int statusCode()
```
    Returns:
    
    the status code of the response
  - statusMessage
```
public String statusMessage()
```
    Returns:
    
    the status message of the response
  - headers
```
public MultiMap headers()
```
    Returns:
    
    the headers
  - getHeader
```
public String getHeader(String headerName)
```
    Return the first header value with the specified name
    
    Parameters:
    
    headerName - the header name
    
    Returns:
    
    the header value
  - 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
  - cookies
```
public List<String> cookies()
```
    Returns:
    
    the Set-Cookie headers (including 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 HttpClientResponse body(Handler<AsyncResult<Buffer>> handler)
```
    Same as body(io.vertx.core.Handler<io.vertx.core.AsyncResult<io.vertx.reactivex.core.buffer.Buffer>>) but with an handler called when the operation completes
    
    Parameters:
    
    handler -
    
    Returns:
  - body
```
public HttpClientResponse body()
```
    Same as body(io.vertx.core.Handler<io.vertx.core.AsyncResult<io.vertx.reactivex.core.buffer.Buffer>>) but with an handler called when the operation completes
    
    Returns:
  - rxBody
```
public Single<Buffer> rxBody()
```
    Same as body(io.vertx.core.Handler<io.vertx.core.AsyncResult<io.vertx.reactivex.core.buffer.Buffer>>) but with an handler called when the operation completes
    
    Returns:
  - end
```
public void end(Handler<AsyncResult<Void>> handler)
```
    Same as end(io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>) but with an handler called when the operation completes
    
    Parameters:
    
    handler -
  - end
```
public void end()
```
    Same as end(io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>) but with an handler called when the operation completes
  - rxEnd
```
public Completable rxEnd()
```
    Same as end(io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>) but with an handler called when the operation completes
    
    Returns:
  - 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)
```

Class HttpClientResponse

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Methods inherited from interface io.vertx.reactivex.core.streams.ReadStream

Methods inherited from interface io.vertx.reactivex.core.streams.StreamBase

Field Detail

__TYPE_ARG

Constructor Detail

HttpClientResponse

HttpClientResponse

Method Detail

toString

equals

hashCode

getDelegate

toObservable

toFlowable

pipe

pipeTo

pipeTo

rxPipeTo

fetch

resume

exceptionHandler

handler

pause

endHandler

netSocket

version

statusCode

statusMessage

headers

getHeader

getTrailer

trailers

cookies

bodyHandler

body

body

rxBody

end

end

rxEnd

customFrameHandler

request

streamPriorityHandler

getHeader

newInstance