townforge/beast
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Implement asio dealloc-before-invoke guarantee:

Browse Source 
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.
This commit is contained in:
Vinnie Falco 2017-01-02 13:29:48 -05:00
parent 1a26484eca
commit 01e1fa2dc9
21 changed files with 574 additions and 322 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
CHANGELOG.md
View File

@ -1,6 +1,7 @@
1.0.0-b22
* Fix broken Intellisense
* Implement the Asio deallocation-before-invocation guarantee
--------------------------------------------------------------------------------

1
doc/quickref.xml
View File

@ -174,6 +174,7 @@
<member><link linkend="beast.ref.error_code">error_code</link></member>
<member><link linkend="beast.ref.error_condition">error_condition</link></member>
<member><link linkend="beast.ref.handler_alloc">handler_alloc</link></member>
<member><link linkend="beast.ref.handler_ptr">handler_ptr</link></member>
<member><link linkend="beast.ref.static_streambuf">static_streambuf</link></member>
<member><link linkend="beast.ref.static_streambuf_n">static_streambuf_n</link></member>
<member><link linkend="beast.ref.static_string">static_string</link></member>

26
examples/http_async_server.hpp
View File

@ -12,6 +12,7 @@
#include "mime_type.hpp"
#include <beast/http.hpp>
#include <beast/core/handler_ptr.hpp>
#include <beast/core/placeholders.hpp>
#include <beast/core/streambuf.hpp>
#include <boost/asio.hpp>
@ -93,24 +94,21 @@ private:
struct data
{
bool cont;
Stream& s;
message<isRequest, Body, Fields> m;
Handler h;
bool cont;
template<class DeducedHandler>
data(DeducedHandler&& h_, Stream& s_,
data(Handler& handler, Stream& s_,
message<isRequest, Body, Fields>&& m_)
: s(s_)
: cont(boost_asio_handler_cont_helpers::
is_continuation(handler))
, s(s_)
, m(std::move(m_))
, h(std::forward<DeducedHandler>(h_))
, cont(boost_asio_handler_cont_helpers::
is_continuation(h))
{
}
};
std::shared_ptr<data> d_;
handler_ptr<data, Handler> d_;
public:
write_op(write_op&&) = default;
@ -118,7 +116,7 @@ private:
template<class DeducedHandler, class... Args>
write_op(DeducedHandler&& h, Stream& s, Args&&... args)
: d_(std::allocate_shared<data>(alloc_type{h},
: d_(make_handler_ptr<data, Handler>(
std::forward<DeducedHandler>(h), s,
std::forward<Args>(args)...))
{
@ -135,7 +133,7 @@ private:
beast::http::async_write(d.s, d.m, std::move(*this));
return;
}
d.h(ec);
d_.invoke(ec);
}
friend
@ -143,7 +141,7 @@ private:
std::size_t size, write_op* op)
{
return boost_asio_handler_alloc_helpers::
allocate(size, op->d_->h);
allocate(size, op->d_.handler());
}
friend
@ -151,7 +149,7 @@ private:
void* p, std::size_t size, write_op* op)
{
return boost_asio_handler_alloc_helpers::
deallocate(p, size, op->d_->h);
deallocate(p, size, op->d_.handler());
}
friend
@ -165,7 +163,7 @@ private:
void asio_handler_invoke(Function&& f, write_op* op)
{
return boost_asio_handler_invoke_helpers::
invoke(f, op->d_->h);
invoke(f, op->d_.handler());
}
};

173
include/beast/core/handler_ptr.hpp Normal file
View File

@ -0,0 +1,173 @@
//
// Copyright (c) 2013-2016 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_HANDLER_PTR_HPP
#define BEAST_HANDLER_PTR_HPP
#include <beast/core/detail/type_traits.hpp>
#include <atomic>
#include <cstdint>
#include <utility>
namespace beast {
/** A smart pointer container.
This is a smart pointer that retains shared ownership of an
object through a pointer. Memory is managed using the allocation
and deallocation functions associated with a completion handler,
which is also stored in the object. The object is destroyed and
its memory deallocated when one of the following happens:
@li The function @ref invoke is called.
@li The function @ref release_handler is called
@li The last remaining container owning the object is destroyed
Objects of this type are used in the implementation of
composed operations. Typically the composed operation's shared
state is managed by the @ref handler_ptr and an allocator
associated with the final handler is used to create the managed
object.
@note The reference count is stored using a 16 bit unsigned
integer. Making more than 2^16 copies of one object results
in undefined behavior.
*/
template<class T, class Handler>
class handler_ptr
{
struct P
{
T* t;
std::atomic<std::uint16_t> n;
// There's no way to put the handler anywhere else
// without exposing ourselves to race conditions
// and all sorts of ugliness.
// See:
// https://github.com/vinniefalco/Beast/issues/215
Handler handler;
template<class DeducedHandler, class... Args>
P(DeducedHandler&& handler, Args&&... args);
};
P* p_;
template<class DeducedHandler, class... Args>
handler_ptr(int, DeducedHandler&& handler, Args&&... args);
public:
/// The type of handler this object stores
using handler_type = Handler;
/// Copy assignment (disallowed).
handler_ptr& operator=(handler_ptr const&) = delete;
/** Destructs the owned object if no more @ref handler_ptr link to it.
If `*this` owns an object and it is the last @ref handler_ptr
owning it, the object is destroyed and the memory deallocated
using the associated deallocator.
*/
~handler_ptr();
/** Move constructor.
When this call returns, the moved-from container
will have no owned object.
*/
handler_ptr(handler_ptr&& other);
/// Copy constructor
handler_ptr(handler_ptr const& other);
/// Returns a reference to the handler
handler_type&
handler() const
{
return p_->handler;
}
/// Returns a pointer to the owned object
T*
get() const
{
return p_->t;
}
/// Return a reference to the owned object.
T&
operator*() const
{
return *get();
}
/// Return a pointer to the owned object.
T*
operator->() const
{
return get();
}
/** Release ownership of the handler
If `*this` owns an object, it is first destroyed.
@return The released handler.
*/
handler_type
release_handler();
/** Invoke the handler in the owned object.
This function invokes the handler in the owned object
with a forwarded argument list. Before the invocation,
the owned object is destroyed, satisfying the
deallocation-before-invocation Asio guarantee. All
instances of @ref handler_ptr which refer to the
same owned object will be reset, including this instance.
*/
template<class... Args>
void
invoke(Args&&... args);
// VFALCO The free function interface works around
// a horrible Visual Studio 15 Update 3 bug
/** Construct a new `handler_ptr`.
@param handler The handler. The allocator associated with
the handler will be used to allocate memory for the owned
object. This argument will be forwarded to the owned object's
constructor.
@param args Optional arguments forwarded to
the owned object's constructor.
*/
/** @{ */
template<class U, class CompletionHandler, class... Args>
friend
handler_ptr<U, CompletionHandler>
make_handler_ptr(
CompletionHandler&& handler, Args&&... args);
template<class U, class CompletionHandler, class... Args>
friend
handler_ptr<U, CompletionHandler>
make_handler_ptr(
CompletionHandler const& handler, Args&&... args);
/** @} */
};
} // beast
#include <beast/core/impl/handler_ptr.ipp>
#endif

22
include/beast/core/impl/dynabuf_readstream.ipp
View File

@ -12,6 +12,7 @@
#include <beast/core/error.hpp>
#include <beast/core/handler_concepts.hpp>
#include <beast/core/handler_alloc.hpp>
#include <beast/core/handler_ptr.hpp>
namespace beast {
@ -23,25 +24,22 @@ class dynabuf_readstream<
using alloc_type =
handler_alloc<char, Handler>;
// VFALCO What about bool cont for is_continuation?
struct data
{
dynabuf_readstream& srs;
MutableBufferSequence bs;
Handler h;
int state = 0;
template<class DeducedHandler>
data(DeducedHandler&& h_,
dynabuf_readstream& srs_,
data(Handler&, dynabuf_readstream& srs_,
MutableBufferSequence const& bs_)
: srs(srs_)
, bs(bs_)
, h(std::forward<DeducedHandler>(h_))
{
}
};
std::shared_ptr<data> d_;
handler_ptr<data, Handler> d_;
public:
read_some_op(read_some_op&&) = default;
@ -50,7 +48,7 @@ public:
template<class DeducedHandler, class... Args>
read_some_op(DeducedHandler&& h,
dynabuf_readstream& srs, Args&&... args)
: d_(std::allocate_shared<data>(alloc_type{h},
: d_(make_handler_ptr<data, Handler>(
std::forward<DeducedHandler>(h), srs,
std::forward<Args>(args)...))
{
@ -66,7 +64,7 @@ public:
std::size_t size, read_some_op* op)
{
return boost_asio_handler_alloc_helpers::
allocate(size, op->d_->h);
allocate(size, op->d_.handler());
}
friend
@ -74,14 +72,14 @@ public:
void* p, std::size_t size, read_some_op* op)
{
return boost_asio_handler_alloc_helpers::
deallocate(p, size, op->d_->h);
deallocate(p, size, op->d_.handler());
}
friend
bool asio_handler_is_continuation(read_some_op* op)
{
return boost_asio_handler_cont_helpers::
is_continuation(op->d_->h);
is_continuation(op->d_.handler());
}
template<class Function>
@ -89,7 +87,7 @@ public:
void asio_handler_invoke(Function&& f, read_some_op* op)
{
return boost_asio_handler_invoke_helpers::
invoke(f, op->d_->h);
invoke(f, op->d_.handler());
}
};
@ -149,7 +147,7 @@ read_some_op<MutableBufferSequence, Handler>::operator()(
break;
}
}
d.h(ec, bytes_transferred);
d_.invoke(ec, bytes_transferred);
}
//------------------------------------------------------------------------------

137
include/beast/core/impl/handler_ptr.ipp Normal file
View File

@ -0,0 +1,137 @@
//
// Copyright (c) 2013-2016 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_IMPL_HANDLER_PTR_HPP
#define BEAST_IMPL_HANDLER_PTR_HPP
#include <boost/asio/detail/handler_alloc_helpers.hpp>
#include <boost/assert.hpp>
#include <memory>
namespace beast {
template<class T, class Handler>
template<class DeducedHandler, class... Args>
inline
handler_ptr<T, Handler>::P::
P(DeducedHandler&& h, Args&&... args)
: n(1)
, handler(std::forward<DeducedHandler>(h))
{
t = reinterpret_cast<T*>(
boost_asio_handler_alloc_helpers::
allocate(sizeof(T), handler));
try
{
t = new(t) T{handler,
std::forward<Args>(args)...};
}
catch(...)
{
boost_asio_handler_alloc_helpers::
deallocate(t, sizeof(T), handler);
throw;
}
}
template<class T, class Handler>
template<class DeducedHandler, class... Args>
handler_ptr<T, Handler>::
handler_ptr(int, DeducedHandler&& handler, Args&&... args)
: p_(new P(std::forward<DeducedHandler>(handler),
std::forward<Args>(args)...))
{
}
template<class T, class Handler>
handler_ptr<T, Handler>::
~handler_ptr()
{
if(! p_)
return;
if(--p_->n)
return;
if(p_->t)
{
p_->t->~T();
boost_asio_handler_alloc_helpers::
deallocate(p_->t, sizeof(T), p_->handler);
}
delete p_;
}
template<class T, class Handler>
handler_ptr<T, Handler>::
handler_ptr(handler_ptr&& other)
: p_(other.p_)
{
other.p_ = nullptr;
}
template<class T, class Handler>
handler_ptr<T, Handler>::
handler_ptr(handler_ptr const& other)
: p_(other.p_)
{
if(p_)
++p_->n;
}
template<class T, class Handler>
auto
handler_ptr<T, Handler>::
release_handler() ->
handler_type
{
BOOST_ASSERT(p_);
BOOST_ASSERT(p_->t);
p_->t->~T();
boost_asio_handler_alloc_helpers::
deallocate(p_->t, sizeof(T), p_->handler);
p_->t = nullptr;
return std::move(p_->handler);
}
template<class T, class Handler>
template<class... Args>
void
handler_ptr<T, Handler>::
invoke(Args&&... args)
{
BOOST_ASSERT(p_);
BOOST_ASSERT(p_->t);
p_->t->~T();
boost_asio_handler_alloc_helpers::
deallocate(p_->t, sizeof(T), p_->handler);
p_->t = nullptr;
p_->handler(std::forward<Args>(args)...);
}
template<
class T, class CompletionHandler, class... Args>
handler_ptr<T, CompletionHandler>
make_handler_ptr(
CompletionHandler&& handler, Args&&... args)
{
return handler_ptr<T, CompletionHandler>{0,
std::move(handler),
std::forward<Args>(args)...};
}
template<
class T, class CompletionHandler, class... Args>
handler_ptr<T, CompletionHandler>
make_handler_ptr(
CompletionHandler const& handler, Args&&... args)
{
return handler_ptr<T, CompletionHandler>{0,
handler, std::forward<Args>(args)...};
}
} // beast
#endif

29
include/beast/http/impl/parse.ipp
View File

@ -11,6 +11,7 @@
#include <beast/http/concepts.hpp>
#include <beast/core/bind_handler.hpp>
#include <beast/core/handler_alloc.hpp>
#include <beast/core/handler_ptr.hpp>
#include <beast/core/stream_concepts.hpp>
#include <boost/assert.hpp>
@ -23,34 +24,28 @@ template<class Stream,
class DynamicBuffer, class Parser, class Handler>
class parse_op
{
using alloc_type =
handler_alloc<char, Handler>;
struct data
{
bool cont;
Stream& s;
DynamicBuffer& db;
Parser& p;
Handler h;
bool got_some = false;
bool cont;
int state = 0;
template<class DeducedHandler>
data(DeducedHandler&& h_, Stream& s_,
data(Handler& handler, Stream& s_,
DynamicBuffer& sb_, Parser& p_)
: s(s_)
: cont(boost_asio_handler_cont_helpers::
is_continuation(handler))
, s(s_)
, db(sb_)
, p(p_)
, h(std::forward<DeducedHandler>(h_))
, cont(boost_asio_handler_cont_helpers::
is_continuation(h))
{
BOOST_ASSERT(! p.complete());
}
};
std::shared_ptr<data> d_;
handler_ptr<data, Handler> d_;
public:
parse_op(parse_op&&) = default;
@ -58,7 +53,7 @@ public:
template<class DeducedHandler, class... Args>
parse_op(DeducedHandler&& h, Stream& s, Args&&... args)
: d_(std::allocate_shared<data>(alloc_type{h},
: d_(make_handler_ptr<data, Handler>(
std::forward<DeducedHandler>(h), s,
std::forward<Args>(args)...))
{
@ -74,7 +69,7 @@ public:
std::size_t size, parse_op* op)
{
return boost_asio_handler_alloc_helpers::
allocate(size, op->d_->h);
allocate(size, op->d_.handler());
}
friend
@ -82,7 +77,7 @@ public:
void* p, std::size_t size, parse_op* op)
{
return boost_asio_handler_alloc_helpers::
deallocate(p, size, op->d_->h);
deallocate(p, size, op->d_.handler());
}
friend
@ -96,7 +91,7 @@ public:
void asio_handler_invoke(Function&& f, parse_op* op)
{
return boost_asio_handler_invoke_helpers::
invoke(f, op->d_->h);
invoke(f, op->d_.handler());
}
};
@ -214,7 +209,7 @@ operator()(error_code ec, std::size_t bytes_transferred, bool again)
}
}
}
d.h(ec);
d_.invoke(ec);
}
} // detail

57
include/beast/http/impl/read.ipp
View File

@ -14,6 +14,7 @@
#include <beast/http/parser_v1.hpp>
#include <beast/core/bind_handler.hpp>
#include <beast/core/handler_alloc.hpp>
#include <beast/core/handler_ptr.hpp>
#include <beast/core/stream_concepts.hpp>
#include <boost/assert.hpp>
@ -27,9 +28,6 @@ template<class Stream, class DynamicBuffer,
class Handler>
class read_header_op
{
using alloc_type =
handler_alloc<char, Handler>;
using parser_type =
header_parser_v1<isRequest, Fields>;
@ -38,29 +36,26 @@ class read_header_op
struct data
{
bool cont;
Stream& s;
DynamicBuffer& db;
message_type& m;
parser_type p;
Handler h;
bool started = false;
bool cont;
int state = 0;
template<class DeducedHandler>
data(DeducedHandler&& h_, Stream& s_,
data(Handler& handler, Stream& s_,
DynamicBuffer& sb_, message_type& m_)
: s(s_)
: cont(boost_asio_handler_cont_helpers::
is_continuation(handler))
, s(s_)
, db(sb_)
, m(m_)
, h(std::forward<DeducedHandler>(h_))
, cont(boost_asio_handler_cont_helpers::
is_continuation(h))
{
}
};
std::shared_ptr<data> d_;
handler_ptr<data, Handler> d_;
public:
read_header_op(read_header_op&&) = default;
@ -69,7 +64,7 @@ public:
template<class DeducedHandler, class... Args>
read_header_op(
DeducedHandler&& h, Stream& s, Args&&... args)
: d_(std::allocate_shared<data>(alloc_type{h},
: d_(make_handler_ptr<data, Handler>(
std::forward<DeducedHandler>(h), s,
std::forward<Args>(args)...))
{
@ -84,7 +79,7 @@ public:
std::size_t size, read_header_op* op)
{
return boost_asio_handler_alloc_helpers::
allocate(size, op->d_->h);
allocate(size, op->d_.handler());
}
friend
@ -92,7 +87,7 @@ public:
void* p, std::size_t size, read_header_op* op)
{
return boost_asio_handler_alloc_helpers::
deallocate(p, size, op->d_->h);
deallocate(p, size, op->d_.handler());
}
friend
@ -106,7 +101,7 @@ public:
void asio_handler_invoke(Function&& f, read_header_op* op)
{
return boost_asio_handler_invoke_helpers::
invoke(f, op->d_->h);
invoke(f, op->d_.handler());
}
};
@ -135,7 +130,7 @@ operator()(error_code ec, bool again)
break;
}
}
d.h(ec);
d_.invoke(ec);
}
} // detail
@ -206,9 +201,6 @@ template<class Stream, class DynamicBuffer,
class Handler>
class read_op
{
using alloc_type =
handler_alloc<char, Handler>;
using parser_type =
parser_v1<isRequest, Body, Fields>;
@ -217,29 +209,26 @@ class read_op
struct data
{
bool cont;
Stream& s;
DynamicBuffer& db;
message_type& m;
parser_type p;
Handler h;
bool started = false;
bool cont;
int state = 0;
template<class DeducedHandler>
data(DeducedHandler&& h_, Stream& s_,
data(Handler& handler, Stream& s_,
DynamicBuffer& sb_, message_type& m_)
: s(s_)
: cont(boost_asio_handler_cont_helpers::
is_continuation(handler))
, s(s_)
, db(sb_)
, m(m_)
, h(std::forward<DeducedHandler>(h_))
, cont(boost_asio_handler_cont_helpers::
is_continuation(h))
{
}
};
std::shared_ptr<data> d_;
handler_ptr<data, Handler> d_;
public:
read_op(read_op&&) = default;
@ -247,7 +236,7 @@ public:
template<class DeducedHandler, class... Args>
read_op(DeducedHandler&& h, Stream& s, Args&&... args)
: d_(std::allocate_shared<data>(alloc_type{h},
: d_(make_handler_ptr<data, Handler>(
std::forward<DeducedHandler>(h), s,
std::forward<Args>(args)...))
{
@ -262,7 +251,7 @@ public:
std::size_t size, read_op* op)
{
return boost_asio_handler_alloc_helpers::
allocate(size, op->d_->h);
allocate(size, op->d_.handler());
}
friend
@ -270,7 +259,7 @@ public:
void* p, std::size_t size, read_op* op)
{
return boost_asio_handler_alloc_helpers::
deallocate(p, size, op->d_->h);
deallocate(p, size, op->d_.handler());
}
friend
@ -284,7 +273,7 @@ public:
void asio_handler_invoke(Function&& f, read_op* op)
{
return boost_asio_handler_invoke_helpers::
invoke(f, op->d_->h);
invoke(f, op->d_.handler());
}
};
@ -313,7 +302,7 @@ operator()(error_code ec, bool again)
break;
}
}
d.h(ec);
d_.invoke(ec);
}
} // detail

71
include/beast/http/impl/write.ipp
View File

@ -15,6 +15,7 @@
#include <beast/core/bind_handler.hpp>
#include <beast/core/buffer_concepts.hpp>
#include <beast/core/handler_alloc.hpp>
#include <beast/core/handler_ptr.hpp>
#include <beast/core/stream_concepts.hpp>
#include <beast/core/streambuf.hpp>
#include <beast/core/write_dynabuf.hpp>
@ -99,30 +100,24 @@ namespace detail {
template<class Stream, class Handler>
class write_streambuf_op
{
using alloc_type =
handler_alloc<char, Handler>;
struct data
{
bool cont;
Stream& s;
streambuf sb;
Handler h;
bool cont;
int state = 0;
template<class DeducedHandler>
data(DeducedHandler&& h_, Stream& s_,
data(Handler& handler, Stream& s_,
streambuf&& sb_)
: s(s_)
: cont(boost_asio_handler_cont_helpers::
is_continuation(handler))
, s(s_)
, sb(std::move(sb_))
, h(std::forward<DeducedHandler>(h_))
, cont(boost_asio_handler_cont_helpers::
is_continuation(h))
{
}
};
std::shared_ptr<data> d_;
handler_ptr<data, Handler> d_;
public:
write_streambuf_op(write_streambuf_op&&) = default;
@ -131,19 +126,13 @@ public:
template<class DeducedHandler, class... Args>
write_streambuf_op(DeducedHandler&& h, Stream& s,
Args&&... args)
: d_(std::allocate_shared<data>(alloc_type{h},
std::forward<DeducedHandler>(h), s,
std::forward<Args>(args)...))
: d_(make_handler_ptr<data, Handler>(
std::forward<DeducedHandler>(h),
s, std::forward<Args>(args)...))
{
(*this)(error_code{}, 0, false);
}
explicit
write_streambuf_op(std::shared_ptr<data> d)
: d_(std::move(d))
{
}
void
operator()(error_code ec,
std::size_t bytes_transferred, bool again = true);
@ -153,7 +142,7 @@ public:
std::size_t size, write_streambuf_op* op)
{
return boost_asio_handler_alloc_helpers::
allocate(size, op->d_->h);
allocate(size, op->d_.handler());
}
friend
@ -161,7 +150,7 @@ public:
void* p, std::size_t size, write_streambuf_op* op)
{
return boost_asio_handler_alloc_helpers::
deallocate(p, size, op->d_->h);
deallocate(p, size, op->d_.handler());
}
friend
@ -175,7 +164,7 @@ public:
void asio_handler_invoke(Function&& f, write_streambuf_op* op)
{
return boost_asio_handler_invoke_helpers::
invoke(f, op->d_->h);
invoke(f, op->d_.handler());
}
};
@ -199,7 +188,7 @@ operator()(error_code ec, std::size_t, bool again)
}
}
}
d.h(ec);
d_.invoke(ec);
}
} // detail
@ -301,29 +290,23 @@ template<class Stream, class Handler,
bool isRequest, class Body, class Fields>
class write_op
{
using alloc_type =
handler_alloc<char, Handler>;
struct data
{
bool cont;
Stream& s;
// VFALCO How do we use handler_alloc in write_preparation?
write_preparation<
isRequest, Body, Fields> wp;
Handler h;
resume_context resume;
resume_context copy;
bool cont;
int state = 0;
template<class DeducedHandler>
data(DeducedHandler&& h_, Stream& s_,
data(Handler& handler, Stream& s_,
message<isRequest, Body, Fields> const& m_)
: s(s_)
: cont(boost_asio_handler_cont_helpers::
is_continuation(handler))
, s(s_)
, wp(m_)
, h(std::forward<DeducedHandler>(h_))
, cont(boost_asio_handler_cont_helpers::
is_continuation(h))
{
}
};
@ -382,7 +365,7 @@ class write_op
}
};
std::shared_ptr<data> d_;
handler_ptr<data, Handler> d_;
public:
write_op(write_op&&) = default;
@ -390,7 +373,7 @@ public:
template<class DeducedHandler, class... Args>
write_op(DeducedHandler&& h, Stream& s, Args&&... args)
: d_(std::allocate_shared<data>(alloc_type{h},
: d_(make_handler_ptr<data, Handler>(
std::forward<DeducedHandler>(h), s,
std::forward<Args>(args)...))
{
@ -410,7 +393,7 @@ public:
}
explicit
write_op(std::shared_ptr<data> d)
write_op(handler_ptr<data, Handler> d)
: d_(std::move(d))
{
}
@ -424,7 +407,7 @@ public:
std::size_t size, write_op* op)
{
return boost_asio_handler_alloc_helpers::
allocate(size, op->d_->h);
allocate(size, op->d_.handler());
}
friend
@ -432,7 +415,7 @@ public:
void* p, std::size_t size, write_op* op)
{
return boost_asio_handler_alloc_helpers::
deallocate(p, size, op->d_->h);
deallocate(p, size, op->d_.handler());
}
friend
@ -446,7 +429,7 @@ public:
void asio_handler_invoke(Function&& f, write_op* op)
{
return boost_asio_handler_invoke_helpers::
invoke(f, op->d_->h);
invoke(f, op->d_.handler());
}
};
@ -552,9 +535,9 @@ operator()(error_code ec, std::size_t, bool again)
break;
}
}
d.h(ec);
d.resume = {};
d.copy = {};
d.resume = {};
d_.invoke(ec);
}
template<class SyncWriteStream, class DynamicBuffer>

16
include/beast/websocket/detail/invokable.hpp
View File

@ -8,6 +8,7 @@
#ifndef BEAST_WEBSOCKET_DETAIL_INVOKABLE_HPP
#define BEAST_WEBSOCKET_DETAIL_INVOKABLE_HPP
#include <beast/core/handler_ptr.hpp>
#include <boost/assert.hpp>
#include <array>
#include <memory>
@ -64,8 +65,19 @@ class invokable
struct exemplar
{
std::shared_ptr<int> _;
void operator()(){}
struct H
{
void operator()();
};
struct T
{
using handler_type = H;
};
handler_ptr<T, H> hp;
void operator()();
};
using buf_type = char[sizeof(holder<exemplar>)];

70
include/beast/websocket/impl/accept.ipp
View File

@ -14,6 +14,7 @@
#include <beast/http/string_body.hpp>
#include <beast/http/write.hpp>
#include <beast/core/handler_alloc.hpp>
#include <beast/core/handler_ptr.hpp>
#include <beast/core/prepare_buffers.hpp>
#include <beast/core/detail/type_traits.hpp>
#include <boost/assert.hpp>
@ -30,27 +31,21 @@ template<class NextLayer>
template<class Handler>
class stream<NextLayer>::response_op
{
using alloc_type =
handler_alloc<char, Handler>;
struct data
{
bool cont;
stream<NextLayer>& ws;
http::response<http::string_body> resp;
Handler h;
error_code final_ec;
bool cont;
int state = 0;
template<class DeducedHandler,
class Body, class Fields>
data(DeducedHandler&& h_, stream<NextLayer>& ws_,
template<class Body, class Fields>
data(Handler&, stream<NextLayer>& ws_,
http::request<Body, Fields> const& req,
bool cont_)
: ws(ws_)
: cont(cont_)
, ws(ws_)
, resp(ws_.build_response(req))
, h(std::forward<DeducedHandler>(h_))
, cont(cont_)
{
// can't call stream::reset() here
// otherwise accept_op will malfunction
@ -60,7 +55,7 @@ class stream<NextLayer>::response_op
}
};
std::shared_ptr<data> d_;
handler_ptr<data, Handler> d_;
public:
response_op(response_op&&) = default;
@ -69,7 +64,7 @@ public:
template<class DeducedHandler, class... Args>
response_op(DeducedHandler&& h,
stream<NextLayer>& ws, Args&&... args)
: d_(std::allocate_shared<data>(alloc_type{h},
: d_(make_handler_ptr<data, Handler>(
std::forward<DeducedHandler>(h), ws,
std::forward<Args>(args)...))
{
@ -84,7 +79,7 @@ public:
std::size_t size, response_op* op)
{
return boost_asio_handler_alloc_helpers::
allocate(size, op->d_->h);
allocate(size, op->d_.handler());
}
friend
@ -92,7 +87,7 @@ public:
void* p, std::size_t size, response_op* op)
{
return boost_asio_handler_alloc_helpers::
deallocate(p, size, op->d_->h);
deallocate(p, size, op->d_.handler());
}
friend
@ -106,7 +101,7 @@ public:
void asio_handler_invoke(Function&& f, response_op* op)
{
return boost_asio_handler_invoke_helpers::
invoke(f, op->d_->h);
invoke(f, op->d_.handler());
}
};
@ -138,7 +133,7 @@ operator()(error_code ec, bool again)
break;
}
}
d.h(ec);
d_.invoke(ec);
}
//------------------------------------------------------------------------------
@ -149,24 +144,19 @@ template<class NextLayer>
template<class Handler>
class stream<NextLayer>::accept_op
{
using alloc_type =
handler_alloc<char, Handler>;
struct data
{
bool cont;
stream<NextLayer>& ws;
http::request<http::string_body> req;
Handler h;
bool cont;
int state = 0;
template<class DeducedHandler, class Buffers>
data(DeducedHandler&& h_, stream<NextLayer>& ws_,
template<class Buffers>
data(Handler& handler, stream<NextLayer>& ws_,
Buffers const& buffers)
: ws(ws_)
, h(std::forward<DeducedHandler>(h_))
, cont(boost_asio_handler_cont_helpers::
is_continuation(h))
: cont(boost_asio_handler_cont_helpers::
is_continuation(handler))
, ws(ws_)
{
using boost::asio::buffer_copy;
using boost::asio::buffer_size;
@ -177,7 +167,7 @@ class stream<NextLayer>::accept_op
}
};
std::shared_ptr<data> d_;
handler_ptr<data, Handler> d_;
public:
accept_op(accept_op&&) = default;
@ -186,7 +176,7 @@ public:
template<class DeducedHandler, class... Args>
accept_op(DeducedHandler&& h,
stream<NextLayer>& ws, Args&&... args)
: d_(std::allocate_shared<data>(alloc_type{h},
: d_(make_handler_ptr<data, Handler>(
std::forward<DeducedHandler>(h), ws,
std::forward<Args>(args)...))
{
@ -206,7 +196,7 @@ public:
std::size_t size, accept_op* op)
{
return boost_asio_handler_alloc_helpers::
allocate(size, op->d_->h);
allocate(size, op->d_.handler());
}
friend
@ -214,7 +204,7 @@ public:
void* p, std::size_t size, accept_op* op)
{
return boost_asio_handler_alloc_helpers::
deallocate(p, size, op->d_->h);
deallocate(p, size, op->d_.handler());
}
friend
@ -228,7 +218,7 @@ public:
void asio_handler_invoke(Function&& f, accept_op* op)
{
return boost_asio_handler_invoke_helpers::
invoke(f, op->d_->h);
invoke(f, op->d_.handler());
}
};
@ -256,19 +246,17 @@ operator()(error_code const& ec,
// got message
case 1:
{
// respond to request
#if 1
// VFALCO I have no idea why passing std::move(*this) crashes
d.state = 99;
d.ws.async_accept(d.req, *this);
#else
auto& ws = d.ws;
auto req = std::move(d.req);
response_op<Handler>{
std::move(d.h), d.ws, d.req, true};
#endif
d_.release_handler(), ws, req, true};
return;
}
}
}
d.h(ec);
d_.invoke(ec);
}
template<class NextLayer>

26
include/beast/websocket/impl/close.ipp
View File

@ -9,6 +9,7 @@
#define BEAST_WEBSOCKET_IMPL_CLOSE_IPP
#include <beast/core/handler_alloc.hpp>
#include <beast/core/handler_ptr.hpp>
#include <beast/core/static_streambuf.hpp>
#include <beast/core/stream_concepts.hpp>
#include <memory>
@ -30,28 +31,25 @@ class stream<NextLayer>::close_op
struct data : op
{
bool cont;
stream<NextLayer>& ws;
close_reason cr;
Handler h;
fb_type fb;
bool cont;
int state = 0;
template<class DeducedHandler>
data(DeducedHandler&& h_, stream<NextLayer>& ws_,
data(Handler& handler, stream<NextLayer>& ws_,
close_reason const& cr_)
: ws(ws_)
: cont(boost_asio_handler_cont_helpers::
is_continuation(handler))
, ws(ws_)
, cr(cr_)
, h(std::forward<DeducedHandler>(h_))
, cont(boost_asio_handler_cont_helpers::
is_continuation(h))
{
ws.template write_close<
static_streambuf>(fb, cr);
}
};
std::shared_ptr<data> d_;
handler_ptr<data, Handler> d_;
public:
close_op(close_op&&) = default;
@ -60,7 +58,7 @@ public:
template<class DeducedHandler, class... Args>
close_op(DeducedHandler&& h,
stream<NextLayer>& ws, Args&&... args)
: d_(std::allocate_shared<data>(alloc_type{h},
: d_(make_handler_ptr<data, Handler>(
std::forward<DeducedHandler>(h), ws,
std::forward<Args>(args)...))
{
@ -83,7 +81,7 @@ public:
std::size_t size, close_op* op)
{
return boost_asio_handler_alloc_helpers::
allocate(size, op->d_->h);
allocate(size, op->d_.handler());
}
friend
@ -91,7 +89,7 @@ public:
void* p, std::size_t size, close_op* op)
{
return boost_asio_handler_alloc_helpers::
deallocate(p, size, op->d_->h);
deallocate(p, size, op->d_.handler());
}
friend
@ -105,7 +103,7 @@ public:
void asio_handler_invoke(Function&& f, close_op* op)
{
return boost_asio_handler_invoke_helpers::
invoke(f, op->d_->h);
invoke(f, op->d_.handler());
}
};
@ -188,7 +186,7 @@ upcall:
if(d.ws.wr_block_ == &d)
d.ws.wr_block_ = nullptr;
d.ws.rd_op_.maybe_invoke();
d.h(ec);
d_.invoke(ec);
}
template<class NextLayer>

26
include/beast/websocket/impl/handshake.ipp
View File

@ -13,6 +13,7 @@
#include <beast/http/read.hpp>
#include <beast/http/write.hpp>
#include <beast/core/handler_alloc.hpp>
#include <beast/core/handler_ptr.hpp>
#include <beast/core/stream_concepts.hpp>
#include <boost/assert.hpp>
#include <memory>
@ -33,29 +34,26 @@ class stream<NextLayer>::handshake_op
struct data
{
bool cont;
stream<NextLayer>& ws;
Handler h;
std::string key;
http::request<http::empty_body> req;
http::response<http::string_body> resp;
bool cont;
int state = 0;
template<class DeducedHandler>
data(DeducedHandler&& h_, stream<NextLayer>& ws_,
data(Handler& handler, stream<NextLayer>& ws_,
boost::string_ref const& host,
boost::string_ref const& resource)
: ws(ws_)
, h(std::forward<DeducedHandler>(h_))
: cont(boost_asio_handler_cont_helpers::
is_continuation(handler))
, ws(ws_)
, req(ws.build_request(host, resource, key))
, cont(boost_asio_handler_cont_helpers::
is_continuation(h))
{
ws.reset();
}
};
std::shared_ptr<data> d_;
handler_ptr<data, Handler> d_;
public:
handshake_op(handshake_op&&) = default;
@ -64,7 +62,7 @@ public:
template<class DeducedHandler, class... Args>
handshake_op(DeducedHandler&& h,
stream<NextLayer>& ws, Args&&... args)
: d_(std::allocate_shared<data>(alloc_type{h},
: d_(make_handler_ptr<data, Handler>(
std::forward<DeducedHandler>(h), ws,
std::forward<Args>(args)...))
{
@ -79,7 +77,7 @@ public:
std::size_t size, handshake_op* op)
{
return boost_asio_handler_alloc_helpers::
allocate(size, op->d_->h);
allocate(size, op->d_.handler());
}
friend
@ -87,7 +85,7 @@ public:
void* p, std::size_t size, handshake_op* op)
{
return boost_asio_handler_alloc_helpers::
deallocate(p, size, op->d_->h);
deallocate(p, size, op->d_.handler());
}
friend
@ -101,7 +99,7 @@ public:
void asio_handler_invoke(Function&& f, handshake_op* op)
{
return boost_asio_handler_invoke_helpers::
invoke(f, op->d_->h);
invoke(f, op->d_.handler());
}
};
@ -147,7 +145,7 @@ operator()(error_code ec, bool again)
}
}
}
d.h(ec);
d_.invoke(ec);
}
template<class NextLayer>

31
include/beast/websocket/impl/ping.ipp
View File

@ -10,6 +10,7 @@
#include <beast/core/bind_handler.hpp>
#include <beast/core/handler_alloc.hpp>
#include <beast/core/handler_ptr.hpp>
#include <beast/core/stream_concepts.hpp>
#include <beast/websocket/detail/frame.hpp>
#include <memory>
@ -25,24 +26,18 @@ template<class NextLayer>
template<class Handler>
class stream<NextLayer>::ping_op
{
using alloc_type =
handler_alloc<char, Handler>;
struct data : op
{
stream<NextLayer>& ws;
Handler h;
detail::frame_streambuf fb;
bool cont;
stream<NextLayer>& ws;
detail::frame_streambuf fb;
int state = 0;
template<class DeducedHandler>
data(DeducedHandler&& h_, stream<NextLayer>& ws_,
data(Handler& handler, stream<NextLayer>& ws_,
opcode op_, ping_data const& payload)
: ws(ws_)
, h(std::forward<DeducedHandler>(h_))
, cont(boost_asio_handler_cont_helpers::
is_continuation(h))
: cont(boost_asio_handler_cont_helpers::
is_continuation(handler))
, ws(ws_)
{
using boost::asio::buffer;
using boost::asio::buffer_copy;
@ -51,7 +46,7 @@ class stream<NextLayer>::ping_op
}
};
std::shared_ptr<data> d_;
handler_ptr<data, Handler> d_;
public:
ping_op(ping_op&&) = default;
@ -60,7 +55,7 @@ public:
template<class DeducedHandler, class... Args>
ping_op(DeducedHandler&& h,
stream<NextLayer>& ws, Args&&... args)
: d_(std::make_shared<data>(
: d_(make_handler_ptr<data, Handler>(
std::forward<DeducedHandler>(h), ws,
std::forward<Args>(args)...))
{
@ -81,7 +76,7 @@ public:
std::size_t size, ping_op* op)
{
return boost_asio_handler_alloc_helpers::
allocate(size, op->d_->h);
allocate(size, op->d_.handler());
}
friend
@ -89,7 +84,7 @@ public:
void* p, std::size_t size, ping_op* op)
{
return boost_asio_handler_alloc_helpers::
deallocate(p, size, op->d_->h);
deallocate(p, size, op->d_.handler());
}
friend
@ -103,7 +98,7 @@ public:
void asio_handler_invoke(Function&& f, ping_op* op)
{
return boost_asio_handler_invoke_helpers::
invoke(f, op->d_->h);
invoke(f, op->d_.handler());
}
};
@ -187,7 +182,7 @@ upcall:
if(d.ws.wr_block_ == &d)
d.ws.wr_block_ = nullptr;
d.ws.rd_op_.maybe_invoke();
d.h(ec);
d_.invoke(ec);
}
template<class NextLayer>

57
include/beast/websocket/impl/read.ipp
View File

@ -11,6 +11,7 @@
#include <beast/websocket/teardown.hpp>
#include <beast/core/buffer_concepts.hpp>
#include <beast/core/handler_alloc.hpp>
#include <beast/core/handler_ptr.hpp>
#include <beast/core/prepare_buffers.hpp>
#include <beast/core/static_streambuf.hpp>
#include <beast/core/stream_concepts.hpp>
@ -31,9 +32,6 @@ template<class NextLayer>
template<class DynamicBuffer, class Handler>
class stream<NextLayer>::read_frame_op
{
using alloc_type =
handler_alloc<char, Handler>;
using fb_type =
detail::frame_streambuf;
@ -45,30 +43,27 @@ class stream<NextLayer>::read_frame_op
struct data : op
{
bool cont;
stream<NextLayer>& ws;
frame_info& fi;
DynamicBuffer& db;
Handler h;
fb_type fb;
boost::optional<dmb_type> dmb;
boost::optional<fmb_type> fmb;
bool cont;
int state = 0;
template<class DeducedHandler>
data(DeducedHandler&& h_, stream<NextLayer>& ws_,
data(Handler& handler, stream<NextLayer>& ws_,
frame_info& fi_, DynamicBuffer& sb_)
: ws(ws_)
: cont(boost_asio_handler_cont_helpers::
is_continuation(handler))
, ws(ws_)
, fi(fi_)
, db(sb_)
, h(std::forward<DeducedHandler>(h_))
, cont(boost_asio_handler_cont_helpers::
is_continuation(h))
{
}
};
std::shared_ptr<data> d_;
handler_ptr<data, Handler> d_;
public:
read_frame_op(read_frame_op&&) = default;
@ -77,7 +72,7 @@ public:
template<class DeducedHandler, class... Args>
read_frame_op(DeducedHandler&& h,
stream<NextLayer>& ws, Args&&... args)
: d_(std::allocate_shared<data>(alloc_type{h},
: d_(make_handler_ptr<data, Handler>(
std::forward<DeducedHandler>(h), ws,
std::forward<Args>(args)...))
{
@ -105,7 +100,7 @@ public:
std::size_t size, read_frame_op* op)
{
return boost_asio_handler_alloc_helpers::
allocate(size, op->d_->h);
allocate(size, op->d_.handler());
}
friend
@ -113,7 +108,7 @@ public:
void* p, std::size_t size, read_frame_op* op)
{
return boost_asio_handler_alloc_helpers::
deallocate(p, size, op->d_->h);
deallocate(p, size, op->d_.handler());
}
friend
@ -127,7 +122,7 @@ public:
void asio_handler_invoke(Function&& f, read_frame_op* op)
{
return boost_asio_handler_invoke_helpers::
invoke(f, op->d_->h);
invoke(f, op->d_.handler());
}
};
@ -545,7 +540,7 @@ upcall:
if(d.ws.wr_block_ == &d)
d.ws.wr_block_ = nullptr;
d.ws.wr_op_.maybe_invoke();
d.h(ec);
d_.invoke(ec);
}
template<class NextLayer>
@ -734,34 +729,28 @@ template<class NextLayer>
template<class DynamicBuffer, class Handler>
class stream<NextLayer>::read_op
{
using alloc_type =
handler_alloc<char, Handler>;
struct data
{
bool cont;
stream<NextLayer>& ws;
opcode& op;
DynamicBuffer& db;
Handler h;
frame_info fi;
bool cont;
int state = 0;
template<class DeducedHandler>
data(DeducedHandler&& h_,
data(Handler& handler,
stream<NextLayer>& ws_, opcode& op_,
DynamicBuffer& sb_)
: ws(ws_)
: cont(boost_asio_handler_cont_helpers::
is_continuation(handler))
, ws(ws_)
, op(op_)
, db(sb_)
, h(std::forward<DeducedHandler>(h_))
, cont(boost_asio_handler_cont_helpers::
is_continuation(h))
{
}
};
std::shared_ptr<data> d_;
handler_ptr<data, Handler> d_;
public:
read_op(read_op&&) = default;
@ -770,7 +759,7 @@ public:
template<class DeducedHandler, class... Args>
read_op(DeducedHandler&& h,
stream<NextLayer>& ws, Args&&... args)
: d_(std::allocate_shared<data>(alloc_type{h},
: d_(make_handler_ptr<data, Handler>(
std::forward<DeducedHandler>(h), ws,
std::forward<Args>(args)...))
{
@ -785,7 +774,7 @@ public:
std::size_t size, read_op* op)
{
return boost_asio_handler_alloc_helpers::
allocate(size, op->d_->h);
allocate(size, op->d_.handler());
}
friend
@ -793,7 +782,7 @@ public:
void* p, std::size_t size, read_op* op)
{
return boost_asio_handler_alloc_helpers::
deallocate(p, size, op->d_->h);
deallocate(p, size, op->d_.handler());
}
friend
@ -807,7 +796,7 @@ public:
void asio_handler_invoke(Function&& f, read_op* op)
{
return boost_asio_handler_invoke_helpers::
invoke(f, op->d_->h);
invoke(f, op->d_.handler());
}
};
@ -847,7 +836,7 @@ operator()(error_code const& ec, bool again)
}
}
upcall:
d.h(ec);
d_.invoke(ec);
}
template<class NextLayer>

31
include/beast/websocket/impl/ssl.ipp
View File

@ -9,7 +9,9 @@
#define BEAST_WEBSOCKET_IMPL_SSL_IPP_INCLUDED
#include <beast/core/async_completion.hpp>
#include <beast/core/handler_alloc.hpp>
#include <beast/core/handler_concepts.hpp>
#include <beast/core/handler_ptr.hpp>
namespace beast {
namespace websocket {
@ -38,31 +40,28 @@ class teardown_ssl_op
struct data
{
stream_type& stream;
Handler h;
bool cont;
stream_type& stream;
int state = 0;
template<class DeducedHandler>
data(DeducedHandler&& h_,
stream_type& stream_)
: stream(stream_)
, h(std::forward<DeducedHandler>(h_))
, cont(boost_asio_handler_cont_helpers::
is_continuation(h))
data(Handler& handler, stream_type& stream_)
: cont(boost_asio_handler_cont_helpers::
is_continuation(handler))
, stream(stream_)
{
}
};
std::shared_ptr<data> d_;
handler_ptr<data, Handler> d_;
public:
template<class DeducedHandler>
explicit
teardown_ssl_op(
DeducedHandler&& h, stream_type& stream)
: d_(std::make_shared<data>(
std::forward<DeducedHandler>(h), stream))
: d_(make_handler_ptr<data, Handler>(
std::forward<DeducedHandler>(
h), stream))
{
(*this)(error_code{}, false);
}
@ -75,7 +74,7 @@ public:
teardown_ssl_op* op)
{
return boost_asio_handler_alloc_helpers::
allocate(size, op->d_->h);
allocate(size, op->d_.handler());
}
friend
@ -83,7 +82,7 @@ public:
std::size_t size, teardown_ssl_op* op)
{
return boost_asio_handler_alloc_helpers::
deallocate(p, size, op->d_->h);
deallocate(p, size, op->d_.handler());
}
friend
@ -99,7 +98,7 @@ public:
teardown_ssl_op* op)
{
return boost_asio_handler_invoke_helpers::
invoke(f, op->d_->h);
invoke(f, op->d_.handler());
}
};
@ -120,7 +119,7 @@ operator()(error_code ec, bool again)
return;
}
}
d.h(ec);
d_.invoke(ec);
}
} // detail

36
include/beast/websocket/impl/teardown.ipp
View File

@ -9,7 +9,9 @@
#define BEAST_WEBSOCKET_IMPL_TEARDOWN_IPP
#include <beast/core/async_completion.hpp>
#include <beast/core/handler_alloc.hpp>
#include <beast/core/handler_concepts.hpp>
#include <beast/core/handler_ptr.hpp>
#include <memory>
namespace beast {
@ -20,37 +22,37 @@ namespace detail {
template<class Handler>
class teardown_tcp_op
{
using alloc_type =
handler_alloc<char, Handler>;
using socket_type =
boost::asio::ip::tcp::socket;
struct data
{
socket_type& socket;
Handler h;
char buf[8192];
bool cont;
socket_type& socket;
char buf[2048];
int state = 0;
template<class DeducedHandler>
data(DeducedHandler&& h_, socket_type& socket_)
: socket(socket_)
, h(std::forward<DeducedHandler>(h_))
, cont(boost_asio_handler_cont_helpers::
is_continuation(h))
data(Handler& handler, socket_type& socket_)
: cont(boost_asio_handler_cont_helpers::
is_continuation(handler))
, socket(socket_)
{
}
};
std::shared_ptr<data> d_;
handler_ptr<data, Handler> d_;
public:
template<class DeducedHandler>
teardown_tcp_op(
DeducedHandler&& h,
socket_type& socket)
: d_(std::make_shared<data>(
std::forward<DeducedHandler>(h),
socket))
: d_(make_handler_ptr<data, Handler>(
std::forward<DeducedHandler>(
h), socket))
{
(*this)(error_code{}, 0, false);
}
@ -63,7 +65,7 @@ public:
teardown_tcp_op* op)
{
return boost_asio_handler_alloc_helpers::
allocate(size, op->d_->h);
allocate(size, op->d_.handler());
}
friend
@ -71,7 +73,7 @@ public:
std::size_t size, teardown_tcp_op* op)
{
return boost_asio_handler_alloc_helpers::
deallocate(p, size, op->d_->h);
deallocate(p, size, op->d_.handler());
}
friend
@ -86,7 +88,7 @@ public:
teardown_tcp_op* op)
{
return boost_asio_handler_invoke_helpers::
invoke(f, op->d_->h);
invoke(f, op->d_.handler());
}
};
@ -119,7 +121,7 @@ operator()(error_code ec, std::size_t, bool again)
d.socket.close(ec);
ec = error_code{};
}
d.h(ec);
d_.invoke(ec);
}
} // detail

75
include/beast/websocket/impl/write.ipp
View File

@ -13,6 +13,7 @@
#include <beast/core/buffer_concepts.hpp>
#include <beast/core/consuming_buffers.hpp>
#include <beast/core/handler_alloc.hpp>
#include <beast/core/handler_ptr.hpp>
#include <beast/core/prepare_buffers.hpp>
#include <beast/core/static_streambuf.hpp>
#include <beast/core/stream_concepts.hpp>
@ -97,31 +98,27 @@ template<class NextLayer>
template<class Buffers, class Handler>
class stream<NextLayer>::write_frame_op
{
using alloc_type =
handler_alloc<char, Handler>;
struct data : op
{
Handler& handler;
bool cont;
stream<NextLayer>& ws;
consuming_buffers<Buffers> cb;
Handler h;
detail::frame_header fh;
detail::fh_streambuf fh_buf;
detail::prepared_key_type key;
void* tmp;
std::size_t tmp_size;
std::uint64_t remain;
bool cont;
int state = 0;
template<class DeducedHandler>
data(DeducedHandler&& h_, stream<NextLayer>& ws_,
data(Handler& handler_, stream<NextLayer>& ws_,
bool fin, Buffers const& bs)
: ws(ws_)
, cb(bs)
, h(std::forward<DeducedHandler>(h_))
: handler(handler_)
, cont(boost_asio_handler_cont_helpers::
is_continuation(h))
is_continuation(handler))
, ws(ws_)
, cb(bs)
{
using beast::detail::clamp;
fh.op = ws.wr_.cont ?
@ -139,7 +136,7 @@ class stream<NextLayer>::write_frame_op
detail::prepare_key(key, fh.key);
tmp_size = clamp(fh.len, ws.wr_buf_size_);
tmp = boost_asio_handler_alloc_helpers::
allocate(tmp_size, h);
allocate(tmp_size, handler);
remain = fh.len;
}
else
@ -153,11 +150,11 @@ class stream<NextLayer>::write_frame_op
{
if(tmp)
boost_asio_handler_alloc_helpers::
deallocate(tmp, tmp_size, h);
deallocate(tmp, tmp_size, handler);
}
};
std::shared_ptr<data> d_;
handler_ptr<data, Handler> d_;
public:
write_frame_op(write_frame_op&&) = default;
@ -166,9 +163,9 @@ public:
template<class DeducedHandler, class... Args>
write_frame_op(DeducedHandler&& h,
stream<NextLayer>& ws, Args&&... args)
: d_(std::make_shared<data>(
std::forward<DeducedHandler>(h), ws,
std::forward<Args>(args)...))
: d_(make_handler_ptr<data, Handler>(
std::forward<DeducedHandler>(h),
ws, std::forward<Args>(args)...))
{
(*this)(error_code{}, false);
}
@ -187,7 +184,7 @@ public:
std::size_t size, write_frame_op* op)
{
return boost_asio_handler_alloc_helpers::
allocate(size, op->d_->h);
allocate(size, op->d_.handler());
}
friend
@ -195,7 +192,7 @@ public:
void* p, std::size_t size, write_frame_op* op)
{
return boost_asio_handler_alloc_helpers::
deallocate(p, size, op->d_->h);
deallocate(p, size, op->d_.handler());
}
friend
@ -209,7 +206,7 @@ public:
void asio_handler_invoke(Function&& f, write_frame_op* op)
{
return boost_asio_handler_invoke_helpers::
invoke(f, op->d_->h);
invoke(f, op->d_.handler());
}
};
@ -333,16 +330,10 @@ operator()(error_code ec, bool again)
}
}
upcall:
if(d.tmp)
{
boost_asio_handler_alloc_helpers::
deallocate(d.tmp, d.tmp_size, d.h);
d.tmp = nullptr;
}
if(d.ws.wr_block_ == &d)
d.ws.wr_block_ = nullptr;
d.ws.rd_op_.maybe_invoke();
d.h(ec);
d_.invoke(ec);
}
template<class NextLayer>
@ -532,32 +523,26 @@ template<class NextLayer>
template<class Buffers, class Handler>
class stream<NextLayer>::write_op
{
using alloc_type =
handler_alloc<char, Handler>;
struct data : op
{
bool cont;
stream<NextLayer>& ws;
consuming_buffers<Buffers> cb;
Handler h;
std::size_t remain;
bool cont;
int state = 0;
template<class DeducedHandler>
data(DeducedHandler&& h_,
stream<NextLayer>& ws_, Buffers const& bs)
: ws(ws_)
data(Handler& handler, stream<NextLayer>& ws_,
Buffers const& bs)
: cont(boost_asio_handler_cont_helpers::
is_continuation(handler))
, ws(ws_)
, cb(bs)
, h(std::forward<DeducedHandler>(h_))
, remain(boost::asio::buffer_size(cb))
, cont(boost_asio_handler_cont_helpers::
is_continuation(h))
{
}
};
std::shared_ptr<data> d_;
handler_ptr<data, Handler> d_;
public:
write_op(write_op&&) = default;
@ -567,7 +552,7 @@ public:
explicit
write_op(DeducedHandler&& h,
stream<NextLayer>& ws, Args&&... args)
: d_(std::allocate_shared<data>(alloc_type{h},
: d_(make_handler_ptr<data, Handler>(
std::forward<DeducedHandler>(h), ws,
std::forward<Args>(args)...))
{
@ -581,7 +566,7 @@ public:
std::size_t size, write_op* op)
{
return boost_asio_handler_alloc_helpers::
allocate(size, op->d_->h);
allocate(size, op->d_.handler());
}
friend
@ -589,7 +574,7 @@ public:
void* p, std::size_t size, write_op* op)
{
return boost_asio_handler_alloc_helpers::
deallocate(p, size, op->d_->h);
deallocate(p, size, op->d_.handler());
}
friend
@ -603,7 +588,7 @@ public:
void asio_handler_invoke(Function&& f, write_op* op)
{
return boost_asio_handler_invoke_helpers::
invoke(f, op->d_->h);
invoke(f, op->d_.handler());
}
};
@ -637,7 +622,7 @@ operator()(error_code ec, bool again)
break;
}
}
d.h(ec);
d_.invoke(ec);
}
template<class NextLayer>

1
test/Jamfile
View File

@ -27,6 +27,7 @@ unit-test core-tests :
core/error.cpp
core/handler_alloc.cpp
core/handler_concepts.cpp
core/handler_ptr.cpp
core/placeholders.cpp
core/prepare_buffers.cpp
core/static_streambuf.cpp

1
test/core/CMakeLists.txt
View File

@ -22,6 +22,7 @@ add_executable (core-tests
error.cpp
handler_alloc.cpp
handler_concepts.cpp
handler_ptr.cpp
placeholders.cpp
prepare_buffers.cpp
static_streambuf.cpp

9
test/core/handler_ptr.cpp Normal file
View File

@ -0,0 +1,9 @@
//
// Copyright (c) 2013-2016 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)
//
// Test that header file is self-contained.
#include <beast/core/handler_ptr.hpp>