Relax the requirements of Handlers to MoveConstructible

[marton78]

(See also https://svn.boost.org/trac/boost/ticket/8714)
(See also http://stackoverflow.com/questions/17211263)

The requirement that handlers be CopyConstructible doesn't allow for the following idiom:

void connection::send_response()
{
    // block until previous response is sent
    std::unique_lock<std::mutex> locker(response_mutex_);

    // prepare response
    response_ = "foo";

    // send response back to caller. move the unique_lock into the binder
    // to keep the mutex locked until asio is done sending.
    asio::async_write(stream_,
                      asio::const_buffers_1(response_.data(), response_.size()),
                      std::bind(&connection::response_sent, shared_from_this(),
                                _1, _2, std::move(locker))
                      );
}

void connection::response_sent(const boost::system::error_code& err, std::size_t len)
{
    if (err) handle_error(err);
    // the mutex is unlocked when the binder is destroyed
}

Please remove this restriction, there is no reason for it when using C++11.

[vinniefalco]

Correct me if I'm wrong but asio often makes copies of handlers, for example to have a context in which to call asio_handler_invoke or the other hooks such as allocation. I don't see how it is possible to do away with the CopyConstructible requirement but on the other hand I'm no expert - I'd love to know if this is right.

[marton78]

Just have a look at the accepted answer in the above mentioned SO post. There I provide a wrapper which declares but never defines copy construction and assignment. Hence, asio ever actually using them would result in a link error. With all recent compilers my projects link fine, but of course there might be some more involved scenario where asio makes copies, but it was never instantiated by my code. If you find an example, please go ahead and comment on SO or here, I'd be very interested!

[vinniefalco]

Here for example:
https://github.com/chriskohlhoff/asio/blob/master/asio/include/asio/detail/wrapped_handler.hpp#L159

The reason you don't get link errors is because you don't call io_service::wrap.

[marton78]

Looks like a bug to me. I guess there should be two ampersands in line 162.

[chriskohlhoff]

The master branch supports move-only handlers.

N.B. The new executor infrastructure is required to enable this support, and consequently move-only handlers are not possible under the old asio_handler_invoke scheme. This is because certain uses (such as strands and wrapped handlers) need multiple copies of the handler. With executors, this need is satisfied by making a copy of the executor instead of the handler.

[vinniefalco]

Brilliant

[rustyx]

But what about io_service::post() which still cannot accept instances of std::packaged_task? (#99)
In practice no copy is ever made.

[marton78]

@rustyx in that case you can use this workaround here

[vinniefalco]

@marton78 Have you seen Beast? https://github.com/vinniefalco/Beast/