(Deprecated: Use the associated_executor trait.) Default invoke function for handlers.

Default handler invocation hook used for non-const function objects.

template<
    typename Function>
asio_handler_invoke_is_deprecated asio_handler_invoke(
    Function & function,
    ... );
  » more...

Default handler invocation hook used for const function objects.

template<
    typename Function>
asio_handler_invoke_is_deprecated asio_handler_invoke(
    const Function & function,
    ... );
  » more...

Completion handlers for asynchronous operations are invoked by the io_context associated with the corresponding object (e.g. a socket or deadline_timer). Certain guarantees are made on when the handler may be invoked, in particular that a handler can only be invoked from a thread that is currently calling run() on the corresponding io_context object. Handlers may subsequently be invoked through other objects (such as io_context::strand objects) that provide additional guarantees.

When asynchronous operations are composed from other asynchronous operations, all intermediate handlers should be invoked using the same method as the final handler. This is required to ensure that user-defined objects are not accessed in a way that may violate the guarantees. This hooking function ensures that the invoked method used for the final handler is accessible at each intermediate step.

Implement asio_handler_invoke for your own handlers to specify a custom invocation strategy.

This default implementation invokes the function object like so:

function();

If necessary, the default implementation makes a copy of the function object so that the non-const operator() can be used.

Example

class my_handler;

template <typename Function>
void asio_handler_invoke(Function function, my_handler* context)
{
  context->strand_.dispatch(function);
}

Requirements

Header: asio/handler_invoke_hook.hpp

Convenience header: asio.hpp