feedc0de/boost_beast
1
0
Fork 0
forked from boostorg/beast
Code Pull Requests Activity
Files
2b92189b65a90a269e0de288cbb0dbdb60969190
boost_beast/include/boost/beast/http/serializer.hpp

371 lines
12 KiB
C++
Raw Normal View History

Refactor serialization algorithms: serializer interface is changed to be buffer-only, no streams, and placed in its own header file. Operations on serializers are moved to free functions as part of the HTTP write family of synchronous and asynchronous algorithms.
2017-05-28 17:04:39 -07:00
//
Update copyrights
2017-07-24 09:42:36 -07:00
// Copyright (c) 2016-2017 Vinnie Falco (vinnie dot falco at gmail dot com)
Refactor serialization algorithms: serializer interface is changed to be buffer-only, no streams, and placed in its own header file. Operations on serializers are moved to free functions as part of the HTTP write family of synchronous and asynchronous algorithms.
2017-05-28 17:04:39 -07:00
//
// Distributed under the Boost Software License, Version 1.0. (See accompanying
// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
//
Boost prep
2017-07-20 13:40:34 -07:00
// Official repository: https://github.com/boostorg/beast
//
Refactor serialization algorithms: serializer interface is changed to be buffer-only, no streams, and placed in its own header file. Operations on serializers are moved to free functions as part of the HTTP write family of synchronous and asynchronous algorithms.
2017-05-28 17:04:39 -07:00
Boost prep
2017-07-20 13:40:34 -07:00
#ifndef BOOST_BEAST_HTTP_SERIALIZER_HPP
#define BOOST_BEAST_HTTP_SERIALIZER_HPP
config.hpp is not a public header
2017-10-10 07:49:03 -07:00
#include <boost/beast/core/detail/config.hpp>
buffers_cat replaces buffer_cat (API Change): fix #773 * buffer_cat is renamed to buffers_cat * buffer_cat_view is renamed to buffers_cat_view Actions Required: * Use buffers_cat instead of buffer_cat * Use buffers_cat_view instead of buffer_cat_view
2017-09-15 10:03:59 -07:00
#include <boost/beast/core/buffers_cat.hpp>
buffers_prefix replaces buffer_prefix (API Change) fix #773 * buffer_prefix is renamed to buffers_prefix * buffer_prefix_view is renamed to buffers_prefix_view Actions Required: * Use buffers_prefix instead of buffer_prefix * Use buffers_prefix_view instead of buffer_prefix_view
2017-09-15 09:55:03 -07:00
#include <boost/beast/core/buffers_prefix.hpp>
buffers_suffix replaces consuming_buffers (API Change): fix #770 * consuming_buffers is renamed to buffers_suffix Actions Required: * Use buffers_suffix instead of consuming_buffers
2017-09-15 12:52:45 -07:00
#include <boost/beast/core/buffers_suffix.hpp>
Boost prep
2017-07-20 13:40:34 -07:00
#include <boost/beast/core/string.hpp>
Use custom variant
2017-07-20 22:54:54 -07:00
#include <boost/beast/core/detail/variant.hpp>
Boost prep
2017-07-20 13:40:34 -07:00
#include <boost/beast/http/message.hpp>
#include <boost/beast/http/chunk_encode.hpp>
Refactor serialization algorithms: serializer interface is changed to be buffer-only, no streams, and placed in its own header file. Operations on serializers are moved to free functions as part of the HTTP write family of synchronous and asynchronous algorithms.
2017-05-28 17:04:39 -07:00
#include <boost/asio/buffer.hpp>
#include <boost/optional.hpp>
Serialize in one step when possible fix #546
2017-06-26 18:26:35 -07:00
Boost prep
2017-07-20 13:40:34 -07:00
namespace boost {
Refactor serialization algorithms: serializer interface is changed to be buffer-only, no streams, and placed in its own header file. Operations on serializers are moved to free functions as part of the HTTP write family of synchronous and asynchronous algorithms.
2017-05-28 17:04:39 -07:00
namespace beast {
namespace http {
/** Provides buffer oriented HTTP message serialization functionality.
An object of this type is used to serialize a complete
Remove make_serializer (API Change): Actions Required: * Replace calls to make_serializer with variable declarations
2017-06-22 07:48:05 -07:00
HTTP message into a sequence of octets. To use this class,
Refactor serialization algorithms: serializer interface is changed to be buffer-only, no streams, and placed in its own header file. Operations on serializers are moved to free functions as part of the HTTP write family of synchronous and asynchronous algorithms.
2017-05-28 17:04:39 -07:00
construct an instance with the message to be serialized.
The implementation will automatically perform chunk encoding
if the contents of the message indicate that chunk encoding
Remove serializer::keep_alive (API Change): * The serializer::keep_alive function is removed Actions Required: * Call message::keep_alive instead of serializer::keep_alive
2017-10-23 12:14:07 -07:00
is required.
Refactor chunked-encoding serialization: New buffer sequence classes are provided to allow full control over the serialization of chunk-encoded message payloads: * chunk_header A ConstBufferSequence representing the chunk header. It includes a hexadecimal-encoded size, an optional set of chunk extensions, and the trailing CRLF required to denote the end of the chunk header. This allows the caller to manually serialize the chunk body in one or more calls to a stream output function. The caller must also output an object of type `chunk_crlf` to the stream to indicate the end of the chunk body. * chunk_crlf A small ConstBufferSequence that simply represents the two character sequence "\r\n" (CRLF). This is needed for the case where the caller wants to output a chunk body as a series of buffers (i.e. "chunking a chunk"). * chunk_body A ConstBufferSequence representing a complete chunk. This includes the size, an optional set of chunk extensions, a caller provided buffer containing the body, and the required CRLF that follows. * chunk_final A ConstBufferSequence representing a final chunk. It includes an optional set of caller-provided field trailers * chunk_extensions A container for building a set of chunk extensions to use during serialization. The use of the container is optional, callers may provide their own buffer containing a correctly formatted set of chunk extensions, or they may use their own convenience container which meets the requirements. The basic_fields container is modified to allow construction outside the context of a message. The container can be used to provide trailers to `chunk_final`. Actions Required: * Remove references to ChunkDecorators. Use the new chunk-encoding buffer sequences to manually produce a chunked payload body in the case where control over the chunk-extensions and/or trailers is required.
2017-07-09 20:09:30 -07:00
Chunked output produced by the serializer never contains chunk
extensions or trailers, and the location of chunk boundaries
is not specified. If callers require chunk extensions, trailers,
or control over the exact contents of each chunk they should
use the serializer to write just the message header, and then
assume control over serializing the chunked payload by using
the chunk buffer sequence types @ref chunk_body, @ref chunk_crlf,
@ref chunk_header, and @ref chunk_last.
Refactor serialization algorithms: serializer interface is changed to be buffer-only, no streams, and placed in its own header file. Operations on serializers are moved to free functions as part of the HTTP write family of synchronous and asynchronous algorithms.
2017-05-28 17:04:39 -07:00
@tparam isRequest `true` if the message is a request.
@tparam Body The body type of the message.
@tparam Fields The type of fields in the message.
*/
template<
Remove make_serializer (API Change): Actions Required: * Replace calls to make_serializer with variable declarations
2017-06-22 07:48:05 -07:00
bool isRequest,
class Body,
Refactor chunked-encoding serialization: New buffer sequence classes are provided to allow full control over the serialization of chunk-encoded message payloads: * chunk_header A ConstBufferSequence representing the chunk header. It includes a hexadecimal-encoded size, an optional set of chunk extensions, and the trailing CRLF required to denote the end of the chunk header. This allows the caller to manually serialize the chunk body in one or more calls to a stream output function. The caller must also output an object of type `chunk_crlf` to the stream to indicate the end of the chunk body. * chunk_crlf A small ConstBufferSequence that simply represents the two character sequence "\r\n" (CRLF). This is needed for the case where the caller wants to output a chunk body as a series of buffers (i.e. "chunking a chunk"). * chunk_body A ConstBufferSequence representing a complete chunk. This includes the size, an optional set of chunk extensions, a caller provided buffer containing the body, and the required CRLF that follows. * chunk_final A ConstBufferSequence representing a final chunk. It includes an optional set of caller-provided field trailers * chunk_extensions A container for building a set of chunk extensions to use during serialization. The use of the container is optional, callers may provide their own buffer containing a correctly formatted set of chunk extensions, or they may use their own convenience container which meets the requirements. The basic_fields container is modified to allow construction outside the context of a message. The container can be used to provide trailers to `chunk_final`. Actions Required: * Remove references to ChunkDecorators. Use the new chunk-encoding buffer sequences to manually produce a chunked payload body in the case where control over the chunk-extensions and/or trailers is required.
2017-07-09 20:09:30 -07:00
class Fields = fields>
Refactor serialization algorithms: serializer interface is changed to be buffer-only, no streams, and placed in its own header file. Operations on serializers are moved to free functions as part of the HTTP write family of synchronous and asynchronous algorithms.
2017-05-28 17:04:39 -07:00
class serializer
{
BodyReader may construct from a non-const message fix #619
2017-07-07 14:32:51 -07:00
public:
Refactor serialization algorithms: serializer interface is changed to be buffer-only, no streams, and placed in its own header file. Operations on serializers are moved to free functions as part of the HTTP write family of synchronous and asynchronous algorithms.
2017-05-28 17:04:39 -07:00
static_assert(is_body<Body>::value,
"Body requirements not met");
BodyReader may construct from a non-const message fix #619
2017-07-07 14:32:51 -07:00
BodyReader and BodyWriter names are swapped (API Change): Body::reader and Body::writer meanings are reversed, for consistency with the names of the stream operations: * Body::reader is used for read, read_some, async_read, async_read_some * Body::writer is used for write, write_some, async_write, async_write_some Actions Required: * Swap the reader and writer names for user defined Body types * Swap use of is_body_reader and is_body_writer
2017-10-30 17:08:52 -07:00
static_assert(is_body_writer<Body>::value,
"BodyWriter requirements not met");
Refactor serialization algorithms: serializer interface is changed to be buffer-only, no streams, and placed in its own header file. Operations on serializers are moved to free functions as part of the HTTP write family of synchronous and asynchronous algorithms.
2017-05-28 17:04:39 -07:00
BodyReader, BodyWriter use two-phase init (API Change): These types now perform error-based initialization in a separate init() functions instead of in the constructor. Actions Required: * Modify instances of user-defined BodyReader and BodyWriter types to perfrom two-phase initialization, as per the updated documented type requirements.
2017-07-07 20:08:52 -07:00
/** The type of message this serializer uses
BodyReader may construct from a non-const message fix #619
2017-07-07 14:32:51 -07:00
This may be const or non-const depending on the
BodyReader and BodyWriter names are swapped (API Change): Body::reader and Body::writer meanings are reversed, for consistency with the names of the stream operations: * Body::reader is used for read, read_some, async_read, async_read_some * Body::writer is used for write, write_some, async_write, async_write_some Actions Required: * Swap the reader and writer names for user defined Body types * Swap use of is_body_reader and is_body_writer
2017-10-30 17:08:52 -07:00
implementation of the corresponding @b BodyWriter.
BodyReader may construct from a non-const message fix #619
2017-07-07 14:32:51 -07:00
*/
Boost prep
2017-07-20 13:40:34 -07:00
#if BOOST_BEAST_DOXYGEN
Squashed 'doc/docca/' changes from 1bfc5ede..df9bd956 df9bd956 Add deduced alias 220ded9a Add see-below alias git-subtree-dir: doc/docca git-subtree-split: df9bd956e2480467447c80ffae3b44b3c0b0756a
2018-11-11 21:53:13 -08:00
using value_type = __implementation_defined__;
BodyReader may construct from a non-const message fix #619
2017-07-07 14:32:51 -07:00
#else
New BodyReader and BodyWriter constructors (API Change): fix #884 * BodyReader and BodyWriter constructors now require the header and body elements to be passed as distinct header and value_type objects. This enables the composition of body types, for example: http::response<compressed_body<http::string_body>> res; * The previous single-argument constructors are deprecated and will be removed in a subsequent version. Actions Required: * Change user-defined instances of BodyReader or BodyWriter constructor signatures to the two-argument form. OR * Define the macro BOOST_BEAST_ALLOW_DEPRECATED in the project (which will accept both the new and the deprecated signatures).
2017-11-13 23:34:14 +01:00
using value_type = typename std::conditional<
Remove deprecated Body reader and writer ctor signatures
2018-05-04 12:46:49 -07:00
std::is_constructible<typename Body::writer,
New BodyReader and BodyWriter constructors (API Change): fix #884 * BodyReader and BodyWriter constructors now require the header and body elements to be passed as distinct header and value_type objects. This enables the composition of body types, for example: http::response<compressed_body<http::string_body>> res; * The previous single-argument constructors are deprecated and will be removed in a subsequent version. Actions Required: * Change user-defined instances of BodyReader or BodyWriter constructor signatures to the two-argument form. OR * Define the macro BOOST_BEAST_ALLOW_DEPRECATED in the project (which will accept both the new and the deprecated signatures).
2017-11-13 23:34:14 +01:00
header<isRequest, Fields>&,
typename Body::value_type&>::value &&
! std::is_constructible<typename Body::writer,
header<isRequest, Fields> const&,
Remove deprecated Body reader and writer ctor signatures
2018-05-04 12:46:49 -07:00
typename Body::value_type const&>::value,
New BodyReader and BodyWriter constructors (API Change): fix #884 * BodyReader and BodyWriter constructors now require the header and body elements to be passed as distinct header and value_type objects. This enables the composition of body types, for example: http::response<compressed_body<http::string_body>> res; * The previous single-argument constructors are deprecated and will be removed in a subsequent version. Actions Required: * Change user-defined instances of BodyReader or BodyWriter constructor signatures to the two-argument form. OR * Define the macro BOOST_BEAST_ALLOW_DEPRECATED in the project (which will accept both the new and the deprecated signatures).
2017-11-13 23:34:14 +01:00
message<isRequest, Body, Fields>,
message<isRequest, Body, Fields> const>::type;
BodyReader may construct from a non-const message fix #619
2017-07-07 14:32:51 -07:00
#endif
private:
Refactor serialization algorithms: serializer interface is changed to be buffer-only, no streams, and placed in its own header file. Operations on serializers are moved to free functions as part of the HTTP write family of synchronous and asynchronous algorithms.
2017-05-28 17:04:39 -07:00
enum
{
Refactor HTTP serialization and parsing (API Change): fix #404 Parsing and serialization interfaces have been fine tuned and unified. For parsing these stream operations are defined: * read * read_header * read_some * async_read * async_read_header * async_read_some For serialization these stream operations are defined: * write * write_header * write_some * async_write * async_write_header * async_write_some
2017-05-31 08:01:55 -07:00
do_construct = 0,
do_init = 10,
do_header_only = 20,
do_header = 30,
Refactor serialization algorithms: serializer interface is changed to be buffer-only, no streams, and placed in its own header file. Operations on serializers are moved to free functions as part of the HTTP write family of synchronous and asynchronous algorithms.
2017-05-28 17:04:39 -07:00
do_body = 40,
do_init_c = 50,
do_header_only_c = 60,
do_header_c = 70,
Serialize in one step when possible fix #546
2017-06-26 18:26:35 -07:00
do_body_c = 80,
do_final_c = 90,
Boost prep
2017-07-20 13:40:34 -07:00
#ifndef BOOST_BEAST_NO_BIG_VARIANTS
Serialize in one step when possible fix #546
2017-06-26 18:26:35 -07:00
do_body_final_c = 100,
do_all_c = 110,
#endif
do_complete = 120
Refactor serialization algorithms: serializer interface is changed to be buffer-only, no streams, and placed in its own header file. Operations on serializers are moved to free functions as part of the HTTP write family of synchronous and asynchronous algorithms.
2017-05-28 17:04:39 -07:00
};
serializer::reader_impl is deprecated: fix #930 * The function serializer::reader_impl is deprecated and will be removed in a subsequent version. * Some private symbols used in the implementation were also renamed to reflect correct terminology. Actions Required: * Call serializer::writer_impl instead of reader_impl
2017-12-11 10:06:27 -08:00
void fwrinit(std::true_type);
void fwrinit(std::false_type);
Refactor serialization algorithms: serializer interface is changed to be buffer-only, no streams, and placed in its own header file. Operations on serializers are moved to free functions as part of the HTTP write family of synchronous and asynchronous algorithms.
2017-05-28 17:04:39 -07:00
Use custom variant
2017-07-20 22:54:54 -07:00
template<std::size_t, class Visit>
Add serializer::limit
2017-07-06 20:58:07 -07:00
void
do_visit(error_code& ec, Visit& visit);
BodyReader and BodyWriter names are swapped (API Change): Body::reader and Body::writer meanings are reversed, for consistency with the names of the stream operations: * Body::reader is used for read, read_some, async_read, async_read_some * Body::writer is used for write, write_some, async_write, async_write_some Actions Required: * Swap the reader and writer names for user defined Body types * Swap use of is_body_reader and is_body_writer
2017-10-30 17:08:52 -07:00
using writer = typename Body::writer;
Refactor serialization algorithms: serializer interface is changed to be buffer-only, no streams, and placed in its own header file. Operations on serializers are moved to free functions as part of the HTTP write family of synchronous and asynchronous algorithms.
2017-05-28 17:04:39 -07:00
buffers_suffix replaces consuming_buffers (API Change): fix #770 * consuming_buffers is renamed to buffers_suffix Actions Required: * Use buffers_suffix instead of consuming_buffers
2017-09-15 12:52:45 -07:00
using cb1_t = buffers_suffix<typename
Fields::writer replaces Fields::reader (API Change): * Fields::writer replaces Fields::reader * The FieldsWriter concept is renamed from FieldsReader Actions Required: * Rename reader to writer for user defined Fields
2017-10-30 16:37:37 -07:00
Fields::writer::const_buffers_type>; // header
buffers_prefix replaces buffer_prefix (API Change) fix #773 * buffer_prefix is renamed to buffers_prefix * buffer_prefix_view is renamed to buffers_prefix_view Actions Required: * Use buffers_prefix instead of buffer_prefix * Use buffers_prefix_view instead of buffer_prefix_view
2017-09-15 09:55:03 -07:00
using pcb1_t = buffers_prefix_view<cb1_t const&>;
Fields concept work
2017-06-06 17:26:11 -07:00
buffers_cat replaces buffer_cat (API Change): fix #773 * buffer_cat is renamed to buffers_cat * buffer_cat_view is renamed to buffers_cat_view Actions Required: * Use buffers_cat instead of buffer_cat * Use buffers_cat_view instead of buffer_cat_view
2017-09-15 10:03:59 -07:00
using cb2_t = buffers_suffix<buffers_cat_view<
Fields::writer replaces Fields::reader (API Change): * Fields::writer replaces Fields::reader * The FieldsWriter concept is renamed from FieldsReader Actions Required: * Rename reader to writer for user defined Fields
2017-10-30 16:37:37 -07:00
typename Fields::writer::const_buffers_type,// header
BodyReader and BodyWriter names are swapped (API Change): Body::reader and Body::writer meanings are reversed, for consistency with the names of the stream operations: * Body::reader is used for read, read_some, async_read, async_read_some * Body::writer is used for write, write_some, async_write, async_write_some Actions Required: * Swap the reader and writer names for user defined Body types * Swap use of is_body_reader and is_body_writer
2017-10-30 17:08:52 -07:00
typename writer::const_buffers_type>>; // body
buffers_prefix replaces buffer_prefix (API Change) fix #773 * buffer_prefix is renamed to buffers_prefix * buffer_prefix_view is renamed to buffers_prefix_view Actions Required: * Use buffers_prefix instead of buffer_prefix * Use buffers_prefix_view instead of buffer_prefix_view
2017-09-15 09:55:03 -07:00
using pcb2_t = buffers_prefix_view<cb2_t const&>;
Refactor serialization algorithms: serializer interface is changed to be buffer-only, no streams, and placed in its own header file. Operations on serializers are moved to free functions as part of the HTTP write family of synchronous and asynchronous algorithms.
2017-05-28 17:04:39 -07:00
buffers_suffix replaces consuming_buffers (API Change): fix #770 * consuming_buffers is renamed to buffers_suffix Actions Required: * Use buffers_suffix instead of consuming_buffers
2017-09-15 12:52:45 -07:00
using cb3_t = buffers_suffix<
BodyReader and BodyWriter names are swapped (API Change): Body::reader and Body::writer meanings are reversed, for consistency with the names of the stream operations: * Body::reader is used for read, read_some, async_read, async_read_some * Body::writer is used for write, write_some, async_write, async_write_some Actions Required: * Swap the reader and writer names for user defined Body types * Swap use of is_body_reader and is_body_writer
2017-10-30 17:08:52 -07:00
typename writer::const_buffers_type>; // body
buffers_prefix replaces buffer_prefix (API Change) fix #773 * buffer_prefix is renamed to buffers_prefix * buffer_prefix_view is renamed to buffers_prefix_view Actions Required: * Use buffers_prefix instead of buffer_prefix * Use buffers_prefix_view instead of buffer_prefix_view
2017-09-15 09:55:03 -07:00
using pcb3_t = buffers_prefix_view<cb3_t const&>;
Refactor serialization algorithms: serializer interface is changed to be buffer-only, no streams, and placed in its own header file. Operations on serializers are moved to free functions as part of the HTTP write family of synchronous and asynchronous algorithms.
2017-05-28 17:04:39 -07:00
buffers_cat replaces buffer_cat (API Change): fix #773 * buffer_cat is renamed to buffers_cat * buffer_cat_view is renamed to buffers_cat_view Actions Required: * Use buffers_cat instead of buffer_cat * Use buffers_cat_view instead of buffer_cat_view
2017-09-15 10:03:59 -07:00
using cb4_t = buffers_suffix<buffers_cat_view<
Fields::writer replaces Fields::reader (API Change): * Fields::writer replaces Fields::reader * The FieldsWriter concept is renamed from FieldsReader Actions Required: * Rename reader to writer for user defined Fields
2017-10-30 16:37:37 -07:00
typename Fields::writer::const_buffers_type,// header
Refactor chunked-encoding serialization: New buffer sequence classes are provided to allow full control over the serialization of chunk-encoded message payloads: * chunk_header A ConstBufferSequence representing the chunk header. It includes a hexadecimal-encoded size, an optional set of chunk extensions, and the trailing CRLF required to denote the end of the chunk header. This allows the caller to manually serialize the chunk body in one or more calls to a stream output function. The caller must also output an object of type `chunk_crlf` to the stream to indicate the end of the chunk body. * chunk_crlf A small ConstBufferSequence that simply represents the two character sequence "\r\n" (CRLF). This is needed for the case where the caller wants to output a chunk body as a series of buffers (i.e. "chunking a chunk"). * chunk_body A ConstBufferSequence representing a complete chunk. This includes the size, an optional set of chunk extensions, a caller provided buffer containing the body, and the required CRLF that follows. * chunk_final A ConstBufferSequence representing a final chunk. It includes an optional set of caller-provided field trailers * chunk_extensions A container for building a set of chunk extensions to use during serialization. The use of the container is optional, callers may provide their own buffer containing a correctly formatted set of chunk extensions, or they may use their own convenience container which meets the requirements. The basic_fields container is modified to allow construction outside the context of a message. The container can be used to provide trailers to `chunk_final`. Actions Required: * Remove references to ChunkDecorators. Use the new chunk-encoding buffer sequences to manually produce a chunked payload body in the case where control over the chunk-extensions and/or trailers is required.
2017-07-09 20:09:30 -07:00
detail::chunk_size, // chunk-size
HTTP tidying
2018-12-19 18:34:51 -08:00
net::const_buffer, // chunk-ext
Refactor chunked-encoding serialization: New buffer sequence classes are provided to allow full control over the serialization of chunk-encoded message payloads: * chunk_header A ConstBufferSequence representing the chunk header. It includes a hexadecimal-encoded size, an optional set of chunk extensions, and the trailing CRLF required to denote the end of the chunk header. This allows the caller to manually serialize the chunk body in one or more calls to a stream output function. The caller must also output an object of type `chunk_crlf` to the stream to indicate the end of the chunk body. * chunk_crlf A small ConstBufferSequence that simply represents the two character sequence "\r\n" (CRLF). This is needed for the case where the caller wants to output a chunk body as a series of buffers (i.e. "chunking a chunk"). * chunk_body A ConstBufferSequence representing a complete chunk. This includes the size, an optional set of chunk extensions, a caller provided buffer containing the body, and the required CRLF that follows. * chunk_final A ConstBufferSequence representing a final chunk. It includes an optional set of caller-provided field trailers * chunk_extensions A container for building a set of chunk extensions to use during serialization. The use of the container is optional, callers may provide their own buffer containing a correctly formatted set of chunk extensions, or they may use their own convenience container which meets the requirements. The basic_fields container is modified to allow construction outside the context of a message. The container can be used to provide trailers to `chunk_final`. Actions Required: * Remove references to ChunkDecorators. Use the new chunk-encoding buffer sequences to manually produce a chunked payload body in the case where control over the chunk-extensions and/or trailers is required.
2017-07-09 20:09:30 -07:00
chunk_crlf, // crlf
BodyReader and BodyWriter names are swapped (API Change): Body::reader and Body::writer meanings are reversed, for consistency with the names of the stream operations: * Body::reader is used for read, read_some, async_read, async_read_some * Body::writer is used for write, write_some, async_write, async_write_some Actions Required: * Swap the reader and writer names for user defined Body types * Swap use of is_body_reader and is_body_writer
2017-10-30 17:08:52 -07:00
typename writer::const_buffers_type, // body
Refactor chunked-encoding serialization: New buffer sequence classes are provided to allow full control over the serialization of chunk-encoded message payloads: * chunk_header A ConstBufferSequence representing the chunk header. It includes a hexadecimal-encoded size, an optional set of chunk extensions, and the trailing CRLF required to denote the end of the chunk header. This allows the caller to manually serialize the chunk body in one or more calls to a stream output function. The caller must also output an object of type `chunk_crlf` to the stream to indicate the end of the chunk body. * chunk_crlf A small ConstBufferSequence that simply represents the two character sequence "\r\n" (CRLF). This is needed for the case where the caller wants to output a chunk body as a series of buffers (i.e. "chunking a chunk"). * chunk_body A ConstBufferSequence representing a complete chunk. This includes the size, an optional set of chunk extensions, a caller provided buffer containing the body, and the required CRLF that follows. * chunk_final A ConstBufferSequence representing a final chunk. It includes an optional set of caller-provided field trailers * chunk_extensions A container for building a set of chunk extensions to use during serialization. The use of the container is optional, callers may provide their own buffer containing a correctly formatted set of chunk extensions, or they may use their own convenience container which meets the requirements. The basic_fields container is modified to allow construction outside the context of a message. The container can be used to provide trailers to `chunk_final`. Actions Required: * Remove references to ChunkDecorators. Use the new chunk-encoding buffer sequences to manually produce a chunked payload body in the case where control over the chunk-extensions and/or trailers is required.
2017-07-09 20:09:30 -07:00
chunk_crlf>>; // crlf
buffers_prefix replaces buffer_prefix (API Change) fix #773 * buffer_prefix is renamed to buffers_prefix * buffer_prefix_view is renamed to buffers_prefix_view Actions Required: * Use buffers_prefix instead of buffer_prefix * Use buffers_prefix_view instead of buffer_prefix_view
2017-09-15 09:55:03 -07:00
using pcb4_t = buffers_prefix_view<cb4_t const&>;
Serialize in one step when possible fix #546
2017-06-26 18:26:35 -07:00
buffers_cat replaces buffer_cat (API Change): fix #773 * buffer_cat is renamed to buffers_cat * buffer_cat_view is renamed to buffers_cat_view Actions Required: * Use buffers_cat instead of buffer_cat * Use buffers_cat_view instead of buffer_cat_view
2017-09-15 10:03:59 -07:00
using cb5_t = buffers_suffix<buffers_cat_view<
Refactor chunked-encoding serialization: New buffer sequence classes are provided to allow full control over the serialization of chunk-encoded message payloads: * chunk_header A ConstBufferSequence representing the chunk header. It includes a hexadecimal-encoded size, an optional set of chunk extensions, and the trailing CRLF required to denote the end of the chunk header. This allows the caller to manually serialize the chunk body in one or more calls to a stream output function. The caller must also output an object of type `chunk_crlf` to the stream to indicate the end of the chunk body. * chunk_crlf A small ConstBufferSequence that simply represents the two character sequence "\r\n" (CRLF). This is needed for the case where the caller wants to output a chunk body as a series of buffers (i.e. "chunking a chunk"). * chunk_body A ConstBufferSequence representing a complete chunk. This includes the size, an optional set of chunk extensions, a caller provided buffer containing the body, and the required CRLF that follows. * chunk_final A ConstBufferSequence representing a final chunk. It includes an optional set of caller-provided field trailers * chunk_extensions A container for building a set of chunk extensions to use during serialization. The use of the container is optional, callers may provide their own buffer containing a correctly formatted set of chunk extensions, or they may use their own convenience container which meets the requirements. The basic_fields container is modified to allow construction outside the context of a message. The container can be used to provide trailers to `chunk_final`. Actions Required: * Remove references to ChunkDecorators. Use the new chunk-encoding buffer sequences to manually produce a chunked payload body in the case where control over the chunk-extensions and/or trailers is required.
2017-07-09 20:09:30 -07:00
detail::chunk_size, // chunk-header
HTTP tidying
2018-12-19 18:34:51 -08:00
net::const_buffer, // chunk-ext
Refactor chunked-encoding serialization: New buffer sequence classes are provided to allow full control over the serialization of chunk-encoded message payloads: * chunk_header A ConstBufferSequence representing the chunk header. It includes a hexadecimal-encoded size, an optional set of chunk extensions, and the trailing CRLF required to denote the end of the chunk header. This allows the caller to manually serialize the chunk body in one or more calls to a stream output function. The caller must also output an object of type `chunk_crlf` to the stream to indicate the end of the chunk body. * chunk_crlf A small ConstBufferSequence that simply represents the two character sequence "\r\n" (CRLF). This is needed for the case where the caller wants to output a chunk body as a series of buffers (i.e. "chunking a chunk"). * chunk_body A ConstBufferSequence representing a complete chunk. This includes the size, an optional set of chunk extensions, a caller provided buffer containing the body, and the required CRLF that follows. * chunk_final A ConstBufferSequence representing a final chunk. It includes an optional set of caller-provided field trailers * chunk_extensions A container for building a set of chunk extensions to use during serialization. The use of the container is optional, callers may provide their own buffer containing a correctly formatted set of chunk extensions, or they may use their own convenience container which meets the requirements. The basic_fields container is modified to allow construction outside the context of a message. The container can be used to provide trailers to `chunk_final`. Actions Required: * Remove references to ChunkDecorators. Use the new chunk-encoding buffer sequences to manually produce a chunked payload body in the case where control over the chunk-extensions and/or trailers is required.
2017-07-09 20:09:30 -07:00
chunk_crlf, // crlf
BodyReader and BodyWriter names are swapped (API Change): Body::reader and Body::writer meanings are reversed, for consistency with the names of the stream operations: * Body::reader is used for read, read_some, async_read, async_read_some * Body::writer is used for write, write_some, async_write, async_write_some Actions Required: * Swap the reader and writer names for user defined Body types * Swap use of is_body_reader and is_body_writer
2017-10-30 17:08:52 -07:00
typename writer::const_buffers_type, // body
Refactor chunked-encoding serialization: New buffer sequence classes are provided to allow full control over the serialization of chunk-encoded message payloads: * chunk_header A ConstBufferSequence representing the chunk header. It includes a hexadecimal-encoded size, an optional set of chunk extensions, and the trailing CRLF required to denote the end of the chunk header. This allows the caller to manually serialize the chunk body in one or more calls to a stream output function. The caller must also output an object of type `chunk_crlf` to the stream to indicate the end of the chunk body. * chunk_crlf A small ConstBufferSequence that simply represents the two character sequence "\r\n" (CRLF). This is needed for the case where the caller wants to output a chunk body as a series of buffers (i.e. "chunking a chunk"). * chunk_body A ConstBufferSequence representing a complete chunk. This includes the size, an optional set of chunk extensions, a caller provided buffer containing the body, and the required CRLF that follows. * chunk_final A ConstBufferSequence representing a final chunk. It includes an optional set of caller-provided field trailers * chunk_extensions A container for building a set of chunk extensions to use during serialization. The use of the container is optional, callers may provide their own buffer containing a correctly formatted set of chunk extensions, or they may use their own convenience container which meets the requirements. The basic_fields container is modified to allow construction outside the context of a message. The container can be used to provide trailers to `chunk_final`. Actions Required: * Remove references to ChunkDecorators. Use the new chunk-encoding buffer sequences to manually produce a chunked payload body in the case where control over the chunk-extensions and/or trailers is required.
2017-07-09 20:09:30 -07:00
chunk_crlf>>; // crlf
buffers_prefix replaces buffer_prefix (API Change) fix #773 * buffer_prefix is renamed to buffers_prefix * buffer_prefix_view is renamed to buffers_prefix_view Actions Required: * Use buffers_prefix instead of buffer_prefix * Use buffers_prefix_view instead of buffer_prefix_view
2017-09-15 09:55:03 -07:00
using pcb5_t = buffers_prefix_view<cb5_t const&>;
Refactor serialization algorithms: serializer interface is changed to be buffer-only, no streams, and placed in its own header file. Operations on serializers are moved to free functions as part of the HTTP write family of synchronous and asynchronous algorithms.
2017-05-28 17:04:39 -07:00
buffers_cat replaces buffer_cat (API Change): fix #773 * buffer_cat is renamed to buffers_cat * buffer_cat_view is renamed to buffers_cat_view Actions Required: * Use buffers_cat instead of buffer_cat * Use buffers_cat_view instead of buffer_cat_view
2017-09-15 10:03:59 -07:00
using cb6_t = buffers_suffix<buffers_cat_view<
Refactor chunked-encoding serialization: New buffer sequence classes are provided to allow full control over the serialization of chunk-encoded message payloads: * chunk_header A ConstBufferSequence representing the chunk header. It includes a hexadecimal-encoded size, an optional set of chunk extensions, and the trailing CRLF required to denote the end of the chunk header. This allows the caller to manually serialize the chunk body in one or more calls to a stream output function. The caller must also output an object of type `chunk_crlf` to the stream to indicate the end of the chunk body. * chunk_crlf A small ConstBufferSequence that simply represents the two character sequence "\r\n" (CRLF). This is needed for the case where the caller wants to output a chunk body as a series of buffers (i.e. "chunking a chunk"). * chunk_body A ConstBufferSequence representing a complete chunk. This includes the size, an optional set of chunk extensions, a caller provided buffer containing the body, and the required CRLF that follows. * chunk_final A ConstBufferSequence representing a final chunk. It includes an optional set of caller-provided field trailers * chunk_extensions A container for building a set of chunk extensions to use during serialization. The use of the container is optional, callers may provide their own buffer containing a correctly formatted set of chunk extensions, or they may use their own convenience container which meets the requirements. The basic_fields container is modified to allow construction outside the context of a message. The container can be used to provide trailers to `chunk_final`. Actions Required: * Remove references to ChunkDecorators. Use the new chunk-encoding buffer sequences to manually produce a chunked payload body in the case where control over the chunk-extensions and/or trailers is required.
2017-07-09 20:09:30 -07:00
detail::chunk_size, // chunk-header
HTTP tidying
2018-12-19 18:34:51 -08:00
net::const_buffer, // chunk-size
Refactor chunked-encoding serialization: New buffer sequence classes are provided to allow full control over the serialization of chunk-encoded message payloads: * chunk_header A ConstBufferSequence representing the chunk header. It includes a hexadecimal-encoded size, an optional set of chunk extensions, and the trailing CRLF required to denote the end of the chunk header. This allows the caller to manually serialize the chunk body in one or more calls to a stream output function. The caller must also output an object of type `chunk_crlf` to the stream to indicate the end of the chunk body. * chunk_crlf A small ConstBufferSequence that simply represents the two character sequence "\r\n" (CRLF). This is needed for the case where the caller wants to output a chunk body as a series of buffers (i.e. "chunking a chunk"). * chunk_body A ConstBufferSequence representing a complete chunk. This includes the size, an optional set of chunk extensions, a caller provided buffer containing the body, and the required CRLF that follows. * chunk_final A ConstBufferSequence representing a final chunk. It includes an optional set of caller-provided field trailers * chunk_extensions A container for building a set of chunk extensions to use during serialization. The use of the container is optional, callers may provide their own buffer containing a correctly formatted set of chunk extensions, or they may use their own convenience container which meets the requirements. The basic_fields container is modified to allow construction outside the context of a message. The container can be used to provide trailers to `chunk_final`. Actions Required: * Remove references to ChunkDecorators. Use the new chunk-encoding buffer sequences to manually produce a chunked payload body in the case where control over the chunk-extensions and/or trailers is required.
2017-07-09 20:09:30 -07:00
chunk_crlf, // crlf
BodyReader and BodyWriter names are swapped (API Change): Body::reader and Body::writer meanings are reversed, for consistency with the names of the stream operations: * Body::reader is used for read, read_some, async_read, async_read_some * Body::writer is used for write, write_some, async_write, async_write_some Actions Required: * Swap the reader and writer names for user defined Body types * Swap use of is_body_reader and is_body_writer
2017-10-30 17:08:52 -07:00
typename writer::const_buffers_type, // body
Refactor chunked-encoding serialization: New buffer sequence classes are provided to allow full control over the serialization of chunk-encoded message payloads: * chunk_header A ConstBufferSequence representing the chunk header. It includes a hexadecimal-encoded size, an optional set of chunk extensions, and the trailing CRLF required to denote the end of the chunk header. This allows the caller to manually serialize the chunk body in one or more calls to a stream output function. The caller must also output an object of type `chunk_crlf` to the stream to indicate the end of the chunk body. * chunk_crlf A small ConstBufferSequence that simply represents the two character sequence "\r\n" (CRLF). This is needed for the case where the caller wants to output a chunk body as a series of buffers (i.e. "chunking a chunk"). * chunk_body A ConstBufferSequence representing a complete chunk. This includes the size, an optional set of chunk extensions, a caller provided buffer containing the body, and the required CRLF that follows. * chunk_final A ConstBufferSequence representing a final chunk. It includes an optional set of caller-provided field trailers * chunk_extensions A container for building a set of chunk extensions to use during serialization. The use of the container is optional, callers may provide their own buffer containing a correctly formatted set of chunk extensions, or they may use their own convenience container which meets the requirements. The basic_fields container is modified to allow construction outside the context of a message. The container can be used to provide trailers to `chunk_final`. Actions Required: * Remove references to ChunkDecorators. Use the new chunk-encoding buffer sequences to manually produce a chunked payload body in the case where control over the chunk-extensions and/or trailers is required.
2017-07-09 20:09:30 -07:00
chunk_crlf, // crlf
HTTP tidying
2018-12-19 18:34:51 -08:00
net::const_buffer, // chunk-final
net::const_buffer, // trailers
Refactor chunked-encoding serialization: New buffer sequence classes are provided to allow full control over the serialization of chunk-encoded message payloads: * chunk_header A ConstBufferSequence representing the chunk header. It includes a hexadecimal-encoded size, an optional set of chunk extensions, and the trailing CRLF required to denote the end of the chunk header. This allows the caller to manually serialize the chunk body in one or more calls to a stream output function. The caller must also output an object of type `chunk_crlf` to the stream to indicate the end of the chunk body. * chunk_crlf A small ConstBufferSequence that simply represents the two character sequence "\r\n" (CRLF). This is needed for the case where the caller wants to output a chunk body as a series of buffers (i.e. "chunking a chunk"). * chunk_body A ConstBufferSequence representing a complete chunk. This includes the size, an optional set of chunk extensions, a caller provided buffer containing the body, and the required CRLF that follows. * chunk_final A ConstBufferSequence representing a final chunk. It includes an optional set of caller-provided field trailers * chunk_extensions A container for building a set of chunk extensions to use during serialization. The use of the container is optional, callers may provide their own buffer containing a correctly formatted set of chunk extensions, or they may use their own convenience container which meets the requirements. The basic_fields container is modified to allow construction outside the context of a message. The container can be used to provide trailers to `chunk_final`. Actions Required: * Remove references to ChunkDecorators. Use the new chunk-encoding buffer sequences to manually produce a chunked payload body in the case where control over the chunk-extensions and/or trailers is required.
2017-07-09 20:09:30 -07:00
chunk_crlf>>; // crlf
buffers_prefix replaces buffer_prefix (API Change) fix #773 * buffer_prefix is renamed to buffers_prefix * buffer_prefix_view is renamed to buffers_prefix_view Actions Required: * Use buffers_prefix instead of buffer_prefix * Use buffers_prefix_view instead of buffer_prefix_view
2017-09-15 09:55:03 -07:00
using pcb6_t = buffers_prefix_view<cb6_t const&>;
Serialize in one step when possible fix #546
2017-06-26 18:26:35 -07:00
buffers_cat replaces buffer_cat (API Change): fix #773 * buffer_cat is renamed to buffers_cat * buffer_cat_view is renamed to buffers_cat_view Actions Required: * Use buffers_cat instead of buffer_cat * Use buffers_cat_view instead of buffer_cat_view
2017-09-15 10:03:59 -07:00
using cb7_t = buffers_suffix<buffers_cat_view<
Fields::writer replaces Fields::reader (API Change): * Fields::writer replaces Fields::reader * The FieldsWriter concept is renamed from FieldsReader Actions Required: * Rename reader to writer for user defined Fields
2017-10-30 16:37:37 -07:00
typename Fields::writer::const_buffers_type,// header
Refactor chunked-encoding serialization: New buffer sequence classes are provided to allow full control over the serialization of chunk-encoded message payloads: * chunk_header A ConstBufferSequence representing the chunk header. It includes a hexadecimal-encoded size, an optional set of chunk extensions, and the trailing CRLF required to denote the end of the chunk header. This allows the caller to manually serialize the chunk body in one or more calls to a stream output function. The caller must also output an object of type `chunk_crlf` to the stream to indicate the end of the chunk body. * chunk_crlf A small ConstBufferSequence that simply represents the two character sequence "\r\n" (CRLF). This is needed for the case where the caller wants to output a chunk body as a series of buffers (i.e. "chunking a chunk"). * chunk_body A ConstBufferSequence representing a complete chunk. This includes the size, an optional set of chunk extensions, a caller provided buffer containing the body, and the required CRLF that follows. * chunk_final A ConstBufferSequence representing a final chunk. It includes an optional set of caller-provided field trailers * chunk_extensions A container for building a set of chunk extensions to use during serialization. The use of the container is optional, callers may provide their own buffer containing a correctly formatted set of chunk extensions, or they may use their own convenience container which meets the requirements. The basic_fields container is modified to allow construction outside the context of a message. The container can be used to provide trailers to `chunk_final`. Actions Required: * Remove references to ChunkDecorators. Use the new chunk-encoding buffer sequences to manually produce a chunked payload body in the case where control over the chunk-extensions and/or trailers is required.
2017-07-09 20:09:30 -07:00
detail::chunk_size, // chunk-size
HTTP tidying
2018-12-19 18:34:51 -08:00
net::const_buffer, // chunk-ext
Refactor chunked-encoding serialization: New buffer sequence classes are provided to allow full control over the serialization of chunk-encoded message payloads: * chunk_header A ConstBufferSequence representing the chunk header. It includes a hexadecimal-encoded size, an optional set of chunk extensions, and the trailing CRLF required to denote the end of the chunk header. This allows the caller to manually serialize the chunk body in one or more calls to a stream output function. The caller must also output an object of type `chunk_crlf` to the stream to indicate the end of the chunk body. * chunk_crlf A small ConstBufferSequence that simply represents the two character sequence "\r\n" (CRLF). This is needed for the case where the caller wants to output a chunk body as a series of buffers (i.e. "chunking a chunk"). * chunk_body A ConstBufferSequence representing a complete chunk. This includes the size, an optional set of chunk extensions, a caller provided buffer containing the body, and the required CRLF that follows. * chunk_final A ConstBufferSequence representing a final chunk. It includes an optional set of caller-provided field trailers * chunk_extensions A container for building a set of chunk extensions to use during serialization. The use of the container is optional, callers may provide their own buffer containing a correctly formatted set of chunk extensions, or they may use their own convenience container which meets the requirements. The basic_fields container is modified to allow construction outside the context of a message. The container can be used to provide trailers to `chunk_final`. Actions Required: * Remove references to ChunkDecorators. Use the new chunk-encoding buffer sequences to manually produce a chunked payload body in the case where control over the chunk-extensions and/or trailers is required.
2017-07-09 20:09:30 -07:00
chunk_crlf, // crlf
BodyReader and BodyWriter names are swapped (API Change): Body::reader and Body::writer meanings are reversed, for consistency with the names of the stream operations: * Body::reader is used for read, read_some, async_read, async_read_some * Body::writer is used for write, write_some, async_write, async_write_some Actions Required: * Swap the reader and writer names for user defined Body types * Swap use of is_body_reader and is_body_writer
2017-10-30 17:08:52 -07:00
typename writer::const_buffers_type, // body
Refactor chunked-encoding serialization: New buffer sequence classes are provided to allow full control over the serialization of chunk-encoded message payloads: * chunk_header A ConstBufferSequence representing the chunk header. It includes a hexadecimal-encoded size, an optional set of chunk extensions, and the trailing CRLF required to denote the end of the chunk header. This allows the caller to manually serialize the chunk body in one or more calls to a stream output function. The caller must also output an object of type `chunk_crlf` to the stream to indicate the end of the chunk body. * chunk_crlf A small ConstBufferSequence that simply represents the two character sequence "\r\n" (CRLF). This is needed for the case where the caller wants to output a chunk body as a series of buffers (i.e. "chunking a chunk"). * chunk_body A ConstBufferSequence representing a complete chunk. This includes the size, an optional set of chunk extensions, a caller provided buffer containing the body, and the required CRLF that follows. * chunk_final A ConstBufferSequence representing a final chunk. It includes an optional set of caller-provided field trailers * chunk_extensions A container for building a set of chunk extensions to use during serialization. The use of the container is optional, callers may provide their own buffer containing a correctly formatted set of chunk extensions, or they may use their own convenience container which meets the requirements. The basic_fields container is modified to allow construction outside the context of a message. The container can be used to provide trailers to `chunk_final`. Actions Required: * Remove references to ChunkDecorators. Use the new chunk-encoding buffer sequences to manually produce a chunked payload body in the case where control over the chunk-extensions and/or trailers is required.
2017-07-09 20:09:30 -07:00
chunk_crlf, // crlf
HTTP tidying
2018-12-19 18:34:51 -08:00
net::const_buffer, // chunk-final
net::const_buffer, // trailers
Refactor chunked-encoding serialization: New buffer sequence classes are provided to allow full control over the serialization of chunk-encoded message payloads: * chunk_header A ConstBufferSequence representing the chunk header. It includes a hexadecimal-encoded size, an optional set of chunk extensions, and the trailing CRLF required to denote the end of the chunk header. This allows the caller to manually serialize the chunk body in one or more calls to a stream output function. The caller must also output an object of type `chunk_crlf` to the stream to indicate the end of the chunk body. * chunk_crlf A small ConstBufferSequence that simply represents the two character sequence "\r\n" (CRLF). This is needed for the case where the caller wants to output a chunk body as a series of buffers (i.e. "chunking a chunk"). * chunk_body A ConstBufferSequence representing a complete chunk. This includes the size, an optional set of chunk extensions, a caller provided buffer containing the body, and the required CRLF that follows. * chunk_final A ConstBufferSequence representing a final chunk. It includes an optional set of caller-provided field trailers * chunk_extensions A container for building a set of chunk extensions to use during serialization. The use of the container is optional, callers may provide their own buffer containing a correctly formatted set of chunk extensions, or they may use their own convenience container which meets the requirements. The basic_fields container is modified to allow construction outside the context of a message. The container can be used to provide trailers to `chunk_final`. Actions Required: * Remove references to ChunkDecorators. Use the new chunk-encoding buffer sequences to manually produce a chunked payload body in the case where control over the chunk-extensions and/or trailers is required.
2017-07-09 20:09:30 -07:00
chunk_crlf>>; // crlf
buffers_prefix replaces buffer_prefix (API Change) fix #773 * buffer_prefix is renamed to buffers_prefix * buffer_prefix_view is renamed to buffers_prefix_view Actions Required: * Use buffers_prefix instead of buffer_prefix * Use buffers_prefix_view instead of buffer_prefix_view
2017-09-15 09:55:03 -07:00
using pcb7_t = buffers_prefix_view<cb7_t const&>;
Serialize in one step when possible fix #546
2017-06-26 18:26:35 -07:00
buffers_cat replaces buffer_cat (API Change): fix #773 * buffer_cat is renamed to buffers_cat * buffer_cat_view is renamed to buffers_cat_view Actions Required: * Use buffers_cat instead of buffer_cat * Use buffers_cat_view instead of buffer_cat_view
2017-09-15 10:03:59 -07:00
using cb8_t = buffers_suffix<buffers_cat_view<
HTTP tidying
2018-12-19 18:34:51 -08:00
net::const_buffer, // chunk-final
net::const_buffer, // trailers
Refactor chunked-encoding serialization: New buffer sequence classes are provided to allow full control over the serialization of chunk-encoded message payloads: * chunk_header A ConstBufferSequence representing the chunk header. It includes a hexadecimal-encoded size, an optional set of chunk extensions, and the trailing CRLF required to denote the end of the chunk header. This allows the caller to manually serialize the chunk body in one or more calls to a stream output function. The caller must also output an object of type `chunk_crlf` to the stream to indicate the end of the chunk body. * chunk_crlf A small ConstBufferSequence that simply represents the two character sequence "\r\n" (CRLF). This is needed for the case where the caller wants to output a chunk body as a series of buffers (i.e. "chunking a chunk"). * chunk_body A ConstBufferSequence representing a complete chunk. This includes the size, an optional set of chunk extensions, a caller provided buffer containing the body, and the required CRLF that follows. * chunk_final A ConstBufferSequence representing a final chunk. It includes an optional set of caller-provided field trailers * chunk_extensions A container for building a set of chunk extensions to use during serialization. The use of the container is optional, callers may provide their own buffer containing a correctly formatted set of chunk extensions, or they may use their own convenience container which meets the requirements. The basic_fields container is modified to allow construction outside the context of a message. The container can be used to provide trailers to `chunk_final`. Actions Required: * Remove references to ChunkDecorators. Use the new chunk-encoding buffer sequences to manually produce a chunked payload body in the case where control over the chunk-extensions and/or trailers is required.
2017-07-09 20:09:30 -07:00
chunk_crlf>>; // crlf
buffers_prefix replaces buffer_prefix (API Change) fix #773 * buffer_prefix is renamed to buffers_prefix * buffer_prefix_view is renamed to buffers_prefix_view Actions Required: * Use buffers_prefix instead of buffer_prefix * Use buffers_prefix_view instead of buffer_prefix_view
2017-09-15 09:55:03 -07:00
using pcb8_t = buffers_prefix_view<cb8_t const&>;
Refactor serialization algorithms: serializer interface is changed to be buffer-only, no streams, and placed in its own header file. Operations on serializers are moved to free functions as part of the HTTP write family of synchronous and asynchronous algorithms.
2017-05-28 17:04:39 -07:00
BodyReader may construct from a non-const message fix #619
2017-07-07 14:32:51 -07:00
value_type& m_;
serializer::reader_impl is deprecated: fix #930 * The function serializer::reader_impl is deprecated and will be removed in a subsequent version. * Some private symbols used in the implementation were also renamed to reflect correct terminology. Actions Required: * Call serializer::writer_impl instead of reader_impl
2017-12-11 10:06:27 -08:00
writer wr_;
boost::optional<typename Fields::writer> fwr_;
Use custom variant
2017-07-20 22:54:54 -07:00
beast::detail::variant<
cb1_t, cb2_t, cb3_t, cb4_t,
cb5_t ,cb6_t, cb7_t, cb8_t> v_;
beast::detail::variant<
pcb1_t, pcb2_t, pcb3_t, pcb4_t,
pcb5_t ,pcb6_t, pcb7_t, pcb8_t> pv_;
Add serializer::limit
2017-07-06 20:58:07 -07:00
std::size_t limit_ =
(std::numeric_limits<std::size_t>::max)();
Refactor HTTP serialization and parsing (API Change): fix #404 Parsing and serialization interfaces have been fine tuned and unified. For parsing these stream operations are defined: * read * read_header * read_some * async_read * async_read_header * async_read_some For serialization these stream operations are defined: * write * write_header * write_some * async_write * async_write_header * async_write_some
2017-05-31 08:01:55 -07:00
int s_ = do_construct;
Remove BodyReader::is_deferred (API Change): The is_deferred nested type is removed from the BodyReader requirements. Performance for sending messages with `file_body` was cut almost in half with is_deferred as `std::true_type` since it caused double the number of socket writes. If the deferred behavior is absolutely necessary, callers can get the same effect by manually sending the headers first. Actions Required: * Callers who need the behavior of is_deferred as `std::true_type` should manually construct a serializer and serialize the header first, followed by the body.
2017-06-25 10:14:18 -07:00
bool split_ = false;
Refactor serialization algorithms: serializer interface is changed to be buffer-only, no streams, and placed in its own header file. Operations on serializers are moved to free functions as part of the HTTP write family of synchronous and asynchronous algorithms.
2017-05-28 17:04:39 -07:00
bool header_done_ = false;
Tidying
2019-02-05 08:24:26 -08:00
bool more_ = false;
Refactor serialization algorithms: serializer interface is changed to be buffer-only, no streams, and placed in its own header file. Operations on serializers are moved to free functions as part of the HTTP write family of synchronous and asynchronous algorithms.
2017-05-28 17:04:39 -07:00
public:
Use custom variant
2017-07-20 22:54:54 -07:00
/// Constructor
serializer(serializer&&) = default;
/// Constructor
serializer(serializer const&) = default;
/// Assignment
serializer& operator=(serializer const&) = delete;
Refactor serialization algorithms: serializer interface is changed to be buffer-only, no streams, and placed in its own header file. Operations on serializers are moved to free functions as part of the HTTP write family of synchronous and asynchronous algorithms.
2017-05-28 17:04:39 -07:00
/** Constructor
Refactor HTTP serialization and parsing (API Change): fix #404 Parsing and serialization interfaces have been fine tuned and unified. For parsing these stream operations are defined: * read * read_header * read_some * async_read * async_read_header * async_read_some For serialization these stream operations are defined: * write * write_header * write_some * async_write * async_write_header * async_write_some
2017-05-31 08:01:55 -07:00
The implementation guarantees that the message passed on
construction will not be accessed until the first call to
serializer::next replaces serializer::get (API Change): Actions Required: * Use serializer::next instead of serializer::get at call sites
2017-07-04 01:17:56 -07:00
@ref next. This allows the message to be lazily created.
Refactor HTTP serialization and parsing (API Change): fix #404 Parsing and serialization interfaces have been fine tuned and unified. For parsing these stream operations are defined: * read * read_header * read_some * async_read * async_read_header * async_read_some For serialization these stream operations are defined: * write * write_header * write_some * async_write * async_write_header * async_write_some
2017-05-31 08:01:55 -07:00
For example, if the header is filled in before serialization.
BodyReader may construct from a non-const message fix #619
2017-07-07 14:32:51 -07:00
@param msg A reference to the message to serialize, which must
remain valid for the lifetime of the serializer. Depending on
the type of Body used, this may or may not be a `const` reference.
@note This function participates in overload resolution only if
BodyReader and BodyWriter names are swapped (API Change): Body::reader and Body::writer meanings are reversed, for consistency with the names of the stream operations: * Body::reader is used for read, read_some, async_read, async_read_some * Body::writer is used for write, write_some, async_write, async_write_some Actions Required: * Swap the reader and writer names for user defined Body types * Swap use of is_body_reader and is_body_writer
2017-10-30 17:08:52 -07:00
Body::writer is constructible from a `const` message reference.
BodyReader may construct from a non-const message fix #619
2017-07-07 14:32:51 -07:00
*/
explicit
serializer(value_type& msg);
Add serializer::get
2017-07-07 09:16:51 -07:00
/// Returns the message being serialized
value_type&
get()
{
return m_;
}
Add serializer::limit
2017-07-06 20:58:07 -07:00
/// Returns the serialized buffer size limit
std::size_t
Serializer members are not const
2017-07-07 23:49:02 -07:00
limit()
Add serializer::limit
2017-07-06 20:58:07 -07:00
{
return limit_;
}
/** Set the serialized buffer size limit
This function adjusts the limit on the maximum size of the
buffers passed to the visitor. The new size limit takes effect
in the following call to @ref next.
The default is no buffer size limit.
@param limit The new buffer size limit. If this number
is zero, the size limit is removed.
*/
void
limit(std::size_t limit)
{
Add file_body_win32: basic_file_body is specialized for file_win32: When serializing file bodies to stream sockets on Windows, the native platform function ::TransmitFile is used, improving performance.
2017-07-07 09:03:06 -07:00
limit_ = limit > 0 ? limit :
Add serializer::limit
2017-07-06 20:58:07 -07:00
(std::numeric_limits<std::size_t>::max)();
}
Documentation work
2017-05-28 19:49:41 -07:00
/** Returns `true` if we will pause after writing the complete header.
Refactor serialization algorithms: serializer interface is changed to be buffer-only, no streams, and placed in its own header file. Operations on serializers are moved to free functions as part of the HTTP write family of synchronous and asynchronous algorithms.
2017-05-28 17:04:39 -07:00
*/
bool
Serializer members are not const
2017-07-07 23:49:02 -07:00
split()
Refactor serialization algorithms: serializer interface is changed to be buffer-only, no streams, and placed in its own header file. Operations on serializers are moved to free functions as part of the HTTP write family of synchronous and asynchronous algorithms.
2017-05-28 17:04:39 -07:00
{
return split_;
}
/** Set whether the header and body are written separately.
When the split feature is enabled, the implementation will
write only the octets corresponding to the serialized header
first. If the header has already been written, this function
Remove BodyReader::is_deferred (API Change): The is_deferred nested type is removed from the BodyReader requirements. Performance for sending messages with `file_body` was cut almost in half with is_deferred as `std::true_type` since it caused double the number of socket writes. If the deferred behavior is absolutely necessary, callers can get the same effect by manually sending the headers first. Actions Required: * Callers who need the behavior of is_deferred as `std::true_type` should manually construct a serializer and serialize the header first, followed by the body.
2017-06-25 10:14:18 -07:00
will have no effect on output.
Refactor serialization algorithms: serializer interface is changed to be buffer-only, no streams, and placed in its own header file. Operations on serializers are moved to free functions as part of the HTTP write family of synchronous and asynchronous algorithms.
2017-05-28 17:04:39 -07:00
*/
void
split(bool v)
{
Remove BodyReader::is_deferred (API Change): The is_deferred nested type is removed from the BodyReader requirements. Performance for sending messages with `file_body` was cut almost in half with is_deferred as `std::true_type` since it caused double the number of socket writes. If the deferred behavior is absolutely necessary, callers can get the same effect by manually sending the headers first. Actions Required: * Callers who need the behavior of is_deferred as `std::true_type` should manually construct a serializer and serialize the header first, followed by the body.
2017-06-25 10:14:18 -07:00
split_ = v;
Refactor serialization algorithms: serializer interface is changed to be buffer-only, no streams, and placed in its own header file. Operations on serializers are moved to free functions as part of the HTTP write family of synchronous and asynchronous algorithms.
2017-05-28 17:04:39 -07:00
}
/** Return `true` if serialization of the header is complete.
Documentation work
2017-05-28 19:49:41 -07:00
This function indicates whether or not all buffers containing
serialized header octets have been retrieved.
Refactor serialization algorithms: serializer interface is changed to be buffer-only, no streams, and placed in its own header file. Operations on serializers are moved to free functions as part of the HTTP write family of synchronous and asynchronous algorithms.
2017-05-28 17:04:39 -07:00
*/
bool
Serializer members are not const
2017-07-07 23:49:02 -07:00
is_header_done()
Refactor serialization algorithms: serializer interface is changed to be buffer-only, no streams, and placed in its own header file. Operations on serializers are moved to free functions as part of the HTTP write family of synchronous and asynchronous algorithms.
2017-05-28 17:04:39 -07:00
{
return header_done_;
}
Documentation work
2017-05-28 19:49:41 -07:00
/** Return `true` if serialization is complete.
Refactor serialization algorithms: serializer interface is changed to be buffer-only, no streams, and placed in its own header file. Operations on serializers are moved to free functions as part of the HTTP write family of synchronous and asynchronous algorithms.
2017-05-28 17:04:39 -07:00
The operation is complete when all octets corresponding
to the serialized representation of the message have been
Documentation work
2017-05-28 19:49:41 -07:00
successfully retrieved.
Refactor serialization algorithms: serializer interface is changed to be buffer-only, no streams, and placed in its own header file. Operations on serializers are moved to free functions as part of the HTTP write family of synchronous and asynchronous algorithms.
2017-05-28 17:04:39 -07:00
*/
bool
Serializer members are not const
2017-07-07 23:49:02 -07:00
is_done()
Refactor serialization algorithms: serializer interface is changed to be buffer-only, no streams, and placed in its own header file. Operations on serializers are moved to free functions as part of the HTTP write family of synchronous and asynchronous algorithms.
2017-05-28 17:04:39 -07:00
{
return s_ == do_complete;
}
/** Returns the next set of buffers in the serialization.
This function will attempt to call the `visit` function
object with a @b ConstBufferSequence of unspecified type
representing the next set of buffers in the serialization
of the message represented by this object.
If there are no more buffers in the serialization, the
visit function will not be called. In this case, no error
will be indicated, and the function @ref is_done will
return `true`.
@param ec Set to the error, if any occurred.
@param visit The function to call. The equivalent function
signature of this object must be:
Documentation work
2017-05-28 19:49:41 -07:00
@code
template<class ConstBufferSequence>
Refactor serialization algorithms: serializer interface is changed to be buffer-only, no streams, and placed in its own header file. Operations on serializers are moved to free functions as part of the HTTP write family of synchronous and asynchronous algorithms.
2017-05-28 17:04:39 -07:00
void visit(error_code&, ConstBufferSequence const&);
@endcode
The function is not copied, if no error occurs it will be
serializer::next replaces serializer::get (API Change): Actions Required: * Use serializer::next instead of serializer::get at call sites
2017-07-04 01:17:56 -07:00
invoked before the call to @ref next returns.
Refactor serialization algorithms: serializer interface is changed to be buffer-only, no streams, and placed in its own header file. Operations on serializers are moved to free functions as part of the HTTP write family of synchronous and asynchronous algorithms.
2017-05-28 17:04:39 -07:00
*/
template<class Visit>
void
serializer::next replaces serializer::get (API Change): Actions Required: * Use serializer::next instead of serializer::get at call sites
2017-07-04 01:17:56 -07:00
next(error_code& ec, Visit&& visit);
Refactor serialization algorithms: serializer interface is changed to be buffer-only, no streams, and placed in its own header file. Operations on serializers are moved to free functions as part of the HTTP write family of synchronous and asynchronous algorithms.
2017-05-28 17:04:39 -07:00
/** Consume buffer octets in the serialization.
This function should be called after one or more octets
contained in the buffers provided in the prior call
serializer::next replaces serializer::get (API Change): Actions Required: * Use serializer::next instead of serializer::get at call sites
2017-07-04 01:17:56 -07:00
to @ref next have been used.
Refactor serialization algorithms: serializer interface is changed to be buffer-only, no streams, and placed in its own header file. Operations on serializers are moved to free functions as part of the HTTP write family of synchronous and asynchronous algorithms.
2017-05-28 17:04:39 -07:00
After a call to @ref consume, callers should check the
return value of @ref is_done to determine if the entire
message has been serialized.
@param n The number of octets to consume. This number must
be greater than zero and no greater than the number of
serializer::next replaces serializer::get (API Change): Actions Required: * Use serializer::next instead of serializer::get at call sites
2017-07-04 01:17:56 -07:00
octets in the buffers provided in the prior call to @ref next.
Refactor serialization algorithms: serializer interface is changed to be buffer-only, no streams, and placed in its own header file. Operations on serializers are moved to free functions as part of the HTTP write family of synchronous and asynchronous algorithms.
2017-05-28 17:04:39 -07:00
*/
void
consume(std::size_t n);
Refactor chunked-encoding serialization: New buffer sequence classes are provided to allow full control over the serialization of chunk-encoded message payloads: * chunk_header A ConstBufferSequence representing the chunk header. It includes a hexadecimal-encoded size, an optional set of chunk extensions, and the trailing CRLF required to denote the end of the chunk header. This allows the caller to manually serialize the chunk body in one or more calls to a stream output function. The caller must also output an object of type `chunk_crlf` to the stream to indicate the end of the chunk body. * chunk_crlf A small ConstBufferSequence that simply represents the two character sequence "\r\n" (CRLF). This is needed for the case where the caller wants to output a chunk body as a series of buffers (i.e. "chunking a chunk"). * chunk_body A ConstBufferSequence representing a complete chunk. This includes the size, an optional set of chunk extensions, a caller provided buffer containing the body, and the required CRLF that follows. * chunk_final A ConstBufferSequence representing a final chunk. It includes an optional set of caller-provided field trailers * chunk_extensions A container for building a set of chunk extensions to use during serialization. The use of the container is optional, callers may provide their own buffer containing a correctly formatted set of chunk extensions, or they may use their own convenience container which meets the requirements. The basic_fields container is modified to allow construction outside the context of a message. The container can be used to provide trailers to `chunk_final`. Actions Required: * Remove references to ChunkDecorators. Use the new chunk-encoding buffer sequences to manually produce a chunked payload body in the case where control over the chunk-extensions and/or trailers is required.
2017-07-09 20:09:30 -07:00
serializer::reader_impl is deprecated: fix #930 * The function serializer::reader_impl is deprecated and will be removed in a subsequent version. * Some private symbols used in the implementation were also renamed to reflect correct terminology. Actions Required: * Call serializer::writer_impl instead of reader_impl
2017-12-11 10:06:27 -08:00
/** Provides low-level access to the associated @b BodyWriter
This function provides access to the instance of the writer
associated with the body and created by the serializer
upon construction. The behavior of accessing this object
is defined by the specification of the particular writer
and its associated body.
@return A reference to the writer.
*/
writer&
writer_impl()
{
return wr_;
Refactor chunked-encoding serialization: New buffer sequence classes are provided to allow full control over the serialization of chunk-encoded message payloads: * chunk_header A ConstBufferSequence representing the chunk header. It includes a hexadecimal-encoded size, an optional set of chunk extensions, and the trailing CRLF required to denote the end of the chunk header. This allows the caller to manually serialize the chunk body in one or more calls to a stream output function. The caller must also output an object of type `chunk_crlf` to the stream to indicate the end of the chunk body. * chunk_crlf A small ConstBufferSequence that simply represents the two character sequence "\r\n" (CRLF). This is needed for the case where the caller wants to output a chunk body as a series of buffers (i.e. "chunking a chunk"). * chunk_body A ConstBufferSequence representing a complete chunk. This includes the size, an optional set of chunk extensions, a caller provided buffer containing the body, and the required CRLF that follows. * chunk_final A ConstBufferSequence representing a final chunk. It includes an optional set of caller-provided field trailers * chunk_extensions A container for building a set of chunk extensions to use during serialization. The use of the container is optional, callers may provide their own buffer containing a correctly formatted set of chunk extensions, or they may use their own convenience container which meets the requirements. The basic_fields container is modified to allow construction outside the context of a message. The container can be used to provide trailers to `chunk_final`. Actions Required: * Remove references to ChunkDecorators. Use the new chunk-encoding buffer sequences to manually produce a chunked payload body in the case where control over the chunk-extensions and/or trailers is required.
2017-07-09 20:09:30 -07:00
}
Refactor serialization algorithms: serializer interface is changed to be buffer-only, no streams, and placed in its own header file. Operations on serializers are moved to free functions as part of the HTTP write family of synchronous and asynchronous algorithms.
2017-05-28 17:04:39 -07:00
};
Add serializer request/response aliases
2017-06-22 22:17:45 -07:00
/// A serializer for HTTP/1 requests
Refactor chunked-encoding serialization: New buffer sequence classes are provided to allow full control over the serialization of chunk-encoded message payloads: * chunk_header A ConstBufferSequence representing the chunk header. It includes a hexadecimal-encoded size, an optional set of chunk extensions, and the trailing CRLF required to denote the end of the chunk header. This allows the caller to manually serialize the chunk body in one or more calls to a stream output function. The caller must also output an object of type `chunk_crlf` to the stream to indicate the end of the chunk body. * chunk_crlf A small ConstBufferSequence that simply represents the two character sequence "\r\n" (CRLF). This is needed for the case where the caller wants to output a chunk body as a series of buffers (i.e. "chunking a chunk"). * chunk_body A ConstBufferSequence representing a complete chunk. This includes the size, an optional set of chunk extensions, a caller provided buffer containing the body, and the required CRLF that follows. * chunk_final A ConstBufferSequence representing a final chunk. It includes an optional set of caller-provided field trailers * chunk_extensions A container for building a set of chunk extensions to use during serialization. The use of the container is optional, callers may provide their own buffer containing a correctly formatted set of chunk extensions, or they may use their own convenience container which meets the requirements. The basic_fields container is modified to allow construction outside the context of a message. The container can be used to provide trailers to `chunk_final`. Actions Required: * Remove references to ChunkDecorators. Use the new chunk-encoding buffer sequences to manually produce a chunked payload body in the case where control over the chunk-extensions and/or trailers is required.
2017-07-09 20:09:30 -07:00
template<class Body, class Fields = fields>
using request_serializer = serializer<true, Body, Fields>;
Add serializer request/response aliases
2017-06-22 22:17:45 -07:00
/// A serializer for HTTP/1 responses
Refactor chunked-encoding serialization: New buffer sequence classes are provided to allow full control over the serialization of chunk-encoded message payloads: * chunk_header A ConstBufferSequence representing the chunk header. It includes a hexadecimal-encoded size, an optional set of chunk extensions, and the trailing CRLF required to denote the end of the chunk header. This allows the caller to manually serialize the chunk body in one or more calls to a stream output function. The caller must also output an object of type `chunk_crlf` to the stream to indicate the end of the chunk body. * chunk_crlf A small ConstBufferSequence that simply represents the two character sequence "\r\n" (CRLF). This is needed for the case where the caller wants to output a chunk body as a series of buffers (i.e. "chunking a chunk"). * chunk_body A ConstBufferSequence representing a complete chunk. This includes the size, an optional set of chunk extensions, a caller provided buffer containing the body, and the required CRLF that follows. * chunk_final A ConstBufferSequence representing a final chunk. It includes an optional set of caller-provided field trailers * chunk_extensions A container for building a set of chunk extensions to use during serialization. The use of the container is optional, callers may provide their own buffer containing a correctly formatted set of chunk extensions, or they may use their own convenience container which meets the requirements. The basic_fields container is modified to allow construction outside the context of a message. The container can be used to provide trailers to `chunk_final`. Actions Required: * Remove references to ChunkDecorators. Use the new chunk-encoding buffer sequences to manually produce a chunked payload body in the case where control over the chunk-extensions and/or trailers is required.
2017-07-09 20:09:30 -07:00
template<class Body, class Fields = fields>
using response_serializer = serializer<false, Body, Fields>;
Add serializer request/response aliases
2017-06-22 22:17:45 -07:00
Refactor serialization algorithms: serializer interface is changed to be buffer-only, no streams, and placed in its own header file. Operations on serializers are moved to free functions as part of the HTTP write family of synchronous and asynchronous algorithms.
2017-05-28 17:04:39 -07:00
} // http
} // beast
Boost prep
2017-07-20 13:40:34 -07:00
} // boost
Refactor serialization algorithms: serializer interface is changed to be buffer-only, no streams, and placed in its own header file. Operations on serializers are moved to free functions as part of the HTTP write family of synchronous and asynchronous algorithms.
2017-05-28 17:04:39 -07:00
Boost prep
2017-07-20 13:40:34 -07:00
#include <boost/beast/http/impl/serializer.ipp>
Refactor serialization algorithms: serializer interface is changed to be buffer-only, no streams, and placed in its own header file. Operations on serializers are moved to free functions as part of the HTTP write family of synchronous and asynchronous algorithms.
2017-05-28 17:04:39 -07:00
#endif
Copy Permalink