### asio_handler_invoke

Default invoke function for handlers.

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

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

Default handler invocation hook used for const function objects.

    template<
        typename Function>
    void 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`