Exit Zen
15
string ID 21
type: table cell
English
Supports buffer-oriented asynchronous writes.
45/450 · 45
103
string ID 103
type: heading
English
Special Fields
14/140 · 14
15
string ID 162
type: paragraph
English
A ['synchronous stream algorithm] is written as a function template accepting a stream object meeting the named requirements for synchronous reading, writing, or both. This example shows an algorithm which writes text and uses exceptions to indicate errors:
257/2570 · 257
15
string ID 80
type: table cell
English
At the highest level, these free functions send or receive a complete HTTP message in one call. They are designed for ease of use: [link beast.ref.boost__beast__http__read.overload4 `read`], [link beast.ref.boost__beast__http__write.overload4 `write`], [link beast.ref.boost__beast__http__async_read.overload2 `async_read`], and [link beast.ref.boost__beast__http__async_write.overload2 `async_write`].
402/4020 · 402
15
string ID 29
type: table cell
English
[link beast.ref.boost__beast__http__response_parser `response_parser`]
70/700 · 70
15
string ID 30
type: table cell
English
If present, indicates that the body can be parsed. The type must meet the requirements of __BodyReader__. The implementation constructs an object of this type to obtain buffers into which parsed body octets are placed.
218/2180 · 218
15
string ID 95
type: list
English
* There is no way to defer the commitment of the type for `body_` to
68/680 · 68
15
string ID 39
type: table cell
English
A type which meets the requirements of __ConstBufferSequence__. This is the type of buffer returned by `W::get`.
112/1120 · 112
15
string ID 50
type: table cell
English
`W::const_buffers_type`
23/230 · 23
15
string ID 36
type: table cell
English
`c.get_method_impl()`
21/210 · 21
15
string ID 73
type: paragraph
English
In this documentation, the example code, and the implementation, the `net` namespace is used to qualify Networking identifiers. For Boost.Beast, `net` will be an alias for the `boost::asio` namespace.
200/2000 · 200
15
string ID 63
type: paragraph
English
This example shows how to send a buffer sequence as a complete message.
71/710 · 71
15
string ID 53
type: paragraph
English
When using a decorator, it must be set on the stream before any handshaking takes place. This sets the decorator on the stream, to be used for all subsequent calls to accept or handshake:
187/1870 · 187
15
string ID 21
type: table cell
English
This function returns a new buffer or buffer sequence which represents a prefix of the original buffers.
104/1040 · 104
15
string ID 36
type: table cell
English
`friend rate_policy_access`
27/270 · 27
15
string ID 68
type: paragraph
English
The `value_type` nested type allows the body to define the declaration of the body type as it appears in the message. This can be any type. For example, a body's value type may specify `std::vector<char>` or `std::list<std::string>`. A custom body may even set the value type to something that is not a container for body octets, such as a [@boost:/libs/filesystem/doc/reference.html#class-path `boost::filesystem::path`]. Or, a more structured container may be chosen. This declares a body's value type as a JSON tree structure produced from a [@boost:/doc/html/json/input_output.html#json.input_output.parsing.streaming_parser `boost::json::stream_parser`]: ``` #include <boost/json/stream_parser.hpp>
703/7030 · 703
15
string ID 16
type: variablelist cell
English
"Some more advanced examples, e.g. including TLS with client/server certificates would help."
93/930 · 93
15
string ID 25
type: table code
English
/// A serializer for HTTP/1 responses
template<
class Body,
class Fields = fields
>
using response_serializer = serializer<false, Body, Fields>;
144/1440 · 144
15
string ID 49
type: table cell
English
Semantics, Pre/Post-conditions
30/300 · 30
15
string ID 68
type: paragraph
English
The implementation uses composed asynchronous operations; although some individual operations can perform both reads and writes, this behavior is coordinated internally to make sure the underlying stream is operated in a safe fashion. This allows an asynchronous read operation to respond to a received ping frame even while a user-initiated call to asynchronous write is active.
379/3790 · 379