Class List Method List File List

# Class: Vertx::HttpServerResponse

Inherits:
  Object
  - Object
  - Vertx::HttpServerResponse
  show all
Includes:
  WriteStream
Defined in:
  /Users/julien/java/vertx-stack/stack-docs/target/rb/vertx/http_server_response.rb

## Overview

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 Pump to pump data with flow control.

## Instance Method Summary (collapse)

- - (self) body_end_handler { ... }
  Provide a handler that will be called just before the last part of the body is written to the wire and the response is ended.
- - (Fixnum) bytes_written
  @return the total number of bytes written for the body of the response.
- - (true, false) chunked?
  @return is the response chunked?.
- - (void) close
  Close the underlying TCP connection corresponding to the request.
- - (self) close_handler { ... }
  Set a close handler for the response.
- - (true, false) closed?
  @return has the underlying TCP connection corresponding to the request already been closed?.
- - (self) drain_handler { ... }
- - (void) end(param_1 = nil, param_2 = nil)
  Same as #end but writes a String with the specified encoding before ending the response.
- - (true, false) ended?
  @return has the response already ended?.
- - (self) exception_handler { ... }
- - (Fixnum) get_status_code
  @return the HTTP status code of the response.
- - (String) get_status_message
  @return the HTTP status message of the response.
- - (true, false) head_written?
  @return have the headers for the response already been written?.
- - (::Vertx::MultiMap) headers
  @return The HTTP headers.
- - (self) headers_end_handler { ... }
  Provide a handler that will be called just before the headers are written to the wire.
- - (self) push(param_1 = nil, param_2 = nil, param_3 = nil, param_4 = nil)
  Push a response to the client.
- - (self) put_header(name = nil, value = nil)
  Put an HTTP header.
- - (self) put_trailer(name = nil, value = nil)
  Put an HTTP trailer.
- - (void) reset(code = nil)
  Reset this HTTP/2 stream with the error code.
- - (self) send_file(filename = nil, offset = nil, length = nil) { ... }
  Like #send_file but providing a handler which will be notified once the file has been completely written to the wire.
- - (self) set_chunked(chunked = nil)
  If chunked is true, this response will use HTTP chunked encoding, and each call to write to the body will correspond to a new HTTP chunk sent on the wire.
- - (self) set_status_code(statusCode = nil)
  Set the status code.
- - (self) set_status_message(statusMessage = nil)
  Set the status message.
- - (self) set_write_queue_max_size(maxSize = nil)
- - (Fixnum) stream_id
  @return the id of the stream of this response, for HTTP/1.x.
- - (::Vertx::MultiMap) trailers
  @return The HTTP trailers.
- - (self) write(param_1 = nil, param_2 = nil)
  Write a String to the response body, encoded using the encoding enc.
- - (self) write_continue
  Used to write an interim 100 Continue response to signify that the client should send the rest of the request.
- - (self) write_custom_frame(param_1 = nil, param_2 = nil, param_3 = nil)
  Write an HTTP/2 frame to the response, allowing to extend the HTTP/2 protocol.
- - (true, false) write_queue_full?
  This will return true if there are more bytes in the write queue than the value set using #set_write_queue_max_size.

## Instance Method Details

### - (`self`) body_end_handler { ... }

Provide a handler that will be called just before the last part of the body is written to the wire and the response is ended.

This provides a hook allowing you to do any more operations before this occurs.

Yields:

- the handler

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    325
    326
    327
    328
    329
    330
    331
    # File '/Users/julien/java/vertx-stack/stack-docs/target/rb/vertx/http_server_response.rb', line 325

    def body_end_handler
      if block_given?
        @j_del.java_method(:bodyEndHandler, [Java::IoVertxCore::Handler.java_class]).call(Proc.new { yield })
        return self
      end
      raise ArgumentError, "Invalid arguments when calling body_end_handler()"
    end

### - (`Fixnum`) bytes_written

@return the total number of bytes written for the body of the response.

Returns:

- (`Fixnum`)

Raises:

- (`ArgumentError`)

    334
    335
    336
    337
    338
    339
    # File '/Users/julien/java/vertx-stack/stack-docs/target/rb/vertx/http_server_response.rb', line 334

    def bytes_written
      if !block_given?
        return @j_del.java_method(:bytesWritten, []).call()
      end
      raise ArgumentError, "Invalid arguments when calling bytes_written()"
    end

### - (`true`, `false`) chunked?

@return is the response chunked?

Returns:

- (`true`, `false`)

Raises:

- (`ArgumentError`)

    155
    156
    157
    158
    159
    160
    # File '/Users/julien/java/vertx-stack/stack-docs/target/rb/vertx/http_server_response.rb', line 155

    def chunked?
      if !block_given?
        return @j_del.java_method(:isChunked, []).call()
      end
      raise ArgumentError, "Invalid arguments when calling chunked?()"
    end

### - (`void`) close

This method returns an undefined value.

Close the underlying TCP connection corresponding to the request.

Raises:

- (`ArgumentError`)

    279
    280
    281
    282
    283
    284
    # File '/Users/julien/java/vertx-stack/stack-docs/target/rb/vertx/http_server_response.rb', line 279

    def close
      if !block_given?
        return @j_del.java_method(:close, []).call()
      end
      raise ArgumentError, "Invalid arguments when calling close()"
    end

### - (`self`) close_handler { ... }

Set a close handler for the response. This will be called if the underlying connection closes before the response is complete.

Yields:

- the handler

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    209
    210
    211
    212
    213
    214
    215
    # File '/Users/julien/java/vertx-stack/stack-docs/target/rb/vertx/http_server_response.rb', line 209

    def close_handler
      if block_given?
        @j_del.java_method(:closeHandler, [Java::IoVertxCore::Handler.java_class]).call(Proc.new { yield })
        return self
      end
      raise ArgumentError, "Invalid arguments when calling close_handler()"
    end

### - (`true`, `false`) closed?

@return has the underlying TCP connection corresponding to the request already been closed?

Returns:

- (`true`, `false`)

Raises:

- (`ArgumentError`)

    295
    296
    297
    298
    299
    300
    # File '/Users/julien/java/vertx-stack/stack-docs/target/rb/vertx/http_server_response.rb', line 295

    def closed?
      if !block_given?
        return @j_del.java_method(:closed, []).call()
      end
      raise ArgumentError, "Invalid arguments when calling closed?()"
    end

### - (`self`) drain_handler { ... }

Yields:

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    88
    89
    90
    91
    92
    93
    94
    # File '/Users/julien/java/vertx-stack/stack-docs/target/rb/vertx/http_server_response.rb', line 88

    def drain_handler
      if block_given?
        @j_del.java_method(:drainHandler, [Java::IoVertxCore::Handler.java_class]).call(Proc.new { yield })
        return self
      end
      raise ArgumentError, "Invalid arguments when calling drain_handler()"
    end

### - (`void`) end - (`void`) end(chunk) - (`void`) end(chunk) - (`void`) end(chunk, enc)

This method returns an undefined value.

Same as #end but writes a String with the specified encoding before ending the response.

Overloads:

- - (`void`) end(chunk)

  Parameters:

  - chunk (`String`) —
    the string to write before ending the response
- - (`void`) end(chunk)

  Parameters:

  - chunk (`::Vertx::Buffer`) —
    the buffer to write before ending the response
- - (`void`) end(chunk, enc)

  Parameters:

  - chunk (`String`) —
    the string to write before ending the response
  - enc (`String`) —
    the encoding to use

Raises:

- (`ArgumentError`)

    236
    237
    238
    239
    240
    241
    242
    243
    244
    245
    246
    247
    # File '/Users/julien/java/vertx-stack/stack-docs/target/rb/vertx/http_server_response.rb', line 236

    def end(param_1=nil,param_2=nil)
      if !block_given? && param_1 == nil && param_2 == nil
        return @j_del.java_method(:end, []).call()
      elsif param_1.class == String && !block_given? && param_2 == nil
        return @j_del.java_method(:end, [Java::java.lang.String.java_class]).call(param_1)
      elsif param_1.class.method_defined?(:j_del) && !block_given? && param_2 == nil
        return @j_del.java_method(:end, [Java::IoVertxCoreBuffer::Buffer.java_class]).call(param_1.j_del)
      elsif param_1.class == String && param_2.class == String && !block_given?
        return @j_del.java_method(:end, [Java::java.lang.String.java_class,Java::java.lang.String.java_class]).call(param_1,param_2)
      end
      raise ArgumentError, "Invalid arguments when calling end(param_1,param_2)"
    end

### - (`true`, `false`) ended?

@return has the response already ended?

Returns:

- (`true`, `false`)

Raises:

- (`ArgumentError`)

    287
    288
    289
    290
    291
    292
    # File '/Users/julien/java/vertx-stack/stack-docs/target/rb/vertx/http_server_response.rb', line 287

    def ended?
      if !block_given?
        return @j_del.java_method(:ended, []).call()
      end
      raise ArgumentError, "Invalid arguments when calling ended?()"
    end

### - (`self`) exception_handler { ... }

Yields:

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    48
    49
    50
    51
    52
    53
    54
    # File '/Users/julien/java/vertx-stack/stack-docs/target/rb/vertx/http_server_response.rb', line 48

    def exception_handler
      if block_given?
        @j_del.java_method(:exceptionHandler, [Java::IoVertxCore::Handler.java_class]).call((Proc.new { |event| yield(::Vertx::Util::Utils.from_throwable(event)) }))
        return self
      end
      raise ArgumentError, "Invalid arguments when calling exception_handler()"
    end

### - (`Fixnum`) get_status_code

@return the HTTP status code of the response. The default is `200` representing `OK`.

Returns:

- (`Fixnum`)

Raises:

- (`ArgumentError`)

    97
    98
    99
    100
    101
    102
    # File '/Users/julien/java/vertx-stack/stack-docs/target/rb/vertx/http_server_response.rb', line 97

    def get_status_code
      if !block_given?
        return @j_del.java_method(:getStatusCode, []).call()
      end
      raise ArgumentError, "Invalid arguments when calling get_status_code()"
    end

### - (`String`) get_status_message

@return the HTTP status message of the response. If this is not specified a default value will be used depending on what #set_status_code has been set to.

Returns:

- (`String`)

Raises:

- (`ArgumentError`)

    117
    118
    119
    120
    121
    122
    # File '/Users/julien/java/vertx-stack/stack-docs/target/rb/vertx/http_server_response.rb', line 117

    def get_status_message
      if !block_given?
        return @j_del.java_method(:getStatusMessage, []).call()
      end
      raise ArgumentError, "Invalid arguments when calling get_status_message()"
    end

### - (`true`, `false`) head_written?

@return have the headers for the response already been written?

Returns:

- (`true`, `false`)

Raises:

- (`ArgumentError`)

    303
    304
    305
    306
    307
    308
    # File '/Users/julien/java/vertx-stack/stack-docs/target/rb/vertx/http_server_response.rb', line 303

    def head_written?
      if !block_given?
        return @j_del.java_method(:headWritten, []).call()
      end
      raise ArgumentError, "Invalid arguments when calling head_written?()"
    end

### - (`::Vertx::MultiMap`) headers

@return The HTTP headers

Returns:

- (`::Vertx::MultiMap`)

Raises:

- (`ArgumentError`)

    163
    164
    165
    166
    167
    168
    169
    170
    171
    # File '/Users/julien/java/vertx-stack/stack-docs/target/rb/vertx/http_server_response.rb', line 163

    def headers
      if !block_given?
        if @cached_headers != nil
          return @cached_headers
        end
        return @cached_headers = ::Vertx::Util::Utils.safe_create(@j_del.java_method(:headers, []).call(),::Vertx::MultiMap)
      end
      raise ArgumentError, "Invalid arguments when calling headers()"
    end

### - (`self`) headers_end_handler { ... }

Provide a handler that will be called just before the headers are written to the wire.

This provides a hook allowing you to add any more headers or do any more operations before this occurs.

Yields:

- the handler

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    313
    314
    315
    316
    317
    318
    319
    # File '/Users/julien/java/vertx-stack/stack-docs/target/rb/vertx/http_server_response.rb', line 313

    def headers_end_handler
      if block_given?
        @j_del.java_method(:headersEndHandler, [Java::IoVertxCore::Handler.java_class]).call(Proc.new { yield })
        return self
      end
      raise ArgumentError, "Invalid arguments when calling headers_end_handler()"
    end

### - (`self`) push(method, path, handler) { ... } - (`self`) push(method, host, path, handler) { ... } - (`self`) push(method, path, headers, handler) { ... } - (`self`) push(method, host, path, headers, handler) { ... }

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.

Overloads:

- - (`self`) push(method, path, handler) { ... }

  Parameters:

  - method (`:OPTIONS`, `:GET`, `:HEAD`, `:POST`, `:PUT`, `:DELETE`, `:TRACE`, `:CONNECT`, `:PATCH`, `:OTHER`)
  - path (`String`)

  Yields:

- - (`self`) push(method, host, path, handler) { ... }

  Parameters:

  - method (`:OPTIONS`, `:GET`, `:HEAD`, `:POST`, `:PUT`, `:DELETE`, `:TRACE`, `:CONNECT`, `:PATCH`, `:OTHER`)
  - host (`String`)
  - path (`String`)

  Yields:

- - (`self`) push(method, path, headers, handler) { ... }

  Parameters:

  - method (`:OPTIONS`, `:GET`, `:HEAD`, `:POST`, `:PUT`, `:DELETE`, `:TRACE`, `:CONNECT`, `:PATCH`, `:OTHER`)
  - path (`String`)
  - headers (`::Vertx::MultiMap`)

  Yields:

- - (`self`) push(method, host, path, headers, handler) { ... }

  Parameters:

  - method (`:OPTIONS`, `:GET`, `:HEAD`, `:POST`, `:PUT`, `:DELETE`, `:TRACE`, `:CONNECT`, `:PATCH`, `:OTHER`) —
    the method of the promised request
  - host (`String`) —
    the host of the promised request
  - path (`String`) —
    the path of the promised request
  - headers (`::Vertx::MultiMap`) —
    the headers of the promised request

  Yields:

  - the handler notified when the response can be written

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    378
    379
    380
    381
    382
    383
    384
    385
    386
    387
    388
    389
    390
    391
    # File '/Users/julien/java/vertx-stack/stack-docs/target/rb/vertx/http_server_response.rb', line 378

    def push(param_1=nil,param_2=nil,param_3=nil,param_4=nil)
      if param_1.class == Symbol && param_2.class == String && block_given? && param_3 == nil && param_4 == nil
        @j_del.java_method(:push, [Java::IoVertxCoreHttp::HttpMethod.java_class,Java::java.lang.String.java_class,Java::IoVertxCore::Handler.java_class]).call(Java::IoVertxCoreHttp::HttpMethod.valueOf(param_1),param_2,(Proc.new { |ar| yield(ar.failed ? ar.cause : nil, ar.succeeded ? ::Vertx::Util::Utils.safe_create(ar.result,::Vertx::HttpServerResponse) : nil) }))
        return self
      elsif param_1.class == Symbol && param_2.class == String && param_3.class == String && block_given? && param_4 == nil
        return ::Vertx::Util::Utils.safe_create(@j_del.java_method(:push, [Java::IoVertxCoreHttp::HttpMethod.java_class,Java::java.lang.String.java_class,Java::java.lang.String.java_class,Java::IoVertxCore::Handler.java_class]).call(Java::IoVertxCoreHttp::HttpMethod.valueOf(param_1),param_2,param_3,(Proc.new { |ar| yield(ar.failed ? ar.cause : nil, ar.succeeded ? ::Vertx::Util::Utils.safe_create(ar.result,::Vertx::HttpServerResponse) : nil) })),::Vertx::HttpServerResponse)
      elsif param_1.class == Symbol && param_2.class == String && param_3.class.method_defined?(:j_del) && block_given? && param_4 == nil
        return ::Vertx::Util::Utils.safe_create(@j_del.java_method(:push, [Java::IoVertxCoreHttp::HttpMethod.java_class,Java::java.lang.String.java_class,Java::IoVertxCore::MultiMap.java_class,Java::IoVertxCore::Handler.java_class]).call(Java::IoVertxCoreHttp::HttpMethod.valueOf(param_1),param_2,param_3.j_del,(Proc.new { |ar| yield(ar.failed ? ar.cause : nil, ar.succeeded ? ::Vertx::Util::Utils.safe_create(ar.result,::Vertx::HttpServerResponse) : nil) })),::Vertx::HttpServerResponse)
      elsif param_1.class == Symbol && param_2.class == String && param_3.class == String && param_4.class.method_defined?(:j_del) && block_given?
        @j_del.java_method(:push, [Java::IoVertxCoreHttp::HttpMethod.java_class,Java::java.lang.String.java_class,Java::java.lang.String.java_class,Java::IoVertxCore::MultiMap.java_class,Java::IoVertxCore::Handler.java_class]).call(Java::IoVertxCoreHttp::HttpMethod.valueOf(param_1),param_2,param_3,param_4.j_del,(Proc.new { |ar| yield(ar.failed ? ar.cause : nil, ar.succeeded ? ::Vertx::Util::Utils.safe_create(ar.result,::Vertx::HttpServerResponse) : nil) }))
        return self
      end
      raise ArgumentError, "Invalid arguments when calling push(param_1,param_2,param_3,param_4)"
    end

### - (`self`) put_header(name = nil, value = nil)

Put an HTTP header

Parameters:

- name (`String`) (defaults to: `nil`) —
  the header name
- value (`String`) (defaults to: `nil`) —
  the header value.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    176
    177
    178
    179
    180
    181
    182
    # File '/Users/julien/java/vertx-stack/stack-docs/target/rb/vertx/http_server_response.rb', line 176

    def put_header(name=nil,value=nil)
      if name.class == String && value.class == String && !block_given?
        @j_del.java_method(:putHeader, [Java::java.lang.String.java_class,Java::java.lang.String.java_class]).call(name,value)
        return self
      end
      raise ArgumentError, "Invalid arguments when calling put_header(name,value)"
    end

### - (`self`) put_trailer(name = nil, value = nil)

Put an HTTP trailer

Parameters:

- name (`String`) (defaults to: `nil`) —
  the trailer name
- value (`String`) (defaults to: `nil`) —
  the trailer value

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    198
    199
    200
    201
    202
    203
    204
    # File '/Users/julien/java/vertx-stack/stack-docs/target/rb/vertx/http_server_response.rb', line 198

    def put_trailer(name=nil,value=nil)
      if name.class == String && value.class == String && !block_given?
        @j_del.java_method(:putTrailer, [Java::java.lang.String.java_class,Java::java.lang.String.java_class]).call(name,value)
        return self
      end
      raise ArgumentError, "Invalid arguments when calling put_trailer(name,value)"
    end

### - (`void`) reset(code = nil)

This method returns an undefined value.

Reset this HTTP/2 stream with the error `code`.

Parameters:

- code (`Fixnum`) (defaults to: `nil`) —
  the error code

Raises:

- (`ArgumentError`)

    395
    396
    397
    398
    399
    400
    401
    402
    # File '/Users/julien/java/vertx-stack/stack-docs/target/rb/vertx/http_server_response.rb', line 395

    def reset(code=nil)
      if !block_given? && code == nil
        return @j_del.java_method(:reset, []).call()
      elsif code.class == Fixnum && !block_given?
        return @j_del.java_method(:reset, [Java::long.java_class]).call(code)
      end
      raise ArgumentError, "Invalid arguments when calling reset(code)"
    end

### - (`self`) send_file(filename = nil, offset = nil, length = nil) { ... }

Like #send_file but providing a handler which will be notified once the file has been completely written to the wire.

Parameters:

- filename (`String`) (defaults to: `nil`) —
  path to the file to serve
- offset (`Fixnum`) (defaults to: `nil`) —
  the offset to serve from
- length (`Fixnum`) (defaults to: `nil`) —
  the length to serve to

Yields:

- handler that will be called on completion

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    255
    256
    257
    258
    259
    260
    261
    262
    263
    264
    265
    266
    267
    268
    269
    270
    271
    272
    273
    274
    275
    276
    # File '/Users/julien/java/vertx-stack/stack-docs/target/rb/vertx/http_server_response.rb', line 255

    def send_file(filename=nil,offset=nil,length=nil)
      if filename.class == String && !block_given? && offset == nil && length == nil
        @j_del.java_method(:sendFile, [Java::java.lang.String.java_class]).call(filename)
        return self
      elsif filename.class == String && offset.class == Fixnum && !block_given? && length == nil
        @j_del.java_method(:sendFile, [Java::java.lang.String.java_class,Java::long.java_class]).call(filename,offset)
        return self
      elsif filename.class == String && block_given? && offset == nil && length == nil
        @j_del.java_method(:sendFile, [Java::java.lang.String.java_class,Java::IoVertxCore::Handler.java_class]).call(filename,(Proc.new { |ar| yield(ar.failed ? ar.cause : nil) }))
        return self
      elsif filename.class == String && offset.class == Fixnum && length.class == Fixnum && !block_given?
        @j_del.java_method(:sendFile, [Java::java.lang.String.java_class,Java::long.java_class,Java::long.java_class]).call(filename,offset,length)
        return self
      elsif filename.class == String && offset.class == Fixnum && block_given? && length == nil
        @j_del.java_method(:sendFile, [Java::java.lang.String.java_class,Java::long.java_class,Java::IoVertxCore::Handler.java_class]).call(filename,offset,(Proc.new { |ar| yield(ar.failed ? ar.cause : nil) }))
        return self
      elsif filename.class == String && offset.class == Fixnum && length.class == Fixnum && block_given?
        @j_del.java_method(:sendFile, [Java::java.lang.String.java_class,Java::long.java_class,Java::long.java_class,Java::IoVertxCore::Handler.java_class]).call(filename,offset,length,(Proc.new { |ar| yield(ar.failed ? ar.cause : nil) }))
        return self
      end
      raise ArgumentError, "Invalid arguments when calling send_file(filename,offset,length)"
    end

### - (`self`) set_chunked(chunked = nil)

If `chunked` is `true`, this response will use HTTP chunked encoding, and each call to write to the body will correspond to a new HTTP chunk sent on the wire.

If chunked encoding is used the HTTP header `Transfer-Encoding` with a value of `Chunked` will be automatically inserted in the response.

If `chunked` is `false`, this response will not use HTTP chunked encoding, and therefore the total size of any data that is written in the respone body must be set in the `Content-Length` header before any data is written out.

An HTTP chunked response is typically used when you do not know the total size of the request body up front.

Parameters:

- chunked (`true`, `false`) (defaults to: `nil`)

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    146
    147
    148
    149
    150
    151
    152
    # File '/Users/julien/java/vertx-stack/stack-docs/target/rb/vertx/http_server_response.rb', line 146

    def set_chunked(chunked=nil)
      if (chunked.class == TrueClass || chunked.class == FalseClass) && !block_given?
        @j_del.java_method(:setChunked, [Java::boolean.java_class]).call(chunked)
        return self
      end
      raise ArgumentError, "Invalid arguments when calling set_chunked(chunked)"
    end

### - (`self`) set_status_code(statusCode = nil)

Set the status code. If the status message hasn't been explicitly set, a default status message corresponding to the code will be looked-up and used.

Parameters:

- statusCode (`Fixnum`) (defaults to: `nil`)

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    107
    108
    109
    110
    111
    112
    113
    # File '/Users/julien/java/vertx-stack/stack-docs/target/rb/vertx/http_server_response.rb', line 107

    def set_status_code(statusCode=nil)
      if statusCode.class == Fixnum && !block_given?
        @j_del.java_method(:setStatusCode, [Java::int.java_class]).call(statusCode)
        return self
      end
      raise ArgumentError, "Invalid arguments when calling set_status_code(statusCode)"
    end

### - (`self`) set_status_message(statusMessage = nil)

Set the status message

Parameters:

- statusMessage (`String`) (defaults to: `nil`)

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    126
    127
    128
    129
    130
    131
    132
    # File '/Users/julien/java/vertx-stack/stack-docs/target/rb/vertx/http_server_response.rb', line 126

    def set_status_message(statusMessage=nil)
      if statusMessage.class == String && !block_given?
        @j_del.java_method(:setStatusMessage, [Java::java.lang.String.java_class]).call(statusMessage)
        return self
      end
      raise ArgumentError, "Invalid arguments when calling set_status_message(statusMessage)"
    end

### - (`self`) set_write_queue_max_size(maxSize = nil)

Parameters:

- maxSize (`Fixnum`) (defaults to: `nil`)

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    79
    80
    81
    82
    83
    84
    85
    # File '/Users/julien/java/vertx-stack/stack-docs/target/rb/vertx/http_server_response.rb', line 79

    def set_write_queue_max_size(maxSize=nil)
      if maxSize.class == Fixnum && !block_given?
        @j_del.java_method(:setWriteQueueMaxSize, [Java::int.java_class]).call(maxSize)
        return self
      end
      raise ArgumentError, "Invalid arguments when calling set_write_queue_max_size(maxSize)"
    end

### - (`Fixnum`) stream_id

@return the id of the stream of this response, for HTTP/1.x

Returns:

- (`Fixnum`)

Raises:

- (`ArgumentError`)

    342
    343
    344
    345
    346
    347
    # File '/Users/julien/java/vertx-stack/stack-docs/target/rb/vertx/http_server_response.rb', line 342

    def stream_id
      if !block_given?
        return @j_del.java_method(:streamId, []).call()
      end
      raise ArgumentError, "Invalid arguments when calling stream_id()"
    end

### - (`::Vertx::MultiMap`) trailers

@return The HTTP trailers

Returns:

- (`::Vertx::MultiMap`)

Raises:

- (`ArgumentError`)

    185
    186
    187
    188
    189
    190
    191
    192
    193
    # File '/Users/julien/java/vertx-stack/stack-docs/target/rb/vertx/http_server_response.rb', line 185

    def trailers
      if !block_given?
        if @cached_trailers != nil
          return @cached_trailers
        end
        return @cached_trailers = ::Vertx::Util::Utils.safe_create(@j_del.java_method(:trailers, []).call(),::Vertx::MultiMap)
      end
      raise ArgumentError, "Invalid arguments when calling trailers()"
    end

### - (`self`) write(data) - (`self`) write(chunk) - (`self`) write(chunk, enc)

Write a String to the response body, encoded using the encoding `enc`.

Overloads:

- - (`self`) write(data)

  Parameters:

  - data (`::Vertx::Buffer`)
- - (`self`) write(chunk)

  Parameters:

  - chunk (`String`) —
    the string to write
- - (`self`) write(chunk, enc)

  Parameters:

  - chunk (`String`) —
    the string to write
  - enc (`String`) —
    the encoding to use

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    64
    65
    66
    67
    68
    69
    70
    71
    72
    73
    74
    75
    76
    # File '/Users/julien/java/vertx-stack/stack-docs/target/rb/vertx/http_server_response.rb', line 64

    def write(param_1=nil,param_2=nil)
      if param_1.class.method_defined?(:j_del) && !block_given? && param_2 == nil
        @j_del.java_method(:write, [Java::IoVertxCoreBuffer::Buffer.java_class]).call(param_1.j_del)
        return self
      elsif param_1.class == String && !block_given? && param_2 == nil
        @j_del.java_method(:write, [Java::java.lang.String.java_class]).call(param_1)
        return self
      elsif param_1.class == String && param_2.class == String && !block_given?
        @j_del.java_method(:write, [Java::java.lang.String.java_class,Java::java.lang.String.java_class]).call(param_1,param_2)
        return self
      end
      raise ArgumentError, "Invalid arguments when calling write(param_1,param_2)"
    end

### - (`self`) write_continue

Used to write an interim 100 Continue response to signify that the client should send the rest of the request. Must only be used if the request contains an "Expect:100-Continue" header

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    219
    220
    221
    222
    223
    224
    225
    # File '/Users/julien/java/vertx-stack/stack-docs/target/rb/vertx/http_server_response.rb', line 219

    def write_continue
      if !block_given?
        @j_del.java_method(:writeContinue, []).call()
        return self
      end
      raise ArgumentError, "Invalid arguments when calling write_continue()"
    end

### - (`self`) writeCustomFrame(frame) - (`self`) writeCustomFrame(type, flags, payload)

Write an HTTP/2 frame to the response, allowing to extend the HTTP/2 protocol.

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

Overloads:

- - (`self`) writeCustomFrame(frame)

  Parameters:

  - frame (`::Vertx::HttpFrame`) —
    the frame to write
- - (`self`) writeCustomFrame(type, flags, payload)

  Parameters:

  - type (`Fixnum`) —
    the 8-bit frame type
  - flags (`Fixnum`) —
    the 8-bit frame flags
  - payload (`::Vertx::Buffer`) —
    the frame payload

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    413
    414
    415
    416
    417
    418
    419
    420
    421
    422
    # File '/Users/julien/java/vertx-stack/stack-docs/target/rb/vertx/http_server_response.rb', line 413

    def write_custom_frame(param_1=nil,param_2=nil,param_3=nil)
      if param_1.class.method_defined?(:j_del) && !block_given? && param_2 == nil && param_3 == nil
        @j_del.java_method(:writeCustomFrame, [Java::IoVertxCoreHttp::HttpFrame.java_class]).call(param_1.j_del)
        return self
      elsif param_1.class == Fixnum && param_2.class == Fixnum && param_3.class.method_defined?(:j_del) && !block_given?
        @j_del.java_method(:writeCustomFrame, [Java::int.java_class,Java::int.java_class,Java::IoVertxCoreBuffer::Buffer.java_class]).call(param_1,param_2,param_3.j_del)
        return self
      end
      raise ArgumentError, "Invalid arguments when calling write_custom_frame(param_1,param_2,param_3)"
    end

### - (`true`, `false`) write_queue_full?

This will return `true` if there are more bytes in the write queue than the value set using #set_write_queue_max_size

Returns:

- (`true`, `false`) —
  true if write queue is full

Raises:

- (`ArgumentError`)

    40
    41
    42
    43
    44
    45
    # File '/Users/julien/java/vertx-stack/stack-docs/target/rb/vertx/http_server_response.rb', line 40

    def write_queue_full?
      if !block_given?
        return @j_del.java_method(:writeQueueFull, []).call()
      end
      raise ArgumentError, "Invalid arguments when calling write_queue_full?()"
    end