feedc0de/boost_beast
1
0
Fork 0
forked from boostorg/beast
Code Pull Requests Activity
Files
d0d08e81f90ee020ddebca1dfac210a8cbd5fb75
boost_beast/include/beast/http/impl/write.ipp

1075 lines
28 KiB
Plaintext
Raw Normal View History

Truncate history, version 1.0.0-b2
2017-07-20 08:01:46 -07:00
//
Update copyright dates
2017-02-06 20:07:03 -05:00
// Copyright (c) 2013-2017 Vinnie Falco (vinnie dot falco at gmail dot com)
Truncate history, version 1.0.0-b2
2017-07-20 08:01:46 -07:00
//
// Distributed under the Boost Software License, Version 1.0. (See accompanying
// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
//
#ifndef BEAST_HTTP_IMPL_WRITE_IPP
#define BEAST_HTTP_IMPL_WRITE_IPP
Refactor type_traits (API Change): fix #373 * concepts.hpp is renamed to type_traits.hpp * Body reader and writer concepts are renamed
2017-05-28 09:05:29 -07:00
#include <beast/http/type_traits.hpp>
Refactor HTTP serialization (API Change): A new class `serializer` is introduced to permit incremental serialization of HTTP messages. Existing free functions are re-implemented in terms of this new class. * The BodyReader concept is refined to support a greater variety of strategies for providing buffers representing the body to the serialization algorithms. * Added buffer_body, a new model of Body which allows the caller to provide a series of owned buffers using their own serialization loop. * Added empty_body, a model of Body which is for serialization only, to represent HTTP messages with no content body. * Removed overloads of write and async_write which send only the HTTP header. * Removed public interfaces for performing low-level chunk encoding.
2017-05-08 12:41:45 -07:00
#include <beast/http/error.hpp>
Tidy up core sources: The core headers are moved to their own directory (but remain in the same namespace).
2016-05-07 14:57:15 -04:00
#include <beast/core/buffer_cat.hpp>
Refactor HTTP serialization (API Change): A new class `serializer` is introduced to permit incremental serialization of HTTP messages. Existing free functions are re-implemented in terms of this new class. * The BodyReader concept is refined to support a greater variety of strategies for providing buffers representing the body to the serialization algorithms. * Added buffer_body, a new model of Body which allows the caller to provide a series of owned buffers using their own serialization loop. * Added empty_body, a model of Body which is for serialization only, to represent HTTP messages with no content body. * Removed overloads of write and async_write which send only the HTTP header. * Removed public interfaces for performing low-level chunk encoding.
2017-05-08 12:41:45 -07:00
#include <beast/core/buffer_prefix.hpp>
Tidy up core sources: The core headers are moved to their own directory (but remain in the same namespace).
2016-05-07 14:57:15 -04:00
#include <beast/core/bind_handler.hpp>
New ostream() returns dynamic buffer output stream (API Change): This eliminates beast::write output for dynamic buffers and replaces it with the function ostream() that wraps a caller provided dynamic buffer and returns the result as a std::ostream derived object. Callers may now produce formatted output into any object meeting the requirements of DynamicBuffer using operator<< and the standard stream modifiers such as std::endl. This new technique is more efficient, as implementations of operator<< can now write directly into the output using std::ostream::write and std::ostream::put. Example of use: beast::streambuf sb; beast::ostream(sb) << "Hello, world!" << std::endl;
2017-05-03 15:29:23 -07:00
#include <beast/core/ostream.hpp>
Refactor HTTP serialization (API Change): A new class `serializer` is introduced to permit incremental serialization of HTTP messages. Existing free functions are re-implemented in terms of this new class. * The BodyReader concept is refined to support a greater variety of strategies for providing buffers representing the body to the serialization algorithms. * Added buffer_body, a new model of Body which allows the caller to provide a series of owned buffers using their own serialization loop. * Added empty_body, a model of Body which is for serialization only, to represent HTTP messages with no content body. * Removed overloads of write and async_write which send only the HTTP header. * Removed public interfaces for performing low-level chunk encoding.
2017-05-08 12:41:45 -07:00
#include <beast/core/handler_alloc.hpp>
Implement asio dealloc-before-invoke guarantee: fix #215 This change guarantees that temporary memory allocated through the asio hooks by the Beast implementation is deallocated before invoking the final handler when performing composed operations. The change is accomplished by replacing std::shared_ptr with a thread-safe custom container handler_ptr to manage composed operation state. The container tracks other instances which manage the same object and resets them in a safe way before invoking the final handler. handler_ptr is provided as a public interface so that users of this library can utilize the same idiom to write their own composed operations.
2017-01-02 13:29:48 -05:00
#include <beast/core/handler_ptr.hpp>
Rename to multi_buffer, basic_multi_buffer (API Change): These classes are renamed: * streambuf to multi_buffer * basic_streambuf to basic_multi_buffer
2017-05-04 15:40:07 -07:00
#include <beast/core/multi_buffer.hpp>
Concept revision and documentation (API Change): The concept type traits are renamed for consistency, and consolidated into a single header file <beast/core/type_traits.hpp> A new section, Core Concepts, is added to the documentation describing all of the core utility classes and functions. This also includes a complete explanation and sample program describing how to write asynchronous initiation functions and their associated composed operations.
2017-05-10 12:03:00 -07:00
#include <beast/core/type_traits.hpp>
Move sync_ostream to core/detail
2016-11-07 06:33:03 -05:00
#include <beast/core/detail/sync_ostream.hpp>
Remove handler helpers, tidy up hook invocations (API Change)
2017-05-14 09:25:43 -07:00
#include <boost/asio/handler_alloc_hook.hpp>
#include <boost/asio/handler_continuation_hook.hpp>
#include <boost/asio/handler_invoke_hook.hpp>
Truncate history, version 1.0.0-b2
2017-07-20 08:01:46 -07:00
#include <boost/asio/write.hpp>
Use BOOST_THROW_EXCEPTION fix #370
2017-05-22 15:30:12 -07:00
#include <boost/throw_exception.hpp>
Truncate history, version 1.0.0-b2
2017-07-20 08:01:46 -07:00
#include <condition_variable>
#include <mutex>
Refactor beast core, http, tests, and examples: * Fix warnings * Port cmake scripts to linux * Add command line options for running test suites * Add examples to CMakeLists * Return std::uint64_t from writer::content_length * basic_parser::write takes asio::const_buffer instead of pointer and size * Turn message test back on now that it passes * Rename to http::headers, use std::allocator, remove http_headers * http::message::method is now a string * Refactor to_string for ConstBufferSequence * Remove chunk_encode from the public interface * Initialize members for default constructed iterators * Disallow default construction for dependent buffer sequences Refactor http::message serialization: * Serialization no longer creates a copy of the headers and modifies them * New function prepare(), sets Connection, Transfer-Encoding, Content-Length based on the body attributes and caller options. Callers can use prepare() to have the fields set automatically, or they can set the fields manually. * Use write for operator<< * Tests for serialization
2016-04-29 06:04:40 -04:00
#include <ostream>
#include <sstream>
Truncate history, version 1.0.0-b2
2017-07-20 08:01:46 -07:00
#include <type_traits>
namespace beast {
namespace http {
namespace detail {
New ostream() returns dynamic buffer output stream (API Change): This eliminates beast::write output for dynamic buffers and replaces it with the function ostream() that wraps a caller provided dynamic buffer and returns the result as a std::ostream derived object. Callers may now produce formatted output into any object meeting the requirements of DynamicBuffer using operator<< and the standard stream modifiers such as std::endl. This new technique is more efficient, as implementations of operator<< can now write directly into the output using std::ostream::write and std::ostream::put. Example of use: beast::streambuf sb; beast::ostream(sb) << "Hello, world!" << std::endl;
2017-05-03 15:29:23 -07:00
template<class Fields>
Distinguish HTTP/1 messages from general HTTP messages: The version field is moved into message_v1, all public interfaces are reworked to identify HTTP/1 wire format operations (suffix "_v1") versus general HTTP.
2016-05-01 11:14:10 -04:00
void
New ostream() returns dynamic buffer output stream (API Change): This eliminates beast::write output for dynamic buffers and replaces it with the function ostream() that wraps a caller provided dynamic buffer and returns the result as a std::ostream derived object. Callers may now produce formatted output into any object meeting the requirements of DynamicBuffer using operator<< and the standard stream modifiers such as std::endl. This new technique is more efficient, as implementations of operator<< can now write directly into the output using std::ostream::write and std::ostream::put. Example of use: beast::streambuf sb; beast::ostream(sb) << "Hello, world!" << std::endl;
2017-05-03 15:29:23 -07:00
write_start_line(std::ostream& os,
Refactor HTTP identifier names (API Change): fix #171 Several names and HTTP identifiers are renamed to be more consistent, self-explanatory, and concise: * "Fields" is a collection of HTTP header fields (rfc7230 section 3.2) * "Header" is the Start Line plus Fields. Another way to look at it is, the HTTP message minus the body. * `basic_fields` replaces `basic_headers` * `fields` replaces `headers` * `Fields` replaces `Headers` in template parameter lists * `header` replaces `message_headers` * `header::fields` replaces `message_headers::fields` The changes are cosmetic and do not affect run-time behavior.
2016-11-10 05:34:49 -05:00
header<true, Fields> const& msg)
Distinguish HTTP/1 messages from general HTTP messages: The version field is moved into message_v1, all public interfaces are reworked to identify HTTP/1 wire format operations (suffix "_v1") versus general HTTP.
2016-05-01 11:14:10 -04:00
{
Add write, async_write, operator<< for message_headers: fix #155 This adds overloads of write, async_write, and operator<< for message_headers.
2016-11-07 13:51:10 -05:00
BOOST_ASSERT(msg.version == 10 || msg.version == 11);
New ostream() returns dynamic buffer output stream (API Change): This eliminates beast::write output for dynamic buffers and replaces it with the function ostream() that wraps a caller provided dynamic buffer and returns the result as a std::ostream derived object. Callers may now produce formatted output into any object meeting the requirements of DynamicBuffer using operator<< and the standard stream modifiers such as std::endl. This new technique is more efficient, as implementations of operator<< can now write directly into the output using std::ostream::write and std::ostream::put. Example of use: beast::streambuf sb; beast::ostream(sb) << "Hello, world!" << std::endl;
2017-05-03 15:29:23 -07:00
os << msg.method() << " " << msg.target();
Improve first line serialization
2016-10-10 09:00:57 -04:00
switch(msg.version)
{
New ostream() returns dynamic buffer output stream (API Change): This eliminates beast::write output for dynamic buffers and replaces it with the function ostream() that wraps a caller provided dynamic buffer and returns the result as a std::ostream derived object. Callers may now produce formatted output into any object meeting the requirements of DynamicBuffer using operator<< and the standard stream modifiers such as std::endl. This new technique is more efficient, as implementations of operator<< can now write directly into the output using std::ostream::write and std::ostream::put. Example of use: beast::streambuf sb; beast::ostream(sb) << "Hello, world!" << std::endl;
2017-05-03 15:29:23 -07:00
case 10: os << " HTTP/1.0\r\n"; break;
case 11: os << " HTTP/1.1\r\n"; break;
Improve first line serialization
2016-10-10 09:00:57 -04:00
}
Distinguish HTTP/1 messages from general HTTP messages: The version field is moved into message_v1, all public interfaces are reworked to identify HTTP/1 wire format operations (suffix "_v1") versus general HTTP.
2016-05-01 11:14:10 -04:00
}
New ostream() returns dynamic buffer output stream (API Change): This eliminates beast::write output for dynamic buffers and replaces it with the function ostream() that wraps a caller provided dynamic buffer and returns the result as a std::ostream derived object. Callers may now produce formatted output into any object meeting the requirements of DynamicBuffer using operator<< and the standard stream modifiers such as std::endl. This new technique is more efficient, as implementations of operator<< can now write directly into the output using std::ostream::write and std::ostream::put. Example of use: beast::streambuf sb; beast::ostream(sb) << "Hello, world!" << std::endl;
2017-05-03 15:29:23 -07:00
template<class Fields>
Distinguish HTTP/1 messages from general HTTP messages: The version field is moved into message_v1, all public interfaces are reworked to identify HTTP/1 wire format operations (suffix "_v1") versus general HTTP.
2016-05-01 11:14:10 -04:00
void
New ostream() returns dynamic buffer output stream (API Change): This eliminates beast::write output for dynamic buffers and replaces it with the function ostream() that wraps a caller provided dynamic buffer and returns the result as a std::ostream derived object. Callers may now produce formatted output into any object meeting the requirements of DynamicBuffer using operator<< and the standard stream modifiers such as std::endl. This new technique is more efficient, as implementations of operator<< can now write directly into the output using std::ostream::write and std::ostream::put. Example of use: beast::streambuf sb; beast::ostream(sb) << "Hello, world!" << std::endl;
2017-05-03 15:29:23 -07:00
write_start_line(std::ostream& os,
Refactor HTTP identifier names (API Change): fix #171 Several names and HTTP identifiers are renamed to be more consistent, self-explanatory, and concise: * "Fields" is a collection of HTTP header fields (rfc7230 section 3.2) * "Header" is the Start Line plus Fields. Another way to look at it is, the HTTP message minus the body. * `basic_fields` replaces `basic_headers` * `fields` replaces `headers` * `Fields` replaces `Headers` in template parameter lists * `header` replaces `message_headers` * `header::fields` replaces `message_headers::fields` The changes are cosmetic and do not affect run-time behavior.
2016-11-10 05:34:49 -05:00
header<false, Fields> const& msg)
Distinguish HTTP/1 messages from general HTTP messages: The version field is moved into message_v1, all public interfaces are reworked to identify HTTP/1 wire format operations (suffix "_v1") versus general HTTP.
2016-05-01 11:14:10 -04:00
{
Add write, async_write, operator<< for message_headers: fix #155 This adds overloads of write, async_write, and operator<< for message_headers.
2016-11-07 13:51:10 -05:00
BOOST_ASSERT(msg.version == 10 || msg.version == 11);
Improve first line serialization
2016-10-10 09:00:57 -04:00
switch(msg.version)
{
New ostream() returns dynamic buffer output stream (API Change): This eliminates beast::write output for dynamic buffers and replaces it with the function ostream() that wraps a caller provided dynamic buffer and returns the result as a std::ostream derived object. Callers may now produce formatted output into any object meeting the requirements of DynamicBuffer using operator<< and the standard stream modifiers such as std::endl. This new technique is more efficient, as implementations of operator<< can now write directly into the output using std::ostream::write and std::ostream::put. Example of use: beast::streambuf sb; beast::ostream(sb) << "Hello, world!" << std::endl;
2017-05-03 15:29:23 -07:00
case 10: os << "HTTP/1.0 "; break;
case 11: os << "HTTP/1.1 "; break;
Improve first line serialization
2016-10-10 09:00:57 -04:00
}
New ostream() returns dynamic buffer output stream (API Change): This eliminates beast::write output for dynamic buffers and replaces it with the function ostream() that wraps a caller provided dynamic buffer and returns the result as a std::ostream derived object. Callers may now produce formatted output into any object meeting the requirements of DynamicBuffer using operator<< and the standard stream modifiers such as std::endl. This new technique is more efficient, as implementations of operator<< can now write directly into the output using std::ostream::write and std::ostream::put. Example of use: beast::streambuf sb; beast::ostream(sb) << "Hello, world!" << std::endl;
2017-05-03 15:29:23 -07:00
os << msg.status << " " << msg.reason() << "\r\n";
Distinguish HTTP/1 messages from general HTTP messages: The version field is moved into message_v1, all public interfaces are reworked to identify HTTP/1 wire format operations (suffix "_v1") versus general HTTP.
2016-05-01 11:14:10 -04:00
}
New ostream() returns dynamic buffer output stream (API Change): This eliminates beast::write output for dynamic buffers and replaces it with the function ostream() that wraps a caller provided dynamic buffer and returns the result as a std::ostream derived object. Callers may now produce formatted output into any object meeting the requirements of DynamicBuffer using operator<< and the standard stream modifiers such as std::endl. This new technique is more efficient, as implementations of operator<< can now write directly into the output using std::ostream::write and std::ostream::put. Example of use: beast::streambuf sb; beast::ostream(sb) << "Hello, world!" << std::endl;
2017-05-03 15:29:23 -07:00
template<class FieldSequence>
Distinguish HTTP/1 messages from general HTTP messages: The version field is moved into message_v1, all public interfaces are reworked to identify HTTP/1 wire format operations (suffix "_v1") versus general HTTP.
2016-05-01 11:14:10 -04:00
void
New ostream() returns dynamic buffer output stream (API Change): This eliminates beast::write output for dynamic buffers and replaces it with the function ostream() that wraps a caller provided dynamic buffer and returns the result as a std::ostream derived object. Callers may now produce formatted output into any object meeting the requirements of DynamicBuffer using operator<< and the standard stream modifiers such as std::endl. This new technique is more efficient, as implementations of operator<< can now write directly into the output using std::ostream::write and std::ostream::put. Example of use: beast::streambuf sb; beast::ostream(sb) << "Hello, world!" << std::endl;
2017-05-03 15:29:23 -07:00
write_fields(std::ostream& os,
FieldSequence const& fields)
Distinguish HTTP/1 messages from general HTTP messages: The version field is moved into message_v1, all public interfaces are reworked to identify HTTP/1 wire format operations (suffix "_v1") versus general HTTP.
2016-05-01 11:14:10 -04:00
{
//static_assert(is_FieldSequence<FieldSequence>::value,
// "FieldSequence requirements not met");
for(auto const& field : fields)
{
Refactor http::header contents (API Change): fix #124 The http::header data members "method", "url", and "reason" are changed from data members, to pairs of get and set functions which forward the call to the Fields type used to instantiate the template. Previously, these data members were implemented using std::string. With this change, the implementation of the Fields type used to instantiate the template is now in control of the representation of those values. This permits custom memory allocation strategies including uniform use of the Allocator type already provided to beast::http::basic_fields.
2017-05-02 15:49:22 -07:00
auto const name = field.name();
BOOST_ASSERT(! name.empty());
if(name[0] == ':')
continue;
New ostream() returns dynamic buffer output stream (API Change): This eliminates beast::write output for dynamic buffers and replaces it with the function ostream() that wraps a caller provided dynamic buffer and returns the result as a std::ostream derived object. Callers may now produce formatted output into any object meeting the requirements of DynamicBuffer using operator<< and the standard stream modifiers such as std::endl. This new technique is more efficient, as implementations of operator<< can now write directly into the output using std::ostream::write and std::ostream::put. Example of use: beast::streambuf sb; beast::ostream(sb) << "Hello, world!" << std::endl;
2017-05-03 15:29:23 -07:00
os << field.name() << ": " << field.value() << "\r\n";
Distinguish HTTP/1 messages from general HTTP messages: The version field is moved into message_v1, all public interfaces are reworked to identify HTTP/1 wire format operations (suffix "_v1") versus general HTTP.
2016-05-01 11:14:10 -04:00
}
}
Add write, async_write, operator<< for message_headers: fix #155 This adds overloads of write, async_write, and operator<< for message_headers.
2016-11-07 13:51:10 -05:00
} // detail
//------------------------------------------------------------------------------
Refactor HTTP serialization (API Change): A new class `serializer` is introduced to permit incremental serialization of HTTP messages. Existing free functions are re-implemented in terms of this new class. * The BodyReader concept is refined to support a greater variety of strategies for providing buffers representing the body to the serialization algorithms. * Added buffer_body, a new model of Body which allows the caller to provide a series of owned buffers using their own serialization loop. * Added empty_body, a model of Body which is for serialization only, to represent HTTP messages with no content body. * Removed overloads of write and async_write which send only the HTTP header. * Removed public interfaces for performing low-level chunk encoding.
2017-05-08 12:41:45 -07:00
template<bool isRequest, class Body, class Fields,
class Decorator, class Allocator>
Add write, async_write, operator<< for message_headers: fix #155 This adds overloads of write, async_write, and operator<< for message_headers.
2016-11-07 13:51:10 -05:00
template<class Stream, class Handler>
Refactor HTTP serialization (API Change): A new class `serializer` is introduced to permit incremental serialization of HTTP messages. Existing free functions are re-implemented in terms of this new class. * The BodyReader concept is refined to support a greater variety of strategies for providing buffers representing the body to the serialization algorithms. * Added buffer_body, a new model of Body which allows the caller to provide a series of owned buffers using their own serialization loop. * Added empty_body, a model of Body which is for serialization only, to represent HTTP messages with no content body. * Removed overloads of write and async_write which send only the HTTP header. * Removed public interfaces for performing low-level chunk encoding.
2017-05-08 12:41:45 -07:00
class serializer<isRequest, Body, Fields,
Decorator, Allocator>::async_op
Add write, async_write, operator<< for message_headers: fix #155 This adds overloads of write, async_write, and operator<< for message_headers.
2016-11-07 13:51:10 -05:00
{
Refactor HTTP serialization (API Change): A new class `serializer` is introduced to permit incremental serialization of HTTP messages. Existing free functions are re-implemented in terms of this new class. * The BodyReader concept is refined to support a greater variety of strategies for providing buffers representing the body to the serialization algorithms. * Added buffer_body, a new model of Body which allows the caller to provide a series of owned buffers using their own serialization loop. * Added empty_body, a model of Body which is for serialization only, to represent HTTP messages with no content body. * Removed overloads of write and async_write which send only the HTTP header. * Removed public interfaces for performing low-level chunk encoding.
2017-05-08 12:41:45 -07:00
serializer<isRequest, Body, Fields,
Decorator, Allocator>& w_;
Stream& s_;
Handler h_;
bool cont_;
Add write, async_write, operator<< for message_headers: fix #155 This adds overloads of write, async_write, and operator<< for message_headers.
2016-11-07 13:51:10 -05:00
public:
Refactor HTTP serialization (API Change): A new class `serializer` is introduced to permit incremental serialization of HTTP messages. Existing free functions are re-implemented in terms of this new class. * The BodyReader concept is refined to support a greater variety of strategies for providing buffers representing the body to the serialization algorithms. * Added buffer_body, a new model of Body which allows the caller to provide a series of owned buffers using their own serialization loop. * Added empty_body, a model of Body which is for serialization only, to represent HTTP messages with no content body. * Removed overloads of write and async_write which send only the HTTP header. * Removed public interfaces for performing low-level chunk encoding.
2017-05-08 12:41:45 -07:00
async_op(async_op&&) = default;
async_op(async_op const&) = default;
async_op(Handler&& h, Stream& s,
serializer<isRequest, Body, Fields,
Decorator, Allocator>& w)
: w_(w)
, s_(s)
, h_(std::move(h))
{
using boost::asio::asio_handler_is_continuation;
cont_ = asio_handler_is_continuation(
std::addressof(h_));
}
Add write, async_write, operator<< for message_headers: fix #155 This adds overloads of write, async_write, and operator<< for message_headers.
2016-11-07 13:51:10 -05:00
Refactor HTTP serialization (API Change): A new class `serializer` is introduced to permit incremental serialization of HTTP messages. Existing free functions are re-implemented in terms of this new class. * The BodyReader concept is refined to support a greater variety of strategies for providing buffers representing the body to the serialization algorithms. * Added buffer_body, a new model of Body which allows the caller to provide a series of owned buffers using their own serialization loop. * Added empty_body, a model of Body which is for serialization only, to represent HTTP messages with no content body. * Removed overloads of write and async_write which send only the HTTP header. * Removed public interfaces for performing low-level chunk encoding.
2017-05-08 12:41:45 -07:00
async_op(Handler const& h, Stream& s,
serializer<isRequest, Body, Fields,
Decorator, Allocator>& w)
: w_(w)
, s_(s)
, h_(h)
Add write, async_write, operator<< for message_headers: fix #155 This adds overloads of write, async_write, and operator<< for message_headers.
2016-11-07 13:51:10 -05:00
{
Refactor HTTP serialization (API Change): A new class `serializer` is introduced to permit incremental serialization of HTTP messages. Existing free functions are re-implemented in terms of this new class. * The BodyReader concept is refined to support a greater variety of strategies for providing buffers representing the body to the serialization algorithms. * Added buffer_body, a new model of Body which allows the caller to provide a series of owned buffers using their own serialization loop. * Added empty_body, a model of Body which is for serialization only, to represent HTTP messages with no content body. * Removed overloads of write and async_write which send only the HTTP header. * Removed public interfaces for performing low-level chunk encoding.
2017-05-08 12:41:45 -07:00
using boost::asio::asio_handler_is_continuation;
cont_ = asio_handler_is_continuation(
std::addressof(h_));
Add write, async_write, operator<< for message_headers: fix #155 This adds overloads of write, async_write, and operator<< for message_headers.
2016-11-07 13:51:10 -05:00
}
void
Refactor HTTP serialization (API Change): A new class `serializer` is introduced to permit incremental serialization of HTTP messages. Existing free functions are re-implemented in terms of this new class. * The BodyReader concept is refined to support a greater variety of strategies for providing buffers representing the body to the serialization algorithms. * Added buffer_body, a new model of Body which allows the caller to provide a series of owned buffers using their own serialization loop. * Added empty_body, a model of Body which is for serialization only, to represent HTTP messages with no content body. * Removed overloads of write and async_write which send only the HTTP header. * Removed public interfaces for performing low-level chunk encoding.
2017-05-08 12:41:45 -07:00
operator()(error_code ec, std::size_t
bytes_transferred, bool again = true);
Add write, async_write, operator<< for message_headers: fix #155 This adds overloads of write, async_write, and operator<< for message_headers.
2016-11-07 13:51:10 -05:00
friend
void* asio_handler_allocate(
Refactor HTTP serialization (API Change): A new class `serializer` is introduced to permit incremental serialization of HTTP messages. Existing free functions are re-implemented in terms of this new class. * The BodyReader concept is refined to support a greater variety of strategies for providing buffers representing the body to the serialization algorithms. * Added buffer_body, a new model of Body which allows the caller to provide a series of owned buffers using their own serialization loop. * Added empty_body, a model of Body which is for serialization only, to represent HTTP messages with no content body. * Removed overloads of write and async_write which send only the HTTP header. * Removed public interfaces for performing low-level chunk encoding.
2017-05-08 12:41:45 -07:00
std::size_t size, async_op* op)
Add write, async_write, operator<< for message_headers: fix #155 This adds overloads of write, async_write, and operator<< for message_headers.
2016-11-07 13:51:10 -05:00
{
Remove handler helpers, tidy up hook invocations (API Change)
2017-05-14 09:25:43 -07:00
using boost::asio::asio_handler_allocate;
return asio_handler_allocate(
Refactor HTTP serialization (API Change): A new class `serializer` is introduced to permit incremental serialization of HTTP messages. Existing free functions are re-implemented in terms of this new class. * The BodyReader concept is refined to support a greater variety of strategies for providing buffers representing the body to the serialization algorithms. * Added buffer_body, a new model of Body which allows the caller to provide a series of owned buffers using their own serialization loop. * Added empty_body, a model of Body which is for serialization only, to represent HTTP messages with no content body. * Removed overloads of write and async_write which send only the HTTP header. * Removed public interfaces for performing low-level chunk encoding.
2017-05-08 12:41:45 -07:00
size, std::addressof(op->h_));
Add write, async_write, operator<< for message_headers: fix #155 This adds overloads of write, async_write, and operator<< for message_headers.
2016-11-07 13:51:10 -05:00
}
friend
void asio_handler_deallocate(
Refactor HTTP serialization (API Change): A new class `serializer` is introduced to permit incremental serialization of HTTP messages. Existing free functions are re-implemented in terms of this new class. * The BodyReader concept is refined to support a greater variety of strategies for providing buffers representing the body to the serialization algorithms. * Added buffer_body, a new model of Body which allows the caller to provide a series of owned buffers using their own serialization loop. * Added empty_body, a model of Body which is for serialization only, to represent HTTP messages with no content body. * Removed overloads of write and async_write which send only the HTTP header. * Removed public interfaces for performing low-level chunk encoding.
2017-05-08 12:41:45 -07:00
void* p, std::size_t size, async_op* op)
Add write, async_write, operator<< for message_headers: fix #155 This adds overloads of write, async_write, and operator<< for message_headers.
2016-11-07 13:51:10 -05:00
{
Remove handler helpers, tidy up hook invocations (API Change)
2017-05-14 09:25:43 -07:00
using boost::asio::asio_handler_deallocate;
asio_handler_deallocate(
Refactor HTTP serialization (API Change): A new class `serializer` is introduced to permit incremental serialization of HTTP messages. Existing free functions are re-implemented in terms of this new class. * The BodyReader concept is refined to support a greater variety of strategies for providing buffers representing the body to the serialization algorithms. * Added buffer_body, a new model of Body which allows the caller to provide a series of owned buffers using their own serialization loop. * Added empty_body, a model of Body which is for serialization only, to represent HTTP messages with no content body. * Removed overloads of write and async_write which send only the HTTP header. * Removed public interfaces for performing low-level chunk encoding.
2017-05-08 12:41:45 -07:00
p, size, std::addressof(op->h_));
Add write, async_write, operator<< for message_headers: fix #155 This adds overloads of write, async_write, and operator<< for message_headers.
2016-11-07 13:51:10 -05:00
}
friend
Refactor HTTP serialization (API Change): A new class `serializer` is introduced to permit incremental serialization of HTTP messages. Existing free functions are re-implemented in terms of this new class. * The BodyReader concept is refined to support a greater variety of strategies for providing buffers representing the body to the serialization algorithms. * Added buffer_body, a new model of Body which allows the caller to provide a series of owned buffers using their own serialization loop. * Added empty_body, a model of Body which is for serialization only, to represent HTTP messages with no content body. * Removed overloads of write and async_write which send only the HTTP header. * Removed public interfaces for performing low-level chunk encoding.
2017-05-08 12:41:45 -07:00
bool asio_handler_is_continuation(async_op* op)
Add write, async_write, operator<< for message_headers: fix #155 This adds overloads of write, async_write, and operator<< for message_headers.
2016-11-07 13:51:10 -05:00
{
Refactor HTTP serialization (API Change): A new class `serializer` is introduced to permit incremental serialization of HTTP messages. Existing free functions are re-implemented in terms of this new class. * The BodyReader concept is refined to support a greater variety of strategies for providing buffers representing the body to the serialization algorithms. * Added buffer_body, a new model of Body which allows the caller to provide a series of owned buffers using their own serialization loop. * Added empty_body, a model of Body which is for serialization only, to represent HTTP messages with no content body. * Removed overloads of write and async_write which send only the HTTP header. * Removed public interfaces for performing low-level chunk encoding.
2017-05-08 12:41:45 -07:00
return op->cont_;
Add write, async_write, operator<< for message_headers: fix #155 This adds overloads of write, async_write, and operator<< for message_headers.
2016-11-07 13:51:10 -05:00
}
template<class Function>
friend
Refactor HTTP serialization (API Change): A new class `serializer` is introduced to permit incremental serialization of HTTP messages. Existing free functions are re-implemented in terms of this new class. * The BodyReader concept is refined to support a greater variety of strategies for providing buffers representing the body to the serialization algorithms. * Added buffer_body, a new model of Body which allows the caller to provide a series of owned buffers using their own serialization loop. * Added empty_body, a model of Body which is for serialization only, to represent HTTP messages with no content body. * Removed overloads of write and async_write which send only the HTTP header. * Removed public interfaces for performing low-level chunk encoding.
2017-05-08 12:41:45 -07:00
void asio_handler_invoke(
Function&& f, async_op* op)
Add write, async_write, operator<< for message_headers: fix #155 This adds overloads of write, async_write, and operator<< for message_headers.
2016-11-07 13:51:10 -05:00
{
Remove handler helpers, tidy up hook invocations (API Change)
2017-05-14 09:25:43 -07:00
using boost::asio::asio_handler_invoke;
asio_handler_invoke(
Refactor HTTP serialization (API Change): A new class `serializer` is introduced to permit incremental serialization of HTTP messages. Existing free functions are re-implemented in terms of this new class. * The BodyReader concept is refined to support a greater variety of strategies for providing buffers representing the body to the serialization algorithms. * Added buffer_body, a new model of Body which allows the caller to provide a series of owned buffers using their own serialization loop. * Added empty_body, a model of Body which is for serialization only, to represent HTTP messages with no content body. * Removed overloads of write and async_write which send only the HTTP header. * Removed public interfaces for performing low-level chunk encoding.
2017-05-08 12:41:45 -07:00
f, std::addressof(op->h_));
Add write, async_write, operator<< for message_headers: fix #155 This adds overloads of write, async_write, and operator<< for message_headers.
2016-11-07 13:51:10 -05:00
}
};
Refactor HTTP serialization (API Change): A new class `serializer` is introduced to permit incremental serialization of HTTP messages. Existing free functions are re-implemented in terms of this new class. * The BodyReader concept is refined to support a greater variety of strategies for providing buffers representing the body to the serialization algorithms. * Added buffer_body, a new model of Body which allows the caller to provide a series of owned buffers using their own serialization loop. * Added empty_body, a model of Body which is for serialization only, to represent HTTP messages with no content body. * Removed overloads of write and async_write which send only the HTTP header. * Removed public interfaces for performing low-level chunk encoding.
2017-05-08 12:41:45 -07:00
template<bool isRequest, class Body, class Fields,
class Decorator, class Allocator>
Add write, async_write, operator<< for message_headers: fix #155 This adds overloads of write, async_write, and operator<< for message_headers.
2016-11-07 13:51:10 -05:00
template<class Stream, class Handler>
void
Refactor HTTP serialization (API Change): A new class `serializer` is introduced to permit incremental serialization of HTTP messages. Existing free functions are re-implemented in terms of this new class. * The BodyReader concept is refined to support a greater variety of strategies for providing buffers representing the body to the serialization algorithms. * Added buffer_body, a new model of Body which allows the caller to provide a series of owned buffers using their own serialization loop. * Added empty_body, a model of Body which is for serialization only, to represent HTTP messages with no content body. * Removed overloads of write and async_write which send only the HTTP header. * Removed public interfaces for performing low-level chunk encoding.
2017-05-08 12:41:45 -07:00
serializer<isRequest, Body, Fields,
Decorator, Allocator>::
async_op<Stream, Handler>::
operator()(error_code ec,
std::size_t bytes_transferred, bool again)
Add write, async_write, operator<< for message_headers: fix #155 This adds overloads of write, async_write, and operator<< for message_headers.
2016-11-07 13:51:10 -05:00
{
Refactor HTTP serialization (API Change): A new class `serializer` is introduced to permit incremental serialization of HTTP messages. Existing free functions are re-implemented in terms of this new class. * The BodyReader concept is refined to support a greater variety of strategies for providing buffers representing the body to the serialization algorithms. * Added buffer_body, a new model of Body which allows the caller to provide a series of owned buffers using their own serialization loop. * Added empty_body, a model of Body which is for serialization only, to represent HTTP messages with no content body. * Removed overloads of write and async_write which send only the HTTP header. * Removed public interfaces for performing low-level chunk encoding.
2017-05-08 12:41:45 -07:00
cont_ = again || cont_;
using boost::asio::buffer_size;
if(ec)
goto upcall;
switch(w_.s_)
{
case do_init:
Add write, async_write, operator<< for message_headers: fix #155 This adds overloads of write, async_write, and operator<< for message_headers.
2016-11-07 13:51:10 -05:00
{
Refactor HTTP serialization (API Change): A new class `serializer` is introduced to permit incremental serialization of HTTP messages. Existing free functions are re-implemented in terms of this new class. * The BodyReader concept is refined to support a greater variety of strategies for providing buffers representing the body to the serialization algorithms. * Added buffer_body, a new model of Body which allows the caller to provide a series of owned buffers using their own serialization loop. * Added empty_body, a model of Body which is for serialization only, to represent HTTP messages with no content body. * Removed overloads of write and async_write which send only the HTTP header. * Removed public interfaces for performing low-level chunk encoding.
2017-05-08 12:41:45 -07:00
if(w_.split_)
goto go_header_only;
Refactor type_traits (API Change): fix #373 * concepts.hpp is renamed to type_traits.hpp * Body reader and writer concepts are renamed
2017-05-28 09:05:29 -07:00
w_.rd_.emplace(w_.m_);
w_.rd_->init(ec);
Refactor HTTP serialization (API Change): A new class `serializer` is introduced to permit incremental serialization of HTTP messages. Existing free functions are re-implemented in terms of this new class. * The BodyReader concept is refined to support a greater variety of strategies for providing buffers representing the body to the serialization algorithms. * Added buffer_body, a new model of Body which allows the caller to provide a series of owned buffers using their own serialization loop. * Added empty_body, a model of Body which is for serialization only, to represent HTTP messages with no content body. * Removed overloads of write and async_write which send only the HTTP header. * Removed public interfaces for performing low-level chunk encoding.
2017-05-08 12:41:45 -07:00
if(ec)
return s_.get_io_service().post(
bind_handler(std::move(*this), ec, 0));
Refactor type_traits (API Change): fix #373 * concepts.hpp is renamed to type_traits.hpp * Body reader and writer concepts are renamed
2017-05-28 09:05:29 -07:00
auto result = w_.rd_->get(ec);
Refactor HTTP serialization (API Change): A new class `serializer` is introduced to permit incremental serialization of HTTP messages. Existing free functions are re-implemented in terms of this new class. * The BodyReader concept is refined to support a greater variety of strategies for providing buffers representing the body to the serialization algorithms. * Added buffer_body, a new model of Body which allows the caller to provide a series of owned buffers using their own serialization loop. * Added empty_body, a model of Body which is for serialization only, to represent HTTP messages with no content body. * Removed overloads of write and async_write which send only the HTTP header. * Removed public interfaces for performing low-level chunk encoding.
2017-05-08 12:41:45 -07:00
if(ec)
{
// Can't use need_more when ! is_deferred
BOOST_ASSERT(ec != error::need_more);
return s_.get_io_service().post(
bind_handler(std::move(*this), ec, 0));
}
if(! result)
goto go_header_only;
w_.more_ = result->second;
w_.v_ = cb0_t{
boost::in_place_init,
w_.b_.data(),
result->first};
// [[fallthrough]]
}
case do_header:
w_.s_ = do_header + 1;
return s_.async_write_some(
buffer_prefix(w_.limit_,
boost::get<cb0_t>(w_.v_)),
std::move(*this));
case do_header + 1:
boost::get<cb0_t>(w_.v_).consume(
bytes_transferred);
if(buffer_size(
boost::get<cb0_t>(w_.v_)) > 0)
Add write, async_write, operator<< for message_headers: fix #155 This adds overloads of write, async_write, and operator<< for message_headers.
2016-11-07 13:51:10 -05:00
{
Refactor HTTP serialization (API Change): A new class `serializer` is introduced to permit incremental serialization of HTTP messages. Existing free functions are re-implemented in terms of this new class. * The BodyReader concept is refined to support a greater variety of strategies for providing buffers representing the body to the serialization algorithms. * Added buffer_body, a new model of Body which allows the caller to provide a series of owned buffers using their own serialization loop. * Added empty_body, a model of Body which is for serialization only, to represent HTTP messages with no content body. * Removed overloads of write and async_write which send only the HTTP header. * Removed public interfaces for performing low-level chunk encoding.
2017-05-08 12:41:45 -07:00
w_.s_ = do_header;
break;
}
w_.header_done_ = true;
w_.v_ = boost::blank{};
w_.b_.consume(w_.b_.size()); // VFALCO delete b_?
if(! w_.more_)
goto go_complete;
w_.s_ = do_body;
break;
go_header_only:
case do_header_only:
w_.s_ = do_header_only + 1;
return s_.async_write_some(
buffer_prefix(w_.limit_,
w_.b_.data()), std::move(*this));
case do_header_only + 1:
w_.b_.consume(bytes_transferred);
if(buffer_size(w_.b_.data()) > 0)
Add write, async_write, operator<< for message_headers: fix #155 This adds overloads of write, async_write, and operator<< for message_headers.
2016-11-07 13:51:10 -05:00
{
Refactor HTTP serialization (API Change): A new class `serializer` is introduced to permit incremental serialization of HTTP messages. Existing free functions are re-implemented in terms of this new class. * The BodyReader concept is refined to support a greater variety of strategies for providing buffers representing the body to the serialization algorithms. * Added buffer_body, a new model of Body which allows the caller to provide a series of owned buffers using their own serialization loop. * Added empty_body, a model of Body which is for serialization only, to represent HTTP messages with no content body. * Removed overloads of write and async_write which send only the HTTP header. * Removed public interfaces for performing low-level chunk encoding.
2017-05-08 12:41:45 -07:00
w_.s_ = do_header_only;
break;
}
// VFALCO delete b_?
w_.header_done_ = true;
if(! is_deferred::value)
goto go_complete;
Refactor type_traits (API Change): fix #373 * concepts.hpp is renamed to type_traits.hpp * Body reader and writer concepts are renamed
2017-05-28 09:05:29 -07:00
BOOST_ASSERT(! w_.rd_);
w_.rd_.emplace(w_.m_);
w_.rd_->init(ec);
Refactor HTTP serialization (API Change): A new class `serializer` is introduced to permit incremental serialization of HTTP messages. Existing free functions are re-implemented in terms of this new class. * The BodyReader concept is refined to support a greater variety of strategies for providing buffers representing the body to the serialization algorithms. * Added buffer_body, a new model of Body which allows the caller to provide a series of owned buffers using their own serialization loop. * Added empty_body, a model of Body which is for serialization only, to represent HTTP messages with no content body. * Removed overloads of write and async_write which send only the HTTP header. * Removed public interfaces for performing low-level chunk encoding.
2017-05-08 12:41:45 -07:00
if(ec)
goto upcall;
w_.s_ = do_body;
break;
case do_body:
{
Refactor type_traits (API Change): fix #373 * concepts.hpp is renamed to type_traits.hpp * Body reader and writer concepts are renamed
2017-05-28 09:05:29 -07:00
auto result = w_.rd_->get(ec);
Refactor HTTP serialization (API Change): A new class `serializer` is introduced to permit incremental serialization of HTTP messages. Existing free functions are re-implemented in terms of this new class. * The BodyReader concept is refined to support a greater variety of strategies for providing buffers representing the body to the serialization algorithms. * Added buffer_body, a new model of Body which allows the caller to provide a series of owned buffers using their own serialization loop. * Added empty_body, a model of Body which is for serialization only, to represent HTTP messages with no content body. * Removed overloads of write and async_write which send only the HTTP header. * Removed public interfaces for performing low-level chunk encoding.
2017-05-08 12:41:45 -07:00
if(ec)
return s_.get_io_service().post(
bind_handler(std::move(*this), ec, 0));
if(! result)
{
w_.s_ = do_complete;
return s_.get_io_service().post(
bind_handler(std::move(*this),
error_code{}, 0));
Add write, async_write, operator<< for message_headers: fix #155 This adds overloads of write, async_write, and operator<< for message_headers.
2016-11-07 13:51:10 -05:00
}
Refactor HTTP serialization (API Change): A new class `serializer` is introduced to permit incremental serialization of HTTP messages. Existing free functions are re-implemented in terms of this new class. * The BodyReader concept is refined to support a greater variety of strategies for providing buffers representing the body to the serialization algorithms. * Added buffer_body, a new model of Body which allows the caller to provide a series of owned buffers using their own serialization loop. * Added empty_body, a model of Body which is for serialization only, to represent HTTP messages with no content body. * Removed overloads of write and async_write which send only the HTTP header. * Removed public interfaces for performing low-level chunk encoding.
2017-05-08 12:41:45 -07:00
w_.more_ = result->second;
w_.v_ = cb1_t{result->first};
// [[fallthrough]]
}
case do_body + 1:
w_.s_ = do_body + 2;
return s_.async_write_some(
buffer_prefix(w_.limit_,
boost::get<cb1_t>(w_.v_)),
std::move(*this));
case do_body + 2:
boost::get<cb1_t>(w_.v_).consume(
bytes_transferred);
if(buffer_size(
boost::get<cb1_t>(w_.v_)) > 0)
{
w_.s_ = do_body + 1;
break;
Add write, async_write, operator<< for message_headers: fix #155 This adds overloads of write, async_write, and operator<< for message_headers.
2016-11-07 13:51:10 -05:00
}
Refactor HTTP serialization (API Change): A new class `serializer` is introduced to permit incremental serialization of HTTP messages. Existing free functions are re-implemented in terms of this new class. * The BodyReader concept is refined to support a greater variety of strategies for providing buffers representing the body to the serialization algorithms. * Added buffer_body, a new model of Body which allows the caller to provide a series of owned buffers using their own serialization loop. * Added empty_body, a model of Body which is for serialization only, to represent HTTP messages with no content body. * Removed overloads of write and async_write which send only the HTTP header. * Removed public interfaces for performing low-level chunk encoding.
2017-05-08 12:41:45 -07:00
w_.v_ = boost::blank{};
if(! w_.more_)
goto go_complete;
w_.s_ = do_body;
break;
//----------------------------------------------------------------------
case do_init_c:
{
if(w_.split_)
goto go_header_only_c;
Refactor type_traits (API Change): fix #373 * concepts.hpp is renamed to type_traits.hpp * Body reader and writer concepts are renamed
2017-05-28 09:05:29 -07:00
w_.rd_.emplace(w_.m_);
w_.rd_->init(ec);
Refactor HTTP serialization (API Change): A new class `serializer` is introduced to permit incremental serialization of HTTP messages. Existing free functions are re-implemented in terms of this new class. * The BodyReader concept is refined to support a greater variety of strategies for providing buffers representing the body to the serialization algorithms. * Added buffer_body, a new model of Body which allows the caller to provide a series of owned buffers using their own serialization loop. * Added empty_body, a model of Body which is for serialization only, to represent HTTP messages with no content body. * Removed overloads of write and async_write which send only the HTTP header. * Removed public interfaces for performing low-level chunk encoding.
2017-05-08 12:41:45 -07:00
if(ec)
return s_.get_io_service().post(
bind_handler(std::move(*this), ec, 0));
Refactor type_traits (API Change): fix #373 * concepts.hpp is renamed to type_traits.hpp * Body reader and writer concepts are renamed
2017-05-28 09:05:29 -07:00
auto result = w_.rd_->get(ec);
Refactor HTTP serialization (API Change): A new class `serializer` is introduced to permit incremental serialization of HTTP messages. Existing free functions are re-implemented in terms of this new class. * The BodyReader concept is refined to support a greater variety of strategies for providing buffers representing the body to the serialization algorithms. * Added buffer_body, a new model of Body which allows the caller to provide a series of owned buffers using their own serialization loop. * Added empty_body, a model of Body which is for serialization only, to represent HTTP messages with no content body. * Removed overloads of write and async_write which send only the HTTP header. * Removed public interfaces for performing low-level chunk encoding.
2017-05-08 12:41:45 -07:00
if(ec)
{
// Can't use need_more when ! is_deferred
BOOST_ASSERT(ec != error::need_more);
return s_.get_io_service().post(
bind_handler(std::move(*this), ec, 0));
}
if(! result)
goto go_header_only_c;
w_.more_ = result->second;
w_.v_ = ch0_t{
boost::in_place_init,
w_.b_.data(),
detail::chunk_header{
buffer_size(result->first)},
[&]()
{
auto sv = w_.d_(result->first);
return boost::asio::const_buffers_1{
sv.data(), sv.size()};
}(),
result->first,
detail::chunk_crlf()};
// [[fallthrough]]
Add write, async_write, operator<< for message_headers: fix #155 This adds overloads of write, async_write, and operator<< for message_headers.
2016-11-07 13:51:10 -05:00
}
Refactor HTTP serialization (API Change): A new class `serializer` is introduced to permit incremental serialization of HTTP messages. Existing free functions are re-implemented in terms of this new class. * The BodyReader concept is refined to support a greater variety of strategies for providing buffers representing the body to the serialization algorithms. * Added buffer_body, a new model of Body which allows the caller to provide a series of owned buffers using their own serialization loop. * Added empty_body, a model of Body which is for serialization only, to represent HTTP messages with no content body. * Removed overloads of write and async_write which send only the HTTP header. * Removed public interfaces for performing low-level chunk encoding.
2017-05-08 12:41:45 -07:00
case do_header_c:
w_.s_ = do_header_c + 1;
return s_.async_write_some(
buffer_prefix(w_.limit_,
boost::get<ch0_t>(w_.v_)),
std::move(*this));
case do_header_c + 1:
boost::get<ch0_t>(w_.v_).consume(
bytes_transferred);
if(buffer_size(
boost::get<ch0_t>(w_.v_)) > 0)
{
w_.s_ = do_header_c;
break;
}
w_.header_done_ = true;
w_.v_ = boost::blank{};
w_.b_.consume(w_.b_.size()); // VFALCO delete b_?
if(! w_.more_)
w_.s_ = do_final_c;
else
w_.s_ = do_body_c;
break;
go_header_only_c:
case do_header_only_c:
w_.s_ = do_header_only_c + 1;
return s_.async_write_some(
buffer_prefix(w_.limit_,
w_.b_.data()), std::move(*this));
case do_header_only_c + 1:
w_.b_.consume(bytes_transferred);
if(buffer_size(w_.b_.data()) > 0)
{
w_.s_ = do_header_only_c;
break;
}
// VFALCO delete b_?
w_.header_done_ = true;
if(! is_deferred::value)
{
w_.s_ = do_final_c;
break;
}
Refactor type_traits (API Change): fix #373 * concepts.hpp is renamed to type_traits.hpp * Body reader and writer concepts are renamed
2017-05-28 09:05:29 -07:00
BOOST_ASSERT(! w_.rd_);
w_.rd_.emplace(w_.m_);
w_.rd_->init(ec);
Refactor HTTP serialization (API Change): A new class `serializer` is introduced to permit incremental serialization of HTTP messages. Existing free functions are re-implemented in terms of this new class. * The BodyReader concept is refined to support a greater variety of strategies for providing buffers representing the body to the serialization algorithms. * Added buffer_body, a new model of Body which allows the caller to provide a series of owned buffers using their own serialization loop. * Added empty_body, a model of Body which is for serialization only, to represent HTTP messages with no content body. * Removed overloads of write and async_write which send only the HTTP header. * Removed public interfaces for performing low-level chunk encoding.
2017-05-08 12:41:45 -07:00
if(ec)
goto upcall;
w_.s_ = do_body_c;
break;
case do_body_c:
{
Refactor type_traits (API Change): fix #373 * concepts.hpp is renamed to type_traits.hpp * Body reader and writer concepts are renamed
2017-05-28 09:05:29 -07:00
auto result = w_.rd_->get(ec);
Refactor HTTP serialization (API Change): A new class `serializer` is introduced to permit incremental serialization of HTTP messages. Existing free functions are re-implemented in terms of this new class. * The BodyReader concept is refined to support a greater variety of strategies for providing buffers representing the body to the serialization algorithms. * Added buffer_body, a new model of Body which allows the caller to provide a series of owned buffers using their own serialization loop. * Added empty_body, a model of Body which is for serialization only, to represent HTTP messages with no content body. * Removed overloads of write and async_write which send only the HTTP header. * Removed public interfaces for performing low-level chunk encoding.
2017-05-08 12:41:45 -07:00
if(ec)
return s_.get_io_service().post(
bind_handler(std::move(*this),
ec, 0));
if(! result)
goto go_final_c;
w_.more_ = result->second;
w_.v_ = ch1_t{
boost::in_place_init,
detail::chunk_header{
buffer_size(result->first)},
[&]()
{
auto sv = w_.d_(result->first);
return boost::asio::const_buffers_1{
sv.data(), sv.size()};
}(),
result->first,
detail::chunk_crlf()};
// [[fallthrough]]
}
case do_body_c + 1:
w_.s_ = do_body_c + 2;
return s_.async_write_some(
buffer_prefix(w_.limit_,
boost::get<ch1_t>(w_.v_)),
std::move(*this));
case do_body_c + 2:
boost::get<ch1_t>(w_.v_).consume(
bytes_transferred);
if(buffer_size(
boost::get<ch1_t>(w_.v_)) > 0)
{
w_.s_ = do_body_c + 1;
break;
}
w_.v_ = boost::blank{};
if(w_.more_)
w_.s_ = do_body_c;
else
w_.s_ = do_final_c;
break;
go_final_c:
case do_final_c:
w_.v_ = ch2_t{
boost::in_place_init,
detail::chunk_final(),
[&]()
{
auto sv = w_.d_(
boost::asio::null_buffers{});
return boost::asio::const_buffers_1{
sv.data(), sv.size()};
}(),
detail::chunk_crlf()};
// [[fallthrough]]
case do_final_c + 1:
w_.s_ = do_final_c + 2;
return s_.async_write_some(
buffer_prefix(w_.limit_,
boost::get<ch2_t>(w_.v_)),
std::move(*this));
case do_final_c + 2:
boost::get<ch2_t>(w_.v_).consume(
bytes_transferred);
if(buffer_size(boost::get<ch2_t>(w_.v_)) > 0)
{
w_.s_ = do_final_c + 1;
break;
}
w_.v_ = boost::blank{};
goto go_complete;
//----------------------------------------------------------------------
default:
BOOST_ASSERT(false);
go_complete:
w_.s_ = do_complete;
case do_complete:
if(w_.close_)
// VFALCO TODO Decide on an error code
ec = boost::asio::error::eof;
break;
}
upcall:
h_(ec);
Add write, async_write, operator<< for message_headers: fix #155 This adds overloads of write, async_write, and operator<< for message_headers.
2016-11-07 13:51:10 -05:00
}
Refactor HTTP serialization (API Change): A new class `serializer` is introduced to permit incremental serialization of HTTP messages. Existing free functions are re-implemented in terms of this new class. * The BodyReader concept is refined to support a greater variety of strategies for providing buffers representing the body to the serialization algorithms. * Added buffer_body, a new model of Body which allows the caller to provide a series of owned buffers using their own serialization loop. * Added empty_body, a model of Body which is for serialization only, to represent HTTP messages with no content body. * Removed overloads of write and async_write which send only the HTTP header. * Removed public interfaces for performing low-level chunk encoding.
2017-05-08 12:41:45 -07:00
//------------------------------------------------------------------------------
Add write, async_write, operator<< for message_headers: fix #155 This adds overloads of write, async_write, and operator<< for message_headers.
2016-11-07 13:51:10 -05:00
Refactor HTTP serialization (API Change): A new class `serializer` is introduced to permit incremental serialization of HTTP messages. Existing free functions are re-implemented in terms of this new class. * The BodyReader concept is refined to support a greater variety of strategies for providing buffers representing the body to the serialization algorithms. * Added buffer_body, a new model of Body which allows the caller to provide a series of owned buffers using their own serialization loop. * Added empty_body, a model of Body which is for serialization only, to represent HTTP messages with no content body. * Removed overloads of write and async_write which send only the HTTP header. * Removed public interfaces for performing low-level chunk encoding.
2017-05-08 12:41:45 -07:00
template<bool isRequest, class Body, class Fields,
class Decorator, class Allocator>
serializer<isRequest, Body, Fields,
Decorator, Allocator>::
serializer(message<isRequest, Body, Fields> const& m,
Decorator const& d,
Allocator const& alloc)
: m_(m)
, d_(d)
, b_(1024, alloc)
, chunked_(token_list{
m.fields["Transfer-Encoding"]}.exists("chunked"))
, close_(token_list{
m.fields["Connection"]}.exists("close") ||
(m.version < 11 && ! m.fields.exists(
"Content-Length")))
{
s_ = chunked_ ? do_init_c : do_init;
auto os = ostream(b_);
detail::write_start_line(os, m_);
detail::write_fields(os, m_.fields);
os << "\r\n";
}
template<bool isRequest, class Body, class Fields,
class Decorator, class Allocator>
template<class SyncWriteStream>
Add write, async_write, operator<< for message_headers: fix #155 This adds overloads of write, async_write, and operator<< for message_headers.
2016-11-07 13:51:10 -05:00
void
Refactor HTTP serialization (API Change): A new class `serializer` is introduced to permit incremental serialization of HTTP messages. Existing free functions are re-implemented in terms of this new class. * The BodyReader concept is refined to support a greater variety of strategies for providing buffers representing the body to the serialization algorithms. * Added buffer_body, a new model of Body which allows the caller to provide a series of owned buffers using their own serialization loop. * Added empty_body, a model of Body which is for serialization only, to represent HTTP messages with no content body. * Removed overloads of write and async_write which send only the HTTP header. * Removed public interfaces for performing low-level chunk encoding.
2017-05-08 12:41:45 -07:00
serializer<isRequest, Body, Fields,
Decorator, Allocator>::
write_some(SyncWriteStream& stream)
Add write, async_write, operator<< for message_headers: fix #155 This adds overloads of write, async_write, and operator<< for message_headers.
2016-11-07 13:51:10 -05:00
{
Refactor HTTP serialization (API Change): A new class `serializer` is introduced to permit incremental serialization of HTTP messages. Existing free functions are re-implemented in terms of this new class. * The BodyReader concept is refined to support a greater variety of strategies for providing buffers representing the body to the serialization algorithms. * Added buffer_body, a new model of Body which allows the caller to provide a series of owned buffers using their own serialization loop. * Added empty_body, a model of Body which is for serialization only, to represent HTTP messages with no content body. * Removed overloads of write and async_write which send only the HTTP header. * Removed public interfaces for performing low-level chunk encoding.
2017-05-08 12:41:45 -07:00
static_assert(
is_sync_write_stream<SyncWriteStream>::value,
Add write, async_write, operator<< for message_headers: fix #155 This adds overloads of write, async_write, and operator<< for message_headers.
2016-11-07 13:51:10 -05:00
"SyncWriteStream requirements not met");
Refactor type_traits (API Change): fix #373 * concepts.hpp is renamed to type_traits.hpp * Body reader and writer concepts are renamed
2017-05-28 09:05:29 -07:00
static_assert(is_body<Body>::value,
Refactor HTTP serialization (API Change): A new class `serializer` is introduced to permit incremental serialization of HTTP messages. Existing free functions are re-implemented in terms of this new class. * The BodyReader concept is refined to support a greater variety of strategies for providing buffers representing the body to the serialization algorithms. * Added buffer_body, a new model of Body which allows the caller to provide a series of owned buffers using their own serialization loop. * Added empty_body, a model of Body which is for serialization only, to represent HTTP messages with no content body. * Removed overloads of write and async_write which send only the HTTP header. * Removed public interfaces for performing low-level chunk encoding.
2017-05-08 12:41:45 -07:00
"Body requirements not met");
Refactor type_traits (API Change): fix #373 * concepts.hpp is renamed to type_traits.hpp * Body reader and writer concepts are renamed
2017-05-28 09:05:29 -07:00
static_assert(is_body_reader<Body>::value,
"BodyReader requirements not met");
Add write, async_write, operator<< for message_headers: fix #155 This adds overloads of write, async_write, and operator<< for message_headers.
2016-11-07 13:51:10 -05:00
error_code ec;
Refactor HTTP serialization (API Change): A new class `serializer` is introduced to permit incremental serialization of HTTP messages. Existing free functions are re-implemented in terms of this new class. * The BodyReader concept is refined to support a greater variety of strategies for providing buffers representing the body to the serialization algorithms. * Added buffer_body, a new model of Body which allows the caller to provide a series of owned buffers using their own serialization loop. * Added empty_body, a model of Body which is for serialization only, to represent HTTP messages with no content body. * Removed overloads of write and async_write which send only the HTTP header. * Removed public interfaces for performing low-level chunk encoding.
2017-05-08 12:41:45 -07:00
write_some(stream, ec);
Add write, async_write, operator<< for message_headers: fix #155 This adds overloads of write, async_write, and operator<< for message_headers.
2016-11-07 13:51:10 -05:00
if(ec)
Use BOOST_THROW_EXCEPTION fix #370
2017-05-22 15:30:12 -07:00
BOOST_THROW_EXCEPTION(system_error{ec});
Add write, async_write, operator<< for message_headers: fix #155 This adds overloads of write, async_write, and operator<< for message_headers.
2016-11-07 13:51:10 -05:00
}
Refactor HTTP serialization (API Change): A new class `serializer` is introduced to permit incremental serialization of HTTP messages. Existing free functions are re-implemented in terms of this new class. * The BodyReader concept is refined to support a greater variety of strategies for providing buffers representing the body to the serialization algorithms. * Added buffer_body, a new model of Body which allows the caller to provide a series of owned buffers using their own serialization loop. * Added empty_body, a model of Body which is for serialization only, to represent HTTP messages with no content body. * Removed overloads of write and async_write which send only the HTTP header. * Removed public interfaces for performing low-level chunk encoding.
2017-05-08 12:41:45 -07:00
template<bool isRequest, class Body, class Fields,
class Decorator, class Allocator>
template<class SyncWriteStream>
Add write, async_write, operator<< for message_headers: fix #155 This adds overloads of write, async_write, and operator<< for message_headers.
2016-11-07 13:51:10 -05:00
void
Refactor HTTP serialization (API Change): A new class `serializer` is introduced to permit incremental serialization of HTTP messages. Existing free functions are re-implemented in terms of this new class. * The BodyReader concept is refined to support a greater variety of strategies for providing buffers representing the body to the serialization algorithms. * Added buffer_body, a new model of Body which allows the caller to provide a series of owned buffers using their own serialization loop. * Added empty_body, a model of Body which is for serialization only, to represent HTTP messages with no content body. * Removed overloads of write and async_write which send only the HTTP header. * Removed public interfaces for performing low-level chunk encoding.
2017-05-08 12:41:45 -07:00
serializer<isRequest, Body, Fields,
Decorator, Allocator>::
write_some(SyncWriteStream& stream, error_code &ec)
Add write, async_write, operator<< for message_headers: fix #155 This adds overloads of write, async_write, and operator<< for message_headers.
2016-11-07 13:51:10 -05:00
{
Refactor HTTP serialization (API Change): A new class `serializer` is introduced to permit incremental serialization of HTTP messages. Existing free functions are re-implemented in terms of this new class. * The BodyReader concept is refined to support a greater variety of strategies for providing buffers representing the body to the serialization algorithms. * Added buffer_body, a new model of Body which allows the caller to provide a series of owned buffers using their own serialization loop. * Added empty_body, a model of Body which is for serialization only, to represent HTTP messages with no content body. * Removed overloads of write and async_write which send only the HTTP header. * Removed public interfaces for performing low-level chunk encoding.
2017-05-08 12:41:45 -07:00
static_assert(
is_sync_write_stream<SyncWriteStream>::value,
Add write, async_write, operator<< for message_headers: fix #155 This adds overloads of write, async_write, and operator<< for message_headers.
2016-11-07 13:51:10 -05:00
"SyncWriteStream requirements not met");
Refactor type_traits (API Change): fix #373 * concepts.hpp is renamed to type_traits.hpp * Body reader and writer concepts are renamed
2017-05-28 09:05:29 -07:00
static_assert(is_body<Body>::value,
Refactor HTTP serialization (API Change): A new class `serializer` is introduced to permit incremental serialization of HTTP messages. Existing free functions are re-implemented in terms of this new class. * The BodyReader concept is refined to support a greater variety of strategies for providing buffers representing the body to the serialization algorithms. * Added buffer_body, a new model of Body which allows the caller to provide a series of owned buffers using their own serialization loop. * Added empty_body, a model of Body which is for serialization only, to represent HTTP messages with no content body. * Removed overloads of write and async_write which send only the HTTP header. * Removed public interfaces for performing low-level chunk encoding.
2017-05-08 12:41:45 -07:00
"Body requirements not met");
Refactor type_traits (API Change): fix #373 * concepts.hpp is renamed to type_traits.hpp * Body reader and writer concepts are renamed
2017-05-28 09:05:29 -07:00
static_assert(is_body_reader<Body>::value,
"BodyReader requirements not met");
Refactor HTTP serialization (API Change): A new class `serializer` is introduced to permit incremental serialization of HTTP messages. Existing free functions are re-implemented in terms of this new class. * The BodyReader concept is refined to support a greater variety of strategies for providing buffers representing the body to the serialization algorithms. * Added buffer_body, a new model of Body which allows the caller to provide a series of owned buffers using their own serialization loop. * Added empty_body, a model of Body which is for serialization only, to represent HTTP messages with no content body. * Removed overloads of write and async_write which send only the HTTP header. * Removed public interfaces for performing low-level chunk encoding.
2017-05-08 12:41:45 -07:00
using boost::asio::buffer_size;
switch(s_)
{
case do_init:
New ostream() returns dynamic buffer output stream (API Change): This eliminates beast::write output for dynamic buffers and replaces it with the function ostream() that wraps a caller provided dynamic buffer and returns the result as a std::ostream derived object. Callers may now produce formatted output into any object meeting the requirements of DynamicBuffer using operator<< and the standard stream modifiers such as std::endl. This new technique is more efficient, as implementations of operator<< can now write directly into the output using std::ostream::write and std::ostream::put. Example of use: beast::streambuf sb; beast::ostream(sb) << "Hello, world!" << std::endl;
2017-05-03 15:29:23 -07:00
{
Refactor HTTP serialization (API Change): A new class `serializer` is introduced to permit incremental serialization of HTTP messages. Existing free functions are re-implemented in terms of this new class. * The BodyReader concept is refined to support a greater variety of strategies for providing buffers representing the body to the serialization algorithms. * Added buffer_body, a new model of Body which allows the caller to provide a series of owned buffers using their own serialization loop. * Added empty_body, a model of Body which is for serialization only, to represent HTTP messages with no content body. * Removed overloads of write and async_write which send only the HTTP header. * Removed public interfaces for performing low-level chunk encoding.
2017-05-08 12:41:45 -07:00
if(split_)
goto go_header_only;
Refactor type_traits (API Change): fix #373 * concepts.hpp is renamed to type_traits.hpp * Body reader and writer concepts are renamed
2017-05-28 09:05:29 -07:00
rd_.emplace(m_);
rd_->init(ec);
Refactor HTTP serialization (API Change): A new class `serializer` is introduced to permit incremental serialization of HTTP messages. Existing free functions are re-implemented in terms of this new class. * The BodyReader concept is refined to support a greater variety of strategies for providing buffers representing the body to the serialization algorithms. * Added buffer_body, a new model of Body which allows the caller to provide a series of owned buffers using their own serialization loop. * Added empty_body, a model of Body which is for serialization only, to represent HTTP messages with no content body. * Removed overloads of write and async_write which send only the HTTP header. * Removed public interfaces for performing low-level chunk encoding.
2017-05-08 12:41:45 -07:00
if(ec)
return;
Refactor type_traits (API Change): fix #373 * concepts.hpp is renamed to type_traits.hpp * Body reader and writer concepts are renamed
2017-05-28 09:05:29 -07:00
auto result = rd_->get(ec);
Refactor HTTP serialization (API Change): A new class `serializer` is introduced to permit incremental serialization of HTTP messages. Existing free functions are re-implemented in terms of this new class. * The BodyReader concept is refined to support a greater variety of strategies for providing buffers representing the body to the serialization algorithms. * Added buffer_body, a new model of Body which allows the caller to provide a series of owned buffers using their own serialization loop. * Added empty_body, a model of Body which is for serialization only, to represent HTTP messages with no content body. * Removed overloads of write and async_write which send only the HTTP header. * Removed public interfaces for performing low-level chunk encoding.
2017-05-08 12:41:45 -07:00
if(ec)
{
// Can't use need_more when ! is_deferred
BOOST_ASSERT(ec != error::need_more);
return;
}
if(! result)
goto go_header_only;
more_ = result->second;
v_ = cb0_t{
boost::in_place_init,
b_.data(),
result->first};
s_ = do_header;
// [[fallthrough]]
New ostream() returns dynamic buffer output stream (API Change): This eliminates beast::write output for dynamic buffers and replaces it with the function ostream() that wraps a caller provided dynamic buffer and returns the result as a std::ostream derived object. Callers may now produce formatted output into any object meeting the requirements of DynamicBuffer using operator<< and the standard stream modifiers such as std::endl. This new technique is more efficient, as implementations of operator<< can now write directly into the output using std::ostream::write and std::ostream::put. Example of use: beast::streambuf sb; beast::ostream(sb) << "Hello, world!" << std::endl;
2017-05-03 15:29:23 -07:00
}
Add write, async_write, operator<< for message_headers: fix #155 This adds overloads of write, async_write, and operator<< for message_headers.
2016-11-07 13:51:10 -05:00
Refactor HTTP serialization (API Change): A new class `serializer` is introduced to permit incremental serialization of HTTP messages. Existing free functions are re-implemented in terms of this new class. * The BodyReader concept is refined to support a greater variety of strategies for providing buffers representing the body to the serialization algorithms. * Added buffer_body, a new model of Body which allows the caller to provide a series of owned buffers using their own serialization loop. * Added empty_body, a model of Body which is for serialization only, to represent HTTP messages with no content body. * Removed overloads of write and async_write which send only the HTTP header. * Removed public interfaces for performing low-level chunk encoding.
2017-05-08 12:41:45 -07:00
case do_header:
New ostream() returns dynamic buffer output stream (API Change): This eliminates beast::write output for dynamic buffers and replaces it with the function ostream() that wraps a caller provided dynamic buffer and returns the result as a std::ostream derived object. Callers may now produce formatted output into any object meeting the requirements of DynamicBuffer using operator<< and the standard stream modifiers such as std::endl. This new technique is more efficient, as implementations of operator<< can now write directly into the output using std::ostream::write and std::ostream::put. Example of use: beast::streambuf sb; beast::ostream(sb) << "Hello, world!" << std::endl;
2017-05-03 15:29:23 -07:00
{
Refactor HTTP serialization (API Change): A new class `serializer` is introduced to permit incremental serialization of HTTP messages. Existing free functions are re-implemented in terms of this new class. * The BodyReader concept is refined to support a greater variety of strategies for providing buffers representing the body to the serialization algorithms. * Added buffer_body, a new model of Body which allows the caller to provide a series of owned buffers using their own serialization loop. * Added empty_body, a model of Body which is for serialization only, to represent HTTP messages with no content body. * Removed overloads of write and async_write which send only the HTTP header. * Removed public interfaces for performing low-level chunk encoding.
2017-05-08 12:41:45 -07:00
auto bytes_transferred =
stream.write_some(
buffer_prefix(limit_,
boost::get<cb0_t>(v_)), ec);
if(ec)
return;
boost::get<cb0_t>(v_).consume(
bytes_transferred);
if(buffer_size(boost::get<cb0_t>(v_)) > 0)
break;
header_done_ = true;
v_ = boost::blank{};
b_.consume(b_.size()); // VFALCO delete b_?
if(! more_)
goto go_complete;
s_ = do_body;
break;
New ostream() returns dynamic buffer output stream (API Change): This eliminates beast::write output for dynamic buffers and replaces it with the function ostream() that wraps a caller provided dynamic buffer and returns the result as a std::ostream derived object. Callers may now produce formatted output into any object meeting the requirements of DynamicBuffer using operator<< and the standard stream modifiers such as std::endl. This new technique is more efficient, as implementations of operator<< can now write directly into the output using std::ostream::write and std::ostream::put. Example of use: beast::streambuf sb; beast::ostream(sb) << "Hello, world!" << std::endl;
2017-05-03 15:29:23 -07:00
}
Add write, async_write, operator<< for message_headers: fix #155 This adds overloads of write, async_write, and operator<< for message_headers.
2016-11-07 13:51:10 -05:00
Refactor HTTP serialization (API Change): A new class `serializer` is introduced to permit incremental serialization of HTTP messages. Existing free functions are re-implemented in terms of this new class. * The BodyReader concept is refined to support a greater variety of strategies for providing buffers representing the body to the serialization algorithms. * Added buffer_body, a new model of Body which allows the caller to provide a series of owned buffers using their own serialization loop. * Added empty_body, a model of Body which is for serialization only, to represent HTTP messages with no content body. * Removed overloads of write and async_write which send only the HTTP header. * Removed public interfaces for performing low-level chunk encoding.
2017-05-08 12:41:45 -07:00
go_header_only:
s_ = do_header_only;
case do_header_only:
Distinguish HTTP/1 messages from general HTTP messages: The version field is moved into message_v1, all public interfaces are reworked to identify HTTP/1 wire format operations (suffix "_v1") versus general HTTP.
2016-05-01 11:14:10 -04:00
{
Refactor HTTP serialization (API Change): A new class `serializer` is introduced to permit incremental serialization of HTTP messages. Existing free functions are re-implemented in terms of this new class. * The BodyReader concept is refined to support a greater variety of strategies for providing buffers representing the body to the serialization algorithms. * Added buffer_body, a new model of Body which allows the caller to provide a series of owned buffers using their own serialization loop. * Added empty_body, a model of Body which is for serialization only, to represent HTTP messages with no content body. * Removed overloads of write and async_write which send only the HTTP header. * Removed public interfaces for performing low-level chunk encoding.
2017-05-08 12:41:45 -07:00
auto bytes_transferred =
stream.write_some(buffer_prefix(
limit_, b_.data()), ec);
if(ec)
return;
b_.consume(bytes_transferred);
if(buffer_size(b_.data()) > 0)
break;
// VFALCO delete b_?
header_done_ = true;
if(! is_deferred::value)
goto go_complete;
Refactor type_traits (API Change): fix #373 * concepts.hpp is renamed to type_traits.hpp * Body reader and writer concepts are renamed
2017-05-28 09:05:29 -07:00
BOOST_ASSERT(! rd_);
rd_.emplace(m_);
rd_->init(ec);
Refactor HTTP serialization (API Change): A new class `serializer` is introduced to permit incremental serialization of HTTP messages. Existing free functions are re-implemented in terms of this new class. * The BodyReader concept is refined to support a greater variety of strategies for providing buffers representing the body to the serialization algorithms. * Added buffer_body, a new model of Body which allows the caller to provide a series of owned buffers using their own serialization loop. * Added empty_body, a model of Body which is for serialization only, to represent HTTP messages with no content body. * Removed overloads of write and async_write which send only the HTTP header. * Removed public interfaces for performing low-level chunk encoding.
2017-05-08 12:41:45 -07:00
if(ec)
return;
s_ = do_body;
break;
Distinguish HTTP/1 messages from general HTTP messages: The version field is moved into message_v1, all public interfaces are reworked to identify HTTP/1 wire format operations (suffix "_v1") versus general HTTP.
2016-05-01 11:14:10 -04:00
}
Refactor HTTP serialization (API Change): A new class `serializer` is introduced to permit incremental serialization of HTTP messages. Existing free functions are re-implemented in terms of this new class. * The BodyReader concept is refined to support a greater variety of strategies for providing buffers representing the body to the serialization algorithms. * Added buffer_body, a new model of Body which allows the caller to provide a series of owned buffers using their own serialization loop. * Added empty_body, a model of Body which is for serialization only, to represent HTTP messages with no content body. * Removed overloads of write and async_write which send only the HTTP header. * Removed public interfaces for performing low-level chunk encoding.
2017-05-08 12:41:45 -07:00
case do_body:
Distinguish HTTP/1 messages from general HTTP messages: The version field is moved into message_v1, all public interfaces are reworked to identify HTTP/1 wire format operations (suffix "_v1") versus general HTTP.
2016-05-01 11:14:10 -04:00
{
Refactor type_traits (API Change): fix #373 * concepts.hpp is renamed to type_traits.hpp * Body reader and writer concepts are renamed
2017-05-28 09:05:29 -07:00
auto result = rd_->get(ec);
Distinguish HTTP/1 messages from general HTTP messages: The version field is moved into message_v1, all public interfaces are reworked to identify HTTP/1 wire format operations (suffix "_v1") versus general HTTP.
2016-05-01 11:14:10 -04:00
if(ec)
return;
Refactor HTTP serialization (API Change): A new class `serializer` is introduced to permit incremental serialization of HTTP messages. Existing free functions are re-implemented in terms of this new class. * The BodyReader concept is refined to support a greater variety of strategies for providing buffers representing the body to the serialization algorithms. * Added buffer_body, a new model of Body which allows the caller to provide a series of owned buffers using their own serialization loop. * Added empty_body, a model of Body which is for serialization only, to represent HTTP messages with no content body. * Removed overloads of write and async_write which send only the HTTP header. * Removed public interfaces for performing low-level chunk encoding.
2017-05-08 12:41:45 -07:00
if(! result)
goto go_complete;
more_ = result->second;
v_ = cb1_t{result->first};
s_ = do_body + 1;
// [[fallthrough]]
Distinguish HTTP/1 messages from general HTTP messages: The version field is moved into message_v1, all public interfaces are reworked to identify HTTP/1 wire format operations (suffix "_v1") versus general HTTP.
2016-05-01 11:14:10 -04:00
}
Refactor HTTP serialization (API Change): A new class `serializer` is introduced to permit incremental serialization of HTTP messages. Existing free functions are re-implemented in terms of this new class. * The BodyReader concept is refined to support a greater variety of strategies for providing buffers representing the body to the serialization algorithms. * Added buffer_body, a new model of Body which allows the caller to provide a series of owned buffers using their own serialization loop. * Added empty_body, a model of Body which is for serialization only, to represent HTTP messages with no content body. * Removed overloads of write and async_write which send only the HTTP header. * Removed public interfaces for performing low-level chunk encoding.
2017-05-08 12:41:45 -07:00
case do_body + 1:
Truncate history, version 1.0.0-b2
2017-07-20 08:01:46 -07:00
{
Refactor HTTP serialization (API Change): A new class `serializer` is introduced to permit incremental serialization of HTTP messages. Existing free functions are re-implemented in terms of this new class. * The BodyReader concept is refined to support a greater variety of strategies for providing buffers representing the body to the serialization algorithms. * Added buffer_body, a new model of Body which allows the caller to provide a series of owned buffers using their own serialization loop. * Added empty_body, a model of Body which is for serialization only, to represent HTTP messages with no content body. * Removed overloads of write and async_write which send only the HTTP header. * Removed public interfaces for performing low-level chunk encoding.
2017-05-08 12:41:45 -07:00
auto bytes_transferred =
stream.write_some(buffer_prefix(
limit_, boost::get<cb1_t>(v_)), ec);
if(ec)
return;
boost::get<cb1_t>(v_).consume(
bytes_transferred);
if(buffer_size(boost::get<cb1_t>(v_)) > 0)
break;
v_ = boost::blank{};
if(! more_)
goto go_complete;
s_ = do_body;
break;
}
Truncate history, version 1.0.0-b2
2017-07-20 08:01:46 -07:00
Refactor HTTP serialization (API Change): A new class `serializer` is introduced to permit incremental serialization of HTTP messages. Existing free functions are re-implemented in terms of this new class. * The BodyReader concept is refined to support a greater variety of strategies for providing buffers representing the body to the serialization algorithms. * Added buffer_body, a new model of Body which allows the caller to provide a series of owned buffers using their own serialization loop. * Added empty_body, a model of Body which is for serialization only, to represent HTTP messages with no content body. * Removed overloads of write and async_write which send only the HTTP header. * Removed public interfaces for performing low-level chunk encoding.
2017-05-08 12:41:45 -07:00
//----------------------------------------------------------------------
case do_init_c:
{
if(split_)
goto go_header_only_c;
Refactor type_traits (API Change): fix #373 * concepts.hpp is renamed to type_traits.hpp * Body reader and writer concepts are renamed
2017-05-28 09:05:29 -07:00
rd_.emplace(m_);
rd_->init(ec);
Refactor HTTP serialization (API Change): A new class `serializer` is introduced to permit incremental serialization of HTTP messages. Existing free functions are re-implemented in terms of this new class. * The BodyReader concept is refined to support a greater variety of strategies for providing buffers representing the body to the serialization algorithms. * Added buffer_body, a new model of Body which allows the caller to provide a series of owned buffers using their own serialization loop. * Added empty_body, a model of Body which is for serialization only, to represent HTTP messages with no content body. * Removed overloads of write and async_write which send only the HTTP header. * Removed public interfaces for performing low-level chunk encoding.
2017-05-08 12:41:45 -07:00
if(ec)
return;
Refactor type_traits (API Change): fix #373 * concepts.hpp is renamed to type_traits.hpp * Body reader and writer concepts are renamed
2017-05-28 09:05:29 -07:00
auto result = rd_->get(ec);
Refactor HTTP serialization (API Change): A new class `serializer` is introduced to permit incremental serialization of HTTP messages. Existing free functions are re-implemented in terms of this new class. * The BodyReader concept is refined to support a greater variety of strategies for providing buffers representing the body to the serialization algorithms. * Added buffer_body, a new model of Body which allows the caller to provide a series of owned buffers using their own serialization loop. * Added empty_body, a model of Body which is for serialization only, to represent HTTP messages with no content body. * Removed overloads of write and async_write which send only the HTTP header. * Removed public interfaces for performing low-level chunk encoding.
2017-05-08 12:41:45 -07:00
if(ec)
Truncate history, version 1.0.0-b2
2017-07-20 08:01:46 -07:00
{
Refactor HTTP serialization (API Change): A new class `serializer` is introduced to permit incremental serialization of HTTP messages. Existing free functions are re-implemented in terms of this new class. * The BodyReader concept is refined to support a greater variety of strategies for providing buffers representing the body to the serialization algorithms. * Added buffer_body, a new model of Body which allows the caller to provide a series of owned buffers using their own serialization loop. * Added empty_body, a model of Body which is for serialization only, to represent HTTP messages with no content body. * Removed overloads of write and async_write which send only the HTTP header. * Removed public interfaces for performing low-level chunk encoding.
2017-05-08 12:41:45 -07:00
// Can't use need_more when ! is_deferred
BOOST_ASSERT(ec != error::need_more);
return;
Truncate history, version 1.0.0-b2
2017-07-20 08:01:46 -07:00
}
Refactor HTTP serialization (API Change): A new class `serializer` is introduced to permit incremental serialization of HTTP messages. Existing free functions are re-implemented in terms of this new class. * The BodyReader concept is refined to support a greater variety of strategies for providing buffers representing the body to the serialization algorithms. * Added buffer_body, a new model of Body which allows the caller to provide a series of owned buffers using their own serialization loop. * Added empty_body, a model of Body which is for serialization only, to represent HTTP messages with no content body. * Removed overloads of write and async_write which send only the HTTP header. * Removed public interfaces for performing low-level chunk encoding.
2017-05-08 12:41:45 -07:00
if(! result)
goto go_header_only_c;
more_ = result->second;
v_ = ch0_t{
boost::in_place_init,
b_.data(),
detail::chunk_header{
buffer_size(result->first)},
[&]()
{
auto sv = d_(result->first);
return boost::asio::const_buffers_1{
sv.data(), sv.size()};
}(),
result->first,
detail::chunk_crlf()};
s_ = do_header_c;
// [[fallthrough]]
}
Truncate history, version 1.0.0-b2
2017-07-20 08:01:46 -07:00
Refactor HTTP serialization (API Change): A new class `serializer` is introduced to permit incremental serialization of HTTP messages. Existing free functions are re-implemented in terms of this new class. * The BodyReader concept is refined to support a greater variety of strategies for providing buffers representing the body to the serialization algorithms. * Added buffer_body, a new model of Body which allows the caller to provide a series of owned buffers using their own serialization loop. * Added empty_body, a model of Body which is for serialization only, to represent HTTP messages with no content body. * Removed overloads of write and async_write which send only the HTTP header. * Removed public interfaces for performing low-level chunk encoding.
2017-05-08 12:41:45 -07:00
case do_header_c:
Truncate history, version 1.0.0-b2
2017-07-20 08:01:46 -07:00
{
Refactor HTTP serialization (API Change): A new class `serializer` is introduced to permit incremental serialization of HTTP messages. Existing free functions are re-implemented in terms of this new class. * The BodyReader concept is refined to support a greater variety of strategies for providing buffers representing the body to the serialization algorithms. * Added buffer_body, a new model of Body which allows the caller to provide a series of owned buffers using their own serialization loop. * Added empty_body, a model of Body which is for serialization only, to represent HTTP messages with no content body. * Removed overloads of write and async_write which send only the HTTP header. * Removed public interfaces for performing low-level chunk encoding.
2017-05-08 12:41:45 -07:00
auto bytes_transferred =
stream.write_some(buffer_prefix(
limit_, boost::get<ch0_t>(v_)), ec);
if(ec)
return;
boost::get<ch0_t>(v_).consume(
bytes_transferred);
if(buffer_size(boost::get<ch0_t>(v_)) > 0)
break;
header_done_ = true;
v_ = boost::blank{};
b_.consume(b_.size()); // VFALCO delete b_?
if(more_)
s_ = do_body_c;
else
s_ = do_final_c;
break;
}
Truncate history, version 1.0.0-b2
2017-07-20 08:01:46 -07:00
Refactor HTTP serialization (API Change): A new class `serializer` is introduced to permit incremental serialization of HTTP messages. Existing free functions are re-implemented in terms of this new class. * The BodyReader concept is refined to support a greater variety of strategies for providing buffers representing the body to the serialization algorithms. * Added buffer_body, a new model of Body which allows the caller to provide a series of owned buffers using their own serialization loop. * Added empty_body, a model of Body which is for serialization only, to represent HTTP messages with no content body. * Removed overloads of write and async_write which send only the HTTP header. * Removed public interfaces for performing low-level chunk encoding.
2017-05-08 12:41:45 -07:00
go_header_only_c:
s_ = do_header_only_c;
case do_header_only_c:
{
auto bytes_transferred =
stream.write_some(buffer_prefix(
limit_, b_.data()), ec);
if(ec)
return;
b_.consume(bytes_transferred);
if(buffer_size(b_.data()) > 0)
break;
// VFALCO delete b_?
header_done_ = true;
if(! is_deferred::value)
Truncate history, version 1.0.0-b2
2017-07-20 08:01:46 -07:00
{
Refactor HTTP serialization (API Change): A new class `serializer` is introduced to permit incremental serialization of HTTP messages. Existing free functions are re-implemented in terms of this new class. * The BodyReader concept is refined to support a greater variety of strategies for providing buffers representing the body to the serialization algorithms. * Added buffer_body, a new model of Body which allows the caller to provide a series of owned buffers using their own serialization loop. * Added empty_body, a model of Body which is for serialization only, to represent HTTP messages with no content body. * Removed overloads of write and async_write which send only the HTTP header. * Removed public interfaces for performing low-level chunk encoding.
2017-05-08 12:41:45 -07:00
s_ = do_final_c;
break;
Truncate history, version 1.0.0-b2
2017-07-20 08:01:46 -07:00
}
Refactor type_traits (API Change): fix #373 * concepts.hpp is renamed to type_traits.hpp * Body reader and writer concepts are renamed
2017-05-28 09:05:29 -07:00
BOOST_ASSERT(! rd_);
rd_.emplace(m_);
rd_->init(ec);
Refactor HTTP serialization (API Change): A new class `serializer` is introduced to permit incremental serialization of HTTP messages. Existing free functions are re-implemented in terms of this new class. * The BodyReader concept is refined to support a greater variety of strategies for providing buffers representing the body to the serialization algorithms. * Added buffer_body, a new model of Body which allows the caller to provide a series of owned buffers using their own serialization loop. * Added empty_body, a model of Body which is for serialization only, to represent HTTP messages with no content body. * Removed overloads of write and async_write which send only the HTTP header. * Removed public interfaces for performing low-level chunk encoding.
2017-05-08 12:41:45 -07:00
if(ec)
return;
s_ = do_body_c;
break;
}
Truncate history, version 1.0.0-b2
2017-07-20 08:01:46 -07:00
Refactor HTTP serialization (API Change): A new class `serializer` is introduced to permit incremental serialization of HTTP messages. Existing free functions are re-implemented in terms of this new class. * The BodyReader concept is refined to support a greater variety of strategies for providing buffers representing the body to the serialization algorithms. * Added buffer_body, a new model of Body which allows the caller to provide a series of owned buffers using their own serialization loop. * Added empty_body, a model of Body which is for serialization only, to represent HTTP messages with no content body. * Removed overloads of write and async_write which send only the HTTP header. * Removed public interfaces for performing low-level chunk encoding.
2017-05-08 12:41:45 -07:00
case do_body_c:
{
Refactor type_traits (API Change): fix #373 * concepts.hpp is renamed to type_traits.hpp * Body reader and writer concepts are renamed
2017-05-28 09:05:29 -07:00
auto result = rd_->get(ec);
Refactor HTTP serialization (API Change): A new class `serializer` is introduced to permit incremental serialization of HTTP messages. Existing free functions are re-implemented in terms of this new class. * The BodyReader concept is refined to support a greater variety of strategies for providing buffers representing the body to the serialization algorithms. * Added buffer_body, a new model of Body which allows the caller to provide a series of owned buffers using their own serialization loop. * Added empty_body, a model of Body which is for serialization only, to represent HTTP messages with no content body. * Removed overloads of write and async_write which send only the HTTP header. * Removed public interfaces for performing low-level chunk encoding.
2017-05-08 12:41:45 -07:00
if(ec)
return;
if(! result)
goto go_final_c;
more_ = result->second;
v_ = ch1_t{
boost::in_place_init,
detail::chunk_header{
buffer_size(result->first)},
[&]()
{
auto sv = d_(result->first);
return boost::asio::const_buffers_1{
sv.data(), sv.size()};
}(),
result->first,
detail::chunk_crlf()};
s_ = do_body_c + 1;
// [[fallthrough]]
}
Truncate history, version 1.0.0-b2
2017-07-20 08:01:46 -07:00
Refactor HTTP serialization (API Change): A new class `serializer` is introduced to permit incremental serialization of HTTP messages. Existing free functions are re-implemented in terms of this new class. * The BodyReader concept is refined to support a greater variety of strategies for providing buffers representing the body to the serialization algorithms. * Added buffer_body, a new model of Body which allows the caller to provide a series of owned buffers using their own serialization loop. * Added empty_body, a model of Body which is for serialization only, to represent HTTP messages with no content body. * Removed overloads of write and async_write which send only the HTTP header. * Removed public interfaces for performing low-level chunk encoding.
2017-05-08 12:41:45 -07:00
case do_body_c + 1:
Truncate history, version 1.0.0-b2
2017-07-20 08:01:46 -07:00
{
Refactor HTTP serialization (API Change): A new class `serializer` is introduced to permit incremental serialization of HTTP messages. Existing free functions are re-implemented in terms of this new class. * The BodyReader concept is refined to support a greater variety of strategies for providing buffers representing the body to the serialization algorithms. * Added buffer_body, a new model of Body which allows the caller to provide a series of owned buffers using their own serialization loop. * Added empty_body, a model of Body which is for serialization only, to represent HTTP messages with no content body. * Removed overloads of write and async_write which send only the HTTP header. * Removed public interfaces for performing low-level chunk encoding.
2017-05-08 12:41:45 -07:00
auto bytes_transferred =
stream.write_some(buffer_prefix(
limit_, boost::get<ch1_t>(v_)), ec);
if(ec)
return;
boost::get<ch1_t>(v_).consume(
bytes_transferred);
if(buffer_size(boost::get<ch1_t>(v_)) > 0)
break;
v_ = boost::blank{};
if(more_)
s_ = do_body_c;
else
s_ = do_final_c;
break;
}
go_final_c:
case do_final_c:
v_ = ch2_t{
boost::in_place_init,
detail::chunk_final(),
[&]()
{
auto sv = d_(
boost::asio::null_buffers{});
return boost::asio::const_buffers_1{
sv.data(), sv.size()};
}(),
detail::chunk_crlf()};
s_ = do_final_c + 1;
// [[fallthrough]]
case do_final_c + 1:
{
auto bytes_transferred =
stream.write_some(buffer_prefix(
limit_, boost::get<ch2_t>(v_)), ec);
if(ec)
return;
boost::get<ch2_t>(v_).consume(
bytes_transferred);
if(buffer_size(boost::get<ch2_t>(v_)) > 0)
break;
v_ = boost::blank{};
goto go_complete;
}
default:
case do_complete:
BOOST_ASSERT(false);
//----------------------------------------------------------------------
Truncate history, version 1.0.0-b2
2017-07-20 08:01:46 -07:00
Refactor HTTP serialization (API Change): A new class `serializer` is introduced to permit incremental serialization of HTTP messages. Existing free functions are re-implemented in terms of this new class. * The BodyReader concept is refined to support a greater variety of strategies for providing buffers representing the body to the serialization algorithms. * Added buffer_body, a new model of Body which allows the caller to provide a series of owned buffers using their own serialization loop. * Added empty_body, a model of Body which is for serialization only, to represent HTTP messages with no content body. * Removed overloads of write and async_write which send only the HTTP header. * Removed public interfaces for performing low-level chunk encoding.
2017-05-08 12:41:45 -07:00
go_complete:
s_ = do_complete;
if(close_)
Truncate history, version 1.0.0-b2
2017-07-20 08:01:46 -07:00
{
Refactor HTTP serialization (API Change): A new class `serializer` is introduced to permit incremental serialization of HTTP messages. Existing free functions are re-implemented in terms of this new class. * The BodyReader concept is refined to support a greater variety of strategies for providing buffers representing the body to the serialization algorithms. * Added buffer_body, a new model of Body which allows the caller to provide a series of owned buffers using their own serialization loop. * Added empty_body, a model of Body which is for serialization only, to represent HTTP messages with no content body. * Removed overloads of write and async_write which send only the HTTP header. * Removed public interfaces for performing low-level chunk encoding.
2017-05-08 12:41:45 -07:00
// VFALCO TODO Decide on an error code
ec = boost::asio::error::eof;
return;
Truncate history, version 1.0.0-b2
2017-07-20 08:01:46 -07:00
}
Refactor HTTP serialization (API Change): A new class `serializer` is introduced to permit incremental serialization of HTTP messages. Existing free functions are re-implemented in terms of this new class. * The BodyReader concept is refined to support a greater variety of strategies for providing buffers representing the body to the serialization algorithms. * Added buffer_body, a new model of Body which allows the caller to provide a series of owned buffers using their own serialization loop. * Added empty_body, a model of Body which is for serialization only, to represent HTTP messages with no content body. * Removed overloads of write and async_write which send only the HTTP header. * Removed public interfaces for performing low-level chunk encoding.
2017-05-08 12:41:45 -07:00
break;
}
}
template<bool isRequest, class Body, class Fields,
class Decorator, class Allocator>
template<class AsyncWriteStream, class WriteHandler>
async_return_type<WriteHandler, void(error_code)>
serializer<isRequest, Body, Fields,
Decorator, Allocator>::
async_write_some(AsyncWriteStream& stream,
WriteHandler&& handler)
{
static_assert(is_async_write_stream<AsyncWriteStream>::value,
"AsyncWriteStream requirements not met");
Refactor type_traits (API Change): fix #373 * concepts.hpp is renamed to type_traits.hpp * Body reader and writer concepts are renamed
2017-05-28 09:05:29 -07:00
static_assert(is_body<Body>::value,
Refactor HTTP serialization (API Change): A new class `serializer` is introduced to permit incremental serialization of HTTP messages. Existing free functions are re-implemented in terms of this new class. * The BodyReader concept is refined to support a greater variety of strategies for providing buffers representing the body to the serialization algorithms. * Added buffer_body, a new model of Body which allows the caller to provide a series of owned buffers using their own serialization loop. * Added empty_body, a model of Body which is for serialization only, to represent HTTP messages with no content body. * Removed overloads of write and async_write which send only the HTTP header. * Removed public interfaces for performing low-level chunk encoding.
2017-05-08 12:41:45 -07:00
"Body requirements not met");
Refactor type_traits (API Change): fix #373 * concepts.hpp is renamed to type_traits.hpp * Body reader and writer concepts are renamed
2017-05-28 09:05:29 -07:00
static_assert(is_body_reader<Body>::value,
"BodyReader requirements not met");
Refactor HTTP serialization (API Change): A new class `serializer` is introduced to permit incremental serialization of HTTP messages. Existing free functions are re-implemented in terms of this new class. * The BodyReader concept is refined to support a greater variety of strategies for providing buffers representing the body to the serialization algorithms. * Added buffer_body, a new model of Body which allows the caller to provide a series of owned buffers using their own serialization loop. * Added empty_body, a model of Body which is for serialization only, to represent HTTP messages with no content body. * Removed overloads of write and async_write which send only the HTTP header. * Removed public interfaces for performing low-level chunk encoding.
2017-05-08 12:41:45 -07:00
async_completion<WriteHandler,
void(error_code)> init{handler};
async_op<AsyncWriteStream, handler_type<
WriteHandler, void(error_code)>>{
init.completion_handler, stream, *this}(
error_code{}, 0, false);
return init.result.get();
}
//------------------------------------------------------------------------------
Truncate history, version 1.0.0-b2
2017-07-20 08:01:46 -07:00
Refactor HTTP serialization (API Change): A new class `serializer` is introduced to permit incremental serialization of HTTP messages. Existing free functions are re-implemented in terms of this new class. * The BodyReader concept is refined to support a greater variety of strategies for providing buffers representing the body to the serialization algorithms. * Added buffer_body, a new model of Body which allows the caller to provide a series of owned buffers using their own serialization loop. * Added empty_body, a model of Body which is for serialization only, to represent HTTP messages with no content body. * Removed overloads of write and async_write which send only the HTTP header. * Removed public interfaces for performing low-level chunk encoding.
2017-05-08 12:41:45 -07:00
namespace detail {
template<class Stream, class Handler,
bool isRequest, class Body, class Fields>
class write_op
{
struct data
{
int state = 0;
Stream& s;
serializer<isRequest, Body, Fields,
empty_decorator, handler_alloc<char, Handler>> ws;
data(Handler& h, Stream& s_, message<
isRequest, Body, Fields> const& m_)
: s(s_)
, ws(m_, empty_decorator{},
handler_alloc<char, Handler>{h})
Truncate history, version 1.0.0-b2
2017-07-20 08:01:46 -07:00
{
}
};
Implement asio dealloc-before-invoke guarantee: fix #215 This change guarantees that temporary memory allocated through the asio hooks by the Beast implementation is deallocated before invoking the final handler when performing composed operations. The change is accomplished by replacing std::shared_ptr with a thread-safe custom container handler_ptr to manage composed operation state. The container tracks other instances which manage the same object and resets them in a safe way before invoking the final handler. handler_ptr is provided as a public interface so that users of this library can utilize the same idiom to write their own composed operations.
2017-01-02 13:29:48 -05:00
handler_ptr<data, Handler> d_;
Truncate history, version 1.0.0-b2
2017-07-20 08:01:46 -07:00
public:
write_op(write_op&&) = default;
write_op(write_op const&) = default;
template<class DeducedHandler, class... Args>
write_op(DeducedHandler&& h, Stream& s, Args&&... args)
Better handler_ptr (API Change): fix #242 * Add public constructors * Add handler_ptr::empty() * Add handler_ptr::element_type * Remove make_handler_ptr free function * Compiler error if element_type is an array type * handler_ptr::get() returns nullptr if no object is owned
2017-01-29 19:46:17 -05:00
: d_(std::forward<DeducedHandler>(h),
s, std::forward<Args>(args)...)
Truncate history, version 1.0.0-b2
2017-07-20 08:01:46 -07:00
{
}
void
Refactor HTTP serialization (API Change): A new class `serializer` is introduced to permit incremental serialization of HTTP messages. Existing free functions are re-implemented in terms of this new class. * The BodyReader concept is refined to support a greater variety of strategies for providing buffers representing the body to the serialization algorithms. * Added buffer_body, a new model of Body which allows the caller to provide a series of owned buffers using their own serialization loop. * Added empty_body, a model of Body which is for serialization only, to represent HTTP messages with no content body. * Removed overloads of write and async_write which send only the HTTP header. * Removed public interfaces for performing low-level chunk encoding.
2017-05-08 12:41:45 -07:00
operator()(error_code ec);
Truncate history, version 1.0.0-b2
2017-07-20 08:01:46 -07:00
friend
void* asio_handler_allocate(
std::size_t size, write_op* op)
{
Remove handler helpers, tidy up hook invocations (API Change)
2017-05-14 09:25:43 -07:00
using boost::asio::asio_handler_allocate;
return asio_handler_allocate(
size, std::addressof(op->d_.handler()));
Truncate history, version 1.0.0-b2
2017-07-20 08:01:46 -07:00
}
friend
void asio_handler_deallocate(
void* p, std::size_t size, write_op* op)
{
Remove handler helpers, tidy up hook invocations (API Change)
2017-05-14 09:25:43 -07:00
using boost::asio::asio_handler_deallocate;
asio_handler_deallocate(
p, size, std::addressof(op->d_.handler()));
Truncate history, version 1.0.0-b2
2017-07-20 08:01:46 -07:00
}
friend
bool asio_handler_is_continuation(write_op* op)
{
Refactor HTTP serialization (API Change): A new class `serializer` is introduced to permit incremental serialization of HTTP messages. Existing free functions are re-implemented in terms of this new class. * The BodyReader concept is refined to support a greater variety of strategies for providing buffers representing the body to the serialization algorithms. * Added buffer_body, a new model of Body which allows the caller to provide a series of owned buffers using their own serialization loop. * Added empty_body, a model of Body which is for serialization only, to represent HTTP messages with no content body. * Removed overloads of write and async_write which send only the HTTP header. * Removed public interfaces for performing low-level chunk encoding.
2017-05-08 12:41:45 -07:00
using boost::asio::asio_handler_is_continuation;
return op->d_->state == 2 ||
asio_handler_is_continuation(
std::addressof(op->d_.handler()));
Truncate history, version 1.0.0-b2
2017-07-20 08:01:46 -07:00
}
Restyle sources
2016-08-26 08:01:44 -04:00
template<class Function>
Truncate history, version 1.0.0-b2
2017-07-20 08:01:46 -07:00
friend
void asio_handler_invoke(Function&& f, write_op* op)
{
Remove handler helpers, tidy up hook invocations (API Change)
2017-05-14 09:25:43 -07:00
using boost::asio::asio_handler_invoke;
asio_handler_invoke(
f, std::addressof(op->d_.handler()));
Truncate history, version 1.0.0-b2
2017-07-20 08:01:46 -07:00
}
};
template<class Stream, class Handler,
Refactor HTTP identifier names (API Change): fix #171 Several names and HTTP identifiers are renamed to be more consistent, self-explanatory, and concise: * "Fields" is a collection of HTTP header fields (rfc7230 section 3.2) * "Header" is the Start Line plus Fields. Another way to look at it is, the HTTP message minus the body. * `basic_fields` replaces `basic_headers` * `fields` replaces `headers` * `Fields` replaces `Headers` in template parameter lists * `header` replaces `message_headers` * `header::fields` replaces `message_headers::fields` The changes are cosmetic and do not affect run-time behavior.
2016-11-10 05:34:49 -05:00
bool isRequest, class Body, class Fields>
Truncate history, version 1.0.0-b2
2017-07-20 08:01:46 -07:00
void
Refactor HTTP identifier names (API Change): fix #171 Several names and HTTP identifiers are renamed to be more consistent, self-explanatory, and concise: * "Fields" is a collection of HTTP header fields (rfc7230 section 3.2) * "Header" is the Start Line plus Fields. Another way to look at it is, the HTTP message minus the body. * `basic_fields` replaces `basic_headers` * `fields` replaces `headers` * `Fields` replaces `Headers` in template parameter lists * `header` replaces `message_headers` * `header::fields` replaces `message_headers::fields` The changes are cosmetic and do not affect run-time behavior.
2016-11-10 05:34:49 -05:00
write_op<Stream, Handler, isRequest, Body, Fields>::
Refactor HTTP serialization (API Change): A new class `serializer` is introduced to permit incremental serialization of HTTP messages. Existing free functions are re-implemented in terms of this new class. * The BodyReader concept is refined to support a greater variety of strategies for providing buffers representing the body to the serialization algorithms. * Added buffer_body, a new model of Body which allows the caller to provide a series of owned buffers using their own serialization loop. * Added empty_body, a model of Body which is for serialization only, to represent HTTP messages with no content body. * Removed overloads of write and async_write which send only the HTTP header. * Removed public interfaces for performing low-level chunk encoding.
2017-05-08 12:41:45 -07:00
operator()(error_code ec)
Truncate history, version 1.0.0-b2
2017-07-20 08:01:46 -07:00
{
auto& d = *d_;
Refactor HTTP serialization (API Change): A new class `serializer` is introduced to permit incremental serialization of HTTP messages. Existing free functions are re-implemented in terms of this new class. * The BodyReader concept is refined to support a greater variety of strategies for providing buffers representing the body to the serialization algorithms. * Added buffer_body, a new model of Body which allows the caller to provide a series of owned buffers using their own serialization loop. * Added empty_body, a model of Body which is for serialization only, to represent HTTP messages with no content body. * Removed overloads of write and async_write which send only the HTTP header. * Removed public interfaces for performing low-level chunk encoding.
2017-05-08 12:41:45 -07:00
if(ec)
goto upcall;
switch(d.state)
Truncate history, version 1.0.0-b2
2017-07-20 08:01:46 -07:00
{
Refactor HTTP serialization (API Change): A new class `serializer` is introduced to permit incremental serialization of HTTP messages. Existing free functions are re-implemented in terms of this new class. * The BodyReader concept is refined to support a greater variety of strategies for providing buffers representing the body to the serialization algorithms. * Added buffer_body, a new model of Body which allows the caller to provide a series of owned buffers using their own serialization loop. * Added empty_body, a model of Body which is for serialization only, to represent HTTP messages with no content body. * Removed overloads of write and async_write which send only the HTTP header. * Removed public interfaces for performing low-level chunk encoding.
2017-05-08 12:41:45 -07:00
case 0:
d.state = 1;
return d.ws.async_write_some(d.s, std::move(*this));
case 1:
d.state = 2;
case 2:
if(d.ws.is_done())
Truncate history, version 1.0.0-b2
2017-07-20 08:01:46 -07:00
break;
Refactor HTTP serialization (API Change): A new class `serializer` is introduced to permit incremental serialization of HTTP messages. Existing free functions are re-implemented in terms of this new class. * The BodyReader concept is refined to support a greater variety of strategies for providing buffers representing the body to the serialization algorithms. * Added buffer_body, a new model of Body which allows the caller to provide a series of owned buffers using their own serialization loop. * Added empty_body, a model of Body which is for serialization only, to represent HTTP messages with no content body. * Removed overloads of write and async_write which send only the HTTP header. * Removed public interfaces for performing low-level chunk encoding.
2017-05-08 12:41:45 -07:00
return d.ws.async_write_some(d.s, std::move(*this));
Truncate history, version 1.0.0-b2
2017-07-20 08:01:46 -07:00
}
Refactor HTTP serialization (API Change): A new class `serializer` is introduced to permit incremental serialization of HTTP messages. Existing free functions are re-implemented in terms of this new class. * The BodyReader concept is refined to support a greater variety of strategies for providing buffers representing the body to the serialization algorithms. * Added buffer_body, a new model of Body which allows the caller to provide a series of owned buffers using their own serialization loop. * Added empty_body, a model of Body which is for serialization only, to represent HTTP messages with no content body. * Removed overloads of write and async_write which send only the HTTP header. * Removed public interfaces for performing low-level chunk encoding.
2017-05-08 12:41:45 -07:00
upcall:
Implement asio dealloc-before-invoke guarantee: fix #215 This change guarantees that temporary memory allocated through the asio hooks by the Beast implementation is deallocated before invoking the final handler when performing composed operations. The change is accomplished by replacing std::shared_ptr with a thread-safe custom container handler_ptr to manage composed operation state. The container tracks other instances which manage the same object and resets them in a safe way before invoking the final handler. handler_ptr is provided as a public interface so that users of this library can utilize the same idiom to write their own composed operations.
2017-01-02 13:29:48 -05:00
d_.invoke(ec);
Truncate history, version 1.0.0-b2
2017-07-20 08:01:46 -07:00
}
} // detail
template<class SyncWriteStream,
Refactor HTTP identifier names (API Change): fix #171 Several names and HTTP identifiers are renamed to be more consistent, self-explanatory, and concise: * "Fields" is a collection of HTTP header fields (rfc7230 section 3.2) * "Header" is the Start Line plus Fields. Another way to look at it is, the HTTP message minus the body. * `basic_fields` replaces `basic_headers` * `fields` replaces `headers` * `Fields` replaces `Headers` in template parameter lists * `header` replaces `message_headers` * `header::fields` replaces `message_headers::fields` The changes are cosmetic and do not affect run-time behavior.
2016-11-10 05:34:49 -05:00
bool isRequest, class Body, class Fields>
Truncate history, version 1.0.0-b2
2017-07-20 08:01:46 -07:00
void
write(SyncWriteStream& stream,
Refactor HTTP identifier names (API Change): fix #171 Several names and HTTP identifiers are renamed to be more consistent, self-explanatory, and concise: * "Fields" is a collection of HTTP header fields (rfc7230 section 3.2) * "Header" is the Start Line plus Fields. Another way to look at it is, the HTTP message minus the body. * `basic_fields` replaces `basic_headers` * `fields` replaces `headers` * `Fields` replaces `Headers` in template parameter lists * `header` replaces `message_headers` * `header::fields` replaces `message_headers::fields` The changes are cosmetic and do not affect run-time behavior.
2016-11-10 05:34:49 -05:00
message<isRequest, Body, Fields> const& msg)
Distinguish HTTP/1 messages from general HTTP messages: The version field is moved into message_v1, all public interfaces are reworked to identify HTTP/1 wire format operations (suffix "_v1") versus general HTTP.
2016-05-01 11:14:10 -04:00
{
Concept revision and documentation (API Change): The concept type traits are renamed for consistency, and consolidated into a single header file <beast/core/type_traits.hpp> A new section, Core Concepts, is added to the documentation describing all of the core utility classes and functions. This also includes a complete explanation and sample program describing how to write asynchronous initiation functions and their associated composed operations.
2017-05-10 12:03:00 -07:00
static_assert(is_sync_write_stream<SyncWriteStream>::value,
Distinguish HTTP/1 messages from general HTTP messages: The version field is moved into message_v1, all public interfaces are reworked to identify HTTP/1 wire format operations (suffix "_v1") versus general HTTP.
2016-05-01 11:14:10 -04:00
"SyncWriteStream requirements not met");
Refactor type_traits (API Change): fix #373 * concepts.hpp is renamed to type_traits.hpp * Body reader and writer concepts are renamed
2017-05-28 09:05:29 -07:00
static_assert(is_body<Body>::value,
Rework HTTP concepts (API Change): fix #139, fix #140 * Writer uses write instead of operator() * Refactor traits to use void_t * Remove is_ReadableBody, is_WritableBody * Add has_reader, has_writer, is_Reader, is_Writer * More friendly compile errors on failed concept checks
2016-10-15 13:40:17 -04:00
"Body requirements not met");
Refactor type_traits (API Change): fix #373 * concepts.hpp is renamed to type_traits.hpp * Body reader and writer concepts are renamed
2017-05-28 09:05:29 -07:00
static_assert(is_body_reader<Body>::value,
"BodyReader requirements not met");
Distinguish HTTP/1 messages from general HTTP messages: The version field is moved into message_v1, all public interfaces are reworked to identify HTTP/1 wire format operations (suffix "_v1") versus general HTTP.
2016-05-01 11:14:10 -04:00
error_code ec;
write(stream, msg, ec);
if(ec)
Use BOOST_THROW_EXCEPTION fix #370
2017-05-22 15:30:12 -07:00
BOOST_THROW_EXCEPTION(system_error{ec});
Distinguish HTTP/1 messages from general HTTP messages: The version field is moved into message_v1, all public interfaces are reworked to identify HTTP/1 wire format operations (suffix "_v1") versus general HTTP.
2016-05-01 11:14:10 -04:00
}
template<class SyncWriteStream,
Refactor HTTP identifier names (API Change): fix #171 Several names and HTTP identifiers are renamed to be more consistent, self-explanatory, and concise: * "Fields" is a collection of HTTP header fields (rfc7230 section 3.2) * "Header" is the Start Line plus Fields. Another way to look at it is, the HTTP message minus the body. * `basic_fields` replaces `basic_headers` * `fields` replaces `headers` * `Fields` replaces `Headers` in template parameter lists * `header` replaces `message_headers` * `header::fields` replaces `message_headers::fields` The changes are cosmetic and do not affect run-time behavior.
2016-11-10 05:34:49 -05:00
bool isRequest, class Body, class Fields>
Distinguish HTTP/1 messages from general HTTP messages: The version field is moved into message_v1, all public interfaces are reworked to identify HTTP/1 wire format operations (suffix "_v1") versus general HTTP.
2016-05-01 11:14:10 -04:00
void
write(SyncWriteStream& stream,
Refactor HTTP identifier names (API Change): fix #171 Several names and HTTP identifiers are renamed to be more consistent, self-explanatory, and concise: * "Fields" is a collection of HTTP header fields (rfc7230 section 3.2) * "Header" is the Start Line plus Fields. Another way to look at it is, the HTTP message minus the body. * `basic_fields` replaces `basic_headers` * `fields` replaces `headers` * `Fields` replaces `Headers` in template parameter lists * `header` replaces `message_headers` * `header::fields` replaces `message_headers::fields` The changes are cosmetic and do not affect run-time behavior.
2016-11-10 05:34:49 -05:00
message<isRequest, Body, Fields> const& msg,
Tidy up error types: * Restructure header material * Clean up namespace type injections * Remove extraneous 'success' constants
2016-10-04 18:00:11 -04:00
error_code& ec)
Truncate history, version 1.0.0-b2
2017-07-20 08:01:46 -07:00
{
Concept revision and documentation (API Change): The concept type traits are renamed for consistency, and consolidated into a single header file <beast/core/type_traits.hpp> A new section, Core Concepts, is added to the documentation describing all of the core utility classes and functions. This also includes a complete explanation and sample program describing how to write asynchronous initiation functions and their associated composed operations.
2017-05-10 12:03:00 -07:00
static_assert(is_sync_write_stream<SyncWriteStream>::value,
Refactor beast core, http, tests, and examples: * Fix warnings * Port cmake scripts to linux * Add command line options for running test suites * Add examples to CMakeLists * Return std::uint64_t from writer::content_length * basic_parser::write takes asio::const_buffer instead of pointer and size * Turn message test back on now that it passes * Rename to http::headers, use std::allocator, remove http_headers * http::message::method is now a string * Refactor to_string for ConstBufferSequence * Remove chunk_encode from the public interface * Initialize members for default constructed iterators * Disallow default construction for dependent buffer sequences Refactor http::message serialization: * Serialization no longer creates a copy of the headers and modifies them * New function prepare(), sets Connection, Transfer-Encoding, Content-Length based on the body attributes and caller options. Callers can use prepare() to have the fields set automatically, or they can set the fields manually. * Use write for operator<< * Tests for serialization
2016-04-29 06:04:40 -04:00
"SyncWriteStream requirements not met");
Refactor type_traits (API Change): fix #373 * concepts.hpp is renamed to type_traits.hpp * Body reader and writer concepts are renamed
2017-05-28 09:05:29 -07:00
static_assert(is_body<Body>::value,
Rework HTTP concepts (API Change): fix #139, fix #140 * Writer uses write instead of operator() * Refactor traits to use void_t * Remove is_ReadableBody, is_WritableBody * Add has_reader, has_writer, is_Reader, is_Writer * More friendly compile errors on failed concept checks
2016-10-15 13:40:17 -04:00
"Body requirements not met");
Refactor type_traits (API Change): fix #373 * concepts.hpp is renamed to type_traits.hpp * Body reader and writer concepts are renamed
2017-05-28 09:05:29 -07:00
static_assert(is_body_reader<Body>::value,
"BodyReader requirements not met");
Rename to make_serializer
2017-05-28 14:36:38 -07:00
auto ws = make_serializer(msg);
Refactor HTTP serialization (API Change): A new class `serializer` is introduced to permit incremental serialization of HTTP messages. Existing free functions are re-implemented in terms of this new class. * The BodyReader concept is refined to support a greater variety of strategies for providing buffers representing the body to the serialization algorithms. * Added buffer_body, a new model of Body which allows the caller to provide a series of owned buffers using their own serialization loop. * Added empty_body, a model of Body which is for serialization only, to represent HTTP messages with no content body. * Removed overloads of write and async_write which send only the HTTP header. * Removed public interfaces for performing low-level chunk encoding.
2017-05-08 12:41:45 -07:00
for(;;)
Truncate history, version 1.0.0-b2
2017-07-20 08:01:46 -07:00
{
Refactor HTTP serialization (API Change): A new class `serializer` is introduced to permit incremental serialization of HTTP messages. Existing free functions are re-implemented in terms of this new class. * The BodyReader concept is refined to support a greater variety of strategies for providing buffers representing the body to the serialization algorithms. * Added buffer_body, a new model of Body which allows the caller to provide a series of owned buffers using their own serialization loop. * Added empty_body, a model of Body which is for serialization only, to represent HTTP messages with no content body. * Removed overloads of write and async_write which send only the HTTP header. * Removed public interfaces for performing low-level chunk encoding.
2017-05-08 12:41:45 -07:00
ws.write_some(stream, ec);
Truncate history, version 1.0.0-b2
2017-07-20 08:01:46 -07:00
if(ec)
return;
Refactor HTTP serialization (API Change): A new class `serializer` is introduced to permit incremental serialization of HTTP messages. Existing free functions are re-implemented in terms of this new class. * The BodyReader concept is refined to support a greater variety of strategies for providing buffers representing the body to the serialization algorithms. * Added buffer_body, a new model of Body which allows the caller to provide a series of owned buffers using their own serialization loop. * Added empty_body, a model of Body which is for serialization only, to represent HTTP messages with no content body. * Removed overloads of write and async_write which send only the HTTP header. * Removed public interfaces for performing low-level chunk encoding.
2017-05-08 12:41:45 -07:00
if(ws.is_done())
break;
Truncate history, version 1.0.0-b2
2017-07-20 08:01:46 -07:00
}
}
template<class AsyncWriteStream,
Refactor HTTP identifier names (API Change): fix #171 Several names and HTTP identifiers are renamed to be more consistent, self-explanatory, and concise: * "Fields" is a collection of HTTP header fields (rfc7230 section 3.2) * "Header" is the Start Line plus Fields. Another way to look at it is, the HTTP message minus the body. * `basic_fields` replaces `basic_headers` * `fields` replaces `headers` * `Fields` replaces `Headers` in template parameter lists * `header` replaces `message_headers` * `header::fields` replaces `message_headers::fields` The changes are cosmetic and do not affect run-time behavior.
2016-11-10 05:34:49 -05:00
bool isRequest, class Body, class Fields,
Truncate history, version 1.0.0-b2
2017-07-20 08:01:46 -07:00
class WriteHandler>
Replace asynchronous helper macros with template aliases (API Change)
2017-05-12 17:13:03 -07:00
async_return_type<
WriteHandler, void(error_code)>
Truncate history, version 1.0.0-b2
2017-07-20 08:01:46 -07:00
async_write(AsyncWriteStream& stream,
Refactor HTTP identifier names (API Change): fix #171 Several names and HTTP identifiers are renamed to be more consistent, self-explanatory, and concise: * "Fields" is a collection of HTTP header fields (rfc7230 section 3.2) * "Header" is the Start Line plus Fields. Another way to look at it is, the HTTP message minus the body. * `basic_fields` replaces `basic_headers` * `fields` replaces `headers` * `Fields` replaces `Headers` in template parameter lists * `header` replaces `message_headers` * `header::fields` replaces `message_headers::fields` The changes are cosmetic and do not affect run-time behavior.
2016-11-10 05:34:49 -05:00
message<isRequest, Body, Fields> const& msg,
Truncate history, version 1.0.0-b2
2017-07-20 08:01:46 -07:00
WriteHandler&& handler)
{
Refactor HTTP serialization (API Change): A new class `serializer` is introduced to permit incremental serialization of HTTP messages. Existing free functions are re-implemented in terms of this new class. * The BodyReader concept is refined to support a greater variety of strategies for providing buffers representing the body to the serialization algorithms. * Added buffer_body, a new model of Body which allows the caller to provide a series of owned buffers using their own serialization loop. * Added empty_body, a model of Body which is for serialization only, to represent HTTP messages with no content body. * Removed overloads of write and async_write which send only the HTTP header. * Removed public interfaces for performing low-level chunk encoding.
2017-05-08 12:41:45 -07:00
static_assert(
is_async_write_stream<AsyncWriteStream>::value,
Rename concept to DynamicBuffer (API change): Conform to the Networking TS by renaming the Streambuf concept to DynamicBuffer in all places. Values of types meeting the requirements of DynamicBuffer are renamed to dynabuf. See: http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2015/n4478.html#requirements.dynamic_buffers * Headers renamed * Formal parameter names renamed * Template argument types renamed * Documentation updated
2016-05-28 09:23:54 -04:00
"AsyncWriteStream requirements not met");
Refactor type_traits (API Change): fix #373 * concepts.hpp is renamed to type_traits.hpp * Body reader and writer concepts are renamed
2017-05-28 09:05:29 -07:00
static_assert(is_body<Body>::value,
Rework HTTP concepts (API Change): fix #139, fix #140 * Writer uses write instead of operator() * Refactor traits to use void_t * Remove is_ReadableBody, is_WritableBody * Add has_reader, has_writer, is_Reader, is_Writer * More friendly compile errors on failed concept checks
2016-10-15 13:40:17 -04:00
"Body requirements not met");
Refactor type_traits (API Change): fix #373 * concepts.hpp is renamed to type_traits.hpp * Body reader and writer concepts are renamed
2017-05-28 09:05:29 -07:00
static_assert(is_body_reader<Body>::value,
"BodyReader requirements not met");
Harmonize concepts and identifiers with net-ts (API Change): fix #321 This synchronizes identifier names and some implementation details with the Networking-TS document and reference implementation. The following interfaces have changed: * async_completion * is_buffer_sequence (removed) * is_const_buffer_sequence (was is_ConstBufferSequence) * is_dynamic_buffer (was is_DynamicBuffer) * is_mutable_buffer_sequence (was is_MutableBufferSequence) * async_result (new) * BEAST_HANDLER_TYPE macro (new) * BEAST_INITFN_RESULT_TYPE macro (new) Filename changes: * async_result.hpp (was async_completion.hpp)
2017-05-06 12:36:40 -07:00
async_completion<WriteHandler,
void(error_code)> init{handler};
Replace asynchronous helper macros with template aliases (API Change)
2017-05-12 17:13:03 -07:00
detail::write_op<AsyncWriteStream, handler_type<
Refactor HTTP serialization (API Change): A new class `serializer` is introduced to permit incremental serialization of HTTP messages. Existing free functions are re-implemented in terms of this new class. * The BodyReader concept is refined to support a greater variety of strategies for providing buffers representing the body to the serialization algorithms. * Added buffer_body, a new model of Body which allows the caller to provide a series of owned buffers using their own serialization loop. * Added empty_body, a model of Body which is for serialization only, to represent HTTP messages with no content body. * Removed overloads of write and async_write which send only the HTTP header. * Removed public interfaces for performing low-level chunk encoding.
2017-05-08 12:41:45 -07:00
WriteHandler, void(error_code)>,
isRequest, Body, Fields>{
init.completion_handler, stream, msg}(
error_code{});
Harmonize concepts and identifiers with net-ts (API Change): fix #321 This synchronizes identifier names and some implementation details with the Networking-TS document and reference implementation. The following interfaces have changed: * async_completion * is_buffer_sequence (removed) * is_const_buffer_sequence (was is_ConstBufferSequence) * is_dynamic_buffer (was is_DynamicBuffer) * is_mutable_buffer_sequence (was is_MutableBufferSequence) * async_result (new) * BEAST_HANDLER_TYPE macro (new) * BEAST_INITFN_RESULT_TYPE macro (new) Filename changes: * async_result.hpp (was async_completion.hpp)
2017-05-06 12:36:40 -07:00
return init.result.get();
Truncate history, version 1.0.0-b2
2017-07-20 08:01:46 -07:00
}
Add write, async_write, operator<< for message_headers: fix #155 This adds overloads of write, async_write, and operator<< for message_headers.
2016-11-07 13:51:10 -05:00
//------------------------------------------------------------------------------
Refactor HTTP identifier names (API Change): fix #171 Several names and HTTP identifiers are renamed to be more consistent, self-explanatory, and concise: * "Fields" is a collection of HTTP header fields (rfc7230 section 3.2) * "Header" is the Start Line plus Fields. Another way to look at it is, the HTTP message minus the body. * `basic_fields` replaces `basic_headers` * `fields` replaces `headers` * `Fields` replaces `Headers` in template parameter lists * `header` replaces `message_headers` * `header::fields` replaces `message_headers::fields` The changes are cosmetic and do not affect run-time behavior.
2016-11-10 05:34:49 -05:00
template<bool isRequest, class Fields>
Add write, async_write, operator<< for message_headers: fix #155 This adds overloads of write, async_write, and operator<< for message_headers.
2016-11-07 13:51:10 -05:00
std::ostream&
operator<<(std::ostream& os,
Refactor HTTP identifier names (API Change): fix #171 Several names and HTTP identifiers are renamed to be more consistent, self-explanatory, and concise: * "Fields" is a collection of HTTP header fields (rfc7230 section 3.2) * "Header" is the Start Line plus Fields. Another way to look at it is, the HTTP message minus the body. * `basic_fields` replaces `basic_headers` * `fields` replaces `headers` * `Fields` replaces `Headers` in template parameter lists * `header` replaces `message_headers` * `header::fields` replaces `message_headers::fields` The changes are cosmetic and do not affect run-time behavior.
2016-11-10 05:34:49 -05:00
header<isRequest, Fields> const& msg)
Add write, async_write, operator<< for message_headers: fix #155 This adds overloads of write, async_write, and operator<< for message_headers.
2016-11-07 13:51:10 -05:00
{
Refactor HTTP serialization (API Change): A new class `serializer` is introduced to permit incremental serialization of HTTP messages. Existing free functions are re-implemented in terms of this new class. * The BodyReader concept is refined to support a greater variety of strategies for providing buffers representing the body to the serialization algorithms. * Added buffer_body, a new model of Body which allows the caller to provide a series of owned buffers using their own serialization loop. * Added empty_body, a model of Body which is for serialization only, to represent HTTP messages with no content body. * Removed overloads of write and async_write which send only the HTTP header. * Removed public interfaces for performing low-level chunk encoding.
2017-05-08 12:41:45 -07:00
detail::write_start_line(os, msg);
detail::write_fields(os, msg.fields);
os << "\r\n";
Add write, async_write, operator<< for message_headers: fix #155 This adds overloads of write, async_write, and operator<< for message_headers.
2016-11-07 13:51:10 -05:00
return os;
}
Refactor HTTP identifier names (API Change): fix #171 Several names and HTTP identifiers are renamed to be more consistent, self-explanatory, and concise: * "Fields" is a collection of HTTP header fields (rfc7230 section 3.2) * "Header" is the Start Line plus Fields. Another way to look at it is, the HTTP message minus the body. * `basic_fields` replaces `basic_headers` * `fields` replaces `headers` * `Fields` replaces `Headers` in template parameter lists * `header` replaces `message_headers` * `header::fields` replaces `message_headers::fields` The changes are cosmetic and do not affect run-time behavior.
2016-11-10 05:34:49 -05:00
template<bool isRequest, class Body, class Fields>
Refactor beast core, http, tests, and examples: * Fix warnings * Port cmake scripts to linux * Add command line options for running test suites * Add examples to CMakeLists * Return std::uint64_t from writer::content_length * basic_parser::write takes asio::const_buffer instead of pointer and size * Turn message test back on now that it passes * Rename to http::headers, use std::allocator, remove http_headers * http::message::method is now a string * Refactor to_string for ConstBufferSequence * Remove chunk_encode from the public interface * Initialize members for default constructed iterators * Disallow default construction for dependent buffer sequences Refactor http::message serialization: * Serialization no longer creates a copy of the headers and modifies them * New function prepare(), sets Connection, Transfer-Encoding, Content-Length based on the body attributes and caller options. Callers can use prepare() to have the fields set automatically, or they can set the fields manually. * Use write for operator<< * Tests for serialization
2016-04-29 06:04:40 -04:00
std::ostream&
operator<<(std::ostream& os,
Refactor HTTP identifier names (API Change): fix #171 Several names and HTTP identifiers are renamed to be more consistent, self-explanatory, and concise: * "Fields" is a collection of HTTP header fields (rfc7230 section 3.2) * "Header" is the Start Line plus Fields. Another way to look at it is, the HTTP message minus the body. * `basic_fields` replaces `basic_headers` * `fields` replaces `headers` * `Fields` replaces `Headers` in template parameter lists * `header` replaces `message_headers` * `header::fields` replaces `message_headers::fields` The changes are cosmetic and do not affect run-time behavior.
2016-11-10 05:34:49 -05:00
message<isRequest, Body, Fields> const& msg)
Refactor beast core, http, tests, and examples: * Fix warnings * Port cmake scripts to linux * Add command line options for running test suites * Add examples to CMakeLists * Return std::uint64_t from writer::content_length * basic_parser::write takes asio::const_buffer instead of pointer and size * Turn message test back on now that it passes * Rename to http::headers, use std::allocator, remove http_headers * http::message::method is now a string * Refactor to_string for ConstBufferSequence * Remove chunk_encode from the public interface * Initialize members for default constructed iterators * Disallow default construction for dependent buffer sequences Refactor http::message serialization: * Serialization no longer creates a copy of the headers and modifies them * New function prepare(), sets Connection, Transfer-Encoding, Content-Length based on the body attributes and caller options. Callers can use prepare() to have the fields set automatically, or they can set the fields manually. * Use write for operator<< * Tests for serialization
2016-04-29 06:04:40 -04:00
{
Refactor type_traits (API Change): fix #373 * concepts.hpp is renamed to type_traits.hpp * Body reader and writer concepts are renamed
2017-05-28 09:05:29 -07:00
static_assert(is_body<Body>::value,
Rework HTTP concepts (API Change): fix #139, fix #140 * Writer uses write instead of operator() * Refactor traits to use void_t * Remove is_ReadableBody, is_WritableBody * Add has_reader, has_writer, is_Reader, is_Writer * More friendly compile errors on failed concept checks
2016-10-15 13:40:17 -04:00
"Body requirements not met");
Refactor type_traits (API Change): fix #373 * concepts.hpp is renamed to type_traits.hpp * Body reader and writer concepts are renamed
2017-05-28 09:05:29 -07:00
static_assert(is_body_reader<Body>::value,
"BodyReader requirements not met");
Move sync_ostream to core/detail
2016-11-07 06:33:03 -05:00
beast::detail::sync_ostream oss{os};
Refactor beast core, http, tests, and examples: * Fix warnings * Port cmake scripts to linux * Add command line options for running test suites * Add examples to CMakeLists * Return std::uint64_t from writer::content_length * basic_parser::write takes asio::const_buffer instead of pointer and size * Turn message test back on now that it passes * Rename to http::headers, use std::allocator, remove http_headers * http::message::method is now a string * Refactor to_string for ConstBufferSequence * Remove chunk_encode from the public interface * Initialize members for default constructed iterators * Disallow default construction for dependent buffer sequences Refactor http::message serialization: * Serialization no longer creates a copy of the headers and modifies them * New function prepare(), sets Connection, Transfer-Encoding, Content-Length based on the body attributes and caller options. Callers can use prepare() to have the fields set automatically, or they can set the fields manually. * Use write for operator<< * Tests for serialization
2016-04-29 06:04:40 -04:00
error_code ec;
write(oss, msg, ec);
if(ec && ec != boost::asio::error::eof)
Use BOOST_THROW_EXCEPTION fix #370
2017-05-22 15:30:12 -07:00
BOOST_THROW_EXCEPTION(system_error{ec});
Refactor beast core, http, tests, and examples: * Fix warnings * Port cmake scripts to linux * Add command line options for running test suites * Add examples to CMakeLists * Return std::uint64_t from writer::content_length * basic_parser::write takes asio::const_buffer instead of pointer and size * Turn message test back on now that it passes * Rename to http::headers, use std::allocator, remove http_headers * http::message::method is now a string * Refactor to_string for ConstBufferSequence * Remove chunk_encode from the public interface * Initialize members for default constructed iterators * Disallow default construction for dependent buffer sequences Refactor http::message serialization: * Serialization no longer creates a copy of the headers and modifies them * New function prepare(), sets Connection, Transfer-Encoding, Content-Length based on the body attributes and caller options. Callers can use prepare() to have the fields set automatically, or they can set the fields manually. * Use write for operator<< * Tests for serialization
2016-04-29 06:04:40 -04:00
return os;
}
Truncate history, version 1.0.0-b2
2017-07-20 08:01:46 -07:00
} // http
} // beast
#endif
Copy Permalink