2. Boost Beast Translation (zh_Hans)
3. Doc / Qbk / 08 Design / 1 Http Message (qbk)
4. English
5. Zen

192 string ID 192
	Source string description type: paragraph
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — }; 2/10000 · 2
194 string ID 194
	Source string description type: paragraph
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — /// An HTTP response header template<class Fields> struct header<false, Fields> : Fields { 90/10000 · 90
201 string ID 201
	Source string description type: paragraph
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — }; 2/10000 · 2
27 string ID 203
	Source string description type: paragraph
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — /// An HTTP message template<bool isRequest, class Fields, class Body> struct message : header<isRequest, Fields> { 115/10000 · 115
211 string ID 211
	Source string description type: paragraph
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — }; 2/10000 · 2
29 string ID 213
	Source string description type: paragraph
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — ``` 3/10000 · 3
30 string ID 215
	Source string description type: paragraph
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — Note that the `message` class now has a constructor allowing messages to be constructed from a similarly typed `header`. This handles the case where the user already has the header and wants to make a commitment to the type for [*Body]. A function can be declared which accepts any header: ``` template<bool isRequest, class Fields> void f(header<isRequest, Fields>& msg); ``` 376/10000 · 376
31 string ID 224
	Source string description type: paragraph
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — Until now we have not given significant consideration to the constructors of the `message` class. But to achieve all our goals we will need to make sure that there are enough constructor overloads to not only provide for the special copy and move members if the instantiated types support it, but also allow the fields container and body container to be constructed with arbitrary variadic lists of parameters. This allows the container to fully support allocators. 465/10000 · 465
32 string ID 232
	Source string description type: paragraph
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — The solution used in the library is to treat the message like a `std::pair` for the purposes of construction, except that instead of `first` and `second` we have the `Fields` base class and `message::body` member. This means that single-argument constructors for those fields should be accessible as they are with `std::pair`, and that a mechanism identical to the pair's use of `std::piecewise_construct` should be provided. Those constructors are too complex to repeat here, but interested readers can view the declarations in the corresponding header file. 559/10000 · 559
33 string ID 241
	Source string description type: paragraph
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — There is now significant progress with our message container but a stumbling block remains. There is no way to control the allocator for the `std::string` members. We could add an allocator to the template parameter list of the header and message classes, use it for those strings. This is unsatisfying because of the combinatorial explosion of constructor variations needed to support the scheme. It also means that request messages could have [*four] different allocators: two for the fields and body, and two for the method and target strings. A better solution is needed. 575/10000 · 575
34 string ID 250
	Source string description type: paragraph
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — To get around this we make an interface modification and then add a requirement to the [*Fields] type. First, the interface change: ``` /// An HTTP request header template<class Fields> struct header<true, Fields> : Fields { 224/10000 · 224
35 string ID 267
	Source string description type: paragraph
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — private: 8/10000 · 8
269 string ID 269
	Source string description type: paragraph
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — }; 2/10000 · 2
271 string ID 271
	Source string description type: paragraph
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — /// An HTTP response header template<class Fields> struct header<false, Fields> : Fields { 90/10000 · 90
279 string ID 279
	Source string description type: paragraph
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — }; ``` 6/10000 · 6
39 string ID 282
	Source string description type: paragraph
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — The start-line data members are replaced by traditional accessors using non-owning references to string buffers. The method is stored using a simple integer instead of the entire string, for the case where the method is recognized from the set of known verb strings. 266/10000 · 266
40 string ID 287
	Source string description type: paragraph
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — Now we add a requirement to the fields type: management of the corresponding string is delegated to the [*Fields] container, which can already be allocator aware and constructed with the necessary allocator parameter via the provided constructor overloads for `message`. The delegation implementation looks like this (only the response header specialization is shown): ``` /// An HTTP response header template<class Fields> struct header<false, Fields> : Fields { 463/10000 · 463
312 string ID 312
	Source string description type: paragraph
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — }; ``` 6/10000 · 6
42 string ID 315
	Source string description type: paragraph
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — Now that we've accomplished our initial goals and more, there are a few more quality of life improvements to make. Users will choose different types for `Body` far more often than they will for `Fields`. Thus, we swap the order of these types and provide a default. Then, we provide type aliases for requests and responses to soften the impact of using `bool` to choose the specialization: 389/10000 · 389
43 string ID 322
	Source string description type: paragraph
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — ``` /// An HTTP header template<bool isRequest, class Body, class Fields = fields> struct header; 97/10000 · 97