自学教程：C++ BOOST_ASIO_HANDLER_INVOCATION_BEGIN函数代码示例

  static void do_complete(void* owner, operation* base,      const boost::system::error_code& ec, std::size_t bytes_transferred)  {    // Take ownership of the operation object.    win_iocp_overlapped_op* o(static_cast<win_iocp_overlapped_op*>(base));    ptr p = { boost::asio::detail::addressof(o->handler_), o, o };    handler_work<Handler> w(o->handler_);    BOOST_ASIO_HANDLER_COMPLETION((*o));    // Make a copy of the handler so that the memory can be deallocated before    // the upcall is made. Even if we're not about to make an upcall, a    // sub-object of the handler may be the true owner of the memory associated    // with the handler. Consequently, a local copy of the handler is required    // to ensure that any owning sub-object remains valid until after we have    // deallocated the memory here.    detail::binder2<Handler, boost::system::error_code, std::size_t>      handler(o->handler_, ec, bytes_transferred);    p.h = boost::asio::detail::addressof(handler.handler_);    p.reset();    // Make the upcall if required.    if (owner)    {      fenced_block b(fenced_block::half);      BOOST_ASIO_HANDLER_INVOCATION_BEGIN((handler.arg1_, handler.arg2_));      w.complete(handler, handler.handler_);      BOOST_ASIO_HANDLER_INVOCATION_END;    }  }

  static void do_complete(io_service_impl* owner, operation* base,      const lslboost::system::error_code& /*ec*/,      std::size_t /*bytes_transferred*/)  {    // Take ownership of the handler object.    reactive_socket_sendto_op* o(static_cast<reactive_socket_sendto_op*>(base));    ptr p = { lslboost::asio::detail::addressof(o->handler_), o, o };    BOOST_ASIO_HANDLER_COMPLETION((o));    // Make a copy of the handler so that the memory can be deallocated before    // the upcall is made. Even if we're not about to make an upcall, a    // sub-object of the handler may be the true owner of the memory associated    // with the handler. Consequently, a local copy of the handler is required    // to ensure that any owning sub-object remains valid until after we have    // deallocated the memory here.    detail::binder2<Handler, lslboost::system::error_code, std::size_t>      handler(o->handler_, o->ec_, o->bytes_transferred_);    p.h = lslboost::asio::detail::addressof(handler.handler_);    p.reset();    // Make the upcall if required.    if (owner)    {      fenced_block b(fenced_block::half);      BOOST_ASIO_HANDLER_INVOCATION_BEGIN((handler.arg1_, handler.arg2_));      lslboost_asio_handler_invoke_helpers::invoke(handler, handler.handler_);      BOOST_ASIO_HANDLER_INVOCATION_END;    }  }

    static void do_complete(boost::asio::detail::io_service_impl* owner,        boost::asio::detail::operation* base,        const boost::system::error_code& /* ec */,        std::size_t /* bytes_transferred */)    {        // take ownership        coproto_handler* h(static_cast<coproto_handler*>(base));        ptr p = { boost::asio::detail::addressof(h->handler_), h, h };        BOOST_ASIO_HANDLER_COMPLETION((h));        // copy the handler        boost::asio::detail::binder2<Handler, boost::system::error_code, std::string>            handler(h->handler_, h->ec_, h->value_);        p.h = boost::asio::detail::addressof(handler.handler_);        p.reset();        // make the upcall        if (owner)        {            boost::asio::detail::fenced_block(boost::asio::detail::fenced_block::half);            BOOST_ASIO_HANDLER_INVOCATION_BEGIN((handler.arg1_, handler.arg2_));            boost_asio_handler_invoke_helpers::invoke(handler, handler.handler_);            BOOST_ASIO_HANDLER_INVOCATION_END;        }    }

  static void do_complete(void* owner, operation* base,      const boost::system::error_code& /*ec*/,      std::size_t /*bytes_transferred*/)  {    // Take ownership of the handler object.    signal_handler* h(static_cast<signal_handler*>(base));    ptr p = { boost::asio::detail::addressof(h->handler_), h, h };    handler_work<Handler, IoExecutor> w(h->handler_, h->io_executor_);    BOOST_ASIO_HANDLER_COMPLETION((*h));    // Make a copy of the handler so that the memory can be deallocated before    // the upcall is made. Even if we're not about to make an upcall, a    // sub-object of the handler may be the true owner of the memory associated    // with the handler. Consequently, a local copy of the handler is required    // to ensure that any owning sub-object remains valid until after we have    // deallocated the memory here.    detail::binder2<Handler, boost::system::error_code, int>      handler(h->handler_, h->ec_, h->signal_number_);    p.h = boost::asio::detail::addressof(handler.handler_);    p.reset();    // Make the upcall if required.    if (owner)    {      fenced_block b(fenced_block::half);      BOOST_ASIO_HANDLER_INVOCATION_BEGIN((handler.arg1_, handler.arg2_));      w.complete(handler, handler.handler_);      BOOST_ASIO_HANDLER_INVOCATION_END;    }  }

  static void do_complete(io_service_impl* owner, operation* base,      riakboost::system::error_code /*ec*/, std::size_t /*bytes_transferred*/)  {    // Take ownership of the handler object.    wait_handler* h(static_cast<wait_handler*>(base));    ptr p = { riakboost::addressof(h->handler_), h, h };    BOOST_ASIO_HANDLER_COMPLETION((h));    // Make a copy of the handler so that the memory can be deallocated before    // the upcall is made. Even if we're not about to make an upcall, a    // sub-object of the handler may be the true owner of the memory associated    // with the handler. Consequently, a local copy of the handler is required    // to ensure that any owning sub-object remains valid until after we have    // deallocated the memory here.    detail::binder1<Handler, riakboost::system::error_code>      handler(h->handler_, h->ec_);    p.h = riakboost::addressof(handler.handler_);    p.reset();    // Make the upcall if required.    if (owner)    {      riakboost::asio::detail::fenced_block b;      BOOST_ASIO_HANDLER_INVOCATION_BEGIN((handler.arg1_));      riakboost_asio_handler_invoke_helpers::invoke(handler, handler.handler_);      BOOST_ASIO_HANDLER_INVOCATION_END;    }  }

  static void do_complete(void* owner, operation* base,      const boost::system::error_code& /*ec*/,      std::size_t /*bytes_transferred*/)  {    // Take ownership of the operation object.    resolve_query_op* o(static_cast<resolve_query_op*>(base));    ptr p = { boost::asio::detail::addressof(o->handler_), o, o };    if (owner && owner != &o->io_context_impl_)    {      // The operation is being run on the worker io_context. Time to perform      // the resolver operation.          // Perform the blocking host resolution operation.      socket_ops::background_getaddrinfo(o->cancel_token_,          o->query_.host_name().c_str(), o->query_.service_name().c_str(),          o->query_.hints(), &o->addrinfo_, o->ec_);      // Pass operation back to main io_context for completion.      o->io_context_impl_.post_deferred_completion(o);      p.v = p.p = 0;    }    else    {      // The operation has been returned to the main io_context. The completion      // handler is ready to be delivered.      // Take ownership of the operation's outstanding work.      handler_work<Handler> w(o->handler_);      BOOST_ASIO_HANDLER_COMPLETION((*o));      // Make a copy of the handler so that the memory can be deallocated      // before the upcall is made. Even if we're not about to make an upcall,      // a sub-object of the handler may be the true owner of the memory      // associated with the handler. Consequently, a local copy of the handler      // is required to ensure that any owning sub-object remains valid until      // after we have deallocated the memory here.      detail::binder2<Handler, boost::system::error_code, results_type>        handler(o->handler_, o->ec_, results_type());      p.h = boost::asio::detail::addressof(handler.handler_);      if (o->addrinfo_)      {        handler.arg2_ = results_type::create(o->addrinfo_,            o->query_.host_name(), o->query_.service_name());      }      p.reset();      if (owner)      {        fenced_block b(fenced_block::half);        BOOST_ASIO_HANDLER_INVOCATION_BEGIN((handler.arg1_, "..."));        w.complete(handler, handler.handler_);        BOOST_ASIO_HANDLER_INVOCATION_END;      }    }  }

  static void do_complete(io_service_impl* owner, operation* base,      const pdalboost::system::error_code& /*ec*/,      std::size_t /*bytes_transferred*/)  {    // Take ownership of the operation object.    resolve_endpoint_op* o(static_cast<resolve_endpoint_op*>(base));    ptr p = { pdalboost::asio::detail::addressof(o->handler_), o, o };    if (owner && owner != &o->io_service_impl_)    {      // The operation is being run on the worker io_service. Time to perform      // the resolver operation.          // Perform the blocking endpoint resolution operation.      char host_name[NI_MAXHOST];      char service_name[NI_MAXSERV];      socket_ops::background_getnameinfo(o->cancel_token_, o->endpoint_.data(),          o->endpoint_.size(), host_name, NI_MAXHOST, service_name, NI_MAXSERV,          o->endpoint_.protocol().type(), o->ec_);      o->iter_ = iterator_type::create(o->endpoint_, host_name, service_name);      // Pass operation back to main io_service for completion.      o->io_service_impl_.post_deferred_completion(o);      p.v = p.p = 0;    }    else    {      // The operation has been returned to the main io_service. The completion      // handler is ready to be delivered.      BOOST_ASIO_HANDLER_COMPLETION((o));      // Make a copy of the handler so that the memory can be deallocated      // before the upcall is made. Even if we're not about to make an upcall,      // a sub-object of the handler may be the true owner of the memory      // associated with the handler. Consequently, a local copy of the handler      // is required to ensure that any owning sub-object remains valid until      // after we have deallocated the memory here.      detail::binder2<Handler, pdalboost::system::error_code, iterator_type>        handler(o->handler_, o->ec_, o->iter_);      p.h = pdalboost::asio::detail::addressof(handler.handler_);      p.reset();      if (owner)      {        fenced_block b(fenced_block::half);        BOOST_ASIO_HANDLER_INVOCATION_BEGIN((handler.arg1_, "..."));        pdalboost_asio_handler_invoke_helpers::invoke(handler, handler.handler_);        BOOST_ASIO_HANDLER_INVOCATION_END;      }    }  }

  static void do_complete(io_service_impl* owner, operation* base,      const pdalboost::system::error_code& result_ec,      std::size_t bytes_transferred)  {    pdalboost::system::error_code ec(result_ec);    // Take ownership of the operation object.    win_iocp_null_buffers_op* o(static_cast<win_iocp_null_buffers_op*>(base));    ptr p = { pdalboost::asio::detail::addressof(o->handler_), o, o };    BOOST_ASIO_HANDLER_COMPLETION((o));    // The reactor may have stored a result in the operation object.    if (o->ec_)      ec = o->ec_;    // Map non-portable errors to their portable counterparts.    if (ec.value() == ERROR_NETNAME_DELETED)    {      if (o->cancel_token_.expired())        ec = pdalboost::asio::error::operation_aborted;      else        ec = pdalboost::asio::error::connection_reset;    }    else if (ec.value() == ERROR_PORT_UNREACHABLE)    {      ec = pdalboost::asio::error::connection_refused;    }    // Make a copy of the handler so that the memory can be deallocated before    // the upcall is made. Even if we're not about to make an upcall, a    // sub-object of the handler may be the true owner of the memory associated    // with the handler. Consequently, a local copy of the handler is required    // to ensure that any owning sub-object remains valid until after we have    // deallocated the memory here.    detail::binder2<Handler, pdalboost::system::error_code, std::size_t>      handler(o->handler_, ec, bytes_transferred);    p.h = pdalboost::asio::detail::addressof(handler.handler_);    p.reset();    // Make the upcall if required.    if (owner)    {      fenced_block b(fenced_block::half);      BOOST_ASIO_HANDLER_INVOCATION_BEGIN((handler.arg1_, handler.arg2_));      pdalboost_asio_handler_invoke_helpers::invoke(handler, handler.handler_);      BOOST_ASIO_HANDLER_INVOCATION_END;    }  }

  static void do_complete(io_service_impl* owner, operation* base,      const boost::system::error_code& result_ec,      std::size_t bytes_transferred)  {    boost::system::error_code ec(result_ec);    // Take ownership of the operation object.    win_iocp_socket_recvfrom_op* o(        static_cast<win_iocp_socket_recvfrom_op*>(base));    ptr p = { boost::addressof(o->handler_), o, o };    BOOST_ASIO_HANDLER_COMPLETION((o));#if defined(BOOST_ASIO_ENABLE_BUFFER_DEBUGGING)    // Check whether buffers are still valid.    if (owner)    {      buffer_sequence_adapter<boost::asio::mutable_buffer,          MutableBufferSequence>::validate(o->buffers_);    }#endif // defined(BOOST_ASIO_ENABLE_BUFFER_DEBUGGING)    socket_ops::complete_iocp_recvfrom(o->cancel_token_, ec);    // Record the size of the endpoint returned by the operation.    o->endpoint_.resize(o->endpoint_size_);    // Make a copy of the handler so that the memory can be deallocated before    // the upcall is made. Even if we're not about to make an upcall, a    // sub-object of the handler may be the true owner of the memory associated    // with the handler. Consequently, a local copy of the handler is required    // to ensure that any owning sub-object remains valid until after we have    // deallocated the memory here.    detail::binder2<Handler, boost::system::error_code, std::size_t>      handler(o->handler_, ec, bytes_transferred);    p.h = boost::addressof(handler.handler_);    p.reset();    // Make the upcall if required.    if (owner)    {      fenced_block b(fenced_block::half);      BOOST_ASIO_HANDLER_INVOCATION_BEGIN((handler.arg1_, handler.arg2_));      boost_asio_handler_invoke_helpers::invoke(handler, handler.handler_);      BOOST_ASIO_HANDLER_INVOCATION_END;    }  }

  static void do_complete(void* owner, operation* base,      const boost::system::error_code& result_ec,      std::size_t bytes_transferred)  {    boost::system::error_code ec(result_ec);    // Take ownership of the operation object.    win_iocp_handle_read_op* o(static_cast<win_iocp_handle_read_op*>(base));    ptr p = { boost::asio::detail::addressof(o->handler_), o, o };    handler_work<Handler, IoExecutor> w(o->handler_, o->io_executor_);    BOOST_ASIO_HANDLER_COMPLETION((*o));#if defined(BOOST_ASIO_ENABLE_BUFFER_DEBUGGING)    if (owner)    {      // Check whether buffers are still valid.      buffer_sequence_adapter<boost::asio::mutable_buffer,          MutableBufferSequence>::validate(o->buffers_);    }#endif // defined(BOOST_ASIO_ENABLE_BUFFER_DEBUGGING)    // Map non-portable errors to their portable counterparts.    if (ec.value() == ERROR_HANDLE_EOF)      ec = boost::asio::error::eof;    // Make a copy of the handler so that the memory can be deallocated before    // the upcall is made. Even if we're not about to make an upcall, a    // sub-object of the handler may be the true owner of the memory associated    // with the handler. Consequently, a local copy of the handler is required    // to ensure that any owning sub-object remains valid until after we have    // deallocated the memory here.    detail::binder2<Handler, boost::system::error_code, std::size_t>      handler(o->handler_, ec, bytes_transferred);    p.h = boost::asio::detail::addressof(handler.handler_);    p.reset();    // Make the upcall if required.    if (owner)    {      fenced_block b(fenced_block::half);      BOOST_ASIO_HANDLER_INVOCATION_BEGIN((handler.arg1_, handler.arg2_));      w.complete(handler, handler.handler_);      BOOST_ASIO_HANDLER_INVOCATION_END;    }  }

  static void do_complete(io_service_impl* owner, operation* base,      const boost::system::error_code& result_ec,      std::size_t /*bytes_transferred*/)  {    boost::system::error_code ec(result_ec);    // Take ownership of the operation object.    win_iocp_socket_connect_op* o(        static_cast<win_iocp_socket_connect_op*>(base));    ptr p = { boost::asio::detail::addressof(o->handler_), o, o };    if (owner)    {      if (o->connect_ex_)        socket_ops::complete_iocp_connect(o->socket_, ec);      else        ec = o->ec_;    }    BOOST_ASIO_HANDLER_COMPLETION((o));    // Make a copy of the handler so that the memory can be deallocated before    // the upcall is made. Even if we're not about to make an upcall, a    // sub-object of the handler may be the true owner of the memory associated    // with the handler. Consequently, a local copy of the handler is required    // to ensure that any owning sub-object remains valid until after we have    // deallocated the memory here.    detail::binder1<Handler, boost::system::error_code>      handler(o->handler_, ec);    p.h = boost::asio::detail::addressof(handler.handler_);    p.reset();    // Make the upcall if required.    if (owner)    {      fenced_block b(fenced_block::half);      BOOST_ASIO_HANDLER_INVOCATION_BEGIN((handler.arg1_));      boost_asio_handler_invoke_helpers::invoke(handler, handler.handler_);      BOOST_ASIO_HANDLER_INVOCATION_END;    }  }

  static void do_complete(void* owner, operation* base,      const boost::system::error_code& /*ec*/,      std::size_t /*bytes_transferred*/)  {    // Take ownership of the handler object.    reactive_socket_move_accept_op* o(        static_cast<reactive_socket_move_accept_op*>(base));    ptr p = { boost::asio::detail::addressof(o->handler_), o, o };    handler_work<Handler> w(o->handler_);    // On success, assign new connection to peer socket object.    if (owner)      o->do_assign();    BOOST_ASIO_HANDLER_COMPLETION((*o));    // Make a copy of the handler so that the memory can be deallocated before    // the upcall is made. Even if we're not about to make an upcall, a    // sub-object of the handler may be the true owner of the memory associated    // with the handler. Consequently, a local copy of the handler is required    // to ensure that any owning sub-object remains valid until after we have    // deallocated the memory here.    detail::move_binder2<Handler,      boost::system::error_code, typename Protocol::socket>        handler(0, BOOST_ASIO_MOVE_CAST(Handler)(o->handler_), o->ec_,          BOOST_ASIO_MOVE_CAST(typename Protocol::socket)(*o));    p.h = boost::asio::detail::addressof(handler.handler_);    p.reset();    // Make the upcall if required.    if (owner)    {      fenced_block b(fenced_block::half);      BOOST_ASIO_HANDLER_INVOCATION_BEGIN((handler.arg1_, "..."));      w.complete(handler, handler.handler_);      BOOST_ASIO_HANDLER_INVOCATION_END;    }  }

  static void do_complete(io_service_impl* owner, operation* base,      const boost::system::error_code& result_ec,      std::size_t /*bytes_transferred*/)  {    boost::system::error_code ec(result_ec);    // Take ownership of the operation object.    win_iocp_socket_accept_op* o(static_cast<win_iocp_socket_accept_op*>(base));    ptr p = { boost::asio::detail::addressof(o->handler_), o, o };    if (owner)    {      typename Protocol::endpoint peer_endpoint;      std::size_t addr_len = peer_endpoint.capacity();      socket_ops::complete_iocp_accept(o->socket_,          o->output_buffer(), o->address_length(),          peer_endpoint.data(), &addr_len,          o->new_socket_.get(), ec);      // Restart the accept operation if we got the connection_aborted error      // and the enable_connection_aborted socket option is not set.      if (ec == boost::asio::error::connection_aborted          && !o->enable_connection_aborted_)      {        o->reset();        o->socket_service_.restart_accept_op(o->socket_,            o->new_socket_, o->protocol_.family(),            o->protocol_.type(), o->protocol_.protocol(),            o->output_buffer(), o->address_length(), o);        p.v = p.p = 0;        return;      }      // If the socket was successfully accepted, transfer ownership of the      // socket to the peer object.      if (!ec)      {        o->peer_.assign(o->protocol_,            typename Socket::native_handle_type(              o->new_socket_.get(), peer_endpoint), ec);        if (!ec)          o->new_socket_.release();      }      // Pass endpoint back to caller.      if (o->peer_endpoint_)        *o->peer_endpoint_ = peer_endpoint;    }    BOOST_ASIO_HANDLER_COMPLETION((o));    // Make a copy of the handler so that the memory can be deallocated before    // the upcall is made. Even if we're not about to make an upcall, a    // sub-object of the handler may be the true owner of the memory associated    // with the handler. Consequently, a local copy of the handler is required    // to ensure that any owning sub-object remains valid until after we have    // deallocated the memory here.    detail::binder1<Handler, boost::system::error_code>      handler(o->handler_, ec);    p.h = boost::asio::detail::addressof(handler.handler_);    p.reset();    // Make the upcall if required.    if (owner)    {      fenced_block b(fenced_block::half);      BOOST_ASIO_HANDLER_INVOCATION_BEGIN((handler.arg1_));      boost_asio_handler_invoke_helpers::invoke(handler, handler.handler_);      BOOST_ASIO_HANDLER_INVOCATION_END;    }  }