renamed executor_type to executor for io.

include/boost/async/io/acceptor.hpp

@@ -55,10 +55,10 @@ struct acceptor
       else
         return std::move(socket_);
     }
-    accept_op_(    asio::basic_socket_acceptor<protocol_type, executor_type> & acceptor)
+    accept_op_(    asio::basic_socket_acceptor<protocol_type, executor> & acceptor)
       : acceptor_(acceptor) {}
    private:
-    asio::basic_socket_acceptor<protocol_type, executor_type> & acceptor_;
+    asio::basic_socket_acceptor<protocol_type, executor> & acceptor_;
     stream_socket socket_;
     std::exception_ptr error;
     std::optional<std::tuple<system::error_code>> result_;
@@ -93,10 +93,10 @@ struct acceptor
       else
         return std::move(socket_);
     }
-    accept_seq_op_(asio::basic_socket_acceptor<protocol_type, executor_type> & acceptor)
+    accept_seq_op_(asio::basic_socket_acceptor<protocol_type, executor> & acceptor)
         : acceptor_(acceptor) {}
    private:
-    asio::basic_socket_acceptor<protocol_type, executor_type> & acceptor_;
+    asio::basic_socket_acceptor<protocol_type, executor> & acceptor_;
     seq_packet_socket socket_;
     std::exception_ptr error;
     std::optional<std::tuple<system::error_code>> result_;
@@ -105,7 +105,7 @@ struct acceptor
   [[nodiscard]] BOOST_ASYNC_DECL accept_op_     accept();
   [[nodiscard]] BOOST_ASYNC_DECL accept_seq_op_ accept_seq_packet();
  private:
-  asio::basic_socket_acceptor<protocol_type, executor_type> acceptor_;
+  asio::basic_socket_acceptor<protocol_type, executor> acceptor_;
 };
 
 }

include/boost/async/io/datagram_socket.hpp

@@ -52,7 +52,7 @@ struct [[nodiscard]] datagram_socket final : socket
   [[nodiscard]] send_to_op_seq_ send_to(buffers::const_buffer_span    buffers, const endpoint & target);
   [[nodiscard]] send_to_op_     send_to(buffers::const_buffer         buffer,  const endpoint & target);
 
-  asio::basic_datagram_socket<protocol_type, executor_type> datagram_socket_;
+  asio::basic_datagram_socket<protocol_type, executor> datagram_socket_;
 };
 
 inline system::result<std::pair<datagram_socket, datagram_socket>> make_pair(decltype(local_datagram) protocol)

include/boost/async/io/detail/datagram_socket.hpp

@@ -39,12 +39,12 @@ struct datagram_socket::receive_op_ : detail::deferred_op_resource_base
     const auto & [ec, n] = *result_;
     return transfer_result{ec, n};
   }
-  receive_op_(asio::basic_datagram_socket<protocol_type, executor_type> & rs,
+  receive_op_(asio::basic_datagram_socket<protocol_type, executor> & rs,
               buffers::mutable_buffer buffer)
     : datagram_socket_(rs), buffer_(buffer) {}
  private:
   void initiate_(async::completion_handler<system::error_code, std::size_t> h);
-  asio::basic_datagram_socket<protocol_type, executor_type> &datagram_socket_;
+  asio::basic_datagram_socket<protocol_type, executor> &datagram_socket_;
   buffers::mutable_buffer buffer_;
   std::exception_ptr error;
   std::optional<std::tuple<system::error_code, std::size_t>> result_;
@@ -76,16 +76,16 @@ struct datagram_socket::receive_op_seq_ : detail::deferred_op_resource_base
     const auto & [ec, n] = *result_;
     return transfer_result{ec, n};
   }
-  receive_op_seq_(asio::basic_datagram_socket<protocol_type, executor_type> & rs,
+  receive_op_seq_(asio::basic_datagram_socket<protocol_type, executor> & rs,
                   buffers::mutable_buffer_subspan buffer)
       : datagram_socket_(rs), buffer_(buffer) {}
 
-  receive_op_seq_(asio::basic_datagram_socket<protocol_type, executor_type> & rs,
+  receive_op_seq_(asio::basic_datagram_socket<protocol_type, executor> & rs,
                   buffers::mutable_buffer_span buffer)
       : datagram_socket_(rs), buffer_(buffer) {}
  private:
   void initiate_(async::completion_handler<system::error_code, std::size_t> h);
-  asio::basic_datagram_socket<protocol_type, executor_type> &datagram_socket_;
+  asio::basic_datagram_socket<protocol_type, executor> &datagram_socket_;
   buffers::mutable_buffer_subspan buffer_;
   std::exception_ptr error;
   std::optional<std::tuple<system::error_code, std::size_t>> result_;
@@ -117,12 +117,12 @@ struct datagram_socket::receive_from_op_ : detail::deferred_op_resource_base
     const auto & [ec, n] = *result_;
     return transfer_result{ec, n};
   }
-  receive_from_op_(asio::basic_datagram_socket<protocol_type, executor_type> & rs,
+  receive_from_op_(asio::basic_datagram_socket<protocol_type, executor> & rs,
               buffers::mutable_buffer buffer, endpoint & ep)
       : datagram_socket_(rs), buffer_(buffer), ep_(ep) {}
  private:
   void initiate_(async::completion_handler<system::error_code, std::size_t> h);
-  asio::basic_datagram_socket<protocol_type, executor_type> &datagram_socket_;
+  asio::basic_datagram_socket<protocol_type, executor> &datagram_socket_;
   buffers::mutable_buffer buffer_;
   endpoint &ep_;
 
@@ -156,15 +156,15 @@ struct datagram_socket::receive_from_op_seq_ : detail::deferred_op_resource_base
     const auto & [ec, n] = *result_;
     return transfer_result{ec, n};
   }
-  receive_from_op_seq_(asio::basic_datagram_socket<protocol_type, executor_type> & rs,
+  receive_from_op_seq_(asio::basic_datagram_socket<protocol_type, executor> & rs,
                        buffers::mutable_buffer_subspan buffer, endpoint & ep)
       : datagram_socket_(rs), buffer_(buffer), ep_(ep) {}
-  receive_from_op_seq_(asio::basic_datagram_socket<protocol_type, executor_type> & rs,
+  receive_from_op_seq_(asio::basic_datagram_socket<protocol_type, executor> & rs,
                        buffers::mutable_buffer_span buffer, endpoint & ep)
       : datagram_socket_(rs), buffer_(buffer), ep_(ep) {}
  private:
   void initiate_(async::completion_handler<system::error_code, std::size_t> h);
-  asio::basic_datagram_socket<protocol_type, executor_type> &datagram_socket_;
+  asio::basic_datagram_socket<protocol_type, executor> &datagram_socket_;
   buffers::mutable_buffer_subspan buffer_;
   endpoint & ep_;
   std::exception_ptr error;
@@ -196,12 +196,12 @@ struct datagram_socket::send_op_ : detail::deferred_op_resource_base
     const auto & [ec, n] = *result_;
     return transfer_result{ec, n};
   }
-  send_op_(asio::basic_datagram_socket<protocol_type, executor_type> & rs,
+  send_op_(asio::basic_datagram_socket<protocol_type, executor> & rs,
            buffers::const_buffer buffer)
       : datagram_socket_(rs), buffer_(buffer) {}
  private:
   void initiate_(async::completion_handler<system::error_code, std::size_t> h);
-  asio::basic_datagram_socket<protocol_type, executor_type> &datagram_socket_;
+  asio::basic_datagram_socket<protocol_type, executor> &datagram_socket_;
   buffers::const_buffer buffer_;
   std::exception_ptr error;
   std::optional<std::tuple<system::error_code, std::size_t>> result_;
@@ -233,15 +233,15 @@ struct datagram_socket::send_op_seq_ : detail::deferred_op_resource_base
     const auto & [ec, n] = *result_;
     return transfer_result{ec, n};
   }
-  send_op_seq_(asio::basic_datagram_socket<protocol_type, executor_type> & rs,
+  send_op_seq_(asio::basic_datagram_socket<protocol_type, executor> & rs,
                   buffers::const_buffer_subspan buffer)
       : datagram_socket_(rs), buffer_(buffer) {}
-  send_op_seq_(asio::basic_datagram_socket<protocol_type, executor_type> & rs,
+  send_op_seq_(asio::basic_datagram_socket<protocol_type, executor> & rs,
                buffers::const_buffer_span buffer)
       : datagram_socket_(rs), buffer_(buffer) {}
  private:
   void initiate_(async::completion_handler<system::error_code, std::size_t> h);
-  asio::basic_datagram_socket<protocol_type, executor_type> &datagram_socket_;
+  asio::basic_datagram_socket<protocol_type, executor> &datagram_socket_;
   buffers::const_buffer_subspan buffer_;
   std::exception_ptr error;
   std::optional<std::tuple<system::error_code, std::size_t>> result_;
@@ -273,12 +273,12 @@ struct datagram_socket::send_to_op_ : detail::deferred_op_resource_base
     const auto & [ec, n] = *result_;
     return transfer_result{ec, n};
   }
-  send_to_op_(asio::basic_datagram_socket<protocol_type, executor_type> & rs,
+  send_to_op_(asio::basic_datagram_socket<protocol_type, executor> & rs,
                    buffers::const_buffer buffer, const endpoint & ep)
       : datagram_socket_(rs), buffer_(buffer), ep_(ep) {}
  private:
   void initiate_(async::completion_handler<system::error_code, std::size_t> h);
-  asio::basic_datagram_socket<protocol_type, executor_type> &datagram_socket_;
+  asio::basic_datagram_socket<protocol_type, executor> &datagram_socket_;
   buffers::const_buffer buffer_;
   const endpoint &ep_;
 
@@ -312,16 +312,16 @@ struct datagram_socket::send_to_op_seq_ : detail::deferred_op_resource_base
     const auto & [ec, n] = *result_;
     return transfer_result{ec, n};
   }
-  send_to_op_seq_(asio::basic_datagram_socket<protocol_type, executor_type> & rs,
+  send_to_op_seq_(asio::basic_datagram_socket<protocol_type, executor> & rs,
                        buffers::const_buffer_subspan buffer, const endpoint & ep)
       : datagram_socket_(rs), buffer_(buffer), ep_(ep) {}
 
-  send_to_op_seq_(asio::basic_datagram_socket<protocol_type, executor_type> & rs,
+  send_to_op_seq_(asio::basic_datagram_socket<protocol_type, executor> & rs,
                   buffers::const_buffer_span buffer, const endpoint & ep)
       : datagram_socket_(rs), buffer_(buffer), ep_(ep) {}
  private:
   void initiate_(async::completion_handler<system::error_code, std::size_t> h);
-  asio::basic_datagram_socket<protocol_type, executor_type> &datagram_socket_;
+  asio::basic_datagram_socket<protocol_type, executor> &datagram_socket_;
   buffers::const_buffer_subspan buffer_;
   const endpoint & ep_;
   std::exception_ptr error;

include/boost/async/io/detail/seq_packet_socket.hpp

@@ -39,12 +39,12 @@ struct seq_packet_socket::receive_op_ : detail::deferred_op_resource_base
     const auto & [ec, n] = *result_;
     return transfer_result{ec, n};
   }
-  receive_op_(asio::basic_seq_packet_socket<protocol_type, executor_type> & rs,
+  receive_op_(asio::basic_seq_packet_socket<protocol_type, executor> & rs,
               buffers::mutable_buffer buffer, message_flags &out_flags)
     : seq_packet_socket_(rs), buffer_(buffer), out_flags_(out_flags) {}
  private:
   void initiate_(async::completion_handler<system::error_code, std::size_t> h);
-  asio::basic_seq_packet_socket<protocol_type, executor_type> &seq_packet_socket_;
+  asio::basic_seq_packet_socket<protocol_type, executor> &seq_packet_socket_;
   buffers::mutable_buffer buffer_;
   message_flags &out_flags_;
   std::exception_ptr error;
@@ -77,15 +77,15 @@ struct seq_packet_socket::receive_op_seq_ : detail::deferred_op_resource_base
     const auto & [ec, n] = *result_;
     return transfer_result{ec, n};
   }
-  receive_op_seq_(asio::basic_seq_packet_socket<protocol_type, executor_type> & rs,
+  receive_op_seq_(asio::basic_seq_packet_socket<protocol_type, executor> & rs,
                   buffers::mutable_buffer_subspan buffer, message_flags &out_flags)
       : seq_packet_socket_(rs), buffer_(buffer), out_flags_(out_flags) {}
-  receive_op_seq_(asio::basic_seq_packet_socket<protocol_type, executor_type> & rs,
+  receive_op_seq_(asio::basic_seq_packet_socket<protocol_type, executor> & rs,
                   buffers::mutable_buffer_span buffer, message_flags &out_flags)
       : seq_packet_socket_(rs), buffer_(buffer), out_flags_(out_flags) {}
  private:
   void initiate_(async::completion_handler<system::error_code, std::size_t> h);
-  asio::basic_seq_packet_socket<protocol_type, executor_type> &seq_packet_socket_;
+  asio::basic_seq_packet_socket<protocol_type, executor> &seq_packet_socket_;
   buffers::mutable_buffer_subspan buffer_;
   message_flags &out_flags_;
   std::exception_ptr error;
@@ -117,12 +117,12 @@ struct seq_packet_socket::send_op_ : detail::deferred_op_resource_base
     const auto & [ec, n] = *result_;
     return transfer_result{ec, n};
   }
-  send_op_(asio::basic_seq_packet_socket<protocol_type, executor_type> & rs,
+  send_op_(asio::basic_seq_packet_socket<protocol_type, executor> & rs,
            buffers::const_buffer buffer, message_flags out_flags)
       : seq_packet_socket_(rs), buffer_(buffer), out_flags_(out_flags) {}
  private:
   void initiate_(async::completion_handler<system::error_code, std::size_t> h);
-  asio::basic_seq_packet_socket<protocol_type, executor_type> &seq_packet_socket_;
+  asio::basic_seq_packet_socket<protocol_type, executor> &seq_packet_socket_;
   buffers::const_buffer buffer_;
   message_flags out_flags_;
   std::exception_ptr error;
@@ -155,15 +155,15 @@ struct seq_packet_socket::send_op_seq_ : detail::deferred_op_resource_base
     const auto & [ec, n] = *result_;
     return transfer_result{ec, n};
   }
-  send_op_seq_(asio::basic_seq_packet_socket<protocol_type, executor_type> & rs,
+  send_op_seq_(asio::basic_seq_packet_socket<protocol_type, executor> & rs,
                buffers::const_buffer_subspan buffer, message_flags out_flags)
       : seq_packet_socket_(rs), buffer_(buffer), out_flags_(out_flags) {}
-  send_op_seq_(asio::basic_seq_packet_socket<protocol_type, executor_type> & rs,
+  send_op_seq_(asio::basic_seq_packet_socket<protocol_type, executor> & rs,
                buffers::const_buffer_span buffer, message_flags out_flags)
       : seq_packet_socket_(rs), buffer_(buffer), out_flags_(out_flags) {}
  private:
   void initiate_(async::completion_handler<system::error_code, std::size_t> h);
-  asio::basic_seq_packet_socket<protocol_type, executor_type> &seq_packet_socket_;
+  asio::basic_seq_packet_socket<protocol_type, executor> &seq_packet_socket_;
   buffers::const_buffer_subspan buffer_;
   message_flags out_flags_;
   std::exception_ptr error;

include/boost/async/io/detail/socket.hpp

@@ -46,10 +46,10 @@ struct socket::wait_op_ : detail::deferred_op_resource_base
     else
       return {};
   }
-  wait_op_(asio::basic_socket<protocol_type, executor_type> & socket,
+  wait_op_(asio::basic_socket<protocol_type, executor> & socket,
            asio::socket_base::wait_type wt) : socket_(socket), wt_(wt) {}
  private:
-  asio::basic_socket<protocol_type, executor_type>  & socket_;
+  asio::basic_socket<protocol_type, executor>  & socket_;
   asio::socket_base::wait_type wt_;
   std::exception_ptr error;
   std::optional<std::tuple<system::error_code>> result_;

include/boost/async/io/file.hpp

@@ -37,16 +37,16 @@ struct file
   [[nodiscard]] BOOST_ASYNC_DECL system::result<void> sync_data();
 
 
-  using native_handle_type = asio::basic_file<executor_type>::native_handle_type;
+  using native_handle_type = asio::basic_file<executor>::native_handle_type;
   BOOST_ASYNC_DECL native_handle_type native_handle();
 
   BOOST_ASYNC_DECL system::result<void> assign(native_handle_type native_handle);
   BOOST_ASYNC_DECL system::result<native_handle_type> release();
 
  private:
-  asio::basic_file<executor_type> & file_;
+  asio::basic_file<executor> & file_;
  public:
-  file(asio::basic_file<executor_type> & file) : file_(file) {}
+  file(asio::basic_file<executor> & file) : file_(file) {}
 };
 
 }

include/boost/async/io/pipe.hpp

@@ -24,7 +24,7 @@ struct readable_pipe final : stream
   BOOST_ASYNC_DECL system::result<void> cancel() override;
   BOOST_ASYNC_DECL bool is_open() const override;
 
-  using native_handle_type = typename asio::basic_readable_pipe<executor_type>::native_handle_type;
+  using native_handle_type = typename asio::basic_readable_pipe<executor>::native_handle_type;
   native_handle_type native_handle() {return pipe_.native_handle();}
 
   BOOST_ASYNC_DECL readable_pipe();
@@ -43,7 +43,7 @@ struct readable_pipe final : stream
   BOOST_ASYNC_DECL void async_write_some_impl_(buffers::const_buffer_subspan buffer, async::completion_handler<system::error_code, std::size_t> h) override;
 
   friend system::result<std::pair<readable_pipe, writable_pipe>> make_pipe();
-  asio::basic_readable_pipe<executor_type> pipe_;
+  asio::basic_readable_pipe<executor> pipe_;
 };
 
 struct writable_pipe final : stream
@@ -52,7 +52,7 @@ struct writable_pipe final : stream
   BOOST_ASYNC_DECL system::result<void> cancel() override;
   BOOST_ASYNC_DECL bool is_open() const override;
 
-  using native_handle_type = typename asio::basic_readable_pipe<executor_type>::native_handle_type;
+  using native_handle_type = typename asio::basic_readable_pipe<executor>::native_handle_type;
   native_handle_type native_handle() {return pipe_.native_handle();}
 
   BOOST_ASYNC_DECL writable_pipe();
@@ -68,7 +68,7 @@ struct writable_pipe final : stream
   BOOST_ASYNC_DECL void async_read_some_impl_(buffers::mutable_buffer_subspan buffer, async::completion_handler<system::error_code, std::size_t> h) override;
   BOOST_ASYNC_DECL void async_write_some_impl_(buffers::const_buffer_subspan buffer, async::completion_handler<system::error_code, std::size_t> h) override;
   friend system::result<std::pair<readable_pipe, writable_pipe>> make_pipe();
-  asio::basic_writable_pipe<executor_type> pipe_;
+  asio::basic_writable_pipe<executor> pipe_;
 };
 
 system::result<std::pair<readable_pipe, writable_pipe>> make_pipe();

include/boost/async/io/random_access_file.hpp

@@ -32,7 +32,7 @@ struct random_access_file : file, random_access_device
  private:
   BOOST_ASYNC_DECL void async_read_some_at_impl_ (std::uint64_t offset, buffers::mutable_buffer_subspan buffer, async::completion_handler<system::error_code, std::size_t> h) override;
   BOOST_ASYNC_DECL void async_write_some_at_impl_(std::uint64_t offset, buffers::const_buffer_subspan buffer,   async::completion_handler<system::error_code, std::size_t> h) override;
-  asio::basic_random_access_file<executor_type> random_access_file_;
+  asio::basic_random_access_file<executor> random_access_file_;
 
 };
 }

include/boost/async/io/resolver.hpp

@@ -33,7 +33,7 @@ struct resolver
 
   struct resolve_op_ : detail::deferred_op_resource_base
   {
-    using result_type = asio::ip::basic_resolver<protocol_type, executor_type>::results_type;
+    using result_type = asio::ip::basic_resolver<protocol_type, executor>::results_type;
 
     constexpr static bool await_ready() { return false; }
 
@@ -53,11 +53,11 @@ struct resolver
     }
 
     [[nodiscard]] resolve_result await_resume();
-    resolve_op_(asio::ip::basic_resolver<protocol_type, executor_type> & resolver,
+    resolve_op_(asio::ip::basic_resolver<protocol_type, executor> & resolver,
                 core::string_view host, core::string_view service)
                 : resolver_(resolver), host_(host), service_(service) {}
    private:
-    asio::ip::basic_resolver<protocol_type, executor_type> & resolver_;
+    asio::ip::basic_resolver<protocol_type, executor> & resolver_;
     core::string_view host_;
     core::string_view service_;
     std::exception_ptr error;
@@ -76,7 +76,7 @@ struct resolver
 
 
  private:
-  asio::ip::basic_resolver<protocol_type, executor_type> resolver_;
+  asio::ip::basic_resolver<protocol_type, executor> resolver_;
 };
 
 // NOTE: Doesn't need to be a promise, can be optimized.

include/boost/async/io/seq_packet_socket.hpp

@@ -53,7 +53,7 @@ struct [[nodiscard]] seq_packet_socket final : socket
   [[nodiscard]] BOOST_ASYNC_DECL send_op_seq_    send(buffers::const_buffer_span    buffers, message_flags out_flags);
   [[nodiscard]] BOOST_ASYNC_DECL send_op_        send(buffers::const_buffer         buffer,  message_flags out_flags);
 
-  asio::basic_seq_packet_socket<protocol_type, executor_type> seq_packet_socket_;
+  asio::basic_seq_packet_socket<protocol_type, executor> seq_packet_socket_;
 };
 
 

include/boost/async/io/serial_port.hpp

@@ -40,7 +40,7 @@ struct [[nodiscard]] serial_port final : stream
   [[nodiscard]] BOOST_ASYNC_DECL system::result<void>   set_parity(parity rate);
   [[nodiscard]] BOOST_ASYNC_DECL system::result<parity> get_parity();
 
-  using native_handle_type = typename asio::basic_serial_port<executor_type>::native_handle_type;
+  using native_handle_type = typename asio::basic_serial_port<executor>::native_handle_type;
   native_handle_type native_handle() {return serial_port_.native_handle();}
 
   BOOST_ASYNC_DECL serial_port();
@@ -58,7 +58,7 @@ struct [[nodiscard]] serial_port final : stream
   BOOST_ASYNC_DECL void async_read_some_impl_(buffers::mutable_buffer_subspan buffer, async::completion_handler<system::error_code, std::size_t> h) override;
   BOOST_ASYNC_DECL void async_write_some_impl_(buffers::const_buffer_subspan buffer, async::completion_handler<system::error_code, std::size_t> h) override;
 
-  asio::basic_serial_port<executor_type> serial_port_;
+  asio::basic_serial_port<executor> serial_port_;
 };