Exit Zen
23
string ID 110
type: table cell
English
When present, this field informs the recipient about the exact size in bytes of the body which follows the message header.
122/1220 · 122
23
string ID 236
type: paragraph
English
The function [@boost:/doc/html/boost_asio/reference/bind_allocator.html `net::bind_allocator`] can be used when the caller wants to assign a custom allocator to the operation.
175/1750 · 175
23
string ID 99
type: paragraph
English
Requests and responses share the version, fields, and body but have a few members unique to the type. This is implemented by declaring the header classes as partial specializations of `isRequest`. __message__ is derived from __header__; a message may be passed as an argument to a function taking a suitably typed header as a parameter. Additionally, `header` is publicly derived from `Fields`; a message inherits all the member functions of `Fields`. This diagram shows the inheritance relationship between header and message, along with some of the notable differences in members in each partial specialization:
613/6130 · 613
23
string ID 71
type: table cell
English
Read everything into a parser from a __SyncReadStream__.
56/560 · 56
23
string ID 51
type: table cell
English
Returns the size, in bytes, of the input sequence.
50/500 · 50
23
string ID 105
type: list
English
* [link beast.ref.boost__beast__http__basic_dynamic_body `basic_dynamic_body`]
* [link beast.ref.boost__beast__http__basic_file_body `basic_file_body`]
* [link beast.ref.boost__beast__http__basic_string_body `basic_string_body`]
* [link beast.ref.boost__beast__http__buffer_body `buffer_body`]
* [link beast.ref.boost__beast__http__empty_body `empty_body`]
* [link beast.ref.boost__beast__http__span_body `span_body`]
* [link beast.ref.boost__beast__http__vector_body `vector_body`]
482/4820 · 482
23
string ID 34
type: table cell
English
If `f` refers to an open file, this function attempts to close the file. Regardless of whether an error occurs or not, a subsequent call to `f.is_open()` will return `false`. The function will ensure that `!ec` is `true` if there was no error or set to the appropriate error code if an error occurred.
301/3010 · 301
23
string ID 143
type: paragraph
English
is a library resulting from the 2014 Google Summer of Code. It was submitted for a Boost formal review and rejected in 2015. It is based on Boost.Asio, and development on the library has continued to the present. As of the branch previously linked, it uses these message declarations: ``` template<class Headers, class Body> struct basic_message {
347/3470 · 347
23
string ID 39
type: table cell
English
Called once after construction, this function returns a constant buffer sequence containing the serialized representation of the HTTP request or response including the final carriage return linefeed sequence (`"\r\n"`).

Copies may be made of the returned sequence, but the underlying memory is still owned by the writer. The implementation will destroy all copies of the buffer sequence before destroying `a`.
410/4100 · 410
23
string ID 50
type: table cell
English
Called one or more times after `init` succeeds. This function returns `boost::none` if all buffers representing the body have been returned in previous calls or if it sets `ec` to indicate an error. Otherwise, if there are buffers remaining the function should return a pair with the first element containing a non-zero length buffer sequence representing the next set of octets in the body, while the second element is a `bool` meaning `true` if there may be additional buffers returned on a subsequent call, or `false` if the buffer returned on this call is the last buffer representing the body. The function will ensure that `!ec` is `true` if there was no error or set to the appropriate error code if there was one.
721/7210 · 721
23
string ID 71
type: table cell
English
[link beast.ref.boost__beast__websocket__stream.read_some.overload2 `read_some`], [link beast.ref.boost__beast__websocket__stream.async_read_some.overload1 `async_read_some`]
174/1740 · 174
23
string ID 21
type: table cell
English
This function converts a buffer sequence to a `std::string`. It can be used for diagnostic purposes and tests.
110/1100 · 110
23
string ID 134
type: paragraph
English
When implementing an HTTP server that also supports WebSocket, the server usually reads the HTTP request from the client. To detect when the incoming HTTP request is a WebSocket Upgrade request, the function [link beast.ref.boost__beast__websocket__is_upgrade `is_upgrade`] may be used.
286/2860 · 286
23
string ID 36
type: table cell
English
The implementation calls this function to inform the policy that `n` bytes were successfully transferred in the most recent read operation. The policy object may optionally use this information to calculate throughputs and/or inform the algorithm used to determine subsequently queried transfer maximums.
304/3040 · 304
23
string ID 122
type: paragraph
English
Our implementation of __BodyWriter__ will contain a small buffer from which the file contents are read. The buffer is provided to the implementation on each call until everything has been read in.
196/1960 · 196
23
string ID 45
type: table cell
English
This function is called to signal that the consumer (caller) of the generator has processed part of the data returned by the previous call to `prepare`.

The value of `n` indicates how much of the data processed (in bytes).

When `n` exceeds the number of bytes returned from the last call to `prepare`, `consume` shall behave as if `n` was equal to that number.

Remaining unconsumed data will be returned from subsequent calls to `prepare`.

[*Note:] Any buffers obtained by previous calls to `prepare` are invalidated.
521/5210 · 521
23
string ID 16
type: variablelist cell
English
"There should also be more examples of how to integrate the http service with getting files from the file system, generating responses CGI-style"
145/1450 · 145
23
string ID 73
type: table cell
English
[link beast.ref.boost__beast__http__async_write.overload1 [*async_write]]
73/730 · 73
23
string ID 157
type: paragraph
English
It is important to note that all of the examples thus far which perform reads and writes with a timeout, make use of the existing networking stream algorithms. As these algorithms are written generically to work with any object meeting the stream requirements, they transparently support timeouts when used with `tcp_stream`. This can be used to enable timeouts for stream wrappers that do not currently support timeouts.
421/4210 · 421
23
string ID 178
type: paragraph
English
Code which accesses the fields has to laboriously mention the `fields` member, so we'll not only make `header` a base class but we'll make a quality of life improvement and derive the header from the fields for notational convenience. In order to properly support all forms of construction of [*Fields] there will need to be a set of suitable constructor overloads (not shown): ``` /// An HTTP request header template<class Fields> struct header<true, Fields> : Fields {
470/4700 · 470