// in namemspace asioclass socket{private:  detail::io_object_impl<    detail::reactive_socket_service<ip::tcp>,     io_context::executor  > impl_;
public:  socket(const io_context::executor& ex)    : impl_(0, ex)  {}};

// in namespace asio::detailtemplate <typename IoObjectService,    typename Executor = io_context::executor_type>class io_object_impl{public:  // The type of the service that will be used to provide I/O operations.  typedef IoObjectService service_type;
  // The underlying implementation type of I/O object.  typedef typename service_type::implementation_type implementation_type;
  // The type of the executor associated with the object.  typedef Executor executor_type;
  // Construct an I/O object using an executor.  explicit io_object_impl(int, const executor_type& ex)    : service_(&asio::use_service<IoObjectService>(          io_object_impl::get_context(ex))),      executor_(ex)  {    service_->construct(implementation_);  }
private:  // The service associated with the I/O object.  service_type* service_;
  // The underlying implementation of the I/O object.  implementation_type implementation_;
  // The associated executor.  executor_type executor_;};

// Special derived service id type to keep classes header-file only.template <typename Type>class service_id  : public execution_context::id{};
// Special service base class to keep classes header-file only.template <typename Type>class execution_context_service_base  : public execution_context::service{public:  static service_id<Type> id;
  // Constructor.  execution_context_service_base(execution_context& e)    : execution_context::service(e)  {  }};
// implement your private servicetemplate <typename PortSpace>class rdma_core_service :   public execution_context_service_base<rdma_core_service<PortSpace>>{  // ....};

template <typename PortSpace>class rdma_core_service :   public execution_context_service_base<rdma_core_service<PortSpace>>{public:  // The implementation type of the cm id.  struct implementation_type  {    // The native cm representation.    rdma_cm_id_data*      cm_id_data_;
    // state for memory region    rdma_mr_state         mr_state_;
    // if there is a queue pair attached to this io object    bool                  has_qp_;  };};

template <typename PortSpace>class rdma_core_service :   public execution_context_service_base<rdma_core_service<PortSpace>>{public:  // Construct a new implementation.  inline void construct(implementation_type& impl);
  // Destroy a implementation  inline void destroy(implementation_type& impl);
  // move constructor  inline void move_construct(implementation_type& impl, implementation_type& other_impl);
  // move assign  inline void move_assign(implementation_type& impl,    rdma_core_service& other_service, implementation_type& other_impl);};

template <typename PortSpace>class rdma_core_service :   public execution_context_service_base<rdma_core_service<PortSpace>>{public:  /// Destructor.  ASIO_DECL virtual ~rdma_core_service()
  /// Destroy all user-defined handler objects owned by the service.  ASIO_DECL virtual void shutdown();
  /// Handle notification of a fork-related event to perform any necessary  /// housekeeping.  /**   * This function is not a pure virtual so that services only have to   * implement it if necessary. The default implementation does nothing.   */  ASIO_DECL virtual void notify_fork(execution_context::fork_event event);};

// IO object for rdma, provides rdma functionalitytemplate <typename PortSpace, typename Executor = any_io_executor>class rdma_connection{public:  // ....#if ASIO_HAS_IOCP  using service_type = detail::rdma_iocp_connector_service<PortSpace>;#else  using service_type = detail::rdma_core_service<PortSpace>;#endif
private:  detail::io_object_impl<service_type> impl_;
public: // implement interface  void open(port_space_type const& port_space);
  bool is_open() const{    return impl_.get_service().is_open(impl_.get_implementation());  }  // .....};

// reactor_op implemetionclass reactor_op : public operation{ /******/ };
class your_reactor_async_op : public reactor_op{public:  your_reactor_async_op(asio::error_code const& success_ec, ...)    : reactor_op(success_ec, do_perform, do_complete)  //, other initialization  {}
  static status do_perform(reactor_op* base){    auto* this_op = static_cast<your_reactor_async_op*>(base);    // TODO ... call your sync io  }
  static void do_complete(void* owner, operation* base,      const asio::error_code& /*ec*/,      std::size_t /*bytes_transferred*/){    auto* this_op = static_cast<your_reactor_async_op*>(base);    // TODO ... do your io completion logic  }};

class your_iocp_async_op : public operation{public:  your_iocp_async_op(...)    : operation(do_complete)  //, other initialization  {}
  static void do_complete(void* owner, operation* base,      const asio::error_code& /*ec*/,      std::size_t /*bytes_transferred*/){    auto* this_op = static_cast<your_iocp_async_op*>(base);    // TODO ... do your io completion logic  }};

asio::io_context ioc{};asio::rdma::completion_queue cq{ ioc };
std::thread thread {  [&] { cq.run(); }}

// IO object for rdma, provides rdma functionalitytemplate <typename PortSpace, typename Executor = any_io_executor>class rdma_connection{public:  // .......  class initiate_async_connect;
  // async connect  template <    ASIO_COMPLETION_TOKEN_FOR(void (asio::error_code))      ConnectToken ASIO_DEFAULT_COMPLETION_TOKEN_TYPE(executor_type)>  ASIO_INITFN_AUTO_RESULT_TYPE_PREFIX(ConnectToken,      void (asio::error_code))  async_connect(endpoint_type const& endpoint,        ASIO_MOVE_ARG(ConnectToken) token        ASIO_DEFAULT_COMPLETION_TOKEN(executor_type))    ASIO_INITFN_AUTO_RESULT_TYPE_SUFFIX((      async_initiate<ConnectToken, void (asio::error_code)>(          declval<initiate_async_resolve_route>(), token,          declval<asio::error_code&>())))  {    asio::error_code open_ec{};    if(!is_open())    {      open_ec = asio::error::try_again;    }
#if ASIO_HAS_IOCP    if(!open_ec)    {      impl_.get_service().allocate_qp(        impl_.get_implementation(), open_ec);    }#endif
    return async_initiate<ConnectToken, void(asio::error_code)>(      initiate_async_connect(this), token, endpoint, open_ec);  }
  // initializer for async_connect_op  class initiate_async_connect  {  public:    using executor_type = Executor;
    explicit initiate_async_connect(rdma_connection* self) ASIO_NOEXCEPT      : self_(self) {}
    template <typename Handler>    void operator() (ASIO_MOVE_ARG(Handler) handler,      endpoint_type const& endpoint,      asio::error_code const& open_ec) const    {      ASIO_CONNECT_HANDLER_CHECK(Handler, handler) type_check;
      if(open_ec)      {        asio::post(self_->impl_.get_executor(),          asio::detail::bind_handler(            ASIO_MOVE_CAST(Handler)(handler), open_ec));      }      else      {        detail::non_const_lvalue<Handler> handler2(handler);        self_->impl_.get_service().async_connect(          self_->impl_.get_implementation(), endpoint,          handler2.value, self_->impl_.get_executor());      }    }
  private:    rdma_connection* self_;  };};

// rdma-core for linuxtemplate <typename PortSpace>template <typename Handler, typename IoExecutor>void rdma_core_service<PortSpace>::async_connect(implementation_type& impl,  endpoint_type const& endpoint,  Handler& handler, const IoExecutor& io_ex){  bool const is_continuation =      asio_handler_cont_helpers::is_continuation(handler);
  // TODO ... cancellation
  using op = rdma_cm_connect_op<PortSpace, Handler, IoExecutor>;  typename op::ptr p = { asio::detail::addressof(handler),      op::ptr::allocate(handler), 0 };  p.p = new (p.v) op(success_ec_, implNaN_id_data_->cm_id_, get_context(), handler, io_ex);
  cm_event_service_.start_connect_op(implNaN_id_data_, p.p, endpoint.data(), is_continuation);  p.v = p.p = 0;}
// iocp for windowstemplate <typename PortSpace>template <typename Handler, typename IoExecutor>void rdma_iocp_connector_service<PortSpace>::async_connect(  implementation_type& impl, endpoint_type const& endpoint,  Handler& handler, const IoExecutor& io_ex){  // TODO ... cancellation  using op = rdma_nd_connect_op<Handler, IoExecutor>;  typename op::ptr p = { asio::detail::addressof(handler),      op::ptr::allocate(handler), 0 };
  p.p = new (p.v) op(impl.connector_.Get(), handler, io_ex);
  start_connect_op(impl, endpoint, p.p);  p.v = p.p = 0;}