Zen

Translation

type: table code
/// A typical HTTP request
template<class Body, class Fields = fields>
using request = message<true, Body, Fields>;
115/1150 · 115

Sign in to save translations.

Key English Chinese (Simplified Han script) Actions
Message Containers
Message Containers
Beast provides a single class template __message__ and some aliases which model HTTP/1 and [@https://tools.ietf.org/html/rfc7540 HTTP/2] messages:
Beast provides a single class template __message__ and some aliases which model HTTP/1 and [@https://tools.ietf.org/html/rfc7540 HTTP/2] messages:
Message
Message
17
Name
Name
17
Description
Description
__message__
__message__
/// An HTTP message
template<
bool isRequest, // `true` for requests, `false` for responses
class Body, // Controls the container and algorithms used for the body
class Fields = fields> // The type of container to store the fields
class message;
/// An HTTP message
template<
bool isRequest, // `true` for requests, `false` for responses
class Body, // Controls the container and algorithms used for the body
class Fields = fields> // The type of container to store the fields
class message;
[link beast.ref.boost__beast__http__request `request`]
[link beast.ref.boost__beast__http__request `request`]
/// A typical HTTP request
template<class Body, class Fields = fields>
using request = message<true, Body, Fields>;
/// A typical HTTP request
template<class Body, class Fields = fields>
using request = message<true, Body, Fields>;
[link beast.ref.boost__beast__http__response `response`]
[link beast.ref.boost__beast__http__response `response`]
/// A typical HTTP response
template<class Body, class Fields = fields>
using response = message<false, Body, Fields>;
/// A typical HTTP response
template<class Body, class Fields = fields>
using response = message<false, Body, Fields>;
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.
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.
Sometimes it is desired to only work with a header. Beast provides a single class template __header__ and some aliases to model HTTP/1 and HTTP/2 headers:
Sometimes it is desired to only work with a header. Beast provides a single class template __header__ and some aliases to model HTTP/1 and HTTP/2 headers:
Header
Header
66
Name
Name
66
Description
Description
__header__
__header__
/// An HTTP header
template<
bool isRequest, // `true` for requests, `false` for responses
class Fields = fields> // The type of container to store the fields
class header;
/// An HTTP header
template<
bool isRequest, // `true` for requests, `false` for responses
class Fields = fields> // The type of container to store the fields
class header;
[link beast.ref.boost__beast__http__request_header `request_header`]
[link beast.ref.boost__beast__http__request_header `request_header`]
/// A typical HTTP request header
template<class Fields>
using request_header = header<true, Fields>;
/// A typical HTTP request header
template<class Fields>
using request_header = header<true, Fields>;
[link beast.ref.boost__beast__http__response_header `response_header`]
[link beast.ref.boost__beast__http__response_header `response_header`]
/// A typical HTTP response header
template<class Fields>
using response_header = header<false, Fields>;
/// A typical HTTP response header
template<class Fields>
using response_header = header<false, Fields>;
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:
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:
Body Types
Body Types
English Chinese (Simplified Han script) Actions
Message Containers
Message Containers
Beast provides a single class template __message__ and some aliases which model HTTP/1 and [@https://tools.ietf.org/html/rfc7540 HTTP/2] messages:
Beast provides a single class template __message__ and some aliases which model HTTP/1 and [@https://tools.ietf.org/html/rfc7540 HTTP/2] messages:
Message
Message
__message__
__message__
/// An HTTP message
template<
bool isRequest, // `true` for requests, `false` for responses
class Body, // Controls the container and algorithms used for the body
class Fields = fields> // The type of container to store the fields
class message;
/// An HTTP message
template<
bool isRequest, // `true` for requests, `false` for responses
class Body, // Controls the container and algorithms used for the body
class Fields = fields> // The type of container to store the fields
class message;
[link beast.ref.boost__beast__http__request `request`]
[link beast.ref.boost__beast__http__request `request`]
/// A typical HTTP request
template<class Body, class Fields = fields>
using request = message<true, Body, Fields>;
/// A typical HTTP request
template<class Body, class Fields = fields>
using request = message<true, Body, Fields>;
[link beast.ref.boost__beast__http__response `response`]
[link beast.ref.boost__beast__http__response `response`]
/// A typical HTTP response
template<class Body, class Fields = fields>
using response = message<false, Body, Fields>;
/// A typical HTTP response
template<class Body, class Fields = fields>
using response = message<false, Body, Fields>;
A body whose [link beast.ref.boost__beast__http__buffer_body__value_type `value_type`] holds a raw pointer and size to a caller-provided buffer. This allows for serialization of body data coming from external sources, and incremental parsing of message body content using a fixed size buffer.
A body whose [link beast.ref.boost__beast__http__buffer_body__value_type `value_type`] holds a raw pointer and size to a caller-provided buffer. This allows for serialization of body data coming from external sources, and incremental parsing of message body content using a fixed size buffer.
[link beast.ref.boost__beast__http__dynamic_body `dynamic_body`]

[link beast.ref.boost__beast__http__basic_dynamic_body `basic_dynamic_body`]
[link beast.ref.boost__beast__http__dynamic_body `dynamic_body`]

[link beast.ref.boost__beast__http__basic_dynamic_body `basic_dynamic_body`]
A body whose `value_type` is a __DynamicBuffer__. It inherits the insertion complexity of the underlying choice of dynamic buffer. Messages with this body type may be serialized and parsed.
A body whose `value_type` is a __DynamicBuffer__. It inherits the insertion complexity of the underlying choice of dynamic buffer. Messages with this body type may be serialized and parsed.
[link beast.ref.boost__beast__http__empty_body `empty_body`]
[link beast.ref.boost__beast__http__empty_body `empty_body`]
A special body with an empty `value_type` indicating that the message has no body. Messages with this body may be serialized and parsed; however, body octets received while parsing a message with this body will generate a unique error.
A special body with an empty `value_type` indicating that the message has no body. Messages with this body may be serialized and parsed; however, body octets received while parsing a message with this body will generate a unique error.
[link beast.ref.boost__beast__http__file_body `file_body`]

[link beast.ref.boost__beast__http__basic_file_body `basic_file_body`]
[link beast.ref.boost__beast__http__file_body `file_body`]

[link beast.ref.boost__beast__http__basic_file_body `basic_file_body`]
This body is represented by a file opened for either reading or writing. Messages with this body may be serialized and parsed. HTTP algorithms will use the open file for reading and writing, for streaming and incremental sends and receives.
This body is represented by a file opened for either reading or writing. Messages with this body may be serialized and parsed. HTTP algorithms will use the open file for reading and writing, for streaming and incremental sends and receives.
[link beast.ref.boost__beast__http__span_body `span_body`]
[link beast.ref.boost__beast__http__span_body `span_body`]
A body whose `value_type` is a [@boost:/libs/core/doc/html/core/span.html `span`], a non-owning reference to a single linear buffer of bytes. Messages with this body type may be serialized and parsed.
A body whose `value_type` is a [@boost:/libs/core/doc/html/core/span.html `span`], a non-owning reference to a single linear buffer of bytes. Messages with this body type may be serialized and parsed.
[link beast.ref.boost__beast__http__string_body `string_body`]

[link beast.ref.boost__beast__http__basic_string_body `basic_string_body`]
[link beast.ref.boost__beast__http__string_body `string_body`]

[link beast.ref.boost__beast__http__basic_string_body `basic_string_body`]
A body whose `value_type` is `std::basic_string` or `std::string`. Insertion complexity is amortized constant time, while capacity grows geometrically. Messages with this body type may be serialized and parsed. This is the type of body used in the examples.
A body whose `value_type` is `std::basic_string` or `std::string`. Insertion complexity is amortized constant time, while capacity grows geometrically. Messages with this body type may be serialized and parsed. This is the type of body used in the examples.
[link beast.ref.boost__beast__http__vector_body `vector_body`]
[link beast.ref.boost__beast__http__vector_body `vector_body`]
[link beast.ref.boost__beast__http__request_header `request_header`]
[link beast.ref.boost__beast__http__request_header `request_header`]
/// A typical HTTP request header
template<class Fields>
using request_header = header<true, Fields>;
/// A typical HTTP request header
template<class Fields>
using request_header = header<true, Fields>;
[link beast.ref.boost__beast__http__response_header `response_header`]
[link beast.ref.boost__beast__http__response_header `response_header`]
/// A typical HTTP response header
template<class Fields>
using response_header = header<false, Fields>;
/// A typical HTTP response header
template<class Fields>
using response_header = header<false, Fields>;
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:
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:
Body Types
Body Types
Beast defines the __Body__ concept, which determines both the type of the [link beast.ref.boost__beast__http__message.body `message::body`] member (as seen in the diagram above) and may also include algorithms for transferring buffers in and out. These algorithms are used during parsing and serialization. Users may define their own body types which meet the requirements, or use the ones that come with the library:
Beast defines the __Body__ concept, which determines both the type of the [link beast.ref.boost__beast__http__message.body `message::body`] member (as seen in the diagram above) and may also include algorithms for transferring buffers in and out. These algorithms are used during parsing and serialization. Users may define their own body types which meet the requirements, or use the ones that come with the library:
[link beast.ref.boost__beast__http__buffer_body `buffer_body`]
[link beast.ref.boost__beast__http__buffer_body `buffer_body`]

Loading…

User avatar admin

String added in the repository
/// A typical HTTP request
template<class Body, class Fields = fields>
using request = message<true, Body, Fields>;
/// A typical HTTP request
template<class Body, class Fields = fields>
using request = message<true, Body, Fields>;
06/05/2026
Browse all string changes

Things to check

Unchanged translation

Source and translation are identical.

Reset

Glossary

English Chinese (Simplified Han script)
No related strings found in the glossary.

String information

Source string description
type: table code
Unit identifier
58124
Source string location
string ID 17
String age
06/05/2026
Last updated
06/05/2026
Source string age
06/05/2026
Translation file QuickBook file
doc/qbk/04_http/02_message_zh_Hans.qbk, string 9