feedc0de/boost_beast
1
0
Fork 0
forked from boostorg/beast
Code Pull Requests Activity
Files
477cd75153997b2e4d561220599bd3d1fc9e8e3a
boost_beast/include/boost/beast/http/parser.hpp

466 lines
13 KiB
C++
Raw Normal View History

New HTTP interfaces (API Change): fix #123 fix #154 fix #265 This completely replaces the HTTP parser used to read and parse incoming messages. The new version is faster than the old one, and written in fewer lines. A summary of changes: * parse and async_parse renamed to read and async_read * basic_parser is optimized for linear buffers, use flat_streambuf for the best performance with these functions: - http::read - http::read_some - http::async_read - http::async_read_some * The overloads of read() and async_read() which take just a header have been removed, since they would throw away important parse metadata. * The derived class callbacks for basic_parser have been streamlined. All strings passed to callbacks are presented in their entirety, instead of being provided in pieces. These changes allow use-cases that were previously difficult or impossible, such as: - Efficient relaying - Late body type commitment - Expect: 100-continue handling
2016-11-20 07:32:41 -05:00
//
Update copyrights
2017-07-24 09:42:36 -07:00
// Copyright (c) 2016-2017 Vinnie Falco (vinnie dot falco at gmail dot com)
New HTTP interfaces (API Change): fix #123 fix #154 fix #265 This completely replaces the HTTP parser used to read and parse incoming messages. The new version is faster than the old one, and written in fewer lines. A summary of changes: * parse and async_parse renamed to read and async_read * basic_parser is optimized for linear buffers, use flat_streambuf for the best performance with these functions: - http::read - http::read_some - http::async_read - http::async_read_some * The overloads of read() and async_read() which take just a header have been removed, since they would throw away important parse metadata. * The derived class callbacks for basic_parser have been streamlined. All strings passed to callbacks are presented in their entirety, instead of being provided in pieces. These changes allow use-cases that were previously difficult or impossible, such as: - Efficient relaying - Late body type commitment - Expect: 100-continue handling
2016-11-20 07:32:41 -05: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
//
New HTTP interfaces (API Change): fix #123 fix #154 fix #265 This completely replaces the HTTP parser used to read and parse incoming messages. The new version is faster than the old one, and written in fewer lines. A summary of changes: * parse and async_parse renamed to read and async_read * basic_parser is optimized for linear buffers, use flat_streambuf for the best performance with these functions: - http::read - http::read_some - http::async_read - http::async_read_some * The overloads of read() and async_read() which take just a header have been removed, since they would throw away important parse metadata. * The derived class callbacks for basic_parser have been streamlined. All strings passed to callbacks are presented in their entirety, instead of being provided in pieces. These changes allow use-cases that were previously difficult or impossible, such as: - Efficient relaying - Late body type commitment - Expect: 100-continue handling
2016-11-20 07:32:41 -05:00
Boost prep
2017-07-20 13:40:34 -07:00
#ifndef BOOST_BEAST_HTTP_PARSER_HPP
#define BOOST_BEAST_HTTP_PARSER_HPP
New HTTP interfaces (API Change): fix #123 fix #154 fix #265 This completely replaces the HTTP parser used to read and parse incoming messages. The new version is faster than the old one, and written in fewer lines. A summary of changes: * parse and async_parse renamed to read and async_read * basic_parser is optimized for linear buffers, use flat_streambuf for the best performance with these functions: - http::read - http::read_some - http::async_read - http::async_read_some * The overloads of read() and async_read() which take just a header have been removed, since they would throw away important parse metadata. * The derived class callbacks for basic_parser have been streamlined. All strings passed to callbacks are presented in their entirety, instead of being provided in pieces. These changes allow use-cases that were previously difficult or impossible, such as: - Efficient relaying - Late body type commitment - Expect: 100-continue handling
2016-11-20 07:32:41 -05:00
config.hpp is not a public header
2017-10-10 07:49:03 -07:00
#include <boost/beast/core/detail/config.hpp>
Boost prep
2017-07-20 13:40:34 -07:00
#include <boost/beast/http/basic_parser.hpp>
#include <boost/beast/http/message.hpp>
#include <boost/beast/http/type_traits.hpp>
New HTTP interfaces (API Change): fix #123 fix #154 fix #265 This completely replaces the HTTP parser used to read and parse incoming messages. The new version is faster than the old one, and written in fewer lines. A summary of changes: * parse and async_parse renamed to read and async_read * basic_parser is optimized for linear buffers, use flat_streambuf for the best performance with these functions: - http::read - http::read_some - http::async_read - http::async_read_some * The overloads of read() and async_read() which take just a header have been removed, since they would throw away important parse metadata. * The derived class callbacks for basic_parser have been streamlined. All strings passed to callbacks are presented in their entirety, instead of being provided in pieces. These changes allow use-cases that were previously difficult or impossible, such as: - Efficient relaying - Late body type commitment - Expect: 100-continue handling
2016-11-20 07:32:41 -05:00
#include <boost/optional.hpp>
Consolidate parsers to parser.hpp fix #405
2017-06-03 08:40:53 -07:00
#include <boost/throw_exception.hpp>
Use std::function and reference wrapper
2017-07-14 17:26:05 -07:00
#include <functional>
parser requires basic_fields (API Change): * `parser` is now templated on Allocator * `parser` only produces messages using `basic_fields<Allocator>` as the Fields type. * message-oriented read and async_read only work on messages using basic_fields as the Fields type. Actions Required: * Callers using `parser` with Fields types other than basic_fields will need to create their own subclass of basic_parser to work with their custom fields type.
2017-06-19 11:54:53 -07:00
#include <memory>
New HTTP interfaces (API Change): fix #123 fix #154 fix #265 This completely replaces the HTTP parser used to read and parse incoming messages. The new version is faster than the old one, and written in fewer lines. A summary of changes: * parse and async_parse renamed to read and async_read * basic_parser is optimized for linear buffers, use flat_streambuf for the best performance with these functions: - http::read - http::read_some - http::async_read - http::async_read_some * The overloads of read() and async_read() which take just a header have been removed, since they would throw away important parse metadata. * The derived class callbacks for basic_parser have been streamlined. All strings passed to callbacks are presented in their entirety, instead of being provided in pieces. These changes allow use-cases that were previously difficult or impossible, such as: - Efficient relaying - Late body type commitment - Expect: 100-continue handling
2016-11-20 07:32:41 -05:00
#include <type_traits>
#include <utility>
Boost prep
2017-07-20 13:40:34 -07:00
namespace boost {
New HTTP interfaces (API Change): fix #123 fix #154 fix #265 This completely replaces the HTTP parser used to read and parse incoming messages. The new version is faster than the old one, and written in fewer lines. A summary of changes: * parse and async_parse renamed to read and async_read * basic_parser is optimized for linear buffers, use flat_streambuf for the best performance with these functions: - http::read - http::read_some - http::async_read - http::async_read_some * The overloads of read() and async_read() which take just a header have been removed, since they would throw away important parse metadata. * The derived class callbacks for basic_parser have been streamlined. All strings passed to callbacks are presented in their entirety, instead of being provided in pieces. These changes allow use-cases that were previously difficult or impossible, such as: - Efficient relaying - Late body type commitment - Expect: 100-continue handling
2016-11-20 07:32:41 -05:00
namespace beast {
namespace http {
Rename to parser (API Change): * message_parser is renamed to parser
2017-06-03 08:56:21 -07:00
/** An HTTP/1 parser for producing a message.
New HTTP interfaces (API Change): fix #123 fix #154 fix #265 This completely replaces the HTTP parser used to read and parse incoming messages. The new version is faster than the old one, and written in fewer lines. A summary of changes: * parse and async_parse renamed to read and async_read * basic_parser is optimized for linear buffers, use flat_streambuf for the best performance with these functions: - http::read - http::read_some - http::async_read - http::async_read_some * The overloads of read() and async_read() which take just a header have been removed, since they would throw away important parse metadata. * The derived class callbacks for basic_parser have been streamlined. All strings passed to callbacks are presented in their entirety, instead of being provided in pieces. These changes allow use-cases that were previously difficult or impossible, such as: - Efficient relaying - Late body type commitment - Expect: 100-continue handling
2016-11-20 07:32:41 -05:00
This class uses the basic HTTP/1 wire format parser to convert
parser requires basic_fields (API Change): * `parser` is now templated on Allocator * `parser` only produces messages using `basic_fields<Allocator>` as the Fields type. * message-oriented read and async_read only work on messages using basic_fields as the Fields type. Actions Required: * Callers using `parser` with Fields types other than basic_fields will need to create their own subclass of basic_parser to work with their custom fields type.
2017-06-19 11:54:53 -07:00
a series of octets into a @ref message using the @ref basic_fields
container to represent the fields.
New HTTP interfaces (API Change): fix #123 fix #154 fix #265 This completely replaces the HTTP parser used to read and parse incoming messages. The new version is faster than the old one, and written in fewer lines. A summary of changes: * parse and async_parse renamed to read and async_read * basic_parser is optimized for linear buffers, use flat_streambuf for the best performance with these functions: - http::read - http::read_some - http::async_read - http::async_read_some * The overloads of read() and async_read() which take just a header have been removed, since they would throw away important parse metadata. * The derived class callbacks for basic_parser have been streamlined. All strings passed to callbacks are presented in their entirety, instead of being provided in pieces. These changes allow use-cases that were previously difficult or impossible, such as: - Efficient relaying - Late body type commitment - Expect: 100-continue handling
2016-11-20 07:32:41 -05:00
@tparam isRequest Indicates whether a request or response
will be parsed.
parser requires basic_fields (API Change): * `parser` is now templated on Allocator * `parser` only produces messages using `basic_fields<Allocator>` as the Fields type. * message-oriented read and async_read only work on messages using basic_fields as the Fields type. Actions Required: * Callers using `parser` with Fields types other than basic_fields will need to create their own subclass of basic_parser to work with their custom fields type.
2017-06-19 11:54:53 -07:00
@tparam Body The type used to represent the body. This must
meet the requirements of @b Body.
New HTTP interfaces (API Change): fix #123 fix #154 fix #265 This completely replaces the HTTP parser used to read and parse incoming messages. The new version is faster than the old one, and written in fewer lines. A summary of changes: * parse and async_parse renamed to read and async_read * basic_parser is optimized for linear buffers, use flat_streambuf for the best performance with these functions: - http::read - http::read_some - http::async_read - http::async_read_some * The overloads of read() and async_read() which take just a header have been removed, since they would throw away important parse metadata. * The derived class callbacks for basic_parser have been streamlined. All strings passed to callbacks are presented in their entirety, instead of being provided in pieces. These changes allow use-cases that were previously difficult or impossible, such as: - Efficient relaying - Late body type commitment - Expect: 100-continue handling
2016-11-20 07:32:41 -05:00
parser requires basic_fields (API Change): * `parser` is now templated on Allocator * `parser` only produces messages using `basic_fields<Allocator>` as the Fields type. * message-oriented read and async_read only work on messages using basic_fields as the Fields type. Actions Required: * Callers using `parser` with Fields types other than basic_fields will need to create their own subclass of basic_parser to work with their custom fields type.
2017-06-19 11:54:53 -07:00
@tparam Allocator The type of allocator used with the
@ref basic_fields container.
New HTTP interfaces (API Change): fix #123 fix #154 fix #265 This completely replaces the HTTP parser used to read and parse incoming messages. The new version is faster than the old one, and written in fewer lines. A summary of changes: * parse and async_parse renamed to read and async_read * basic_parser is optimized for linear buffers, use flat_streambuf for the best performance with these functions: - http::read - http::read_some - http::async_read - http::async_read_some * The overloads of read() and async_read() which take just a header have been removed, since they would throw away important parse metadata. * The derived class callbacks for basic_parser have been streamlined. All strings passed to callbacks are presented in their entirety, instead of being provided in pieces. These changes allow use-cases that were previously difficult or impossible, such as: - Efficient relaying - Late body type commitment - Expect: 100-continue handling
2016-11-20 07:32:41 -05:00
@note A new instance of the parser is required for each message.
*/
Remove header_parser (API Change)
2017-06-05 07:20:58 -07:00
template<
bool isRequest,
class Body,
parser requires basic_fields (API Change): * `parser` is now templated on Allocator * `parser` only produces messages using `basic_fields<Allocator>` as the Fields type. * message-oriented read and async_read only work on messages using basic_fields as the Fields type. Actions Required: * Callers using `parser` with Fields types other than basic_fields will need to create their own subclass of basic_parser to work with their custom fields type.
2017-06-19 11:54:53 -07:00
class Allocator = std::allocator<char>>
Rename to parser (API Change): * message_parser is renamed to parser
2017-06-03 08:56:21 -07:00
class parser
New HTTP interfaces (API Change): fix #123 fix #154 fix #265 This completely replaces the HTTP parser used to read and parse incoming messages. The new version is faster than the old one, and written in fewer lines. A summary of changes: * parse and async_parse renamed to read and async_read * basic_parser is optimized for linear buffers, use flat_streambuf for the best performance with these functions: - http::read - http::read_some - http::async_read - http::async_read_some * The overloads of read() and async_read() which take just a header have been removed, since they would throw away important parse metadata. * The derived class callbacks for basic_parser have been streamlined. All strings passed to callbacks are presented in their entirety, instead of being provided in pieces. These changes allow use-cases that were previously difficult or impossible, such as: - Efficient relaying - Late body type commitment - Expect: 100-continue handling
2016-11-20 07:32:41 -05:00
: public basic_parser<isRequest,
parser requires basic_fields (API Change): * `parser` is now templated on Allocator * `parser` only produces messages using `basic_fields<Allocator>` as the Fields type. * message-oriented read and async_read only work on messages using basic_fields as the Fields type. Actions Required: * Callers using `parser` with Fields types other than basic_fields will need to create their own subclass of basic_parser to work with their custom fields type.
2017-06-19 11:54:53 -07:00
parser<isRequest, Body, Allocator>>
New HTTP interfaces (API Change): fix #123 fix #154 fix #265 This completely replaces the HTTP parser used to read and parse incoming messages. The new version is faster than the old one, and written in fewer lines. A summary of changes: * parse and async_parse renamed to read and async_read * basic_parser is optimized for linear buffers, use flat_streambuf for the best performance with these functions: - http::read - http::read_some - http::async_read - http::async_read_some * The overloads of read() and async_read() which take just a header have been removed, since they would throw away important parse metadata. * The derived class callbacks for basic_parser have been streamlined. All strings passed to callbacks are presented in their entirety, instead of being provided in pieces. These changes allow use-cases that were previously difficult or impossible, such as: - Efficient relaying - Late body type commitment - Expect: 100-continue handling
2016-11-20 07:32:41 -05:00
{
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
static_assert(is_body<Body>::value,
"Body requirements not met");
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_reader<Body>::value,
"BodyReader requirements not met");
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
parser is constructible from other body types
2017-06-05 06:44:31 -07:00
template<bool, class, class>
friend class parser;
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
using base_type = basic_parser<isRequest,
parser requires basic_fields (API Change): * `parser` is now templated on Allocator * `parser` only produces messages using `basic_fields<Allocator>` as the Fields type. * message-oriented read and async_read only work on messages using basic_fields as the Fields type. Actions Required: * Callers using `parser` with Fields types other than basic_fields will need to create their own subclass of basic_parser to work with their custom fields type.
2017-06-19 11:54:53 -07:00
parser<isRequest, Body, Allocator>>;
New HTTP interfaces (API Change): fix #123 fix #154 fix #265 This completely replaces the HTTP parser used to read and parse incoming messages. The new version is faster than the old one, and written in fewer lines. A summary of changes: * parse and async_parse renamed to read and async_read * basic_parser is optimized for linear buffers, use flat_streambuf for the best performance with these functions: - http::read - http::read_some - http::async_read - http::async_read_some * The overloads of read() and async_read() which take just a header have been removed, since they would throw away important parse metadata. * The derived class callbacks for basic_parser have been streamlined. All strings passed to callbacks are presented in their entirety, instead of being provided in pieces. These changes allow use-cases that were previously difficult or impossible, such as: - Efficient relaying - Late body type commitment - Expect: 100-continue handling
2016-11-20 07:32:41 -05:00
parser requires basic_fields (API Change): * `parser` is now templated on Allocator * `parser` only produces messages using `basic_fields<Allocator>` as the Fields type. * message-oriented read and async_read only work on messages using basic_fields as the Fields type. Actions Required: * Callers using `parser` with Fields types other than basic_fields will need to create their own subclass of basic_parser to work with their custom fields type.
2017-06-19 11:54:53 -07:00
message<isRequest, Body, basic_fields<Allocator>> 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
typename Body::reader rd_;
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
bool rd_inited_ = false;
New HTTP interfaces (API Change): fix #123 fix #154 fix #265 This completely replaces the HTTP parser used to read and parse incoming messages. The new version is faster than the old one, and written in fewer lines. A summary of changes: * parse and async_parse renamed to read and async_read * basic_parser is optimized for linear buffers, use flat_streambuf for the best performance with these functions: - http::read - http::read_some - http::async_read - http::async_read_some * The overloads of read() and async_read() which take just a header have been removed, since they would throw away important parse metadata. * The derived class callbacks for basic_parser have been streamlined. All strings passed to callbacks are presented in their entirety, instead of being provided in pieces. These changes allow use-cases that were previously difficult or impossible, such as: - Efficient relaying - Late body type commitment - Expect: 100-continue handling
2016-11-20 07:32:41 -05:00
Use std::function and reference wrapper
2017-07-14 17:26:05 -07:00
std::function<void(
std::uint64_t,
string_view,
error_code&)> cb_h_;
Refactor chunked parsing (API Change): * parser now has a callback feature for intercepting chunk headers and chunk bodies * The names for basic_parser derived class callbacks have been refactored * basic_parser offers an additional callback for distinguishing chunk body data. Actions Required: * Adjust signatures for required members of user-defined subclasses of basic_parser * Use the new basic_parser chunk callbacks for accessing chunk extensions and chunk bodies.
2017-07-12 18:06:36 -07:00
Use std::function and reference wrapper
2017-07-14 17:26:05 -07:00
std::function<std::size_t(
std::uint64_t,
string_view,
error_code&)> cb_b_;
Refactor chunked parsing (API Change): * parser now has a callback feature for intercepting chunk headers and chunk bodies * The names for basic_parser derived class callbacks have been refactored * basic_parser offers an additional callback for distinguishing chunk body data. Actions Required: * Adjust signatures for required members of user-defined subclasses of basic_parser * Use the new basic_parser chunk callbacks for accessing chunk extensions and chunk bodies.
2017-07-12 18:06:36 -07:00
New HTTP interfaces (API Change): fix #123 fix #154 fix #265 This completely replaces the HTTP parser used to read and parse incoming messages. The new version is faster than the old one, and written in fewer lines. A summary of changes: * parse and async_parse renamed to read and async_read * basic_parser is optimized for linear buffers, use flat_streambuf for the best performance with these functions: - http::read - http::read_some - http::async_read - http::async_read_some * The overloads of read() and async_read() which take just a header have been removed, since they would throw away important parse metadata. * The derived class callbacks for basic_parser have been streamlined. All strings passed to callbacks are presented in their entirety, instead of being provided in pieces. These changes allow use-cases that were previously difficult or impossible, such as: - Efficient relaying - Late body type commitment - Expect: 100-continue handling
2016-11-20 07:32:41 -05:00
public:
/// The type of message returned by the parser
parser requires basic_fields (API Change): * `parser` is now templated on Allocator * `parser` only produces messages using `basic_fields<Allocator>` as the Fields type. * message-oriented read and async_read only work on messages using basic_fields as the Fields type. Actions Required: * Callers using `parser` with Fields types other than basic_fields will need to create their own subclass of basic_parser to work with their custom fields type.
2017-06-19 11:54:53 -07:00
using value_type =
message<isRequest, Body, basic_fields<Allocator>>;
New HTTP interfaces (API Change): fix #123 fix #154 fix #265 This completely replaces the HTTP parser used to read and parse incoming messages. The new version is faster than the old one, and written in fewer lines. A summary of changes: * parse and async_parse renamed to read and async_read * basic_parser is optimized for linear buffers, use flat_streambuf for the best performance with these functions: - http::read - http::read_some - http::async_read - http::async_read_some * The overloads of read() and async_read() which take just a header have been removed, since they would throw away important parse metadata. * The derived class callbacks for basic_parser have been streamlined. All strings passed to callbacks are presented in their entirety, instead of being provided in pieces. These changes allow use-cases that were previously difficult or impossible, such as: - Efficient relaying - Late body type commitment - Expect: 100-continue handling
2016-11-20 07:32:41 -05:00
Refactor chunked parsing (API Change): * parser now has a callback feature for intercepting chunk headers and chunk bodies * The names for basic_parser derived class callbacks have been refactored * basic_parser offers an additional callback for distinguishing chunk body data. Actions Required: * Adjust signatures for required members of user-defined subclasses of basic_parser * Use the new basic_parser chunk callbacks for accessing chunk extensions and chunk bodies.
2017-07-12 18:06:36 -07:00
/// Destructor
Use std::function and reference wrapper
2017-07-14 17:26:05 -07:00
~parser() = default;
Refactor chunked parsing (API Change): * parser now has a callback feature for intercepting chunk headers and chunk bodies * The names for basic_parser derived class callbacks have been refactored * basic_parser offers an additional callback for distinguishing chunk body data. Actions Required: * Adjust signatures for required members of user-defined subclasses of basic_parser * Use the new basic_parser chunk callbacks for accessing chunk extensions and chunk bodies.
2017-07-12 18:06:36 -07:00
http::parser is not MoveConstructible (API Change)
2017-12-30 06:08:28 -08:00
/// Constructor (disallowed)
Rename to parser (API Change): * message_parser is renamed to parser
2017-06-03 08:56:21 -07:00
parser(parser const&) = delete;
New HTTP interfaces (API Change): fix #123 fix #154 fix #265 This completely replaces the HTTP parser used to read and parse incoming messages. The new version is faster than the old one, and written in fewer lines. A summary of changes: * parse and async_parse renamed to read and async_read * basic_parser is optimized for linear buffers, use flat_streambuf for the best performance with these functions: - http::read - http::read_some - http::async_read - http::async_read_some * The overloads of read() and async_read() which take just a header have been removed, since they would throw away important parse metadata. * The derived class callbacks for basic_parser have been streamlined. All strings passed to callbacks are presented in their entirety, instead of being provided in pieces. These changes allow use-cases that were previously difficult or impossible, such as: - Efficient relaying - Late body type commitment - Expect: 100-continue handling
2016-11-20 07:32:41 -05:00
http::parser is not MoveConstructible (API Change)
2017-12-30 06:08:28 -08:00
/// Assignment (disallowed)
Rename to parser (API Change): * message_parser is renamed to parser
2017-06-03 08:56:21 -07:00
parser& operator=(parser const&) = delete;
New HTTP interfaces (API Change): fix #123 fix #154 fix #265 This completely replaces the HTTP parser used to read and parse incoming messages. The new version is faster than the old one, and written in fewer lines. A summary of changes: * parse and async_parse renamed to read and async_read * basic_parser is optimized for linear buffers, use flat_streambuf for the best performance with these functions: - http::read - http::read_some - http::async_read - http::async_read_some * The overloads of read() and async_read() which take just a header have been removed, since they would throw away important parse metadata. * The derived class callbacks for basic_parser have been streamlined. All strings passed to callbacks are presented in their entirety, instead of being provided in pieces. These changes allow use-cases that were previously difficult or impossible, such as: - Efficient relaying - Late body type commitment - Expect: 100-continue handling
2016-11-20 07:32:41 -05:00
http::parser is not MoveConstructible (API Change)
2017-12-30 06:08:28 -08:00
/// Constructor (disallowed)
parser(parser&& other) = delete;
New HTTP interfaces (API Change): fix #123 fix #154 fix #265 This completely replaces the HTTP parser used to read and parse incoming messages. The new version is faster than the old one, and written in fewer lines. A summary of changes: * parse and async_parse renamed to read and async_read * basic_parser is optimized for linear buffers, use flat_streambuf for the best performance with these functions: - http::read - http::read_some - http::async_read - http::async_read_some * The overloads of read() and async_read() which take just a header have been removed, since they would throw away important parse metadata. * The derived class callbacks for basic_parser have been streamlined. All strings passed to callbacks are presented in their entirety, instead of being provided in pieces. These changes allow use-cases that were previously difficult or impossible, such as: - Efficient relaying - Late body type commitment - Expect: 100-continue handling
2016-11-20 07:32:41 -05:00
http::parser is not MoveConstructible (API Change)
2017-12-30 06:08:28 -08:00
/// Constructor
parser();
New HTTP interfaces (API Change): fix #123 fix #154 fix #265 This completely replaces the HTTP parser used to read and parse incoming messages. The new version is faster than the old one, and written in fewer lines. A summary of changes: * parse and async_parse renamed to read and async_read * basic_parser is optimized for linear buffers, use flat_streambuf for the best performance with these functions: - http::read - http::read_some - http::async_read - http::async_read_some * The overloads of read() and async_read() which take just a header have been removed, since they would throw away important parse metadata. * The derived class callbacks for basic_parser have been streamlined. All strings passed to callbacks are presented in their entirety, instead of being provided in pieces. These changes allow use-cases that were previously difficult or impossible, such as: - Efficient relaying - Late body type commitment - Expect: 100-continue handling
2016-11-20 07:32:41 -05:00
/** Constructor
@param args Optional arguments forwarded to the
Fix http::parser constructor javadoc
2018-05-28 11:23:37 -07:00
@ref http::message constructor.
New HTTP interfaces (API Change): fix #123 fix #154 fix #265 This completely replaces the HTTP parser used to read and parse incoming messages. The new version is faster than the old one, and written in fewer lines. A summary of changes: * parse and async_parse renamed to read and async_read * basic_parser is optimized for linear buffers, use flat_streambuf for the best performance with these functions: - http::read - http::read_some - http::async_read - http::async_read_some * The overloads of read() and async_read() which take just a header have been removed, since they would throw away important parse metadata. * The derived class callbacks for basic_parser have been streamlined. All strings passed to callbacks are presented in their entirety, instead of being provided in pieces. These changes allow use-cases that were previously difficult or impossible, such as: - Efficient relaying - Late body type commitment - Expect: 100-continue handling
2016-11-20 07:32:41 -05:00
@note This function participates in overload
resolution only if the first argument is not a
parser is constructible from other body types
2017-06-05 06:44:31 -07:00
@ref parser.
New HTTP interfaces (API Change): fix #123 fix #154 fix #265 This completely replaces the HTTP parser used to read and parse incoming messages. The new version is faster than the old one, and written in fewer lines. A summary of changes: * parse and async_parse renamed to read and async_read * basic_parser is optimized for linear buffers, use flat_streambuf for the best performance with these functions: - http::read - http::read_some - http::async_read - http::async_read_some * The overloads of read() and async_read() which take just a header have been removed, since they would throw away important parse metadata. * The derived class callbacks for basic_parser have been streamlined. All strings passed to callbacks are presented in their entirety, instead of being provided in pieces. These changes allow use-cases that were previously difficult or impossible, such as: - Efficient relaying - Late body type commitment - Expect: 100-continue handling
2016-11-20 07:32:41 -05:00
*/
Boost prep
2017-07-20 13:40:34 -07:00
#if BOOST_BEAST_DOXYGEN
New HTTP interfaces (API Change): fix #123 fix #154 fix #265 This completely replaces the HTTP parser used to read and parse incoming messages. The new version is faster than the old one, and written in fewer lines. A summary of changes: * parse and async_parse renamed to read and async_read * basic_parser is optimized for linear buffers, use flat_streambuf for the best performance with these functions: - http::read - http::read_some - http::async_read - http::async_read_some * The overloads of read() and async_read() which take just a header have been removed, since they would throw away important parse metadata. * The derived class callbacks for basic_parser have been streamlined. All strings passed to callbacks are presented in their entirety, instead of being provided in pieces. These changes allow use-cases that were previously difficult or impossible, such as: - Efficient relaying - Late body type commitment - Expect: 100-continue handling
2016-11-20 07:32:41 -05:00
template<class... Args>
explicit
Documentation revision fix #567, fix #572
2017-06-28 18:30:59 -07:00
parser(Args&&... args);
New HTTP interfaces (API Change): fix #123 fix #154 fix #265 This completely replaces the HTTP parser used to read and parse incoming messages. The new version is faster than the old one, and written in fewer lines. A summary of changes: * parse and async_parse renamed to read and async_read * basic_parser is optimized for linear buffers, use flat_streambuf for the best performance with these functions: - http::read - http::read_some - http::async_read - http::async_read_some * The overloads of read() and async_read() which take just a header have been removed, since they would throw away important parse metadata. * The derived class callbacks for basic_parser have been streamlined. All strings passed to callbacks are presented in their entirety, instead of being provided in pieces. These changes allow use-cases that were previously difficult or impossible, such as: - Efficient relaying - Late body type commitment - Expect: 100-continue handling
2016-11-20 07:32:41 -05:00
#else
template<class Arg1, class... ArgN,
class = typename std::enable_if<
parser is constructible from other body types
2017-06-05 06:44:31 -07:00
! detail::is_parser<typename
std::decay<Arg1>::type>::value>::type>
New HTTP interfaces (API Change): fix #123 fix #154 fix #265 This completely replaces the HTTP parser used to read and parse incoming messages. The new version is faster than the old one, and written in fewer lines. A summary of changes: * parse and async_parse renamed to read and async_read * basic_parser is optimized for linear buffers, use flat_streambuf for the best performance with these functions: - http::read - http::read_some - http::async_read - http::async_read_some * The overloads of read() and async_read() which take just a header have been removed, since they would throw away important parse metadata. * The derived class callbacks for basic_parser have been streamlined. All strings passed to callbacks are presented in their entirety, instead of being provided in pieces. These changes allow use-cases that were previously difficult or impossible, such as: - Efficient relaying - Late body type commitment - Expect: 100-continue handling
2016-11-20 07:32:41 -05:00
explicit
Rename to parser (API Change): * message_parser is renamed to parser
2017-06-03 08:56:21 -07:00
parser(Arg1&& arg1, ArgN&&... argn);
New HTTP interfaces (API Change): fix #123 fix #154 fix #265 This completely replaces the HTTP parser used to read and parse incoming messages. The new version is faster than the old one, and written in fewer lines. A summary of changes: * parse and async_parse renamed to read and async_read * basic_parser is optimized for linear buffers, use flat_streambuf for the best performance with these functions: - http::read - http::read_some - http::async_read - http::async_read_some * The overloads of read() and async_read() which take just a header have been removed, since they would throw away important parse metadata. * The derived class callbacks for basic_parser have been streamlined. All strings passed to callbacks are presented in their entirety, instead of being provided in pieces. These changes allow use-cases that were previously difficult or impossible, such as: - Efficient relaying - Late body type commitment - Expect: 100-continue handling
2016-11-20 07:32:41 -05:00
#endif
parser is constructible from other body types
2017-06-05 06:44:31 -07:00
/** Construct a parser from another parser, changing the Body type.
This constructs a new parser by move constructing the
header from another parser with a different body type. The
constructed-from parser must not have any parsed body octets or
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
initialized @b BodyReader, otherwise an exception is generated.
parser is constructible from other body types
2017-06-05 06:44:31 -07:00
@par Example
@code
// Deferred body type commitment
request_parser<empty_body> req0;
...
request_parser<string_body> req{std::move(req0)};
@endcode
If an exception is thrown, the state of the constructed-from
parser is undefined.
@param parser The other parser to construct from. After
this call returns, the constructed-from parser may only
be destroyed.
@param args Optional arguments forwarded to the message
constructor.
@throws std::invalid_argument Thrown when the constructed-from
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
parser has already initialized a body reader.
parser requires basic_fields (API Change): * `parser` is now templated on Allocator * `parser` only produces messages using `basic_fields<Allocator>` as the Fields type. * message-oriented read and async_read only work on messages using basic_fields as the Fields type. Actions Required: * Callers using `parser` with Fields types other than basic_fields will need to create their own subclass of basic_parser to work with their custom fields type.
2017-06-19 11:54:53 -07:00
@note This function participates in overload resolution only
if the other parser uses a different body type.
parser is constructible from other body types
2017-06-05 06:44:31 -07:00
*/
Boost prep
2017-07-20 13:40:34 -07:00
#if BOOST_BEAST_DOXYGEN
parser is constructible from other body types
2017-06-05 06:44:31 -07:00
template<class OtherBody, class... Args>
#else
Remove header_parser (API Change)
2017-06-05 07:20:58 -07:00
template<class OtherBody, class... Args,
class = typename std::enable_if<
! std::is_same<Body, OtherBody>::value>::type>
parser is constructible from other body types
2017-06-05 06:44:31 -07:00
#endif
explicit
parser requires basic_fields (API Change): * `parser` is now templated on Allocator * `parser` only produces messages using `basic_fields<Allocator>` as the Fields type. * message-oriented read and async_read only work on messages using basic_fields as the Fields type. Actions Required: * Callers using `parser` with Fields types other than basic_fields will need to create their own subclass of basic_parser to work with their custom fields type.
2017-06-19 11:54:53 -07:00
parser(parser<isRequest, OtherBody,
Allocator>&& parser, Args&&... args);
parser is constructible from other body types
2017-06-05 06:44:31 -07:00
New HTTP interfaces (API Change): fix #123 fix #154 fix #265 This completely replaces the HTTP parser used to read and parse incoming messages. The new version is faster than the old one, and written in fewer lines. A summary of changes: * parse and async_parse renamed to read and async_read * basic_parser is optimized for linear buffers, use flat_streambuf for the best performance with these functions: - http::read - http::read_some - http::async_read - http::async_read_some * The overloads of read() and async_read() which take just a header have been removed, since they would throw away important parse metadata. * The derived class callbacks for basic_parser have been streamlined. All strings passed to callbacks are presented in their entirety, instead of being provided in pieces. These changes allow use-cases that were previously difficult or impossible, such as: - Efficient relaying - Late body type commitment - Expect: 100-continue handling
2016-11-20 07:32:41 -05:00
/** Returns the parsed message.
parser requires basic_fields (API Change): * `parser` is now templated on Allocator * `parser` only produces messages using `basic_fields<Allocator>` as the Fields type. * message-oriented read and async_read only work on messages using basic_fields as the Fields type. Actions Required: * Callers using `parser` with Fields types other than basic_fields will need to create their own subclass of basic_parser to work with their custom fields type.
2017-06-19 11:54:53 -07:00
Depending on the parser's progress,
parts of this object may be incomplete.
New HTTP interfaces (API Change): fix #123 fix #154 fix #265 This completely replaces the HTTP parser used to read and parse incoming messages. The new version is faster than the old one, and written in fewer lines. A summary of changes: * parse and async_parse renamed to read and async_read * basic_parser is optimized for linear buffers, use flat_streambuf for the best performance with these functions: - http::read - http::read_some - http::async_read - http::async_read_some * The overloads of read() and async_read() which take just a header have been removed, since they would throw away important parse metadata. * The derived class callbacks for basic_parser have been streamlined. All strings passed to callbacks are presented in their entirety, instead of being provided in pieces. These changes allow use-cases that were previously difficult or impossible, such as: - Efficient relaying - Late body type commitment - Expect: 100-continue handling
2016-11-20 07:32:41 -05:00
*/
value_type const&
get() const
{
return m_;
}
/** Returns the parsed message.
parser requires basic_fields (API Change): * `parser` is now templated on Allocator * `parser` only produces messages using `basic_fields<Allocator>` as the Fields type. * message-oriented read and async_read only work on messages using basic_fields as the Fields type. Actions Required: * Callers using `parser` with Fields types other than basic_fields will need to create their own subclass of basic_parser to work with their custom fields type.
2017-06-19 11:54:53 -07:00
Depending on the parser's progress,
parts of this object may be incomplete.
New HTTP interfaces (API Change): fix #123 fix #154 fix #265 This completely replaces the HTTP parser used to read and parse incoming messages. The new version is faster than the old one, and written in fewer lines. A summary of changes: * parse and async_parse renamed to read and async_read * basic_parser is optimized for linear buffers, use flat_streambuf for the best performance with these functions: - http::read - http::read_some - http::async_read - http::async_read_some * The overloads of read() and async_read() which take just a header have been removed, since they would throw away important parse metadata. * The derived class callbacks for basic_parser have been streamlined. All strings passed to callbacks are presented in their entirety, instead of being provided in pieces. These changes allow use-cases that were previously difficult or impossible, such as: - Efficient relaying - Late body type commitment - Expect: 100-continue handling
2016-11-20 07:32:41 -05:00
*/
value_type&
get()
{
return m_;
}
/** Returns ownership of the parsed message.
Ownership is transferred to the caller.
parser requires basic_fields (API Change): * `parser` is now templated on Allocator * `parser` only produces messages using `basic_fields<Allocator>` as the Fields type. * message-oriented read and async_read only work on messages using basic_fields as the Fields type. Actions Required: * Callers using `parser` with Fields types other than basic_fields will need to create their own subclass of basic_parser to work with their custom fields type.
2017-06-19 11:54:53 -07:00
Depending on the parser's progress,
parts of this object may be incomplete.
New HTTP interfaces (API Change): fix #123 fix #154 fix #265 This completely replaces the HTTP parser used to read and parse incoming messages. The new version is faster than the old one, and written in fewer lines. A summary of changes: * parse and async_parse renamed to read and async_read * basic_parser is optimized for linear buffers, use flat_streambuf for the best performance with these functions: - http::read - http::read_some - http::async_read - http::async_read_some * The overloads of read() and async_read() which take just a header have been removed, since they would throw away important parse metadata. * The derived class callbacks for basic_parser have been streamlined. All strings passed to callbacks are presented in their entirety, instead of being provided in pieces. These changes allow use-cases that were previously difficult or impossible, such as: - Efficient relaying - Late body type commitment - Expect: 100-continue handling
2016-11-20 07:32:41 -05:00
@par Requires
@ref value_type is @b MoveConstructible
*/
value_type
release()
{
static_assert(std::is_move_constructible<decltype(m_)>::value,
"MoveConstructible requirements not met");
return std::move(m_);
}
Refactor chunked parsing (API Change): * parser now has a callback feature for intercepting chunk headers and chunk bodies * The names for basic_parser derived class callbacks have been refactored * basic_parser offers an additional callback for distinguishing chunk body data. Actions Required: * Adjust signatures for required members of user-defined subclasses of basic_parser * Use the new basic_parser chunk callbacks for accessing chunk extensions and chunk bodies.
2017-07-12 18:06:36 -07:00
/** Set a callback to be invoked on each chunk header.
Add parser::on_header to set a callback
2017-06-28 04:01:33 -07:00
Refactor chunked parsing (API Change): * parser now has a callback feature for intercepting chunk headers and chunk bodies * The names for basic_parser derived class callbacks have been refactored * basic_parser offers an additional callback for distinguishing chunk body data. Actions Required: * Adjust signatures for required members of user-defined subclasses of basic_parser * Use the new basic_parser chunk callbacks for accessing chunk extensions and chunk bodies.
2017-07-12 18:06:36 -07:00
The callback will be invoked once for every chunk in the message
payload, as well as once for the last chunk. The invocation
happens after the chunk header is available but before any body
octets have been parsed.
The extensions are provided in raw, validated form, use
@ref chunk_extensions::parse to parse the extensions into a
structured container for easier access.
The implementation type-erases the callback without requiring
a dynamic allocation. For this reason, the callback object is
passed by a non-constant reference.
@par Example
Add parser::on_header to set a callback
2017-06-28 04:01:33 -07:00
@code
Refactor chunked parsing (API Change): * parser now has a callback feature for intercepting chunk headers and chunk bodies * The names for basic_parser derived class callbacks have been refactored * basic_parser offers an additional callback for distinguishing chunk body data. Actions Required: * Adjust signatures for required members of user-defined subclasses of basic_parser * Use the new basic_parser chunk callbacks for accessing chunk extensions and chunk bodies.
2017-07-12 18:06:36 -07:00
auto callback =
[](std::uint64_t size, string_view extensions, error_code& ec)
{
//...
};
parser.on_chunk_header(callback);
Add parser::on_header to set a callback
2017-06-28 04:01:33 -07:00
@endcode
Refactor chunked parsing (API Change): * parser now has a callback feature for intercepting chunk headers and chunk bodies * The names for basic_parser derived class callbacks have been refactored * basic_parser offers an additional callback for distinguishing chunk body data. Actions Required: * Adjust signatures for required members of user-defined subclasses of basic_parser * Use the new basic_parser chunk callbacks for accessing chunk extensions and chunk bodies.
2017-07-12 18:06:36 -07:00
@param cb The function to set, which must be invocable with
this equivalent signature:
@code
void
on_chunk_header(
std::uint64_t size, // Size of the chunk, zero for the last chunk
string_view extensions, // The chunk-extensions in raw form
error_code& ec); // May be set by the callback to indicate an error
@endcode
Add parser::on_header to set a callback
2017-06-28 04:01:33 -07:00
*/
Refactor chunked parsing (API Change): * parser now has a callback feature for intercepting chunk headers and chunk bodies * The names for basic_parser derived class callbacks have been refactored * basic_parser offers an additional callback for distinguishing chunk body data. Actions Required: * Adjust signatures for required members of user-defined subclasses of basic_parser * Use the new basic_parser chunk callbacks for accessing chunk extensions and chunk bodies.
2017-07-12 18:06:36 -07:00
template<class Callback>
Add parser::on_header to set a callback
2017-06-28 04:01:33 -07:00
void
Use std::function and reference wrapper
2017-07-14 17:26:05 -07:00
on_chunk_header(Callback& cb)
{
// Callback may not be constant, caller is responsible for
// managing the lifetime of the callback. Copies are not made.
BOOST_STATIC_ASSERT(! std::is_const<Callback>::value);
// Can't set the callback after receiving any chunk data!
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
BOOST_ASSERT(! rd_inited_);
Use std::function and reference wrapper
2017-07-14 17:26:05 -07:00
cb_h_ = std::ref(cb);
}
Refactor chunked parsing (API Change): * parser now has a callback feature for intercepting chunk headers and chunk bodies * The names for basic_parser derived class callbacks have been refactored * basic_parser offers an additional callback for distinguishing chunk body data. Actions Required: * Adjust signatures for required members of user-defined subclasses of basic_parser * Use the new basic_parser chunk callbacks for accessing chunk extensions and chunk bodies.
2017-07-12 18:06:36 -07:00
/** Set a callback to be invoked on chunk body data
The provided function object will be invoked one or more times
to provide buffers corresponding to the chunk body for the current
chunk. The callback receives the number of octets remaining in this
chunk body including the octets in the buffer provided.
The callback must return the number of octets actually consumed.
Any octets not consumed will be presented again in a subsequent
invocation of the callback.
The implementation type-erases the callback without requiring
a dynamic allocation. For this reason, the callback object is
passed by a non-constant reference.
@par Example
@code
auto callback =
[](std::uint64_t remain, string_view body, error_code& ec)
{
//...
};
parser.on_chunk_body(callback);
@endcode
@param cb The function to set, which must be invocable with
this equivalent signature:
@code
std::size_t
on_chunk_header(
std::uint64_t remain, // Octets remaining in this chunk, includes `body`
string_view body, // A buffer holding some or all of the remainder of the chunk body
error_code& ec); // May be set by the callback to indicate an error
@endcode
*/
template<class Callback>
void
Use std::function and reference wrapper
2017-07-14 17:26:05 -07:00
on_chunk_body(Callback& cb)
{
// Callback may not be constant, caller is responsible for
// managing the lifetime of the callback. Copies are not made.
BOOST_STATIC_ASSERT(! std::is_const<Callback>::value);
// Can't set the callback after receiving any chunk data!
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
BOOST_ASSERT(! rd_inited_);
Use std::function and reference wrapper
2017-07-14 17:26:05 -07:00
cb_b_ = std::ref(cb);
}
Add parser::on_header to set a callback
2017-06-28 04:01:33 -07:00
New HTTP interfaces (API Change): fix #123 fix #154 fix #265 This completely replaces the HTTP parser used to read and parse incoming messages. The new version is faster than the old one, and written in fewer lines. A summary of changes: * parse and async_parse renamed to read and async_read * basic_parser is optimized for linear buffers, use flat_streambuf for the best performance with these functions: - http::read - http::read_some - http::async_read - http::async_read_some * The overloads of read() and async_read() which take just a header have been removed, since they would throw away important parse metadata. * The derived class callbacks for basic_parser have been streamlined. All strings passed to callbacks are presented in their entirety, instead of being provided in pieces. These changes allow use-cases that were previously difficult or impossible, such as: - Efficient relaying - Late body type commitment - Expect: 100-continue handling
2016-11-20 07:32:41 -05:00
private:
Documentation work
2017-06-03 09:45:09 -07:00
friend class basic_parser<isRequest, parser>;
New HTTP interfaces (API Change): fix #123 fix #154 fix #265 This completely replaces the HTTP parser used to read and parse incoming messages. The new version is faster than the old one, and written in fewer lines. A summary of changes: * parse and async_parse renamed to read and async_read * basic_parser is optimized for linear buffers, use flat_streambuf for the best performance with these functions: - http::read - http::read_some - http::async_read - http::async_read_some * The overloads of read() and async_read() which take just a header have been removed, since they would throw away important parse metadata. * The derived class callbacks for basic_parser have been streamlined. All strings passed to callbacks are presented in their entirety, instead of being provided in pieces. These changes allow use-cases that were previously difficult or impossible, such as: - Efficient relaying - Late body type commitment - Expect: 100-continue handling
2016-11-20 07:32:41 -05:00
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
parser(std::true_type);
parser(std::false_type);
template<class OtherBody, class... Args,
class = typename std::enable_if<
! std::is_same<Body, OtherBody>::value>::type>
parser(
std::true_type,
parser<isRequest, OtherBody, Allocator>&& parser,
Args&&... args);
template<class OtherBody, class... Args,
class = typename std::enable_if<
! std::is_same<Body, OtherBody>::value>::type>
parser(
std::false_type,
parser<isRequest, OtherBody, Allocator>&& parser,
Args&&... args);
template<class Arg1, class... ArgN,
class = typename std::enable_if<
! detail::is_parser<typename
std::decay<Arg1>::type>::value>::type>
explicit
parser(Arg1&& arg1, std::true_type, ArgN&&... argn);
template<class Arg1, class... ArgN,
class = typename std::enable_if<
! detail::is_parser<typename
std::decay<Arg1>::type>::value>::type>
explicit
parser(Arg1&& arg1, std::false_type, ArgN&&... argn);
New HTTP interfaces (API Change): fix #123 fix #154 fix #265 This completely replaces the HTTP parser used to read and parse incoming messages. The new version is faster than the old one, and written in fewer lines. A summary of changes: * parse and async_parse renamed to read and async_read * basic_parser is optimized for linear buffers, use flat_streambuf for the best performance with these functions: - http::read - http::read_some - http::async_read - http::async_read_some * The overloads of read() and async_read() which take just a header have been removed, since they would throw away important parse metadata. * The derived class callbacks for basic_parser have been streamlined. All strings passed to callbacks are presented in their entirety, instead of being provided in pieces. These changes allow use-cases that were previously difficult or impossible, such as: - Efficient relaying - Late body type commitment - Expect: 100-continue handling
2016-11-20 07:32:41 -05:00
void
Refactor chunked parsing (API Change): * parser now has a callback feature for intercepting chunk headers and chunk bodies * The names for basic_parser derived class callbacks have been refactored * basic_parser offers an additional callback for distinguishing chunk body data. Actions Required: * Adjust signatures for required members of user-defined subclasses of basic_parser * Use the new basic_parser chunk callbacks for accessing chunk extensions and chunk bodies.
2017-07-12 18:06:36 -07:00
on_request_impl(
verb method,
string_view method_str,
string_view target,
int version,
error_code& ec)
New HTTP interfaces (API Change): fix #123 fix #154 fix #265 This completely replaces the HTTP parser used to read and parse incoming messages. The new version is faster than the old one, and written in fewer lines. A summary of changes: * parse and async_parse renamed to read and async_read * basic_parser is optimized for linear buffers, use flat_streambuf for the best performance with these functions: - http::read - http::read_some - http::async_read - http::async_read_some * The overloads of read() and async_read() which take just a header have been removed, since they would throw away important parse metadata. * The derived class callbacks for basic_parser have been streamlined. All strings passed to callbacks are presented in their entirety, instead of being provided in pieces. These changes allow use-cases that were previously difficult or impossible, such as: - Efficient relaying - Late body type commitment - Expect: 100-continue handling
2016-11-20 07:32:41 -05:00
{
Handle bad_alloc in parser
2017-06-23 02:22:15 -07:00
try
{
m_.target(target);
if(method != verb::unknown)
m_.method(method);
else
m_.method_string(method_str);
Clear error codes idiomatically
2019-01-20 09:50:43 -08:00
ec = {};
Handle bad_alloc in parser
2017-06-23 02:22:15 -07:00
}
catch(std::bad_alloc const&)
{
ec = error::bad_alloc;
}
message::version is a member function (API Change): fix #778 * The version data member is replaced with accessor member functions. Actions Required: * Call member function message::version instead of accessing the version member at call sites.
2017-09-12 13:49:45 -07:00
m_.version(version);
New HTTP interfaces (API Change): fix #123 fix #154 fix #265 This completely replaces the HTTP parser used to read and parse incoming messages. The new version is faster than the old one, and written in fewer lines. A summary of changes: * parse and async_parse renamed to read and async_read * basic_parser is optimized for linear buffers, use flat_streambuf for the best performance with these functions: - http::read - http::read_some - http::async_read - http::async_read_some * The overloads of read() and async_read() which take just a header have been removed, since they would throw away important parse metadata. * The derived class callbacks for basic_parser have been streamlined. All strings passed to callbacks are presented in their entirety, instead of being provided in pieces. These changes allow use-cases that were previously difficult or impossible, such as: - Efficient relaying - Late body type commitment - Expect: 100-continue handling
2016-11-20 07:32:41 -05:00
}
void
Refactor chunked parsing (API Change): * parser now has a callback feature for intercepting chunk headers and chunk bodies * The names for basic_parser derived class callbacks have been refactored * basic_parser offers an additional callback for distinguishing chunk body data. Actions Required: * Adjust signatures for required members of user-defined subclasses of basic_parser * Use the new basic_parser chunk callbacks for accessing chunk extensions and chunk bodies.
2017-07-12 18:06:36 -07:00
on_response_impl(
int code,
Canonicalize string_view parameter types
2017-06-04 10:52:28 -07:00
string_view reason,
Refactor chunked parsing (API Change): * parser now has a callback feature for intercepting chunk headers and chunk bodies * The names for basic_parser derived class callbacks have been refactored * basic_parser offers an additional callback for distinguishing chunk body data. Actions Required: * Adjust signatures for required members of user-defined subclasses of basic_parser * Use the new basic_parser chunk callbacks for accessing chunk extensions and chunk bodies.
2017-07-12 18:06:36 -07:00
int version,
error_code& ec)
New HTTP interfaces (API Change): fix #123 fix #154 fix #265 This completely replaces the HTTP parser used to read and parse incoming messages. The new version is faster than the old one, and written in fewer lines. A summary of changes: * parse and async_parse renamed to read and async_read * basic_parser is optimized for linear buffers, use flat_streambuf for the best performance with these functions: - http::read - http::read_some - http::async_read - http::async_read_some * The overloads of read() and async_read() which take just a header have been removed, since they would throw away important parse metadata. * The derived class callbacks for basic_parser have been streamlined. All strings passed to callbacks are presented in their entirety, instead of being provided in pieces. These changes allow use-cases that were previously difficult or impossible, such as: - Efficient relaying - Late body type commitment - Expect: 100-continue handling
2016-11-20 07:32:41 -05:00
{
Refactor header status, reason, and target (API Change): * header::result is a family of functions to replace header::status * header interface now uses status enum and also ints * reason-phrase is no longer stored unless the user explicitly requests it. * When serializing, the standard reason is used for the corresponding status code unless the user has changed it.
2017-06-04 12:38:42 -07:00
m_.result(code);
message::version is a member function (API Change): fix #778 * The version data member is replaced with accessor member functions. Actions Required: * Call member function message::version instead of accessing the version member at call sites.
2017-09-12 13:49:45 -07:00
m_.version(version);
Handle bad_alloc in parser
2017-06-23 02:22:15 -07:00
try
{
m_.reason(reason);
Clear error codes idiomatically
2019-01-20 09:50:43 -08:00
ec = {};
Handle bad_alloc in parser
2017-06-23 02:22:15 -07:00
}
catch(std::bad_alloc const&)
{
ec = error::bad_alloc;
}
New HTTP interfaces (API Change): fix #123 fix #154 fix #265 This completely replaces the HTTP parser used to read and parse incoming messages. The new version is faster than the old one, and written in fewer lines. A summary of changes: * parse and async_parse renamed to read and async_read * basic_parser is optimized for linear buffers, use flat_streambuf for the best performance with these functions: - http::read - http::read_some - http::async_read - http::async_read_some * The overloads of read() and async_read() which take just a header have been removed, since they would throw away important parse metadata. * The derived class callbacks for basic_parser have been streamlined. All strings passed to callbacks are presented in their entirety, instead of being provided in pieces. These changes allow use-cases that were previously difficult or impossible, such as: - Efficient relaying - Late body type commitment - Expect: 100-continue handling
2016-11-20 07:32:41 -05:00
}
void
Refactor chunked parsing (API Change): * parser now has a callback feature for intercepting chunk headers and chunk bodies * The names for basic_parser derived class callbacks have been refactored * basic_parser offers an additional callback for distinguishing chunk body data. Actions Required: * Adjust signatures for required members of user-defined subclasses of basic_parser * Use the new basic_parser chunk callbacks for accessing chunk extensions and chunk bodies.
2017-07-12 18:06:36 -07:00
on_field_impl(
field name,
string_view name_string,
string_view value,
error_code& ec)
New HTTP interfaces (API Change): fix #123 fix #154 fix #265 This completely replaces the HTTP parser used to read and parse incoming messages. The new version is faster than the old one, and written in fewer lines. A summary of changes: * parse and async_parse renamed to read and async_read * basic_parser is optimized for linear buffers, use flat_streambuf for the best performance with these functions: - http::read - http::read_some - http::async_read - http::async_read_some * The overloads of read() and async_read() which take just a header have been removed, since they would throw away important parse metadata. * The derived class callbacks for basic_parser have been streamlined. All strings passed to callbacks are presented in their entirety, instead of being provided in pieces. These changes allow use-cases that were previously difficult or impossible, such as: - Efficient relaying - Late body type commitment - Expect: 100-continue handling
2016-11-20 07:32:41 -05:00
{
Handle bad_alloc in parser
2017-06-23 02:22:15 -07:00
try
{
m_.insert(name, name_string, value);
Clear error codes idiomatically
2019-01-20 09:50:43 -08:00
ec = {};
Handle bad_alloc in parser
2017-06-23 02:22:15 -07:00
}
catch(std::bad_alloc const&)
{
ec = error::bad_alloc;
}
New HTTP interfaces (API Change): fix #123 fix #154 fix #265 This completely replaces the HTTP parser used to read and parse incoming messages. The new version is faster than the old one, and written in fewer lines. A summary of changes: * parse and async_parse renamed to read and async_read * basic_parser is optimized for linear buffers, use flat_streambuf for the best performance with these functions: - http::read - http::read_some - http::async_read - http::async_read_some * The overloads of read() and async_read() which take just a header have been removed, since they would throw away important parse metadata. * The derived class callbacks for basic_parser have been streamlined. All strings passed to callbacks are presented in their entirety, instead of being provided in pieces. These changes allow use-cases that were previously difficult or impossible, such as: - Efficient relaying - Late body type commitment - Expect: 100-continue handling
2016-11-20 07:32:41 -05:00
}
void
Refactor chunked parsing (API Change): * parser now has a callback feature for intercepting chunk headers and chunk bodies * The names for basic_parser derived class callbacks have been refactored * basic_parser offers an additional callback for distinguishing chunk body data. Actions Required: * Adjust signatures for required members of user-defined subclasses of basic_parser * Use the new basic_parser chunk callbacks for accessing chunk extensions and chunk bodies.
2017-07-12 18:06:36 -07:00
on_header_impl(error_code& ec)
New HTTP interfaces (API Change): fix #123 fix #154 fix #265 This completely replaces the HTTP parser used to read and parse incoming messages. The new version is faster than the old one, and written in fewer lines. A summary of changes: * parse and async_parse renamed to read and async_read * basic_parser is optimized for linear buffers, use flat_streambuf for the best performance with these functions: - http::read - http::read_some - http::async_read - http::async_read_some * The overloads of read() and async_read() which take just a header have been removed, since they would throw away important parse metadata. * The derived class callbacks for basic_parser have been streamlined. All strings passed to callbacks are presented in their entirety, instead of being provided in pieces. These changes allow use-cases that were previously difficult or impossible, such as: - Efficient relaying - Late body type commitment - Expect: 100-continue handling
2016-11-20 07:32:41 -05:00
{
Clear error codes idiomatically
2019-01-20 09:50:43 -08:00
ec = {};
New HTTP interfaces (API Change): fix #123 fix #154 fix #265 This completely replaces the HTTP parser used to read and parse incoming messages. The new version is faster than the old one, and written in fewer lines. A summary of changes: * parse and async_parse renamed to read and async_read * basic_parser is optimized for linear buffers, use flat_streambuf for the best performance with these functions: - http::read - http::read_some - http::async_read - http::async_read_some * The overloads of read() and async_read() which take just a header have been removed, since they would throw away important parse metadata. * The derived class callbacks for basic_parser have been streamlined. All strings passed to callbacks are presented in their entirety, instead of being provided in pieces. These changes allow use-cases that were previously difficult or impossible, such as: - Efficient relaying - Late body type commitment - Expect: 100-continue handling
2016-11-20 07:32:41 -05:00
}
void
Refactor chunked parsing (API Change): * parser now has a callback feature for intercepting chunk headers and chunk bodies * The names for basic_parser derived class callbacks have been refactored * basic_parser offers an additional callback for distinguishing chunk body data. Actions Required: * Adjust signatures for required members of user-defined subclasses of basic_parser * Use the new basic_parser chunk callbacks for accessing chunk extensions and chunk bodies.
2017-07-12 18:06:36 -07:00
on_body_init_impl(
boost::optional<std::uint64_t> const& content_length,
error_code& ec)
New HTTP interfaces (API Change): fix #123 fix #154 fix #265 This completely replaces the HTTP parser used to read and parse incoming messages. The new version is faster than the old one, and written in fewer lines. A summary of changes: * parse and async_parse renamed to read and async_read * basic_parser is optimized for linear buffers, use flat_streambuf for the best performance with these functions: - http::read - http::read_some - http::async_read - http::async_read_some * The overloads of read() and async_read() which take just a header have been removed, since they would throw away important parse metadata. * The derived class callbacks for basic_parser have been streamlined. All strings passed to callbacks are presented in their entirety, instead of being provided in pieces. These changes allow use-cases that were previously difficult or impossible, such as: - Efficient relaying - Late body type commitment - Expect: 100-continue handling
2016-11-20 07:32:41 -05: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
rd_.init(content_length, ec);
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
rd_inited_ = true;
New HTTP interfaces (API Change): fix #123 fix #154 fix #265 This completely replaces the HTTP parser used to read and parse incoming messages. The new version is faster than the old one, and written in fewer lines. A summary of changes: * parse and async_parse renamed to read and async_read * basic_parser is optimized for linear buffers, use flat_streambuf for the best performance with these functions: - http::read - http::read_some - http::async_read - http::async_read_some * The overloads of read() and async_read() which take just a header have been removed, since they would throw away important parse metadata. * The derived class callbacks for basic_parser have been streamlined. All strings passed to callbacks are presented in their entirety, instead of being provided in pieces. These changes allow use-cases that were previously difficult or impossible, such as: - Efficient relaying - Late body type commitment - Expect: 100-continue handling
2016-11-20 07:32:41 -05:00
}
Return std::size_t from Body::writer::put (API Change) `put` returns the number of bytes actually transferred from the input buffers. Actions Required: * Return the number of bytes actually transferred from the input buffers in user defined `Body::writer::put` functions.
2017-07-02 06:32:19 -07:00
std::size_t
Refactor chunked parsing (API Change): * parser now has a callback feature for intercepting chunk headers and chunk bodies * The names for basic_parser derived class callbacks have been refactored * basic_parser offers an additional callback for distinguishing chunk body data. Actions Required: * Adjust signatures for required members of user-defined subclasses of basic_parser * Use the new basic_parser chunk callbacks for accessing chunk extensions and chunk bodies.
2017-07-12 18:06:36 -07:00
on_body_impl(
string_view body,
error_code& ec)
New HTTP interfaces (API Change): fix #123 fix #154 fix #265 This completely replaces the HTTP parser used to read and parse incoming messages. The new version is faster than the old one, and written in fewer lines. A summary of changes: * parse and async_parse renamed to read and async_read * basic_parser is optimized for linear buffers, use flat_streambuf for the best performance with these functions: - http::read - http::read_some - http::async_read - http::async_read_some * The overloads of read() and async_read() which take just a header have been removed, since they would throw away important parse metadata. * The derived class callbacks for basic_parser have been streamlined. All strings passed to callbacks are presented in their entirety, instead of being provided in pieces. These changes allow use-cases that were previously difficult or impossible, such as: - Efficient relaying - Late body type commitment - Expect: 100-continue handling
2016-11-20 07:32:41 -05:00
{
net is a namespace alias for boost::asio: The namespace alias beast::net replaces boost::asio in all code and documentation.
2018-11-30 14:58:38 -08:00
return rd_.put(net::buffer(
Refactor chunked parsing (API Change): * parser now has a callback feature for intercepting chunk headers and chunk bodies * The names for basic_parser derived class callbacks have been refactored * basic_parser offers an additional callback for distinguishing chunk body data. Actions Required: * Adjust signatures for required members of user-defined subclasses of basic_parser * Use the new basic_parser chunk callbacks for accessing chunk extensions and chunk bodies.
2017-07-12 18:06:36 -07:00
body.data(), body.size()), ec);
New HTTP interfaces (API Change): fix #123 fix #154 fix #265 This completely replaces the HTTP parser used to read and parse incoming messages. The new version is faster than the old one, and written in fewer lines. A summary of changes: * parse and async_parse renamed to read and async_read * basic_parser is optimized for linear buffers, use flat_streambuf for the best performance with these functions: - http::read - http::read_some - http::async_read - http::async_read_some * The overloads of read() and async_read() which take just a header have been removed, since they would throw away important parse metadata. * The derived class callbacks for basic_parser have been streamlined. All strings passed to callbacks are presented in their entirety, instead of being provided in pieces. These changes allow use-cases that were previously difficult or impossible, such as: - Efficient relaying - Late body type commitment - Expect: 100-continue handling
2016-11-20 07:32:41 -05:00
}
void
Refactor chunked parsing (API Change): * parser now has a callback feature for intercepting chunk headers and chunk bodies * The names for basic_parser derived class callbacks have been refactored * basic_parser offers an additional callback for distinguishing chunk body data. Actions Required: * Adjust signatures for required members of user-defined subclasses of basic_parser * Use the new basic_parser chunk callbacks for accessing chunk extensions and chunk bodies.
2017-07-12 18:06:36 -07:00
on_chunk_header_impl(
std::uint64_t size,
string_view extensions,
error_code& ec)
New HTTP interfaces (API Change): fix #123 fix #154 fix #265 This completely replaces the HTTP parser used to read and parse incoming messages. The new version is faster than the old one, and written in fewer lines. A summary of changes: * parse and async_parse renamed to read and async_read * basic_parser is optimized for linear buffers, use flat_streambuf for the best performance with these functions: - http::read - http::read_some - http::async_read - http::async_read_some * The overloads of read() and async_read() which take just a header have been removed, since they would throw away important parse metadata. * The derived class callbacks for basic_parser have been streamlined. All strings passed to callbacks are presented in their entirety, instead of being provided in pieces. These changes allow use-cases that were previously difficult or impossible, such as: - Efficient relaying - Late body type commitment - Expect: 100-continue handling
2016-11-20 07:32:41 -05:00
{
Refactor chunked parsing (API Change): * parser now has a callback feature for intercepting chunk headers and chunk bodies * The names for basic_parser derived class callbacks have been refactored * basic_parser offers an additional callback for distinguishing chunk body data. Actions Required: * Adjust signatures for required members of user-defined subclasses of basic_parser * Use the new basic_parser chunk callbacks for accessing chunk extensions and chunk bodies.
2017-07-12 18:06:36 -07:00
if(cb_h_)
Use std::function and reference wrapper
2017-07-14 17:26:05 -07:00
return cb_h_(size, extensions, ec);
Clear error codes idiomatically
2019-01-20 09:50:43 -08:00
ec = {};
New HTTP interfaces (API Change): fix #123 fix #154 fix #265 This completely replaces the HTTP parser used to read and parse incoming messages. The new version is faster than the old one, and written in fewer lines. A summary of changes: * parse and async_parse renamed to read and async_read * basic_parser is optimized for linear buffers, use flat_streambuf for the best performance with these functions: - http::read - http::read_some - http::async_read - http::async_read_some * The overloads of read() and async_read() which take just a header have been removed, since they would throw away important parse metadata. * The derived class callbacks for basic_parser have been streamlined. All strings passed to callbacks are presented in their entirety, instead of being provided in pieces. These changes allow use-cases that were previously difficult or impossible, such as: - Efficient relaying - Late body type commitment - Expect: 100-continue handling
2016-11-20 07:32:41 -05:00
}
Refactor chunked parsing (API Change): * parser now has a callback feature for intercepting chunk headers and chunk bodies * The names for basic_parser derived class callbacks have been refactored * basic_parser offers an additional callback for distinguishing chunk body data. Actions Required: * Adjust signatures for required members of user-defined subclasses of basic_parser * Use the new basic_parser chunk callbacks for accessing chunk extensions and chunk bodies.
2017-07-12 18:06:36 -07:00
std::size_t
on_chunk_body_impl(
std::uint64_t remain,
string_view body,
error_code& ec)
{
if(cb_b_)
Use std::function and reference wrapper
2017-07-14 17:26:05 -07:00
return cb_b_(remain, body, ec);
net is a namespace alias for boost::asio: The namespace alias beast::net replaces boost::asio in all code and documentation.
2018-11-30 14:58:38 -08:00
return rd_.put(net::buffer(
Refactor chunked parsing (API Change): * parser now has a callback feature for intercepting chunk headers and chunk bodies * The names for basic_parser derived class callbacks have been refactored * basic_parser offers an additional callback for distinguishing chunk body data. Actions Required: * Adjust signatures for required members of user-defined subclasses of basic_parser * Use the new basic_parser chunk callbacks for accessing chunk extensions and chunk bodies.
2017-07-12 18:06:36 -07:00
body.data(), body.size()), ec);
}
New HTTP interfaces (API Change): fix #123 fix #154 fix #265 This completely replaces the HTTP parser used to read and parse incoming messages. The new version is faster than the old one, and written in fewer lines. A summary of changes: * parse and async_parse renamed to read and async_read * basic_parser is optimized for linear buffers, use flat_streambuf for the best performance with these functions: - http::read - http::read_some - http::async_read - http::async_read_some * The overloads of read() and async_read() which take just a header have been removed, since they would throw away important parse metadata. * The derived class callbacks for basic_parser have been streamlined. All strings passed to callbacks are presented in their entirety, instead of being provided in pieces. These changes allow use-cases that were previously difficult or impossible, such as: - Efficient relaying - Late body type commitment - Expect: 100-continue handling
2016-11-20 07:32:41 -05:00
void
Refactor chunked parsing (API Change): * parser now has a callback feature for intercepting chunk headers and chunk bodies * The names for basic_parser derived class callbacks have been refactored * basic_parser offers an additional callback for distinguishing chunk body data. Actions Required: * Adjust signatures for required members of user-defined subclasses of basic_parser * Use the new basic_parser chunk callbacks for accessing chunk extensions and chunk bodies.
2017-07-12 18:06:36 -07:00
on_finish_impl(error_code& ec)
New HTTP interfaces (API Change): fix #123 fix #154 fix #265 This completely replaces the HTTP parser used to read and parse incoming messages. The new version is faster than the old one, and written in fewer lines. A summary of changes: * parse and async_parse renamed to read and async_read * basic_parser is optimized for linear buffers, use flat_streambuf for the best performance with these functions: - http::read - http::read_some - http::async_read - http::async_read_some * The overloads of read() and async_read() which take just a header have been removed, since they would throw away important parse metadata. * The derived class callbacks for basic_parser have been streamlined. All strings passed to callbacks are presented in their entirety, instead of being provided in pieces. These changes allow use-cases that were previously difficult or impossible, such as: - Efficient relaying - Late body type commitment - Expect: 100-continue handling
2016-11-20 07:32:41 -05: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
rd_.finish(ec);
New HTTP interfaces (API Change): fix #123 fix #154 fix #265 This completely replaces the HTTP parser used to read and parse incoming messages. The new version is faster than the old one, and written in fewer lines. A summary of changes: * parse and async_parse renamed to read and async_read * basic_parser is optimized for linear buffers, use flat_streambuf for the best performance with these functions: - http::read - http::read_some - http::async_read - http::async_read_some * The overloads of read() and async_read() which take just a header have been removed, since they would throw away important parse metadata. * The derived class callbacks for basic_parser have been streamlined. All strings passed to callbacks are presented in their entirety, instead of being provided in pieces. These changes allow use-cases that were previously difficult or impossible, such as: - Efficient relaying - Late body type commitment - Expect: 100-continue handling
2016-11-20 07:32:41 -05:00
}
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
};
New HTTP interfaces (API Change): fix #123 fix #154 fix #265 This completely replaces the HTTP parser used to read and parse incoming messages. The new version is faster than the old one, and written in fewer lines. A summary of changes: * parse and async_parse renamed to read and async_read * basic_parser is optimized for linear buffers, use flat_streambuf for the best performance with these functions: - http::read - http::read_some - http::async_read - http::async_read_some * The overloads of read() and async_read() which take just a header have been removed, since they would throw away important parse metadata. * The derived class callbacks for basic_parser have been streamlined. All strings passed to callbacks are presented in their entirety, instead of being provided in pieces. These changes allow use-cases that were previously difficult or impossible, such as: - Efficient relaying - Late body type commitment - Expect: 100-continue handling
2016-11-20 07:32:41 -05:00
Rename to parser (API Change): * message_parser is renamed to parser
2017-06-03 08:56:21 -07:00
/// An HTTP/1 parser for producing a request message.
parser requires basic_fields (API Change): * `parser` is now templated on Allocator * `parser` only produces messages using `basic_fields<Allocator>` as the Fields type. * message-oriented read and async_read only work on messages using basic_fields as the Fields type. Actions Required: * Callers using `parser` with Fields types other than basic_fields will need to create their own subclass of basic_parser to work with their custom fields type.
2017-06-19 11:54:53 -07:00
template<class Body, class Allocator = std::allocator<char>>
using request_parser = parser<true, Body, Allocator>;
New HTTP interfaces (API Change): fix #123 fix #154 fix #265 This completely replaces the HTTP parser used to read and parse incoming messages. The new version is faster than the old one, and written in fewer lines. A summary of changes: * parse and async_parse renamed to read and async_read * basic_parser is optimized for linear buffers, use flat_streambuf for the best performance with these functions: - http::read - http::read_some - http::async_read - http::async_read_some * The overloads of read() and async_read() which take just a header have been removed, since they would throw away important parse metadata. * The derived class callbacks for basic_parser have been streamlined. All strings passed to callbacks are presented in their entirety, instead of being provided in pieces. These changes allow use-cases that were previously difficult or impossible, such as: - Efficient relaying - Late body type commitment - Expect: 100-continue handling
2016-11-20 07:32:41 -05:00
Rename to parser (API Change): * message_parser is renamed to parser
2017-06-03 08:56:21 -07:00
/// An HTTP/1 parser for producing a response message.
parser requires basic_fields (API Change): * `parser` is now templated on Allocator * `parser` only produces messages using `basic_fields<Allocator>` as the Fields type. * message-oriented read and async_read only work on messages using basic_fields as the Fields type. Actions Required: * Callers using `parser` with Fields types other than basic_fields will need to create their own subclass of basic_parser to work with their custom fields type.
2017-06-19 11:54:53 -07:00
template<class Body, class Allocator = std::allocator<char>>
using response_parser = parser<false, Body, Allocator>;
New HTTP interfaces (API Change): fix #123 fix #154 fix #265 This completely replaces the HTTP parser used to read and parse incoming messages. The new version is faster than the old one, and written in fewer lines. A summary of changes: * parse and async_parse renamed to read and async_read * basic_parser is optimized for linear buffers, use flat_streambuf for the best performance with these functions: - http::read - http::read_some - http::async_read - http::async_read_some * The overloads of read() and async_read() which take just a header have been removed, since they would throw away important parse metadata. * The derived class callbacks for basic_parser have been streamlined. All strings passed to callbacks are presented in their entirety, instead of being provided in pieces. These changes allow use-cases that were previously difficult or impossible, such as: - Efficient relaying - Late body type commitment - Expect: 100-continue handling
2016-11-20 07:32:41 -05:00
} // http
} // beast
Boost prep
2017-07-20 13:40:34 -07:00
} // boost
New HTTP interfaces (API Change): fix #123 fix #154 fix #265 This completely replaces the HTTP parser used to read and parse incoming messages. The new version is faster than the old one, and written in fewer lines. A summary of changes: * parse and async_parse renamed to read and async_read * basic_parser is optimized for linear buffers, use flat_streambuf for the best performance with these functions: - http::read - http::read_some - http::async_read - http::async_read_some * The overloads of read() and async_read() which take just a header have been removed, since they would throw away important parse metadata. * The derived class callbacks for basic_parser have been streamlined. All strings passed to callbacks are presented in their entirety, instead of being provided in pieces. These changes allow use-cases that were previously difficult or impossible, such as: - Efficient relaying - Late body type commitment - Expect: 100-continue handling
2016-11-20 07:32:41 -05:00
Boost prep
2017-07-20 13:40:34 -07:00
#include <boost/beast/http/impl/parser.ipp>
New HTTP interfaces (API Change): fix #123 fix #154 fix #265 This completely replaces the HTTP parser used to read and parse incoming messages. The new version is faster than the old one, and written in fewer lines. A summary of changes: * parse and async_parse renamed to read and async_read * basic_parser is optimized for linear buffers, use flat_streambuf for the best performance with these functions: - http::read - http::read_some - http::async_read - http::async_read_some * The overloads of read() and async_read() which take just a header have been removed, since they would throw away important parse metadata. * The derived class callbacks for basic_parser have been streamlined. All strings passed to callbacks are presented in their entirety, instead of being provided in pieces. These changes allow use-cases that were previously difficult or impossible, such as: - Efficient relaying - Late body type commitment - Expect: 100-continue handling
2016-11-20 07:32:41 -05:00
#endif
Copy Permalink