Exit Zen
11
string ID 42
type: list
English
* `a` denotes a value of type `R`.
* `b` is an object whose type meets the requirements of __ConstBufferSequence__
* `h` denotes a value of type `header<isRequest, Fields>&`.
* `v` denotes a value of type `Body::value_type&`.
* `n` is a value of type `boost::optional<std::uint64_t>`.
* `ec` is a value of type [link beast.ref.boost__beast__error_code `error_code&`].
367/3670 · 367
11
string ID 22
type: table cell
English
This function sets timeout and other options on the stream.
59/590 · 59
11
string ID 47
type: paragraph
English
Like a regular __Asio__ socket, a [link beast.ref.boost__beast__websocket__stream `stream`] is not thread safe. Callers are responsible for synchronizing operations on the socket using an implicit or explicit strand, as per the Asio documentation. The websocket stream asynchronous interface supports one of each of the following operations to be active at the same time:
371/3710 · 371
11
string ID 55
type: paragraph
English
We would also like our message container to have customization points permitting the following: allocator awareness, user-defined containers to represent header fields, and user-defined types and algorithms to represent the body. And finally, because requests and responses have different fields in the ['start-line], we would like the containers for requests and responses to be represented by different types for function overloading.
436/4360 · 436
11
string ID 50
type: table cell
English
The type of the next layer. An object of this type will be constructed and maintained for the lifetime of the stream. All reads and writes will go through the next layer. This type must meet the requirements of either __SyncStream__, __AsyncStream__, or both, depending on the style of I/O that is to be performed.
314/3140 · 314
11
string ID 81
type: heading
English
Close Frames
12/120 · 12
11
string ID 77
type: paragraph
English
The [@https://tools.ietf.org/html/rfc7231#section-4.3.2 HEAD request] method indicates to the server that the client wishes to receive the entire header that would be delivered if the method was GET, except that the body is omitted. When a client wishes to receive the response to a HEAD request, it is necessary to inform the parser not to expect a body. This is done by calling [link beast.ref.boost__beast__http__basic_parser.skip `basic_parser::skip`] with the value `true`, as shown in this example:
504/5040 · 504
12
string ID 47
type: table cell
English
A buffer sequence representing the CRLF (`"\r\n"`) delimiter. This class is used when the caller desires to emit the chunk body in two or more individual stream operations.
172/1720 · 172
12
string ID 25
type: table cell
English
[path_link example/http/client/async-local/http_client_async_local.cpp http_client_async_local.cpp]
99/990 · 99
12
string ID 21
type: table cell
English
__AsyncReadStream__
19/190 · 19
12
string ID 16
type: table cell
English
[link beast.ref.boost__beast__http__async_write [*async_write]]
63/630 · 63
12
string ID 75
type: table cell
English
This response has a [@https://tools.ietf.org/html/rfc7231#section-6 200 status code] meaning the operation requested completed successfully. The obsolete reason phrase is "OK". It specifies HTTP version 1.1, and contains a body 13 octets in size with the text "Hello, world!".
276/2760 · 276
12
string ID 74
type: paragraph
English
Interfaces for operating on HTTP messages are structured into several layers. The highest level provides ease of use, while lower levels provide progressively more control, options, and flexibility. At the lowest level customization points are provided, where user defined types can replace parts of the implementation. The layers are arranged thusly:
351/3510 · 351
12
string ID 51
type: paragraph
English
The container offers value semantics including move and copy if supported by __Body__ and __Fields__. User defined template function parameters can accept any message, or can use partial specialization to accept just requests or responses. The default __fields__ is a provided associative container using the standard allocator and supporting modification and inspection of fields. As per __rfc7230__, a non-case-sensitive comparison is used for field names. User defined types for fields are possible. The `Body` type determines the type of the container used to represent the body as well as the algorithms for transferring buffers to and from the container. The library comes with a collection of common body types. As with fields, user defined body types are possible.
772/7720 · 772
12
string ID 29
type: table code
English
/// An HTTP/1 parser for producing a message.
template<
bool isRequest, // `true` to parse an HTTP request
class Body, // The Body type for the resulting message
class Allocator = std::allocator<char>> // The type of allocator for the header
class parser
: public basic_parser<...>;
334/3340 · 334
12
string ID 63
type: list
English
* [issue 3002] Conditionally defined `immediate_executor_type` in `async_base`
* [issue 2999] Used `handshake_timeout` for closing handshake during read operations
* [issue 3003] Added missing `cstdint` header to `detail/cpu_info.hpp`
* [issue 3016] Fixed `std::is_trivial` deprecation warnings
* [issue 3019] Fixed `-Wmaybe-uninitialized` warnings
348/3480 · 348
12
string ID 30
type: table cell
English
`B::value_type`
15/150 · 15
12
string ID 85
type: paragraph
English
This container is the base class template used to represent HTTP messages. It uses a "tag" type style specializations for a variety of trait classes, allowing for customization of the various parts of the message. For example, a user specializes `headers_container<T>` to determine what container type holds the header fields. We note some problems with the container declaration:
380/3800 · 380
12
string ID 36
type: table cell
English
`F::writer`
11/110 · 11
12
string ID 30
type: table cell
English
[link beast.ref.boost__beast__http__basic_parser.skip.overload2 `skip`]
71/710 · 71