java.lang.Object
- io.vertx.mutiny.core.http.HttpServerResponse

All Implemented Interfaces:

StreamBase, WriteStream<Buffer>
```
public class HttpServerResponse
extends Object
implements WriteStream<Buffer>
```
Represents a server-side HTTP response.
An instance of this is created and associated to every instance of HttpServerRequest that.
It allows the developer to control the HTTP response that is sent back to the client for a particular HTTP request.
It contains methods that allow HTTP headers and trailers to be set, and for a body to be written out to the response.
It also allows files to be streamed by the kernel directly from disk to the outgoing HTTP connection, bypassing user space altogether (where supported by the underlying operating system). This is a very efficient way of serving files from the server since buffers do not have to be read one by one from the file and written to the outgoing socket.
It implements WriteStream so it can be used with Pipe to pipe data with flow control.
NOTE: This class has been automatically generated from the original non Mutiny-ified interface using Vert.x codegen.

Field Summary

Fields
Modifier and Type Field Description

static TypeArg<HttpServerResponse> __TYPE_ARG

Constructor Summary

Constructors
Constructor Description

HttpServerResponse(io.vertx.core.http.HttpServerResponse delegate)

HttpServerResponse(Object delegate)

Method Summary

All Methods Static Methods Instance Methods Concrete Methods Deprecated Methods
Modifier and Type	Method	Description
`HttpServerResponse`	`addCookie(Cookie cookie)`
`HttpServerResponse`	`bodyEndHandler(Runnable handler)`
`long`	`bytesWritten()`
`void`	`close()`	Deprecated. instead use `HttpConnection.close()` or `reset(long)`, this method is removed in Vert.x 5
`boolean`	`closed()`
`HttpServerResponse`	`closeHandler(Runnable handler)`
`HttpServerResponse`	`drainHandler(Runnable handler)`
`io.smallrye.mutiny.Uni<Void>`	`end()`	Same as `end()` but with an `handler` called when the operation completes
`io.smallrye.mutiny.Uni<Void>`	`end(Buffer chunk)`	Same as `end()` but with an `handler` called when the operation completes
`io.smallrye.mutiny.Uni<Void>`	`end(String chunk)`	Same as `end()` but with an `handler` called when the operation completes
`io.smallrye.mutiny.Uni<Void>`	`end(String chunk, String enc)`	Same as `end()` but with an `handler` called when the operation completes
`Void`	`endAndAwait()`	Blocking variant of `WriteStream.end()`.
`Void`	`endAndAwait(Buffer chunk)`	Blocking variant of `io.vertx.mutiny.core.streams.WriteStream#end(io.vertx.mutiny.core.buffer.Buffer)`.
`Void`	`endAndAwait(String chunk)`	Blocking variant of `end(String)`.
`Void`	`endAndAwait(String chunk, String enc)`	Blocking variant of `end(String,String)`.
`void`	`endAndForget()`	Variant of `WriteStream.end()` that ignores the result of the operation.
`void`	`endAndForget(Buffer chunk)`	Variant of `io.vertx.mutiny.core.streams.WriteStream#end(io.vertx.mutiny.core.buffer.Buffer)` that ignores the result of the operation.
`void`	`endAndForget(String chunk)`	Variant of `end(String)` that ignores the result of the operation.
`void`	`endAndForget(String chunk, String enc)`	Variant of `end(String,String)` that ignores the result of the operation.
`boolean`	`ended()`
`HttpServerResponse`	`endHandler(Runnable handler)`
`boolean`	`equals(Object o)`
`HttpServerResponse`	`exceptionHandler(Consumer<Throwable> handler)`
`io.vertx.core.http.HttpServerResponse`	`getDelegate()`
`int`	`getStatusCode()`
`String`	`getStatusMessage()`
`int`	`hashCode()`
`MultiMap`	`headers()`
`HttpServerResponse`	`headersEndHandler(Runnable handler)`
`boolean`	`headWritten()`
`boolean`	`isChunked()`
`static HttpServerResponse`	`newInstance(io.vertx.core.http.HttpServerResponse arg)`
`io.smallrye.mutiny.Uni<HttpServerResponse>`	`push(io.vertx.core.http.HttpMethod method, HostAndPort authority, String path, MultiMap headers)`	Same as `push(io.vertx.core.http.HttpMethod, java.lang.String, java.lang.String)` but with an `handler` called when the operation completes
`io.smallrye.mutiny.Uni<HttpServerResponse>`	`push(io.vertx.core.http.HttpMethod method, String path)`	Like `push(io.vertx.core.http.HttpMethod, java.lang.String, java.lang.String)` with the host copied from the current request.
`io.smallrye.mutiny.Uni<HttpServerResponse>`	`push(io.vertx.core.http.HttpMethod method, String path, MultiMap headers)`	Like `push(io.vertx.core.http.HttpMethod, java.lang.String, java.lang.String)` with the host copied from the current request.
`io.smallrye.mutiny.Uni<HttpServerResponse>`	`push(io.vertx.core.http.HttpMethod method, String host, String path)`	Like `push(io.vertx.core.http.HttpMethod, java.lang.String, java.lang.String)` with no headers.
`io.smallrye.mutiny.Uni<HttpServerResponse>`	`push(io.vertx.core.http.HttpMethod method, String host, String path, MultiMap headers)`	Push a response to the client.
`HttpServerResponse`	`pushAndAwait(io.vertx.core.http.HttpMethod method, HostAndPort authority, String path, MultiMap headers)`	Blocking variant of `push(HttpMethod,io.vertx.mutiny.core.net.HostAndPort,String,io.vertx.mutiny.core.MultiMap)`.
`HttpServerResponse`	`pushAndAwait(io.vertx.core.http.HttpMethod method, String path)`	Blocking variant of `push(HttpMethod,String)`.
`HttpServerResponse`	`pushAndAwait(io.vertx.core.http.HttpMethod method, String path, MultiMap headers)`	Blocking variant of `push(HttpMethod,String,io.vertx.mutiny.core.MultiMap)`.
`HttpServerResponse`	`pushAndAwait(io.vertx.core.http.HttpMethod method, String host, String path)`	Blocking variant of `push(HttpMethod,String,String)`.
`HttpServerResponse`	`pushAndAwait(io.vertx.core.http.HttpMethod method, String host, String path, MultiMap headers)`	Blocking variant of `push(HttpMethod,String,String,io.vertx.mutiny.core.MultiMap)`.
`HttpServerResponse`	`pushAndForget(io.vertx.core.http.HttpMethod method, HostAndPort authority, String path, MultiMap headers)`	Variant of `push(HttpMethod,io.vertx.mutiny.core.net.HostAndPort,String,io.vertx.mutiny.core.MultiMap)` that ignores the result of the operation.
`HttpServerResponse`	`pushAndForget(io.vertx.core.http.HttpMethod method, String path)`	Variant of `push(HttpMethod,String)` that ignores the result of the operation.
`HttpServerResponse`	`pushAndForget(io.vertx.core.http.HttpMethod method, String path, MultiMap headers)`	Variant of `push(HttpMethod,String,io.vertx.mutiny.core.MultiMap)` that ignores the result of the operation.
`HttpServerResponse`	`pushAndForget(io.vertx.core.http.HttpMethod method, String host, String path)`	Variant of `push(HttpMethod,String,String)` that ignores the result of the operation.
`HttpServerResponse`	`pushAndForget(io.vertx.core.http.HttpMethod method, String host, String path, MultiMap headers)`	Variant of `push(HttpMethod,String,String,io.vertx.mutiny.core.MultiMap)` that ignores the result of the operation.
`HttpServerResponse`	`putHeader(CharSequence name, CharSequence value)`
`HttpServerResponse`	`putHeader(CharSequence name, Iterable<CharSequence> values)`
`HttpServerResponse`	`putHeader(String name, Iterable<String> values)`
`HttpServerResponse`	`putHeader(String name, String value)`
`HttpServerResponse`	`putTrailer(CharSequence name, CharSequence value)`
`HttpServerResponse`	`putTrailer(CharSequence name, Iterable<CharSequence> value)`
`HttpServerResponse`	`putTrailer(String name, Iterable<String> values)`
`HttpServerResponse`	`putTrailer(String name, String value)`
`Cookie`	`removeCookie(String name)`
`Cookie`	`removeCookie(String name, boolean invalidate)`
`Cookie`	`removeCookie(String name, String domain, String path)`
`Cookie`	`removeCookie(String name, String domain, String path, boolean invalidate)`
`Set<Cookie>`	`removeCookies(String name)`
`Set<Cookie>`	`removeCookies(String name, boolean invalidate)`
`boolean`	`reset()`
`boolean`	`reset(long code)`
`io.smallrye.mutiny.Uni<Void>`	`send()`	Send the request with an empty body.
`io.smallrye.mutiny.Uni<Void>`	`send(Buffer body)`	Send the request with a buffer `body`.
`io.smallrye.mutiny.Uni<Void>`	`send(ReadStream<Buffer> body)`	Send the request with a stream `body`.
`io.smallrye.mutiny.Uni<Void>`	`send(String body)`	Send the request with a string `body`.
`io.smallrye.mutiny.Uni<Void>`	`send(Flow.Publisher<Buffer> body)`	Send the request with a stream `body`.
`Void`	`sendAndAwait()`	Blocking variant of `send()`.
`Void`	`sendAndAwait(Buffer body)`	Blocking variant of `send(io.vertx.mutiny.core.buffer.Buffer)`.
`Void`	`sendAndAwait(ReadStream<Buffer> body)`	Blocking variant of `send(io.vertx.mutiny.core.streams.ReadStream)`.
`Void`	`sendAndAwait(String body)`	Blocking variant of `send(String)`.
`Void`	`sendAndAwait(Flow.Publisher<Buffer> body)`	Blocking variant of `io.vertx.mutiny.core.http.HttpServerResponse#send(Flow$Publisher)`.
`void`	`sendAndForget()`	Variant of `send()` that ignores the result of the operation.
`void`	`sendAndForget(Buffer body)`	Variant of `send(io.vertx.mutiny.core.buffer.Buffer)` that ignores the result of the operation.
`void`	`sendAndForget(ReadStream<Buffer> body)`	Variant of `send(io.vertx.mutiny.core.streams.ReadStream)` that ignores the result of the operation.
`void`	`sendAndForget(String body)`	Variant of `send(String)` that ignores the result of the operation.
`void`	`sendAndForget(Flow.Publisher<Buffer> body)`	Variant of `io.vertx.mutiny.core.http.HttpServerResponse#send(Flow$Publisher)` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<Void>`	`sendFile(String filename)`	Like `sendFile(java.lang.String)` but providing a handler which will be notified once the file has been completely written to the wire.
`io.smallrye.mutiny.Uni<Void>`	`sendFile(String filename, long offset)`	Like `sendFile(java.lang.String)` but providing a handler which will be notified once the file has been completely written to the wire.
`io.smallrye.mutiny.Uni<Void>`	`sendFile(String filename, long offset, long length)`	Like `sendFile(java.lang.String)` but providing a handler which will be notified once the file has been completely written to the wire.
`Void`	`sendFileAndAwait(String filename)`	Blocking variant of `sendFile(String)`.
`Void`	`sendFileAndAwait(String filename, long offset)`	Blocking variant of `sendFile(String,long)`.
`Void`	`sendFileAndAwait(String filename, long offset, long length)`	Blocking variant of `sendFile(String,long,long)`.
`HttpServerResponse`	`sendFileAndForget(String filename)`	Variant of `sendFile(String)` that ignores the result of the operation.
`HttpServerResponse`	`sendFileAndForget(String filename, long offset)`	Variant of `sendFile(String,long)` that ignores the result of the operation.
`HttpServerResponse`	`sendFileAndForget(String filename, long offset, long length)`	Variant of `sendFile(String,long,long)` that ignores the result of the operation.
`HttpServerResponse`	`setChunked(boolean chunked)`
`HttpServerResponse`	`setStatusCode(int statusCode)`
`HttpServerResponse`	`setStatusMessage(String statusMessage)`
`HttpServerResponse`	`setStreamPriority(io.vertx.core.http.StreamPriority streamPriority)`
`HttpServerResponse`	`setWriteQueueMaxSize(int maxSize)`
`int`	`streamId()`
`String`	`toString()`
`WriteStreamSubscriber<Buffer>`	`toSubscriber()`
`MultiMap`	`trailers()`
`io.smallrye.mutiny.Uni<Void>`	`write(Buffer data)`	Same as but with an `handler` called when the operation completes
`io.smallrye.mutiny.Uni<Void>`	`write(String chunk)`	Same as `write(io.vertx.mutiny.core.buffer.Buffer)` but with an `handler` called when the operation completes
`io.smallrye.mutiny.Uni<Void>`	`write(String chunk, String enc)`	Same as `write(io.vertx.mutiny.core.buffer.Buffer)` but with an `handler` called when the operation completes
`Void`	`writeAndAwait(Buffer data)`	Blocking variant of `io.vertx.mutiny.core.streams.WriteStream#write(io.vertx.mutiny.core.buffer.Buffer)`.
`Void`	`writeAndAwait(String chunk)`	Blocking variant of `write(String)`.
`Void`	`writeAndAwait(String chunk, String enc)`	Blocking variant of `write(String,String)`.
`void`	`writeAndForget(Buffer data)`	Variant of `io.vertx.mutiny.core.streams.WriteStream#write(io.vertx.mutiny.core.buffer.Buffer)` that ignores the result of the operation.
`void`	`writeAndForget(String chunk)`	Variant of `write(String)` that ignores the result of the operation.
`void`	`writeAndForget(String chunk, String enc)`	Variant of `write(String,String)` that ignores the result of the operation.
`HttpServerResponse`	`writeContinue()`
`HttpServerResponse`	`writeCustomFrame(int type, int flags, Buffer payload)`
`HttpServerResponse`	`writeCustomFrame(HttpFrame frame)`
`io.smallrye.mutiny.Uni<Void>`	`writeEarlyHints(MultiMap headers)`	Same as `writeEarlyHints(io.vertx.mutiny.core.MultiMap)` but with an `handler` called when the operation completes
`Void`	`writeEarlyHintsAndAwait(MultiMap headers)`	Blocking variant of `writeEarlyHints(io.vertx.mutiny.core.MultiMap)`.
`void`	`writeEarlyHintsAndForget(MultiMap headers)`	Variant of `writeEarlyHints(io.vertx.mutiny.core.MultiMap)` that ignores the result of the operation.
`boolean`	`writeQueueFull()`

Methods inherited from class java.lang.Object
clone, finalize, getClass, notify, notifyAll, wait, wait, wait

- Field Detail
  - __TYPE_ARG
```
public static final TypeArg<HttpServerResponse> __TYPE_ARG
```
- Constructor Detail
  - HttpServerResponse
```
public HttpServerResponse(io.vertx.core.http.HttpServerResponse delegate)
```
  - HttpServerResponse
```
public HttpServerResponse(Object delegate)
```
- Method Detail
  - getDelegate
```
public io.vertx.core.http.HttpServerResponse getDelegate()
```
    Specified by:
    
    getDelegate in interface StreamBase
    
    Specified by:
    
    getDelegate in interface WriteStream<Buffer>
  - 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
  - toSubscriber
```
@CheckReturnValue
public WriteStreamSubscriber<Buffer> toSubscriber()
```
  - write
```
@CheckReturnValue
public io.smallrye.mutiny.Uni<Void> write(Buffer data)
```
    Same as but with an handler called when the operation completes
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.
    
    Specified by:
    
    write in interface WriteStream<Buffer>
    
    Parameters:
    
    data -
    
    Returns:
    
    the uni firing the result of the operation when completed, or a failure if the operation failed.
  - writeAndAwait
```
public Void writeAndAwait(Buffer data)
```
    Blocking variant of io.vertx.mutiny.core.streams.WriteStream#write(io.vertx.mutiny.core.buffer.Buffer).
    This method waits 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).
    
    Specified by:
    
    writeAndAwait in interface WriteStream<Buffer>
    
    Parameters:
    
    data -
    
    Returns:
    
    the Void instance produced by the operation.
  - writeAndForget
```
public void writeAndForget(Buffer data)
```
    Variant of io.vertx.mutiny.core.streams.WriteStream#write(io.vertx.mutiny.core.buffer.Buffer) that ignores the result of the operation.
    This method subscribes on the result of io.vertx.mutiny.core.streams.WriteStream#write(io.vertx.mutiny.core.buffer.Buffer), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from io.vertx.mutiny.core.streams.WriteStream#write(io.vertx.mutiny.core.buffer.Buffer) but you don't need to compose it with other operations.
    
    Specified by:
    
    writeAndForget in interface WriteStream<Buffer>
    
    Parameters:
    
    data -
  - end
```
@CheckReturnValue
public io.smallrye.mutiny.Uni<Void> end()
```
    Same as end() but with an handler called when the operation completes
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.
    
    Specified by:
    
    end in interface WriteStream<Buffer>
    
    Returns:
    
    the uni firing the result of the operation when completed, or a failure if the operation failed.
  - endAndAwait
```
public Void endAndAwait()
```
    Blocking variant of WriteStream.end().
    This method waits 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).
    
    Specified by:
    
    endAndAwait in interface WriteStream<Buffer>
    
    Returns:
    
    the Void instance produced by the operation.
  - endAndForget
```
public void endAndForget()
```
    Variant of WriteStream.end() that ignores the result of the operation.
    This method subscribes on the result of WriteStream.end(), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from WriteStream.end() but you don't need to compose it with other operations.
    
    Specified by:
    
    endAndForget in interface WriteStream<Buffer>
  - writeQueueFull
```
public boolean writeQueueFull()
```
    Specified by:
    
    writeQueueFull in interface WriteStream<Buffer>
    
    Returns:
    
    true if write queue is full
  - exceptionHandler
```
public HttpServerResponse exceptionHandler(Consumer<Throwable> handler)
```
    Specified by:
    
    exceptionHandler in interface StreamBase
    
    Specified by:
    
    exceptionHandler in interface WriteStream<Buffer>
    
    Parameters:
    
    handler - the exception handler
    
    Returns:
  - setWriteQueueMaxSize
```
public HttpServerResponse setWriteQueueMaxSize(int maxSize)
```
    Specified by:
    
    setWriteQueueMaxSize in interface WriteStream<Buffer>
    
    Parameters:
    
    maxSize - the max size of the write stream
    
    Returns:
    
    a reference to this, so the API can be used fluently
  - drainHandler
```
public HttpServerResponse drainHandler(Runnable handler)
```
    Specified by:
    
    drainHandler in interface WriteStream<Buffer>
    
    Parameters:
    
    handler - the handler
    
    Returns:
  - getStatusCode
```
public int getStatusCode()
```
    Returns:
    
    the HTTP status code of the response. The default is 200 representing OK.
  - setStatusCode
```
public HttpServerResponse setStatusCode(int statusCode)
```
    Parameters:
    
    statusCode -
    
    Returns:
    
    a reference to this, so the API can be used fluently
  - getStatusMessage
```
public String getStatusMessage()
```
    Returns:
    
    the HTTP status message of the response. If this is not specified a default value will be used depending on what setStatusCode(int) has been set to.
  - setStatusMessage
```
public HttpServerResponse setStatusMessage(String statusMessage)
```
    Parameters:
    
    statusMessage -
    
    Returns:
    
    a reference to this, so the API can be used fluently
  - setChunked
```
public HttpServerResponse setChunked(boolean chunked)
```
    Parameters:
    
    chunked -
    
    Returns:
    
    a reference to this, so the API can be used fluently
  - isChunked
```
public boolean isChunked()
```
    Returns:
    
    is the response chunked?
  - headers
```
public MultiMap headers()
```
    Returns:
    
    The HTTP headers
  - putHeader
```
public HttpServerResponse putHeader(String name,
                                    String value)
```
    Parameters:
    
    name - the header name
    
    value - the header value.
    
    Returns:
    
    a reference to this, so the API can be used fluently
  - trailers
```
public MultiMap trailers()
```
    Returns:
    
    The HTTP trailers
  - putTrailer
```
public HttpServerResponse putTrailer(String name,
                                     String value)
```
    Parameters:
    
    name - the trailer name
    
    value - the trailer value
    
    Returns:
    
    a reference to this, so the API can be used fluently
  - closeHandler
```
public HttpServerResponse closeHandler(Runnable handler)
```
    Parameters:
    
    handler - the handler
    
    Returns:
  - endHandler
```
public HttpServerResponse endHandler(Runnable handler)
```
    Parameters:
    
    handler - the handler
    
    Returns:
  - write
```
@CheckReturnValue
public io.smallrye.mutiny.Uni<Void> write(String chunk,
                                          String enc)
```
    Same as write(io.vertx.mutiny.core.buffer.Buffer) but with an handler called when the operation completes
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.
    
    Parameters:
    
    chunk -
    
    enc -
    
    Returns:
    
    the uni firing the result of the operation when completed, or a failure if the operation failed.
  - writeAndAwait
```
public Void writeAndAwait(String chunk,
                          String enc)
```
    Blocking variant of write(String,String).
    This method waits 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 -
    
    enc -
    
    Returns:
    
    the Void instance produced by the operation.
  - writeAndForget
```
public void writeAndForget(String chunk,
                           String enc)
```
    Variant of write(String,String) that ignores the result of the operation.
    This method subscribes on the result of write(String,String), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from write(String,String) but you don't need to compose it with other operations.
    
    Parameters:
    
    chunk -
    
    enc -
  - write
```
@CheckReturnValue
public io.smallrye.mutiny.Uni<Void> write(String chunk)
```
    Same as write(io.vertx.mutiny.core.buffer.Buffer) but with an handler called when the operation completes
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.
    
    Parameters:
    
    chunk -
    
    Returns:
    
    the uni firing the result of the operation when completed, or a failure if the operation failed.
  - writeAndAwait
```
public Void writeAndAwait(String chunk)
```
    Blocking variant of write(String).
    This method waits 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 -
    
    Returns:
    
    the Void instance produced by the operation.
  - writeAndForget
```
public void writeAndForget(String chunk)
```
    Variant of write(String) that ignores the result of the operation.
    This method subscribes on the result of write(String), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from write(String) but you don't need to compose it with other operations.
    
    Parameters:
    
    chunk -
  - writeContinue
```
public HttpServerResponse writeContinue()
```
    Returns:
    
    a reference to this, so the API can be used fluently
  - writeEarlyHints
```
@CheckReturnValue
public io.smallrye.mutiny.Uni<Void> writeEarlyHints(MultiMap headers)
```
    Same as writeEarlyHints(io.vertx.mutiny.core.MultiMap) but with an handler called when the operation completes
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.
    
    Parameters:
    
    headers - headers to write
    
    Returns:
    
    the uni firing the result of the operation when completed, or a failure if the operation failed.
  - writeEarlyHintsAndAwait
```
public Void writeEarlyHintsAndAwait(MultiMap headers)
```
    Blocking variant of writeEarlyHints(io.vertx.mutiny.core.MultiMap).
    This method waits 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:
    
    headers - headers to write
    
    Returns:
    
    the Void instance produced by the operation.
  - writeEarlyHintsAndForget
```
public void writeEarlyHintsAndForget(MultiMap headers)
```
    Variant of writeEarlyHints(io.vertx.mutiny.core.MultiMap) that ignores the result of the operation.
    This method subscribes on the result of writeEarlyHints(io.vertx.mutiny.core.MultiMap), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from writeEarlyHints(io.vertx.mutiny.core.MultiMap) but you don't need to compose it with other operations.
    
    Parameters:
    
    headers - headers to write
  - end
```
@CheckReturnValue
public io.smallrye.mutiny.Uni<Void> end(String chunk)
```
    Same as end() but with an handler called when the operation completes
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.
    
    Parameters:
    
    chunk -
    
    Returns:
    
    the uni firing the result of the operation when completed, or a failure if the operation failed.
  - endAndAwait
```
public Void endAndAwait(String chunk)
```
    Blocking variant of end(String).
    This method waits 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 -
    
    Returns:
    
    the Void instance produced by the operation.
  - endAndForget
```
public void endAndForget(String chunk)
```
    Variant of end(String) that ignores the result of the operation.
    This method subscribes on the result of end(String), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from end(String) but you don't need to compose it with other operations.
    
    Parameters:
    
    chunk -
  - end
```
@CheckReturnValue
public io.smallrye.mutiny.Uni<Void> end(String chunk,
                                        String enc)
```
    Same as end() but with an handler called when the operation completes
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.
    
    Parameters:
    
    chunk -
    
    enc -
    
    Returns:
    
    the uni firing the result of the operation when completed, or a failure if the operation failed.
  - endAndAwait
```
public Void endAndAwait(String chunk,
                        String enc)
```
    Blocking variant of end(String,String).
    This method waits 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 -
    
    enc -
    
    Returns:
    
    the Void instance produced by the operation.
  - endAndForget
```
public void endAndForget(String chunk,
                         String enc)
```
    Variant of end(String,String) that ignores the result of the operation.
    This method subscribes on the result of end(String,String), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from end(String,String) but you don't need to compose it with other operations.
    
    Parameters:
    
    chunk -
    
    enc -
  - end
```
@CheckReturnValue
public io.smallrye.mutiny.Uni<Void> end(Buffer chunk)
```
    Same as end() but with an handler called when the operation completes
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.
    
    Specified by:
    
    end in interface WriteStream<Buffer>
    
    Parameters:
    
    chunk -
    
    Returns:
    
    the uni firing the result of the operation when completed, or a failure if the operation failed.
  - endAndAwait
```
public Void endAndAwait(Buffer chunk)
```
    Blocking variant of io.vertx.mutiny.core.streams.WriteStream#end(io.vertx.mutiny.core.buffer.Buffer).
    This method waits 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).
    
    Specified by:
    
    endAndAwait in interface WriteStream<Buffer>
    
    Parameters:
    
    chunk -
    
    Returns:
    
    the Void instance produced by the operation.
  - endAndForget
```
public void endAndForget(Buffer chunk)
```
    Variant of io.vertx.mutiny.core.streams.WriteStream#end(io.vertx.mutiny.core.buffer.Buffer) that ignores the result of the operation.
    This method subscribes on the result of io.vertx.mutiny.core.streams.WriteStream#end(io.vertx.mutiny.core.buffer.Buffer), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from io.vertx.mutiny.core.streams.WriteStream#end(io.vertx.mutiny.core.buffer.Buffer) but you don't need to compose it with other operations.
    
    Specified by:
    
    endAndForget in interface WriteStream<Buffer>
    
    Parameters:
    
    chunk -
  - send
```
@CheckReturnValue
public io.smallrye.mutiny.Uni<Void> send()
```
    Send the request with an empty body.
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.
    
    Returns:
    
    the uni firing the result of the operation when completed, or a failure if the operation failed.
  - sendAndAwait
```
public Void sendAndAwait()
```
    Blocking variant of send().
    This method waits 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 Void instance produced by the operation.
  - sendAndForget
```
public void sendAndForget()
```
    Variant of send() that ignores the result of the operation.
    This method subscribes on the result of send(), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from send() but you don't need to compose it with other operations.
  - send
```
@CheckReturnValue
public io.smallrye.mutiny.Uni<Void> send(String body)
```
    Send the request with a string body.
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.
    
    Parameters:
    
    body -
    
    Returns:
    
    the uni firing the result of the operation when completed, or a failure if the operation failed.
  - sendAndAwait
```
public Void sendAndAwait(String body)
```
    Blocking variant of send(String).
    This method waits 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:
    
    body -
    
    Returns:
    
    the Void instance produced by the operation.
  - sendAndForget
```
public void sendAndForget(String body)
```
    Variant of send(String) that ignores the result of the operation.
    This method subscribes on the result of send(String), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from send(String) but you don't need to compose it with other operations.
    
    Parameters:
    
    body -
  - send
```
@CheckReturnValue
public io.smallrye.mutiny.Uni<Void> send(Buffer body)
```
    Send the request with a buffer body.
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.
    
    Parameters:
    
    body -
    
    Returns:
    
    the uni firing the result of the operation when completed, or a failure if the operation failed.
  - sendAndAwait
```
public Void sendAndAwait(Buffer body)
```
    Blocking variant of send(io.vertx.mutiny.core.buffer.Buffer).
    This method waits 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:
    
    body -
    
    Returns:
    
    the Void instance produced by the operation.
  - sendAndForget
```
public void sendAndForget(Buffer body)
```
    Variant of send(io.vertx.mutiny.core.buffer.Buffer) that ignores the result of the operation.
    This method subscribes on the result of send(io.vertx.mutiny.core.buffer.Buffer), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from send(io.vertx.mutiny.core.buffer.Buffer) but you don't need to compose it with other operations.
    
    Parameters:
    
    body -
  - send
```
@CheckReturnValue
public io.smallrye.mutiny.Uni<Void> send(ReadStream<Buffer> body)
```
    Send the request with a stream body.
    If the HttpHeaders is set then the request assumes this is the length of the {stream}, otherwise the request will set a chunked HttpHeaders.
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.
    
    Parameters:
    
    body -
    
    Returns:
    
    the uni firing the result of the operation when completed, or a failure if the operation failed.
  - sendAndAwait
```
public Void sendAndAwait(ReadStream<Buffer> body)
```
    Blocking variant of send(io.vertx.mutiny.core.streams.ReadStream).
    This method waits 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:
    
    body -
    
    Returns:
    
    the Void instance produced by the operation.
  - sendAndForget
```
public void sendAndForget(ReadStream<Buffer> body)
```
    Variant of send(io.vertx.mutiny.core.streams.ReadStream) that ignores the result of the operation.
    This method subscribes on the result of send(io.vertx.mutiny.core.streams.ReadStream), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from send(io.vertx.mutiny.core.streams.ReadStream) but you don't need to compose it with other operations.
    
    Parameters:
    
    body -
  - send
```
@CheckReturnValue
public io.smallrye.mutiny.Uni<Void> send(Flow.Publisher<Buffer> body)
```
    Send the request with a stream body.
    If the HttpHeaders is set then the request assumes this is the length of the {stream}, otherwise the request will set a chunked HttpHeaders.
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.
    
    Parameters:
    
    body -
    
    Returns:
    
    the uni firing the result of the operation when completed, or a failure if the operation failed.
  - sendAndAwait
```
public Void sendAndAwait(Flow.Publisher<Buffer> body)
```
    Blocking variant of io.vertx.mutiny.core.http.HttpServerResponse#send(Flow$Publisher).
    This method waits 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:
    
    body -
    
    Returns:
    
    the Void instance produced by the operation.
  - sendAndForget
```
public void sendAndForget(Flow.Publisher<Buffer> body)
```
    Variant of io.vertx.mutiny.core.http.HttpServerResponse#send(Flow$Publisher) that ignores the result of the operation.
    This method subscribes on the result of io.vertx.mutiny.core.http.HttpServerResponse#send(Flow$Publisher), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from io.vertx.mutiny.core.http.HttpServerResponse#send(Flow$Publisher) but you don't need to compose it with other operations.
    
    Parameters:
    
    body -
  - sendFile
```
@CheckReturnValue
public io.smallrye.mutiny.Uni<Void> sendFile(String filename)
```
    Like sendFile(java.lang.String) but providing a handler which will be notified once the file has been completely written to the wire.
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.
    
    Parameters:
    
    filename - path to the file to serve
    
    Returns:
    
    the uni firing the result of the operation when completed, or a failure if the operation failed.
  - sendFileAndAwait
```
public Void sendFileAndAwait(String filename)
```
    Blocking variant of sendFile(String).
    This method waits 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:
    
    filename - path to the file to serve
    
    Returns:
    
    the Void instance produced by the operation.
  - sendFileAndForget
```
public HttpServerResponse sendFileAndForget(String filename)
```
    Variant of sendFile(String) that ignores the result of the operation.
    This method subscribes on the result of sendFile(String), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from sendFile(String) but you don't need to compose it with other operations.
    
    Parameters:
    
    filename - path to the file to serve
    
    Returns:
    
    the instance of HttpServerResponse to chain method calls.
  - sendFile
```
@CheckReturnValue
public io.smallrye.mutiny.Uni<Void> sendFile(String filename,
                                             long offset)
```
    Like sendFile(java.lang.String) but providing a handler which will be notified once the file has been completely written to the wire.
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.
    
    Parameters:
    
    filename - path to the file to serve
    
    offset - the offset to serve from
    
    Returns:
    
    the uni firing the result of the operation when completed, or a failure if the operation failed.
  - sendFileAndAwait
```
public Void sendFileAndAwait(String filename,
                             long offset)
```
    Blocking variant of sendFile(String,long).
    This method waits 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:
    
    filename - path to the file to serve
    
    offset - the offset to serve from
    
    Returns:
    
    the Void instance produced by the operation.
  - sendFileAndForget
```
public HttpServerResponse sendFileAndForget(String filename,
                                            long offset)
```
    Variant of sendFile(String,long) that ignores the result of the operation.
    This method subscribes on the result of sendFile(String,long), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from sendFile(String,long) but you don't need to compose it with other operations.
    
    Parameters:
    
    filename - path to the file to serve
    
    offset - the offset to serve from
    
    Returns:
    
    the instance of HttpServerResponse to chain method calls.
  - sendFile
```
@CheckReturnValue
public io.smallrye.mutiny.Uni<Void> sendFile(String filename,
                                             long offset,
                                             long length)
```
    Like sendFile(java.lang.String) but providing a handler which will be notified once the file has been completely written to the wire.
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.
    
    Parameters:
    
    filename - path to the file to serve
    
    offset - the offset to serve from
    
    length - length the number of bytes to send
    
    Returns:
    
    the uni firing the result of the operation when completed, or a failure if the operation failed.
  - sendFileAndAwait
```
public Void sendFileAndAwait(String filename,
                             long offset,
                             long length)
```
    Blocking variant of sendFile(String,long,long).
    This method waits 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:
    
    filename - path to the file to serve
    
    offset - the offset to serve from
    
    length - length the number of bytes to send
    
    Returns:
    
    the Void instance produced by the operation.
  - sendFileAndForget
```
public HttpServerResponse sendFileAndForget(String filename,
                                            long offset,
                                            long length)
```
    Variant of sendFile(String,long,long) that ignores the result of the operation.
    This method subscribes on the result of sendFile(String,long,long), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from sendFile(String,long,long) but you don't need to compose it with other operations.
    
    Parameters:
    
    filename - path to the file to serve
    
    offset - the offset to serve from
    
    length - length the number of bytes to send
    
    Returns:
    
    the instance of HttpServerResponse to chain method calls.
  - close
```
@Deprecated
public void close()
```
    Deprecated.
    instead use HttpConnection.close() or reset(long), this method is removed in Vert.x 5
  - ended
```
public boolean ended()
```
    Returns:
    
    has the response already ended?
  - closed
```
public boolean closed()
```
    Returns:
    
    has the underlying TCP connection corresponding to the request already been closed?
  - headWritten
```
public boolean headWritten()
```
    Returns:
    
    have the headers for the response already been written?
  - headersEndHandler
```
public HttpServerResponse headersEndHandler(Runnable handler)
```
    Parameters:
    
    handler - the handler
    
    Returns:
  - bodyEndHandler
```
public HttpServerResponse bodyEndHandler(Runnable handler)
```
    Parameters:
    
    handler - the handler
    
    Returns:
  - bytesWritten
```
public long bytesWritten()
```
    Returns:
    
    the total number of bytes written for the body of the response.
  - streamId
```
public int streamId()
```
    Returns:
    
    the id of the stream of this response, for HTTP/1.x
  - push
```
@CheckReturnValue
public io.smallrye.mutiny.Uni<HttpServerResponse> push(io.vertx.core.http.HttpMethod method,
                                                       String host,
                                                       String path)
```
    Like push(io.vertx.core.http.HttpMethod, java.lang.String, java.lang.String) with no headers.
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.
    
    Parameters:
    
    method -
    
    host -
    
    path -
    
    Returns:
    
    the uni firing the result of the operation when completed, or a failure if the operation failed.
  - pushAndAwait
```
public HttpServerResponse pushAndAwait(io.vertx.core.http.HttpMethod method,
                                       String host,
                                       String path)
```
    Blocking variant of push(HttpMethod,String,String).
    This method waits 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:
    
    method -
    
    host -
    
    path -
    
    Returns:
    
    the HttpServerResponse instance produced by the operation.
  - pushAndForget
```
public HttpServerResponse pushAndForget(io.vertx.core.http.HttpMethod method,
                                        String host,
                                        String path)
```
    Variant of push(HttpMethod,String,String) that ignores the result of the operation.
    This method subscribes on the result of push(HttpMethod,String,String), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from push(HttpMethod,String,String) but you don't need to compose it with other operations.
    
    Parameters:
    
    method -
    
    host -
    
    path -
    
    Returns:
    
    the instance of HttpServerResponse to chain method calls.
  - push
```
@CheckReturnValue
public io.smallrye.mutiny.Uni<HttpServerResponse> push(io.vertx.core.http.HttpMethod method,
                                                       String path,
                                                       MultiMap headers)
```
    Like push(io.vertx.core.http.HttpMethod, java.lang.String, java.lang.String) with the host copied from the current request.
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.
    
    Parameters:
    
    method -
    
    path -
    
    headers -
    
    Returns:
    
    the uni firing the result of the operation when completed, or a failure if the operation failed.
  - pushAndAwait
```
public HttpServerResponse pushAndAwait(io.vertx.core.http.HttpMethod method,
                                       String path,
                                       MultiMap headers)
```
    Blocking variant of push(HttpMethod,String,io.vertx.mutiny.core.MultiMap).
    This method waits 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:
    
    method -
    
    path -
    
    headers -
    
    Returns:
    
    the HttpServerResponse instance produced by the operation.
  - pushAndForget
```
public HttpServerResponse pushAndForget(io.vertx.core.http.HttpMethod method,
                                        String path,
                                        MultiMap headers)
```
    Variant of push(HttpMethod,String,io.vertx.mutiny.core.MultiMap) that ignores the result of the operation.
    This method subscribes on the result of push(HttpMethod,String,io.vertx.mutiny.core.MultiMap), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from push(HttpMethod,String,io.vertx.mutiny.core.MultiMap) but you don't need to compose it with other operations.
    
    Parameters:
    
    method -
    
    path -
    
    headers -
    
    Returns:
    
    the instance of HttpServerResponse to chain method calls.
  - push
```
@CheckReturnValue
public io.smallrye.mutiny.Uni<HttpServerResponse> push(io.vertx.core.http.HttpMethod method,
                                                       String path)
```
    Like push(io.vertx.core.http.HttpMethod, java.lang.String, java.lang.String) with the host copied from the current request.
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.
    
    Parameters:
    
    method -
    
    path -
    
    Returns:
    
    the uni firing the result of the operation when completed, or a failure if the operation failed.
  - pushAndAwait
```
public HttpServerResponse pushAndAwait(io.vertx.core.http.HttpMethod method,
                                       String path)
```
    Blocking variant of push(HttpMethod,String).
    This method waits 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:
    
    method -
    
    path -
    
    Returns:
    
    the HttpServerResponse instance produced by the operation.
  - pushAndForget
```
public HttpServerResponse pushAndForget(io.vertx.core.http.HttpMethod method,
                                        String path)
```
    Variant of push(HttpMethod,String) that ignores the result of the operation.
    This method subscribes on the result of push(HttpMethod,String), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from push(HttpMethod,String) but you don't need to compose it with other operations.
    
    Parameters:
    
    method -
    
    path -
    
    Returns:
    
    the instance of HttpServerResponse to chain method calls.
  - push
```
@CheckReturnValue
public io.smallrye.mutiny.Uni<HttpServerResponse> push(io.vertx.core.http.HttpMethod method,
                                                       String host,
                                                       String path,
                                                       MultiMap headers)
```
    Push a response to the client.
    The handler will be notified with a success when the push can be sent and with a failure when the client has disabled push or reset the push before it has been sent.
    The handler may be queued if the client has reduced the maximum number of streams the server can push concurrently.
    Push can be sent only for peer initiated streams and if the response is not ended.
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.
    
    Parameters:
    
    method - the method of the promised request
    
    host -
    
    path - the path of the promised request
    
    headers - the headers of the promised request
    
    Returns:
    
    the uni firing the result of the operation when completed, or a failure if the operation failed.
  - pushAndAwait
```
public HttpServerResponse pushAndAwait(io.vertx.core.http.HttpMethod method,
                                       String host,
                                       String path,
                                       MultiMap headers)
```
    Blocking variant of push(HttpMethod,String,String,io.vertx.mutiny.core.MultiMap).
    This method waits 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:
    
    method - the method of the promised request
    
    host -
    
    path - the path of the promised request
    
    headers - the headers of the promised request
    
    Returns:
    
    the HttpServerResponse instance produced by the operation.
  - pushAndForget
```
public HttpServerResponse pushAndForget(io.vertx.core.http.HttpMethod method,
                                        String host,
                                        String path,
                                        MultiMap headers)
```
    Variant of push(HttpMethod,String,String,io.vertx.mutiny.core.MultiMap) that ignores the result of the operation.
    This method subscribes on the result of push(HttpMethod,String,String,io.vertx.mutiny.core.MultiMap), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from push(HttpMethod,String,String,io.vertx.mutiny.core.MultiMap) but you don't need to compose it with other operations.
    
    Parameters:
    
    method - the method of the promised request
    
    host -
    
    path - the path of the promised request
    
    headers - the headers of the promised request
    
    Returns:
    
    the instance of HttpServerResponse to chain method calls.
  - push
```
@CheckReturnValue
public io.smallrye.mutiny.Uni<HttpServerResponse> push(io.vertx.core.http.HttpMethod method,
                                                       HostAndPort authority,
                                                       String path,
                                                       MultiMap headers)
```
    Same as push(io.vertx.core.http.HttpMethod, java.lang.String, java.lang.String) but with an handler called when the operation completes
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.
    
    Parameters:
    
    method -
    
    authority -
    
    path -
    
    headers -
    
    Returns:
    
    the uni firing the result of the operation when completed, or a failure if the operation failed.
  - pushAndAwait
```
public HttpServerResponse pushAndAwait(io.vertx.core.http.HttpMethod method,
                                       HostAndPort authority,
                                       String path,
                                       MultiMap headers)
```
    Blocking variant of push(HttpMethod,io.vertx.mutiny.core.net.HostAndPort,String,io.vertx.mutiny.core.MultiMap).
    This method waits 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:
    
    method -
    
    authority -
    
    path -
    
    headers -
    
    Returns:
    
    the HttpServerResponse instance produced by the operation.
  - pushAndForget
```
public HttpServerResponse pushAndForget(io.vertx.core.http.HttpMethod method,
                                        HostAndPort authority,
                                        String path,
                                        MultiMap headers)
```
    Variant of push(HttpMethod,io.vertx.mutiny.core.net.HostAndPort,String,io.vertx.mutiny.core.MultiMap) that ignores the result of the operation.
    This method subscribes on the result of push(HttpMethod,io.vertx.mutiny.core.net.HostAndPort,String,io.vertx.mutiny.core.MultiMap), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from push(HttpMethod,io.vertx.mutiny.core.net.HostAndPort,String,io.vertx.mutiny.core.MultiMap) but you don't need to compose it with other operations.
    
    Parameters:
    
    method -
    
    authority -
    
    path -
    
    headers -
    
    Returns:
    
    the instance of HttpServerResponse to chain method calls.
  - reset
```
public boolean reset()
```
    Returns:
  - reset
```
public boolean reset(long code)
```
    Parameters:
    
    code - the error code
    
    Returns:
    
    true when reset has been performed
  - writeCustomFrame
```
public HttpServerResponse writeCustomFrame(int type,
                                           int flags,
                                           Buffer payload)
```
    Parameters:
    
    type - the 8-bit frame type
    
    flags - the 8-bit frame flags
    
    payload - the frame payload
    
    Returns:
    
    a reference to this, so the API can be used fluently
  - writeCustomFrame
```
public HttpServerResponse writeCustomFrame(HttpFrame frame)
```
    Parameters:
    
    frame - the frame to write
    
    Returns:
    
    the instance of HttpServerResponse to chain method calls.
  - setStreamPriority
```
public HttpServerResponse setStreamPriority(io.vertx.core.http.StreamPriority streamPriority)
```
    Parameters:
    
    streamPriority - the priority for this request's stream
    
    Returns:
    
    the instance of HttpServerResponse to chain method calls.
  - addCookie
```
public HttpServerResponse addCookie(Cookie cookie)
```
    Parameters:
    
    cookie - the cookie
    
    Returns:
    
    a reference to this, so the API can be used fluently
  - removeCookie
```
public Cookie removeCookie(String name)
```
    Parameters:
    
    name - the name of the cookie
    
    Returns:
    
    the cookie, if it existed, or null
  - removeCookie
```
public Cookie removeCookie(String name,
                           boolean invalidate)
```
    Parameters:
    
    name - the name of the cookie
    
    invalidate -
    
    Returns:
    
    the cookie, if it existed, or null
  - removeCookies
```
public Set<Cookie> removeCookies(String name)
```
    Parameters:
    
    name - the name of the cookie
    
    Returns:
    
    a read only set of affected cookies, if they existed, or an empty set.
  - removeCookies
```
public Set<Cookie> removeCookies(String name,
                                 boolean invalidate)
```
    Parameters:
    
    name - the name of the cookie
    
    invalidate - invalidate from the user agent
    
    Returns:
    
    a read only set of affected cookies, if they existed, or an empty set.
  - removeCookie
```
public Cookie removeCookie(String name,
                           String domain,
                           String path)
```
    Parameters:
    
    name - the name of the cookie
    
    domain - the domain of the cookie
    
    path - the path of the cookie
    
    Returns:
    
    the cookie, if it existed, or null
  - removeCookie
```
public Cookie removeCookie(String name,
                           String domain,
                           String path,
                           boolean invalidate)
```
    Parameters:
    
    name - the name of the cookie
    
    domain - the domain of the cookie
    
    path - the path of the cookie
    
    invalidate -
    
    Returns:
    
    the cookie, if it existed, or null
  - putHeader
```
public HttpServerResponse putHeader(CharSequence name,
                                    CharSequence value)
```
    Parameters:
    
    name -
    
    value -
    
    Returns:
    
    the instance of HttpServerResponse to chain method calls.
  - putHeader
```
public HttpServerResponse putHeader(String name,
                                    Iterable<String> values)
```
    Parameters:
    
    name -
    
    values -
    
    Returns:
    
    the instance of HttpServerResponse to chain method calls.
  - putHeader
```
public HttpServerResponse putHeader(CharSequence name,
                                    Iterable<CharSequence> values)
```
    Parameters:
    
    name -
    
    values -
    
    Returns:
    
    the instance of HttpServerResponse to chain method calls.
  - putTrailer
```
public HttpServerResponse putTrailer(CharSequence name,
                                     CharSequence value)
```
    Parameters:
    
    name -
    
    value -
    
    Returns:
    
    the instance of HttpServerResponse to chain method calls.
  - putTrailer
```
public HttpServerResponse putTrailer(String name,
                                     Iterable<String> values)
```
    Parameters:
    
    name -
    
    values -
    
    Returns:
    
    the instance of HttpServerResponse to chain method calls.
  - putTrailer
```
public HttpServerResponse putTrailer(CharSequence name,
                                     Iterable<CharSequence> value)
```
    Parameters:
    
    name -
    
    value -
    
    Returns:
    
    the instance of HttpServerResponse to chain method calls.
  - newInstance
```
public static HttpServerResponse newInstance(io.vertx.core.http.HttpServerResponse arg)
```

Constructor	Description
`HttpServerResponse(io.vertx.core.http.HttpServerResponse delegate)`
`HttpServerResponse(Object delegate)`

Class HttpServerResponse

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

__TYPE_ARG

Constructor Detail

HttpServerResponse

HttpServerResponse

Method Detail

getDelegate

toString

equals

hashCode

toSubscriber

write

writeAndAwait

writeAndForget

end

endAndAwait

endAndForget

writeQueueFull

exceptionHandler

setWriteQueueMaxSize

drainHandler

getStatusCode

setStatusCode

getStatusMessage

setStatusMessage

setChunked

isChunked

headers

putHeader

trailers

putTrailer

closeHandler

endHandler

write

writeAndAwait

writeAndForget

write

writeAndAwait

writeAndForget

writeContinue

writeEarlyHints

writeEarlyHintsAndAwait

writeEarlyHintsAndForget

end

endAndAwait

endAndForget

end

endAndAwait

endAndForget

end

endAndAwait

endAndForget

send

sendAndAwait

sendAndForget

send

sendAndAwait

sendAndForget

send

sendAndAwait

sendAndForget

send

sendAndAwait

sendAndForget

send

sendAndAwait

sendAndForget

sendFile

sendFileAndAwait

sendFileAndForget

sendFile

sendFileAndAwait

sendFileAndForget

sendFile

sendFileAndAwait