msgid ""
msgstr ""
"Project-Id-Version: Chinese (Simplified Han script) (Boost Beast Translation "
"(zh_Hans))\n"
"Report-Msgid-Bugs-To: \n"
"POT-Creation-Date: 2026-07-24 13:31+0000\n"
"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
"Last-Translator: FULL NAME <EMAIL@ADDRESS>\n"
"Language-Team: Chinese (Simplified Han script) <https://"
"insights.cppalliance.org/weblate/projects/boost-beast-documentation-zh_Hans/"
"doc-qbk-04-http-02-message-qbk/zh_Hans/>\n"
"Language: zh_Hans\n"
"MIME-Version: 1.0\n"
"Content-Type: text/plain; charset=UTF-8\n"
"Content-Transfer-Encoding: 8bit\n"
"Plural-Forms: nplurals=1; plural=0;\n"
"X-Generator: Weblate 2026.5\n"

#. type: section title
#: 10
msgid "Message Containers"
msgstr "消息容器"

#. type: paragraph
#: 12
msgid ""
"Beast provides a single class template __message__ and some aliases which "
"model HTTP/1 and [@https://tools.ietf.org/html/rfc7540 HTTP/2] messages:"
msgstr "Beast 提供单个类模板 __message__ 及若干别名，用于表示 HTTP/1 和 HTTP/2 消息："

#. type: table title
#: 17
msgid "Message"
msgstr "消息"

#. type: table cell
#: 17
msgctxt "17"
msgid "Name"
msgstr "名称"

#. type: table cell
#: 17
msgctxt "17"
msgid "Description"
msgstr "描述"

#. type: table cell
#: 17
msgid "__message__"
msgstr "__消息__"

#. type: table code
#: 17
msgid ""
"/// An HTTP message\n"
"template<\n"
"bool isRequest,             // `true` for requests, `false` for responses\n"
"class Body,                 // Controls the container and algorithms used "
"for the body\n"
"class Fields = fields>      // The type of container to store the fields\n"
"class message;"
msgstr ""
"/// HTTP 消息类\n"
"template<\n"
"bool isRequest, // 若为请求则为 true，若为响应则为 false\n"
"class Body, // 用于控制消息体的容器及算法\n"
"class Fields = fields> // 用于存储字段的容器类型\n"
"class message;"

#. type: table cell
#: 17
msgid "[link beast.ref.boost__beast__http__request `request`]"
msgstr "[link beast.ref.boost__beast__http__request `request`]"

#. type: table code
#: 17
msgid ""
"/// A typical HTTP request\n"
"template<class Body, class Fields = fields>\n"
"using request = message<true, Body, Fields>;"
msgstr ""
"/// 典型的 HTTP 请求\n"
"template<class Body, class Fields = fields>\n"
"using request = message<true, Body, Fields>;"

#. type: table cell
#: 17
msgid "[link beast.ref.boost__beast__http__response `response`]"
msgstr "[link beast.ref.boost__beast__http__response `response`]"

#. type: table code
#: 17
msgid ""
"/// A typical HTTP response\n"
"template<class Body, class Fields = fields>\n"
"using response = message<false, Body, Fields>;"
msgstr ""
"/// 典型的 HTTP 响应\n"
"template<class Body, class Fields = fields>\n"
"using response = message<false, Body, Fields>;"

#. type: paragraph
#: 51
msgid ""
"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."
msgstr ""
"该容器提供值语义，支持移动和拷贝操作（前提是 __Body__ 和 __Fields__ 支持这些"
"操作）。用户定义的模板函数参数可以接受任意消息，也可通过偏特化仅接受请求或响"
"应。默认的 __fields__ 是一个关联容器，使用标准分配器，支持字段的修改与查询。"
"根据 __rfc7230__，字段名称比较时不区分大小写。用户也可以自定义字段类型"
"。`Body` 类型决定消息体的容器类型，以及用于在容器与缓冲区之间传输数据的算法。"
"该库提供一组常用的消息体类型。与字段类似，用户也可以自定义消息体类型。"

#. type: paragraph
#: 63
msgid ""
"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:"
msgstr ""
"有时只需处理头部信息。Beast 提供单个类模板 __header__ 及若干别名，用于表示 "
"HTTP/1 和 HTTP/2 头部："

#. type: table title
#: 66
msgid "Header"
msgstr "头部"

#. type: table cell
#: 66
msgctxt "66"
msgid "Name"
msgstr "名称"

#. type: table cell
#: 66
msgctxt "66"
msgid "Description"
msgstr "描述"

#. type: table cell
#: 66
msgid "__header__"
msgstr "__头部__"

#. type: table code
#: 66
msgid ""
"/// An HTTP header\n"
"template<\n"
"bool isRequest,             // `true` for requests, `false` for responses\n"
"class Fields = fields>      // The type of container to store the fields\n"
"class header;"
msgstr ""
"/// HTTP 头部\n"
"template<\n"
"bool isRequest, // 若为请求则为 true，若为响应则为 false\n"
"class Fields = fields> // 用于存储字段的容器类型\n"
"class header;"

#. type: table cell
#: 66
msgid "[link beast.ref.boost__beast__http__request_header `request_header`]"
msgstr "[link beast.ref.boost__beast__http__request_header `request_header`]"

#. type: table code
#: 66
msgid ""
"/// A typical HTTP request header\n"
"template<class Fields>\n"
"using request_header = header<true, Fields>;"
msgstr ""
"/// 典型的 HTTP 请求头部\n"
"template<class Fields>\n"
"using request_header = header<true, Fields>;"

#. type: table cell
#: 66
msgid "[link beast.ref.boost__beast__http__response_header `response_header`]"
msgstr "[link beast.ref.boost__beast__http__response_header `response_header`]"

#. type: table code
#: 66
msgid ""
"/// A typical HTTP response header\n"
"template<class Fields>\n"
"using response_header = header<false, Fields>;"
msgstr ""
"/// 典型的 HTTP 响应头部\n"
"template<class Fields>\n"
"using response_header = header<false, Fields>;"

#. type: paragraph
#: 99
msgid ""
"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:"
msgstr ""
"请求和响应共享版本号、字段及消息体，但各自拥有一些特有的成员。该设计通过将 "
"`header` 类声明为 `isRequest` 的偏特化来实现。__message__ 派生自 __header__，"
"因此消息可作为参数传递给接受相应类型头部参数的函数。此外，`header` 公开继承"
"自 `Fields`，因此消息也继承了 `Fields` 的所有成员函数。下图展示 `header` 与 "
"`message` 的继承关系，以及每个偏特化中部分显著成员的差异："

#. type: heading
#: 111
msgid "Body Types"
msgstr "消息体类型"

#. type: paragraph
#: 113
msgid ""
"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:"
msgstr ""
"Beast 定义 __Body__ 概念，该概念决定 [link "
"beast.ref.boost__beast__http__message.body `message::body`] 成员的类型，同时"
"还可包含用于传入和传出缓冲区的算法。这些算法在解析和序列化过程中使用。用户可"
"以定义满足要求的自定义消息体类型，也可以直接使用该库提供的现有类型："

#. type: table cell
#: 120
msgid "[link beast.ref.boost__beast__http__buffer_body `buffer_body`]"
msgstr "[link beast.ref.boost__beast__http__buffer_body `buffer_body`]"

#. type: table cell
#: 120
msgid ""
"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."
msgstr ""
"该消息体类型的 [link beast.ref.boost__beast__http__buffer_body__value_type "
"`value_type`] 包含一个原始指针及其长度，指向调用方提供的缓冲区。该类型支持对"
"来自外部来源的消息体数据进行序列化，并使用固定大小的缓冲区进行消息体内容的增"
"量解析。"

#. type: table cell
#: 120
msgid ""
"[link beast.ref.boost__beast__http__dynamic_body `dynamic_body`]\n"
"\n"
"[link beast.ref.boost__beast__http__basic_dynamic_body `basic_dynamic_body`]"
msgstr ""
"[link beast.ref.boost__beast__http__dynamic_body `dynamic_body`]\n"
"\n"
"[link beast.ref.boost__beast__http__basic_dynamic_body `basic_dynamic_body`]"

#. type: table cell
#: 120
msgid ""
"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."
msgstr ""
"该消息体类型的 `value_type` 为一个 __DynamicBuffer__。其插入操作的复杂度取决"
"于底层动态缓冲区的选择。带有该消息体类型的消息支持序列化和解析操作。"

#. type: table cell
#: 120
msgid "[link beast.ref.boost__beast__http__empty_body `empty_body`]"
msgstr "[link beast.ref.boost__beast__http__empty_body `empty_body`]"

#. type: table cell
#: 120
msgid ""
"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."
msgstr ""
"该消息体类型为一个特殊的空消息体，其 `value_type` 为空，表示消息不包含消息体"
"。带有该消息体类型的消息支持序列化和解析操作；但在解析过程中如果接收到消息体"
"数据，则会生成一个特定的错误。"

#. type: table cell
#: 120
msgid ""
"[link beast.ref.boost__beast__http__file_body `file_body`]\n"
"\n"
"[link beast.ref.boost__beast__http__basic_file_body `basic_file_body`]"
msgstr ""
"[link beast.ref.boost__beast__http__file_body `file_body`]\n"
"\n"
"[link beast.ref.boost__beast__http__basic_file_body `basic_file_body`]"

#. type: table cell
#: 120
msgid ""
"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."
msgstr ""
"该消息体类型通过一个已打开的文件来表示，可用于读取或写入。带有该消息体类型的"
"消息支持序列化和解析操作。HTTP 算法会利用这个已打开的文件执行读写操作，从而支"
"持流式传输及增量式数据收发。"

#. type: table cell
#: 120
msgid "[link beast.ref.boost__beast__http__span_body `span_body`]"
msgstr "[link beast.ref.boost__beast__http__span_body `span_body`]"

#. type: table cell
#: 120
msgid ""
"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."
msgstr ""
"该消息体类型的 `value_type` 为 [@boost:/libs/core/doc/html/core/span.html "
"`span`]，这是一个指向单个线性字节缓冲区的非拥有引用。带有该消息体类型的消息可"
"进行序列化和解析。"

#. type: table cell
#: 120
msgid ""
"[link beast.ref.boost__beast__http__string_body `string_body`]\n"
"\n"
"[link beast.ref.boost__beast__http__basic_string_body `basic_string_body`]"
msgstr ""
"[link beast.ref.boost__beast__http__string_body `string_body`]\n"
"\n"
"[link beast.ref.boost__beast__http__basic_string_body `basic_string_body`]"

#. type: table cell
#: 120
msgid ""
"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."
msgstr ""
"该消息体类型的 `value_type` 为 `std::basic_string` 或 `std::string`。插入操作"
"的均摊复杂度为常数时间，容量以几何级数增长。带有该消息体类型的消息支持序列化"
"和解析操作。此类型即为示例中使用的消息体类型。"

#. type: table cell
#: 120
msgid "[link beast.ref.boost__beast__http__vector_body `vector_body`]"
msgstr "[link beast.ref.boost__beast__http__vector_body `vector_body`]"

#. type: table cell
#: 120
msgid ""
"A body whose `value_type` is `std::vector`. Insertion complexity is "
"amortized constant time, while capacity grows geometrically. Messages with "
"this body type may be serialized and parsed."
msgstr ""
"该消息体类型的 `value_type` 为 `std::vector`。插入操作的均摊复杂度为常数时间"
"，容量以几何级数增长。带有该消息体类型的消息支持序列化和解析操作。"

#. type: heading
#: 186
msgid "Usage"
msgstr "用法"

#. type: paragraph
#: 188
msgid ""
"These examples show how to create and fill in request and response objects: "
"Here we build an [@https://tools.ietf.org/html/rfc7231#section-4.3.1 HTTP "
"GET] request with an empty message body:"
msgstr ""
"以下示例展示如何创建并填充请求和响应对象。这里构造一个带有空消息体的 "
"[@https://tools.ietf.org/html/rfc7231#section-4.3.1 HTTP GET] 请求："

#. type: table title
#: 193
msgid "Create Request"
msgstr "创建请求"

#. type: table cell
#: 193
msgctxt "193"
msgid "Statements"
msgstr "声明"

#. type: table cell
#: 193
msgctxt "193"
msgid "Serialized Result"
msgstr "序列化结果"

#. type: table cell
#: 193
msgid "[http_snippet_2]"
msgstr "[http_snippet_2]"

#. type: table code
#: 193
msgid ""
"GET /index.htm HTTP/1.1\\r\\n\n"
"Accept: text/html\\r\\n\n"
"User-Agent: Beast\\r\\n\n"
"\\r\\n"
msgstr ""
"GET /index.htm HTTP/1.1\\r\\n\n"
"Accept: text/html\\r\\n\n"
"User-Agent: Beast\\r\\n\n"
"\\r\\n"

#. type: paragraph
#: 207
msgid ""
"In this code we create an HTTP response with a status code indicating "
"success. This message has a body with a non-zero length. The function [link "
"beast.ref.boost__beast__http__message.prepare_payload "
"`message::prepare_payload`] automatically sets the Content-Length or "
"Transfer-Encoding field depending on the content and type of the `body` "
"member. Use of this function is optional; these fields may also be set "
"explicitly."
msgstr ""
"以下代码创建一个带有成功状态码的 HTTP 响应。该消息包含一个非空的消息体。"
"prepare_payload 函数会根据 body 成员的内容和类型自动设置 Content-Length 或 "
"Transfer-Encoding 字段。该函数可调用也可不调用；这些字段也可手动显式设置。"

#. type: table title
#: 214
msgid "Create Response"
msgstr "创建响应"

#. type: table cell
#: 214
msgctxt "214"
msgid "Statements"
msgstr "声明"

#. type: table cell
#: 214
msgctxt "214"
msgid "Serialized Result"
msgstr "序列化结果"

#. type: table cell
#: 214
msgid "[http_snippet_3]"
msgstr "[http_snippet_3]"

#. type: table code
#: 214
msgid ""
"HTTP/1.1 200 OK\\r\\n\n"
"Server: Beast\\r\\n\n"
"Content-Length: 13\\r\\n\n"
"\\r\\n\n"
"Hello, world!"
msgstr ""
"HTTP/1.1 200 OK\\r\\n\n"
"Server: Beast\\r\\n\n"
"Content-Length: 13\\r\\n\n"
"\\r\\n\n"
"Hello, world!"

#. type: paragraph
#: 229
msgid ""
"The implementation will automatically fill in the obsolete [@https://"
"tools.ietf.org/html/rfc7230#section-3.1.2 reason-phrase] from the status "
"code when serializing a message. Or it may be set directly using [link "
"beast.ref.boost__beast__http__header.reason.overload2 `header::reason`]."
msgstr ""
"当序列化消息时，实现会根据状态码自动填充已废弃的 [@https://tools.ietf.org/"
"html/rfc7230#section-3.1.2 原因短语]。也可通过调用 [link "
"beast.ref.boost__beast__http__header.reason.overload2 `header::reason`] 直接"
"设置该字段。"