Refactor chunked-encoding serialization:

New buffer sequence classes are provided to allow full
control over the serialization of chunk-encoded message
payloads:

* chunk_header

    A ConstBufferSequence representing the chunk header.
    It includes a hexadecimal-encoded size, an optional
    set of chunk extensions, and the trailing CRLF
    required to denote the end of the chunk header.

    This allows the caller to manually serialize the chunk
    body in one or more calls to a stream output function.
    The caller must also output an object of type `chunk_crlf`
    to the stream to indicate the end of the chunk body.

* chunk_crlf

    A small ConstBufferSequence that simply represents
    the two character sequence "\r\n" (CRLF). This is needed
    for the case where the caller wants to output a chunk
    body as a series of buffers (i.e. "chunking a chunk").

* chunk_body

    A ConstBufferSequence representing a complete chunk.
    This includes the size, an optional set of chunk extensions,
    a caller provided buffer containing the body, and the
    required CRLF that follows.

* chunk_final

    A ConstBufferSequence representing a final chunk. It
    includes an optional set of caller-provided field trailers

* chunk_extensions

    A container for building a set of chunk extensions to use
    during serialization. The use of the container is optional,
    callers may provide their own buffer containing a correctly
    formatted set of chunk extensions, or they may use their
    own convenience container which meets the requirements.

The basic_fields container is modified to allow construction
outside the context of a message. The container can be used
to provide trailers to `chunk_final`.

Actions Required:

* Remove references to ChunkDecorators. Use the new chunk-encoding
  buffer sequences to manually produce a chunked payload body in
  the case where control over the chunk-extensions and/or trailers
  is required.
This commit is contained in:
Vinnie Falco committed 2017-07-20 08:15:31 -07:00
1 parent 02de2e5cbb
commit ff15cf8688
69 files changed
+2312 -686

No files matched your search

+283
View File
@@ -0,0 +1,283 @@
//
// Copyright (c) 2013-2017 Vinnie Falco (vinnie dot falco at gmail dot com)
//
// 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_CHUNK_ENCODE_IPP
#define BEAST_HTTP_IMPL_CHUNK_ENCODE_IPP
#include <beast/http/detail/rfc7230.hpp>
namespace beast {
namespace http {
inline
chunk_header::
chunk_header(std::size_t size)
: view_(
size,
boost::asio::const_buffers_1{nullptr, 0},
chunk_crlf{})
{
BOOST_ASSERT(size > 0);
}
inline
chunk_header::
chunk_header(
std::size_t size,
string_view extensions)
: view_(
size,
boost::asio::const_buffers_1{
extensions.data(), extensions.size()},
chunk_crlf{})
{
BOOST_ASSERT(size > 0);
}
template<class ChunkExtensions, class>
chunk_header::
chunk_header(
std::size_t size,
ChunkExtensions&& extensions)
: exts_(std::make_shared<detail::chunk_extensions_impl<
typename std::decay<ChunkExtensions>::type>>(
std::forward<ChunkExtensions>(extensions)))
, view_(
size,
exts_->str(),
chunk_crlf{})
{
static_assert(
detail::is_chunk_extensions<ChunkExtensions>::value,
"ChunkExtensions requirements not met");
BOOST_ASSERT(size > 0);
}
template<class ChunkExtensions, class Allocator, class>
chunk_header::
chunk_header(
std::size_t size,
ChunkExtensions&& extensions,
Allocator const& allocator)
: exts_(std::allocate_shared<detail::chunk_extensions_impl<
typename std::decay<ChunkExtensions>::type>>(allocator,
std::forward<ChunkExtensions>(extensions)))
, view_(
size,
exts_->str(),
chunk_crlf{})
{
static_assert(
detail::is_chunk_extensions<ChunkExtensions>::value,
"ChunkExtensions requirements not met");
BOOST_ASSERT(size > 0);
}
//------------------------------------------------------------------------------
template<class ConstBufferSequence>
chunk_body<ConstBufferSequence>::
chunk_body(ConstBufferSequence const& buffers)
: view_(
boost::asio::buffer_size(buffers),
boost::asio::const_buffers_1{nullptr, 0},
chunk_crlf{},
buffers,
chunk_crlf{})
{
}
template<class ConstBufferSequence>
chunk_body<ConstBufferSequence>::
chunk_body(
ConstBufferSequence const& buffers,
string_view extensions)
: view_(
boost::asio::buffer_size(buffers),
boost::asio::const_buffers_1{
extensions.data(), extensions.size()},
chunk_crlf{},
buffers,
chunk_crlf{})
{
}
template<class ConstBufferSequence>
template<class ChunkExtensions, class>
chunk_body<ConstBufferSequence>::
chunk_body(
ConstBufferSequence const& buffers,
ChunkExtensions&& extensions)
: exts_(std::make_shared<detail::chunk_extensions_impl<
typename std::decay<ChunkExtensions>::type>>(
std::forward<ChunkExtensions>(extensions)))
, view_(
boost::asio::buffer_size(buffers),
exts_->str(),
chunk_crlf{},
buffers,
chunk_crlf{})
{
}
template<class ConstBufferSequence>
template<class ChunkExtensions, class Allocator, class>
chunk_body<ConstBufferSequence>::
chunk_body(
ConstBufferSequence const& buffers,
ChunkExtensions&& extensions,
Allocator const& allocator)
: exts_(std::allocate_shared<detail::chunk_extensions_impl<
typename std::decay<ChunkExtensions>::type>>(allocator,
std::forward<ChunkExtensions>(extensions)))
, view_(
boost::asio::buffer_size(buffers),
exts_->str(),
chunk_crlf{},
buffers,
chunk_crlf{})
{
}
//------------------------------------------------------------------------------
template<class Trailer>
template<class Allocator>
auto
chunk_last<Trailer>::
prepare(Trailer const& trailer, Allocator const& allocator) ->
buffers_type
{
auto sp = std::allocate_shared<typename
Trailer::reader>(allocator, trailer);
sp_ = sp;
return sp->get();
}
template<class Trailer>
auto
chunk_last<Trailer>::
prepare(Trailer const& trailer, std::true_type) ->
buffers_type
{
auto sp = std::make_shared<
typename Trailer::reader>(trailer);
sp_ = sp;
return sp->get();
}
template<class Trailer>
auto
chunk_last<Trailer>::
prepare(Trailer const& trailer, std::false_type) ->
buffers_type
{
return trailer;
}
template<class Trailer>
chunk_last<Trailer>::
chunk_last()
: view_(
detail::chunk_size0{},
Trailer{})
{
}
template<class Trailer>
chunk_last<Trailer>::
chunk_last(Trailer const& trailer)
: view_(
detail::chunk_size0{},
prepare(trailer, is_fields<Trailer>{}))
{
}
template<class Trailer>
template<class DeducedTrailer, class Allocator, class>
chunk_last<Trailer>::
chunk_last(
DeducedTrailer const& trailer, Allocator const& allocator)
: view_(
detail::chunk_size0{},
prepare(trailer, allocator))
{
}
//------------------------------------------------------------------------------
template<class Allocator>
void
basic_chunk_extensions<Allocator>::
insert(string_view name)
{
/*
chunk-ext = *( ";" chunk-ext-name [ "=" chunk-ext-val ] )
*/
s_.reserve(1 + name.size());
s_.push_back(';');
s_.append(name.data(), name.size());
}
template<class Allocator>
void
basic_chunk_extensions<Allocator>::
insert(string_view name, string_view value)
{
/*
chunk-ext = *( ";" chunk-ext-name [ "=" chunk-ext-val ] )
chunk-ext-name = token
chunk-ext-val = token / quoted-string
token = 1*tchar
quoted-string = DQUOTE *( qdtext / quoted-pair ) DQUOTE
qdtext = HTAB / SP / "!" / %x23-5B ; '#'-'[' / %x5D-7E ; ']'-'~' / obs-text
quoted-pair = "\" ( HTAB / SP / VCHAR / obs-text )
obs-text = %x80-FF
*/
bool is_token = true;
for(auto const c : value)
{
if(! detail::is_tchar(c))
{
is_token = false;
break;
}
}
if(is_token)
{
s_.reserve(1 + name.size() + 1 + value.size());
s_.push_back(';');
s_.append(name.data(), name.size());
s_.push_back('=');
s_.append(value.data(), value.size());
return;
}
// quoted-string
s_.reserve(
1 + name.size() + 1 +
1 + value.size() + 20 + 1);
s_.push_back(';');
s_.append(name.data(), name.size());
s_.append("=\"", 2);
for(auto const c : value)
{
if(c == '\\')
s_.append(R"(\\)", 2);
else if(c == '\"')
s_.append(R"(\")", 2);
else
s_.push_back(c);
}
s_.push_back('"');
}
} // http
} // beast
#endif
+42 -22
View File
@@ -11,10 +11,11 @@
#include <beast/core/buffer_cat.hpp>
#include <beast/core/string.hpp>
#include <beast/core/static_string.hpp>
#include <beast/core/detail/buffers_ref.hpp>
#include <beast/http/verb.hpp>
#include <beast/http/rfc7230.hpp>
#include <beast/http/status.hpp>
#include <beast/http/detail/chunk_encode.hpp>
#include <beast/http/chunk_encode.hpp>
#include <boost/throw_exception.hpp>
#include <stdexcept>
#include <string>
@@ -140,18 +141,20 @@ public:
}
};
using view_type = buffer_cat_view<
boost::asio::const_buffers_1,
boost::asio::const_buffers_1,
boost::asio::const_buffers_1,
field_range,
chunk_crlf>;
basic_fields const& f_;
boost::asio::const_buffer cb_[3];
boost::optional<view_type> view_;
char buf_[13];
public:
using const_buffers_type =
buffer_cat_view<
boost::asio::const_buffers_1,
boost::asio::const_buffers_1,
boost::asio::const_buffers_1,
field_range,
boost::asio::const_buffers_1>;
beast::detail::buffers_ref<view_type>;
reader(basic_fields const& f,
unsigned version, verb v);
@@ -159,18 +162,28 @@ public:
reader(basic_fields const& f,
unsigned version, unsigned code);
reader(basic_fields const& f);
const_buffers_type
get() const
{
return buffer_cat(
boost::asio::const_buffers_1{cb_[0]},
boost::asio::const_buffers_1{cb_[1]},
boost::asio::const_buffers_1{cb_[2]},
field_range(f_.list_.begin(), f_.list_.end()),
detail::chunk_crlf());
return const_buffers_type(*view_);
}
};
template<class Allocator>
basic_fields<Allocator>::reader::
reader(basic_fields const& f)
: f_(f)
{
view_.emplace(
boost::asio::const_buffers_1{nullptr, 0},
boost::asio::const_buffers_1{nullptr, 0},
boost::asio::const_buffers_1{nullptr, 0},
field_range(f_.list_.begin(), f_.list_.end()),
chunk_crlf());
}
template<class Allocator>
basic_fields<Allocator>::reader::
reader(basic_fields const& f,
@@ -188,12 +201,8 @@ reader(basic_fields const& f,
sv = f_.get_method_impl();
else
sv = to_string(v);
cb_[0] = {sv.data(), sv.size()};
// target_or_reason_ has a leading SP
cb_[1] = {
f_.target_or_reason_.data(),
f_.target_or_reason_.size()};
buf_[0] = ' ';
buf_[1] = 'H';
@@ -206,7 +215,15 @@ reader(basic_fields const& f,
buf_[8] = '0' + static_cast<char>(version % 10);
buf_[9] = '\r';
buf_[10]= '\n';
cb_[2] = {buf_, 11};
view_.emplace(
boost::asio::const_buffers_1{sv.data(), sv.size()},
boost::asio::const_buffers_1{
f_.target_or_reason_.data(),
f_.target_or_reason_.size()},
boost::asio::const_buffers_1{buf_, 11},
field_range(f_.list_.begin(), f_.list_.end()),
chunk_crlf());
}
template<class Allocator>
@@ -234,16 +251,19 @@ reader(basic_fields const& f,
buf_[10]= '0' + static_cast<char>((code / 10) % 10);
buf_[11]= '0' + static_cast<char>(code % 10);
buf_[12]= ' ';
cb_[0] = {buf_, 13};
string_view sv;
if(! f_.target_or_reason_.empty())
sv = f_.target_or_reason_;
else
sv = obsolete_reason(static_cast<status>(code));
cb_[1] = {sv.data(), sv.size()};
cb_[2] = detail::chunk_crlf();
view_.emplace(
boost::asio::const_buffers_1{buf_, 13},
boost::asio::const_buffers_1{sv.data(), sv.size()},
boost::asio::const_buffers_1{"\r\n", 2},
field_range(f_.list_.begin(), f_.list_.end()),
chunk_crlf{});
}
//------------------------------------------------------------------------------
+34 -32
View File
@@ -30,7 +30,7 @@ namespace beast {
namespace http {
namespace detail {
template<class, class, bool, class, class>
template<class, class, bool, class>
class write_some_win32_op;
} // detail
@@ -50,16 +50,16 @@ struct basic_file_body<file_win32>
friend class writer;
friend struct basic_file_body<file_win32>;
template<class, class, bool, class, class>
template<class, class, bool, class>
friend class detail::write_some_win32_op;
template<class Protocol, bool isRequest,
class Fields, class Decorator>
template<
class Protocol, bool isRequest, class Fields>
friend
void
write_some(
boost::asio::basic_stream_socket<Protocol>& sock,
serializer<isRequest, basic_file_body<file_win32>,
Fields, Decorator>& sr,
serializer<isRequest,
basic_file_body<file_win32>, Fields>& sr,
error_code& ec);
file_win32 file_;
@@ -99,16 +99,16 @@ struct basic_file_body<file_win32>
class reader
{
template<class, class, bool, class, class>
template<class, class, bool, class>
friend class detail::write_some_win32_op;
template<class Protocol, bool isRequest,
class Fields, class Decorator>
template<
class Protocol, bool isRequest, class Fields>
friend
void
write_some(
boost::asio::basic_stream_socket<Protocol>& sock,
serializer<isRequest, basic_file_body<file_win32>,
Fields, Decorator>& sr,
serializer<isRequest,
basic_file_body<file_win32>, Fields>& sr,
error_code& ec);
value_type& body_; // The body we are reading from
@@ -329,13 +329,14 @@ public:
#if BOOST_ASIO_HAS_WINDOWS_OVERLAPPED_PTR
template<class Protocol, class Handler,
bool isRequest, class Fields, class Decorator>
template<
class Protocol, class Handler,
bool isRequest, class Fields>
class write_some_win32_op
{
boost::asio::basic_stream_socket<Protocol>& sock_;
serializer<isRequest, basic_file_body<file_win32>,
Fields, Decorator>& sr_;
serializer<isRequest,
basic_file_body<file_win32>, Fields>& sr_;
bool header_ = false;
Handler h_;
@@ -347,8 +348,8 @@ public:
write_some_win32_op(
DeducedHandler&& h,
boost::asio::basic_stream_socket<Protocol>& s,
serializer<isRequest, basic_file_body<file_win32>,
Fields, Decorator>& sr)
serializer<isRequest,
basic_file_body<file_win32>,Fields>& sr)
: sock_(s)
, sr_(sr)
, h_(std::forward<DeducedHandler>(h))
@@ -398,11 +399,12 @@ public:
}
};
template<class Protocol, class Handler,
bool isRequest, class Fields, class Decorator>
template<
class Protocol, class Handler,
bool isRequest, class Fields>
void
write_some_win32_op<
Protocol, Handler, isRequest, Fields, Decorator>::
Protocol, Handler, isRequest, Fields>::
operator()()
{
if(! sr_.is_header_done())
@@ -449,11 +451,12 @@ operator()()
overlapped.release();
}
template<class Protocol, class Handler,
bool isRequest, class Fields, class Decorator>
template<
class Protocol, class Handler,
bool isRequest, class Fields>
void
write_some_win32_op<
Protocol, Handler,isRequest, Fields, Decorator>::
Protocol, Handler, isRequest, Fields>::
operator()(error_code ec, std::size_t bytes_transferred)
{
if(! ec)
@@ -484,13 +487,12 @@ operator()(error_code ec, std::size_t bytes_transferred)
//------------------------------------------------------------------------------
template<class Protocol,
bool isRequest, class Fields, class Decorator>
template<class Protocol, bool isRequest, class Fields>
void
write_some(
boost::asio::basic_stream_socket<Protocol>& sock,
serializer<isRequest, basic_file_body<file_win32>,
Fields, Decorator>& sr,
serializer<isRequest,
basic_file_body<file_win32>, Fields>& sr,
error_code& ec)
{
if(! sr.is_header_done())
@@ -552,20 +554,20 @@ write_some(
template<
class Protocol,
bool isRequest, class Fields, class Decorator,
bool isRequest, class Fields,
class WriteHandler>
async_return_type<WriteHandler, void(error_code)>
async_write_some(
boost::asio::basic_stream_socket<Protocol>& sock,
serializer<isRequest, basic_file_body<file_win32>,
Fields, Decorator>& sr,
serializer<isRequest,
basic_file_body<file_win32>, Fields>& sr,
WriteHandler&& handler)
{
async_completion<WriteHandler,
void(error_code)> init{handler};
detail::write_some_win32_op<Protocol, handler_type<
WriteHandler, void(error_code)>, isRequest, Fields,
Decorator>{init.completion_handler, sock, sr}();
WriteHandler, void(error_code)>, isRequest, Fields>{
init.completion_handler, sock, sr}();
return init.result.get();
}
+43 -102
View File
@@ -18,30 +18,30 @@
namespace beast {
namespace http {
template<bool isRequest, class Body,
class Fields, class ChunkDecorator>
template<
bool isRequest, class Body, class Fields>
void
serializer<isRequest, Body, Fields, ChunkDecorator>::
serializer<isRequest, Body, Fields>::
frdinit(std::true_type)
{
frd_.emplace(m_, m_.version, m_.method());
}
template<bool isRequest, class Body,
class Fields, class ChunkDecorator>
template<
bool isRequest, class Body, class Fields>
void
serializer<isRequest, Body, Fields, ChunkDecorator>::
serializer<isRequest, Body, Fields>::
frdinit(std::false_type)
{
frd_.emplace(m_, m_.version, m_.result_int());
}
template<bool isRequest, class Body,
class Fields, class ChunkDecorator>
template<
bool isRequest, class Body, class Fields>
template<class T1, class T2, class Visit>
inline
void
serializer<isRequest, Body, Fields, ChunkDecorator>::
serializer<isRequest, Body, Fields>::
do_visit(error_code& ec, Visit& visit)
{
// VFALCO work-around for missing variant::emplace
@@ -54,30 +54,20 @@ do_visit(error_code& ec, Visit& visit)
//------------------------------------------------------------------------------
template<bool isRequest, class Body,
class Fields, class ChunkDecorator>
serializer<isRequest, Body, Fields, ChunkDecorator>::
template<
bool isRequest, class Body, class Fields>
serializer<isRequest, Body, Fields>::
serializer(value_type& m)
: m_(m)
, rd_(m_)
{
}
template<bool isRequest, class Body,
class Fields, class ChunkDecorator>
serializer<isRequest, Body, Fields, ChunkDecorator>::
serializer(value_type& m, ChunkDecorator const& d)
: m_(m)
, rd_(m_)
, d_(d)
{
}
template<bool isRequest, class Body,
class Fields, class ChunkDecorator>
template<
bool isRequest, class Body, class Fields>
template<class Visit>
void
serializer<isRequest, Body, Fields, ChunkDecorator>::
serializer<isRequest, Body, Fields>::
next(error_code& ec, Visit&& visit)
{
using boost::asio::buffer_size;
@@ -177,46 +167,25 @@ next(error_code& ec, Visit&& visit)
v_ = cb7_t{
boost::in_place_init,
frd_->get(),
detail::chunk_header{
buffer_size(result->first)},
[&]()
{
auto sv = d_(result->first);
return boost::asio::const_buffers_1{
sv.data(), sv.size()};
}(),
detail::chunk_crlf(),
buffer_size(result->first),
boost::asio::const_buffers_1{nullptr, 0},
chunk_crlf{},
result->first,
detail::chunk_crlf(),
detail::chunk_final(),
[&]()
{
auto sv = d_(
boost::asio::null_buffers{});
return boost::asio::const_buffers_1{
sv.data(), sv.size()};
}(),
detail::chunk_crlf()};
chunk_crlf{},
detail::chunk_last(),
boost::asio::const_buffers_1{nullptr, 0},
chunk_crlf{}};
goto go_all_c;
}
#endif
v_ = cb4_t{
boost::in_place_init,
frd_->get(),
detail::chunk_header{
buffer_size(result->first)},
[&]()
{
auto sv = d_(result->first);
return boost::asio::const_buffers_1{
sv.data(), sv.size()};
}(),
detail::chunk_crlf(),
buffer_size(result->first),
boost::asio::const_buffers_1{nullptr, 0},
chunk_crlf{},
result->first,
detail::chunk_crlf()};
chunk_crlf{}};
s_ = do_header_c;
BEAST_FALLTHROUGH;
}
@@ -250,45 +219,24 @@ next(error_code& ec, Visit&& visit)
// do it all in one buffer
v_ = cb6_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()};
}(),
detail::chunk_crlf(),
buffer_size(result->first),
boost::asio::const_buffers_1{nullptr, 0},
chunk_crlf{},
result->first,
detail::chunk_crlf(),
detail::chunk_final(),
[&]()
{
auto sv = d_(
boost::asio::null_buffers{});
return boost::asio::const_buffers_1{
sv.data(), sv.size()};
}(),
detail::chunk_crlf()};
chunk_crlf{},
detail::chunk_last(),
boost::asio::const_buffers_1{nullptr, 0},
chunk_crlf{}};
goto go_body_final_c;
}
#endif
v_ = cb5_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()};
}(),
detail::chunk_crlf(),
buffer_size(result->first),
boost::asio::const_buffers_1{nullptr, 0},
chunk_crlf{},
result->first,
detail::chunk_crlf()};
chunk_crlf{}};
s_ = do_body_c + 2;
BEAST_FALLTHROUGH;
}
@@ -315,16 +263,9 @@ next(error_code& ec, Visit&& visit)
case do_final_c:
v_ = cb8_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()};
detail::chunk_last(),
boost::asio::const_buffers_1{nullptr, 0},
chunk_crlf{}};
s_ = do_final_c + 1;
BEAST_FALLTHROUGH;
@@ -345,10 +286,10 @@ next(error_code& ec, Visit&& visit)
}
}
template<bool isRequest, class Body,
class Fields, class ChunkDecorator>
template<
bool isRequest, class Body, class Fields>
void
serializer<isRequest, Body, Fields, ChunkDecorator>::
serializer<isRequest, Body, Fields>::
consume(std::size_t n)
{
using boost::asio::buffer_size;
+110 -102
View File
@@ -28,13 +28,13 @@ namespace beast {
namespace http {
namespace detail {
template<class Stream, class Handler,
bool isRequest, class Body,
class Fields, class Decorator>
template<
class Stream, class Handler,
bool isRequest, class Body, class Fields>
class write_some_op
{
Stream& s_;
serializer<isRequest,Body, Fields, Decorator>& sr_;
serializer<isRequest,Body, Fields>& sr_;
Handler h_;
class lambda
@@ -67,9 +67,8 @@ public:
write_some_op(write_some_op const&) = default;
template<class DeducedHandler>
write_some_op(DeducedHandler&& h,
Stream& s, serializer<isRequest, Body,
Fields, Decorator>& sr)
write_some_op(DeducedHandler&& h, Stream& s,
serializer<isRequest, Body, Fields>& sr)
: s_(s)
, sr_(sr)
, h_(std::forward<DeducedHandler>(h))
@@ -118,12 +117,12 @@ public:
}
};
template<class Stream, class Handler,
bool isRequest, class Body,
class Fields, class Decorator>
template<
class Stream, class Handler,
bool isRequest, class Body, class Fields>
void
write_some_op<Stream, Handler,
isRequest, Body, Fields, Decorator>::
write_some_op<
Stream, Handler, isRequest, Body, Fields>::
operator()()
{
error_code ec;
@@ -150,12 +149,12 @@ operator()()
bind_handler(std::move(*this), ec, 0));
}
template<class Stream, class Handler,
bool isRequest, class Body,
class Fields, class Decorator>
template<
class Stream, class Handler,
bool isRequest, class Body, class Fields>
void
write_some_op<Stream, Handler,
isRequest, Body, Fields, Decorator>::
write_some_op<
Stream, Handler, isRequest, Body, Fields>::
operator()(
error_code ec, std::size_t bytes_transferred)
{
@@ -173,11 +172,11 @@ operator()(
struct serializer_is_header_done
{
template<bool isRequest, class Body,
class Fields, class Decorator>
template<
bool isRequest, class Body, class Fields>
bool
operator()(serializer<isRequest, Body,
Fields, Decorator>& sr) const
operator()(
serializer<isRequest, Body, Fields>& sr) const
{
return sr.is_header_done();
}
@@ -185,11 +184,11 @@ struct serializer_is_header_done
struct serializer_is_done
{
template<bool isRequest, class Body,
class Fields, class Decorator>
template<
bool isRequest, class Body, class Fields>
bool
operator()(serializer<isRequest, Body,
Fields, Decorator>& sr) const
operator()(
serializer<isRequest, Body, Fields>& sr) const
{
return sr.is_done();
}
@@ -199,14 +198,12 @@ struct serializer_is_done
template<
class Stream, class Handler, class Predicate,
bool isRequest, class Body,
class Fields, class Decorator>
bool isRequest, class Body, class Fields>
class write_op
{
int state_ = 0;
Stream& s_;
serializer<isRequest,
Body, Fields, Decorator>& sr_;
serializer<isRequest, Body, Fields>& sr_;
Handler h_;
public:
@@ -215,8 +212,7 @@ public:
template<class DeducedHandler>
write_op(DeducedHandler&& h, Stream& s,
serializer<isRequest, Body, Fields,
Decorator>& sr)
serializer<isRequest, Body, Fields>& sr)
: s_(s)
, sr_(sr)
, h_(std::forward<DeducedHandler>(h))
@@ -265,11 +261,10 @@ public:
template<
class Stream, class Handler, class Predicate,
bool isRequest, class Body,
class Fields, class Decorator>
bool isRequest, class Body, class Fields>
void
write_op<Stream, Handler, Predicate,
isRequest, Body, Fields, Decorator>::
isRequest, Body, Fields>::
operator()(error_code ec)
{
if(ec)
@@ -317,13 +312,12 @@ class write_msg_op
struct data
{
Stream& s;
serializer<isRequest,
Body, Fields, no_chunk_decorator> sr;
serializer<isRequest, Body, Fields> sr;
data(Handler&, Stream& s_, message<
isRequest, Body, Fields>& m_)
: s(s_)
, sr(m_, no_chunk_decorator{})
, sr(m_)
{
}
};
@@ -466,11 +460,11 @@ namespace detail {
template<
class SyncWriteStream,
bool isRequest, class Body, class Fields, class Decorator>
bool isRequest, class Body, class Fields>
void
write_some(
SyncWriteStream& stream, serializer<
isRequest, Body, Fields, Decorator>& sr,
SyncWriteStream& stream,
serializer<isRequest, Body, Fields>& sr,
error_code& ec)
{
if(! sr.is_done())
@@ -492,30 +486,34 @@ write_some(
ec.assign(0, ec.category());
}
template<class AsyncWriteStream,
template<
class AsyncWriteStream,
bool isRequest, class Body, class Fields,
class Decorator, class WriteHandler>
class WriteHandler>
async_return_type<WriteHandler, void(error_code)>
async_write_some(AsyncWriteStream& stream, serializer<
isRequest, Body, Fields, Decorator>& sr,
WriteHandler&& handler)
async_write_some(
AsyncWriteStream& stream,
serializer<isRequest, Body, Fields>& sr,
WriteHandler&& handler)
{
async_completion<WriteHandler,
void(error_code)> init{handler};
detail::write_some_op<AsyncWriteStream,
handler_type<WriteHandler, void(error_code)>,
isRequest, Body, Fields, Decorator>{
isRequest, Body, Fields>{
init.completion_handler, stream, sr}();
return init.result.get();
}
} // detail
template<class SyncWriteStream, bool isRequest,
class Body, class Fields, class Decorator>
template<
class SyncWriteStream,
bool isRequest, class Body, class Fields>
void
write_some(SyncWriteStream& stream, serializer<
isRequest, Body, Fields, Decorator>& sr)
write_some(
SyncWriteStream& stream,
serializer<isRequest, Body, Fields>& sr)
{
static_assert(is_sync_write_stream<SyncWriteStream>::value,
"SyncWriteStream requirements not met");
@@ -529,13 +527,14 @@ write_some(SyncWriteStream& stream, serializer<
BOOST_THROW_EXCEPTION(system_error{ec});
}
template<class SyncWriteStream,
bool isRequest, class Body, class Fields,
class Decorator>
template<
class SyncWriteStream,
bool isRequest, class Body, class Fields>
void
write_some(SyncWriteStream& stream, serializer<
isRequest, Body, Fields, Decorator>& sr,
error_code& ec)
write_some(
SyncWriteStream& stream,
serializer<isRequest, Body, Fields>& sr,
error_code& ec)
{
static_assert(is_sync_write_stream<SyncWriteStream>::value,
"SyncWriteStream requirements not met");
@@ -546,13 +545,15 @@ write_some(SyncWriteStream& stream, serializer<
detail::write_some(stream, sr, ec);
}
template<class AsyncWriteStream,
template<
class AsyncWriteStream,
bool isRequest, class Body, class Fields,
class Decorator, class WriteHandler>
class WriteHandler>
async_return_type<WriteHandler, void(error_code)>
async_write_some(AsyncWriteStream& stream, serializer<
isRequest, Body, Fields, Decorator>& sr,
WriteHandler&& handler)
async_write_some(
AsyncWriteStream& stream,
serializer<isRequest, Body, Fields>& sr,
WriteHandler&& handler)
{
static_assert(is_async_write_stream<
AsyncWriteStream>::value,
@@ -567,12 +568,12 @@ async_write_some(AsyncWriteStream& stream, serializer<
//------------------------------------------------------------------------------
template<class SyncWriteStream,
bool isRequest, class Body, class Fields,
class Decorator>
template<
class SyncWriteStream,
bool isRequest, class Body, class Fields>
void
write_header(SyncWriteStream& stream, serializer<
isRequest, Body, Fields, Decorator>& sr)
write_header(SyncWriteStream& stream,
serializer<isRequest, Body, Fields>& sr)
{
static_assert(is_sync_write_stream<SyncWriteStream>::value,
"SyncWriteStream requirements not met");
@@ -586,13 +587,14 @@ write_header(SyncWriteStream& stream, serializer<
BOOST_THROW_EXCEPTION(system_error{ec});
}
template<class SyncWriteStream,
bool isRequest, class Body, class Fields,
class Decorator>
template<
class SyncWriteStream,
bool isRequest, class Body, class Fields>
void
write_header(SyncWriteStream& stream, serializer<
isRequest, Body, Fields, Decorator>& sr,
error_code& ec)
write_header(
SyncWriteStream& stream,
serializer<isRequest, Body, Fields>& sr,
error_code& ec)
{
static_assert(is_sync_write_stream<SyncWriteStream>::value,
"SyncWriteStream requirements not met");
@@ -620,13 +622,15 @@ write_header(SyncWriteStream& stream, serializer<
}
}
template<class AsyncWriteStream,
template<
class AsyncWriteStream,
bool isRequest, class Body, class Fields,
class Decorator, class WriteHandler>
class WriteHandler>
async_return_type<WriteHandler, void(error_code)>
async_write_header(AsyncWriteStream& stream, serializer<
isRequest, Body, Fields, Decorator>& sr,
WriteHandler&& handler)
async_write_header(
AsyncWriteStream& stream,
serializer<isRequest, Body, Fields>& sr,
WriteHandler&& handler)
{
static_assert(is_async_write_stream<
AsyncWriteStream>::value,
@@ -641,7 +645,7 @@ async_write_header(AsyncWriteStream& stream, serializer<
detail::write_op<AsyncWriteStream, handler_type<
WriteHandler, void(error_code)>,
detail::serializer_is_header_done,
isRequest, Body, Fields, Decorator>{
isRequest, Body, Fields>{
init.completion_handler, stream, sr}(
error_code{}, 0);
return init.result.get();
@@ -651,12 +655,11 @@ async_write_header(AsyncWriteStream& stream, serializer<
template<
class SyncWriteStream,
bool isRequest, class Body,
class Fields, class Decorator>
bool isRequest, class Body, class Fields>
void
write(
SyncWriteStream& stream,
serializer<isRequest, Body, Fields, Decorator>& sr)
serializer<isRequest, Body, Fields>& sr)
{
static_assert(is_sync_write_stream<SyncWriteStream>::value,
"SyncWriteStream requirements not met");
@@ -668,12 +671,11 @@ write(
template<
class SyncWriteStream,
bool isRequest, class Body,
class Fields, class Decorator>
bool isRequest, class Body, class Fields>
void
write(
SyncWriteStream& stream,
serializer<isRequest, Body, Fields, Decorator>& sr,
serializer<isRequest, Body, Fields>& sr,
error_code& ec)
{
static_assert(is_sync_write_stream<SyncWriteStream>::value,
@@ -689,13 +691,15 @@ write(
}
}
template<class AsyncWriteStream,
template<
class AsyncWriteStream,
bool isRequest, class Body, class Fields,
class Decorator, class WriteHandler>
class WriteHandler>
async_return_type<WriteHandler, void(error_code)>
async_write(AsyncWriteStream& stream, serializer<
isRequest, Body, Fields, Decorator>& sr,
WriteHandler&& handler)
async_write(
AsyncWriteStream& stream,
serializer<isRequest, Body, Fields>& sr,
WriteHandler&& handler)
{
static_assert(is_async_write_stream<
AsyncWriteStream>::value,
@@ -709,19 +713,19 @@ async_write(AsyncWriteStream& stream, serializer<
void(error_code)> init{handler};
detail::write_op<AsyncWriteStream, handler_type<
WriteHandler, void(error_code)>,
detail::serializer_is_done,
isRequest, Body, Fields, Decorator>{
init.completion_handler, stream, sr}(
error_code{});
detail::serializer_is_done, isRequest, Body, Fields>{
init.completion_handler, stream, sr}(error_code{});
return init.result.get();
}
//------------------------------------------------------------------------------
template<class SyncWriteStream,
template<
class SyncWriteStream,
bool isRequest, class Body, class Fields>
void
write(SyncWriteStream& stream,
write(
SyncWriteStream& stream,
message<isRequest, Body, Fields> const& msg)
{
static_assert(is_sync_write_stream<SyncWriteStream>::value,
@@ -736,12 +740,14 @@ write(SyncWriteStream& stream,
BOOST_THROW_EXCEPTION(system_error{ec});
}
template<class SyncWriteStream,
template<
class SyncWriteStream,
bool isRequest, class Body, class Fields>
void
write(SyncWriteStream& stream,
write(
SyncWriteStream& stream,
message<isRequest, Body, Fields> const& msg,
error_code& ec)
error_code& ec)
{
static_assert(is_sync_write_stream<SyncWriteStream>::value,
"SyncWriteStream requirements not met");
@@ -753,14 +759,16 @@ write(SyncWriteStream& stream,
write(stream, sr, ec);
}
template<class AsyncWriteStream,
template<
class AsyncWriteStream,
bool isRequest, class Body, class Fields,
class WriteHandler>
class WriteHandler>
async_return_type<
WriteHandler, void(error_code)>
async_write(AsyncWriteStream& stream,
async_write(
AsyncWriteStream& stream,
message<isRequest, Body, Fields>& msg,
WriteHandler&& handler)
WriteHandler&& handler)
{
static_assert(
is_async_write_stream<AsyncWriteStream>::value,