update boost

linx64/include/boost/asio/any_completion_executor.hpp

@@ -0,0 +1,344 @@
+//
+// any_completion_executor.hpp
+// ~~~~~~~~~~~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2023 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef BOOST_ASIO_ANY_COMPLETION_EXECUTOR_HPP
+#define BOOST_ASIO_ANY_COMPLETION_EXECUTOR_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include <boost/asio/detail/config.hpp>
+#if defined(BOOST_ASIO_USE_TS_EXECUTOR_AS_DEFAULT)
+# include <boost/asio/executor.hpp>
+#else // defined(BOOST_ASIO_USE_TS_EXECUTOR_AS_DEFAULT)
+# include <boost/asio/execution.hpp>
+#endif // defined(BOOST_ASIO_USE_TS_EXECUTOR_AS_DEFAULT)
+
+#include <boost/asio/detail/push_options.hpp>
+
+namespace boost {
+namespace asio {
+
+#if defined(BOOST_ASIO_USE_TS_EXECUTOR_AS_DEFAULT)
+
+typedef executor any_completion_executor;
+
+#else // defined(BOOST_ASIO_USE_TS_EXECUTOR_AS_DEFAULT)
+
+/// Polymorphic executor type for use with I/O objects.
+/**
+ * The @c any_completion_executor type is a polymorphic executor that supports
+ * the set of properties required for the execution of completion handlers. It
+ * is defined as the execution::any_executor class template parameterised as
+ * follows:
+ * @code execution::any_executor<
+ *   execution::prefer_only<execution::outstanding_work_t::tracked_t>,
+ *   execution::prefer_only<execution::outstanding_work_t::untracked_t>
+ *   execution::prefer_only<execution::relationship_t::fork_t>,
+ *   execution::prefer_only<execution::relationship_t::continuation_t>
+ * > @endcode
+ */
+class any_completion_executor :
+#if defined(GENERATING_DOCUMENTATION)
+  public execution::any_executor<...>
+#else // defined(GENERATING_DOCUMENTATION)
+  public execution::any_executor<
+      execution::prefer_only<execution::outstanding_work_t::tracked_t>,
+      execution::prefer_only<execution::outstanding_work_t::untracked_t>,
+      execution::prefer_only<execution::relationship_t::fork_t>,
+      execution::prefer_only<execution::relationship_t::continuation_t>
+    >
+#endif // defined(GENERATING_DOCUMENTATION)
+{
+public:
+#if !defined(GENERATING_DOCUMENTATION)
+  typedef execution::any_executor<
+      execution::prefer_only<execution::outstanding_work_t::tracked_t>,
+      execution::prefer_only<execution::outstanding_work_t::untracked_t>,
+      execution::prefer_only<execution::relationship_t::fork_t>,
+      execution::prefer_only<execution::relationship_t::continuation_t>
+    > base_type;
+
+  typedef void supportable_properties_type(
+      execution::prefer_only<execution::outstanding_work_t::tracked_t>,
+      execution::prefer_only<execution::outstanding_work_t::untracked_t>,
+      execution::prefer_only<execution::relationship_t::fork_t>,
+      execution::prefer_only<execution::relationship_t::continuation_t>
+    );
+#endif // !defined(GENERATING_DOCUMENTATION)
+
+  /// Default constructor.
+  BOOST_ASIO_DECL any_completion_executor() BOOST_ASIO_NOEXCEPT;
+
+  /// Construct in an empty state. Equivalent effects to default constructor.
+  BOOST_ASIO_DECL any_completion_executor(nullptr_t) BOOST_ASIO_NOEXCEPT;
+
+  /// Copy constructor.
+  BOOST_ASIO_DECL any_completion_executor(
+      const any_completion_executor& e) BOOST_ASIO_NOEXCEPT;
+
+#if defined(BOOST_ASIO_HAS_MOVE) || defined(GENERATING_DOCUMENTATION)
+  /// Move constructor.
+  BOOST_ASIO_DECL any_completion_executor(
+      any_completion_executor&& e) BOOST_ASIO_NOEXCEPT;
+#endif // defined(BOOST_ASIO_HAS_MOVE) || defined(GENERATING_DOCUMENTATION)
+
+  /// Construct to point to the same target as another any_executor.
+#if defined(GENERATING_DOCUMENTATION)
+  template <class... OtherSupportableProperties>
+    any_completion_executor(
+        execution::any_executor<OtherSupportableProperties...> e);
+#else // defined(GENERATING_DOCUMENTATION)
+  template <typename OtherAnyExecutor>
+  any_completion_executor(OtherAnyExecutor e,
+      typename constraint<
+        conditional<
+          !is_same<OtherAnyExecutor, any_completion_executor>::value
+            && is_base_of<execution::detail::any_executor_base,
+              OtherAnyExecutor>::value,
+          typename execution::detail::supportable_properties<
+            0, supportable_properties_type>::template
+              is_valid_target<OtherAnyExecutor>,
+          false_type
+        >::type::value
+      >::type = 0)
+    : base_type(BOOST_ASIO_MOVE_CAST(OtherAnyExecutor)(e))
+  {
+  }
+#endif // defined(GENERATING_DOCUMENTATION)
+
+  /// Construct to point to the same target as another any_executor.
+#if defined(GENERATING_DOCUMENTATION)
+  template <class... OtherSupportableProperties>
+    any_completion_executor(std::nothrow_t,
+      execution::any_executor<OtherSupportableProperties...> e);
+#else // defined(GENERATING_DOCUMENTATION)
+  template <typename OtherAnyExecutor>
+  any_completion_executor(std::nothrow_t, OtherAnyExecutor e,
+      typename constraint<
+        conditional<
+          !is_same<OtherAnyExecutor, any_completion_executor>::value
+            && is_base_of<execution::detail::any_executor_base,
+              OtherAnyExecutor>::value,
+          typename execution::detail::supportable_properties<
+            0, supportable_properties_type>::template
+              is_valid_target<OtherAnyExecutor>,
+          false_type
+        >::type::value
+      >::type = 0) BOOST_ASIO_NOEXCEPT
+    : base_type(std::nothrow, BOOST_ASIO_MOVE_CAST(OtherAnyExecutor)(e))
+  {
+  }
+#endif // defined(GENERATING_DOCUMENTATION)
+
+  /// Construct to point to the same target as another any_executor.
+  BOOST_ASIO_DECL any_completion_executor(std::nothrow_t,
+      const any_completion_executor& e) BOOST_ASIO_NOEXCEPT;
+
+#if defined(BOOST_ASIO_HAS_MOVE) || defined(GENERATING_DOCUMENTATION)
+  /// Construct to point to the same target as another any_executor.
+  BOOST_ASIO_DECL any_completion_executor(std::nothrow_t,
+      any_completion_executor&& e) BOOST_ASIO_NOEXCEPT;
+#endif // defined(BOOST_ASIO_HAS_MOVE) || defined(GENERATING_DOCUMENTATION)
+
+  /// Construct a polymorphic wrapper for the specified executor.
+#if defined(GENERATING_DOCUMENTATION)
+  template <BOOST_ASIO_EXECUTION_EXECUTOR Executor>
+  any_completion_executor(Executor e);
+#else // defined(GENERATING_DOCUMENTATION)
+  template <BOOST_ASIO_EXECUTION_EXECUTOR Executor>
+  any_completion_executor(Executor e,
+      typename constraint<
+        conditional<
+          !is_same<Executor, any_completion_executor>::value
+            && !is_base_of<execution::detail::any_executor_base,
+              Executor>::value,
+          execution::detail::is_valid_target_executor<
+            Executor, supportable_properties_type>,
+          false_type
+        >::type::value
+      >::type = 0)
+    : base_type(BOOST_ASIO_MOVE_CAST(Executor)(e))
+  {
+  }
+#endif // defined(GENERATING_DOCUMENTATION)
+
+  /// Construct a polymorphic wrapper for the specified executor.
+#if defined(GENERATING_DOCUMENTATION)
+  template <BOOST_ASIO_EXECUTION_EXECUTOR Executor>
+  any_completion_executor(std::nothrow_t, Executor e);
+#else // defined(GENERATING_DOCUMENTATION)
+  template <BOOST_ASIO_EXECUTION_EXECUTOR Executor>
+  any_completion_executor(std::nothrow_t, Executor e,
+      typename constraint<
+        conditional<
+          !is_same<Executor, any_completion_executor>::value
+            && !is_base_of<execution::detail::any_executor_base,
+              Executor>::value,
+          execution::detail::is_valid_target_executor<
+            Executor, supportable_properties_type>,
+          false_type
+        >::type::value
+      >::type = 0) BOOST_ASIO_NOEXCEPT
+    : base_type(std::nothrow, BOOST_ASIO_MOVE_CAST(Executor)(e))
+  {
+  }
+#endif // defined(GENERATING_DOCUMENTATION)
+
+  /// Assignment operator.
+  BOOST_ASIO_DECL any_completion_executor& operator=(
+      const any_completion_executor& e) BOOST_ASIO_NOEXCEPT;
+
+#if defined(BOOST_ASIO_HAS_MOVE) || defined(GENERATING_DOCUMENTATION)
+  /// Move assignment operator.
+  BOOST_ASIO_DECL any_completion_executor& operator=(
+      any_completion_executor&& e) BOOST_ASIO_NOEXCEPT;
+#endif // defined(BOOST_ASIO_HAS_MOVE) || defined(GENERATING_DOCUMENTATION)
+
+  /// Assignment operator that sets the polymorphic wrapper to the empty state.
+  BOOST_ASIO_DECL any_completion_executor& operator=(nullptr_t);
+
+  /// Destructor.
+  BOOST_ASIO_DECL ~any_completion_executor();
+
+  /// Swap targets with another polymorphic wrapper.
+  BOOST_ASIO_DECL void swap(any_completion_executor& other) BOOST_ASIO_NOEXCEPT;
+
+  /// Obtain a polymorphic wrapper with the specified property.
+  /**
+   * Do not call this function directly. It is intended for use with the
+   * boost::asio::require and boost::asio::prefer customisation points.
+   *
+   * For example:
+   * @code any_completion_executor ex = ...;
+   * auto ex2 = boost::asio::require(ex, execution::relationship.fork); @endcode
+   */
+  template <typename Property>
+  any_completion_executor require(const Property& p,
+      typename constraint<
+        traits::require_member<const base_type&, const Property&>::is_valid
+      >::type = 0) const
+  {
+    return static_cast<const base_type&>(*this).require(p);
+  }
+
+  /// Obtain a polymorphic wrapper with the specified property.
+  /**
+   * Do not call this function directly. It is intended for use with the
+   * boost::asio::prefer customisation point.
+   *
+   * For example:
+   * @code any_completion_executor ex = ...;
+   * auto ex2 = boost::asio::prefer(ex, execution::relationship.fork); @endcode
+   */
+  template <typename Property>
+  any_completion_executor prefer(const Property& p,
+      typename constraint<
+        traits::prefer_member<const base_type&, const Property&>::is_valid
+      >::type = 0) const
+  {
+    return static_cast<const base_type&>(*this).prefer(p);
+  }
+};
+
+#if !defined(GENERATING_DOCUMENTATION)
+
+template <>
+BOOST_ASIO_DECL any_completion_executor any_completion_executor::prefer(
+    const execution::outstanding_work_t::tracked_t&, int) const;
+
+template <>
+BOOST_ASIO_DECL any_completion_executor any_completion_executor::prefer(
+    const execution::outstanding_work_t::untracked_t&, int) const;
+
+template <>
+BOOST_ASIO_DECL any_completion_executor any_completion_executor::prefer(
+    const execution::relationship_t::fork_t&, int) const;
+
+template <>
+BOOST_ASIO_DECL any_completion_executor any_completion_executor::prefer(
+    const execution::relationship_t::continuation_t&, int) const;
+
+namespace traits {
+
+#if !defined(BOOST_ASIO_HAS_DEDUCED_EQUALITY_COMPARABLE_TRAIT)
+
+template <>
+struct equality_comparable<any_completion_executor>
+{
+  static const bool is_valid = true;
+  static const bool is_noexcept = true;
+};
+
+#endif // !defined(BOOST_ASIO_HAS_DEDUCED_EQUALITY_COMPARABLE_TRAIT)
+
+#if !defined(BOOST_ASIO_HAS_DEDUCED_EXECUTE_MEMBER_TRAIT)
+
+template <typename F>
+struct execute_member<any_completion_executor, F>
+{
+  static const bool is_valid = true;
+  static const bool is_noexcept = false;
+  typedef void result_type;
+};
+
+#endif // !defined(BOOST_ASIO_HAS_DEDUCED_EXECUTE_MEMBER_TRAIT)
+
+#if !defined(BOOST_ASIO_HAS_DEDUCED_QUERY_MEMBER_TRAIT)
+
+template <typename Prop>
+struct query_member<any_completion_executor, Prop> :
+  query_member<any_completion_executor::base_type, Prop>
+{
+};
+
+#endif // !defined(BOOST_ASIO_HAS_DEDUCED_QUERY_MEMBER_TRAIT)
+
+#if !defined(BOOST_ASIO_HAS_DEDUCED_REQUIRE_MEMBER_TRAIT)
+
+template <typename Prop>
+struct require_member<any_completion_executor, Prop> :
+  require_member<any_completion_executor::base_type, Prop>
+{
+  typedef any_completion_executor result_type;
+};
+
+#endif // !defined(BOOST_ASIO_HAS_DEDUCED_REQUIRE_MEMBER_TRAIT)
+
+#if !defined(BOOST_ASIO_HAS_DEDUCED_PREFER_MEMBER_TRAIT)
+
+template <typename Prop>
+struct prefer_member<any_completion_executor, Prop> :
+  prefer_member<any_completion_executor::base_type, Prop>
+{
+  typedef any_completion_executor result_type;
+};
+
+#endif // !defined(BOOST_ASIO_HAS_DEDUCED_PREFER_MEMBER_TRAIT)
+
+} // namespace traits
+
+#endif // !defined(GENERATING_DOCUMENTATION)
+
+#endif // defined(BOOST_ASIO_USE_TS_EXECUTOR_AS_DEFAULT)
+
+} // namespace asio
+} // namespace boost
+
+#include <boost/asio/detail/pop_options.hpp>
+
+#if defined(BOOST_ASIO_HEADER_ONLY) \
+  && !defined(BOOST_ASIO_USE_TS_EXECUTOR_AS_DEFAULT)
+# include <boost/asio/impl/any_completion_executor.ipp>
+#endif // defined(BOOST_ASIO_HEADER_ONLY)
+       //   && !defined(BOOST_ASIO_USE_TS_EXECUTOR_AS_DEFAULT)
+
+#endif // BOOST_ASIO_ANY_COMPLETION_EXECUTOR_HPP

linx64/include/boost/asio/any_completion_handler.hpp

@@ -0,0 +1,825 @@
+//
+// any_completion_handler.hpp
+// ~~~~~~~~~~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2023 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef BOOST_ASIO_ANY_COMPLETION_HANDLER_HPP
+#define BOOST_ASIO_ANY_COMPLETION_HANDLER_HPP
+
+#include <boost/asio/detail/config.hpp>
+
+#if (defined(BOOST_ASIO_HAS_STD_TUPLE) \
+    && defined(BOOST_ASIO_HAS_MOVE) \
+    && defined(BOOST_ASIO_HAS_VARIADIC_TEMPLATES)) \
+  || defined(GENERATING_DOCUMENTATION)
+
+#include <cstring>
+#include <functional>
+#include <memory>
+#include <utility>
+#include <boost/asio/any_completion_executor.hpp>
+#include <boost/asio/any_io_executor.hpp>
+#include <boost/asio/associated_allocator.hpp>
+#include <boost/asio/associated_cancellation_slot.hpp>
+#include <boost/asio/associated_executor.hpp>
+#include <boost/asio/associated_immediate_executor.hpp>
+#include <boost/asio/cancellation_state.hpp>
+#include <boost/asio/recycling_allocator.hpp>
+
+#include <boost/asio/detail/push_options.hpp>
+
+namespace boost {
+namespace asio {
+namespace detail {
+
+class any_completion_handler_impl_base
+{
+public:
+  template <typename S>
+  explicit any_completion_handler_impl_base(S&& slot)
+    : cancel_state_(BOOST_ASIO_MOVE_CAST(S)(slot), enable_total_cancellation())
+  {
+  }
+
+  cancellation_slot get_cancellation_slot() const BOOST_ASIO_NOEXCEPT
+  {
+    return cancel_state_.slot();
+  }
+
+private:
+  cancellation_state cancel_state_;
+};
+
+template <typename Handler>
+class any_completion_handler_impl :
+  public any_completion_handler_impl_base
+{
+public:
+  template <typename S, typename H>
+  any_completion_handler_impl(S&& slot, H&& h)
+    : any_completion_handler_impl_base(BOOST_ASIO_MOVE_CAST(S)(slot)),
+      handler_(BOOST_ASIO_MOVE_CAST(H)(h))
+  {
+  }
+
+  struct uninit_deleter
+  {
+    typename std::allocator_traits<
+      associated_allocator_t<Handler,
+        boost::asio::recycling_allocator<void>>>::template
+          rebind_alloc<any_completion_handler_impl> alloc;
+
+    void operator()(any_completion_handler_impl* ptr)
+    {
+      std::allocator_traits<decltype(alloc)>::deallocate(alloc, ptr, 1);
+    }
+  };
+
+  struct deleter
+  {
+    typename std::allocator_traits<
+      associated_allocator_t<Handler,
+        boost::asio::recycling_allocator<void>>>::template
+          rebind_alloc<any_completion_handler_impl> alloc;
+
+    void operator()(any_completion_handler_impl* ptr)
+    {
+      std::allocator_traits<decltype(alloc)>::destroy(alloc, ptr);
+      std::allocator_traits<decltype(alloc)>::deallocate(alloc, ptr, 1);
+    }
+  };
+
+  template <typename S, typename H>
+  static any_completion_handler_impl* create(S&& slot, H&& h)
+  {
+    uninit_deleter d{
+        (get_associated_allocator)(h,
+          boost::asio::recycling_allocator<void>())};
+
+    std::unique_ptr<any_completion_handler_impl, uninit_deleter> uninit_ptr(
+        std::allocator_traits<decltype(d.alloc)>::allocate(d.alloc, 1), d);
+
+    any_completion_handler_impl* ptr =
+      new (uninit_ptr.get()) any_completion_handler_impl(
+        BOOST_ASIO_MOVE_CAST(S)(slot), BOOST_ASIO_MOVE_CAST(H)(h));
+
+    uninit_ptr.release();
+    return ptr;
+  }
+
+  void destroy()
+  {
+    deleter d{
+        (get_associated_allocator)(handler_,
+          boost::asio::recycling_allocator<void>())};
+
+    d(this);
+  }
+
+  any_completion_executor executor(
+      const any_completion_executor& candidate) const BOOST_ASIO_NOEXCEPT
+  {
+    return any_completion_executor(std::nothrow,
+        (get_associated_executor)(handler_, candidate));
+  }
+
+  any_completion_executor immediate_executor(
+      const any_io_executor& candidate) const BOOST_ASIO_NOEXCEPT
+  {
+    return any_completion_executor(std::nothrow,
+        (get_associated_immediate_executor)(handler_, candidate));
+  }
+
+  void* allocate(std::size_t size, std::size_t align) const
+  {
+    typename std::allocator_traits<
+      associated_allocator_t<Handler,
+        boost::asio::recycling_allocator<void>>>::template
+          rebind_alloc<unsigned char> alloc(
+            (get_associated_allocator)(handler_,
+              boost::asio::recycling_allocator<void>()));
+
+    std::size_t space = size + align - 1;
+    unsigned char* base =
+      std::allocator_traits<decltype(alloc)>::allocate(
+        alloc, space + sizeof(std::ptrdiff_t));
+
+    void* p = base;
+    if (detail::align(align, size, p, space))
+    {
+      std::ptrdiff_t off = static_cast<unsigned char*>(p) - base;
+      std::memcpy(static_cast<unsigned char*>(p) + size, &off, sizeof(off));
+      return p;
+    }
+
+    std::bad_alloc ex;
+    boost::asio::detail::throw_exception(ex);
+    return nullptr;
+  }
+
+  void deallocate(void* p, std::size_t size, std::size_t align) const
+  {
+    if (p)
+    {
+      typename std::allocator_traits<
+        associated_allocator_t<Handler,
+          boost::asio::recycling_allocator<void>>>::template
+            rebind_alloc<unsigned char> alloc(
+              (get_associated_allocator)(handler_,
+                boost::asio::recycling_allocator<void>()));
+
+      std::ptrdiff_t off;
+      std::memcpy(&off, static_cast<unsigned char*>(p) + size, sizeof(off));
+      unsigned char* base = static_cast<unsigned char*>(p) - off;
+
+      std::allocator_traits<decltype(alloc)>::deallocate(
+          alloc, base, size + align -1 + sizeof(std::ptrdiff_t));
+    }
+  }
+
+  template <typename... Args>
+  void call(Args&&... args)
+  {
+    deleter d{
+        (get_associated_allocator)(handler_,
+          boost::asio::recycling_allocator<void>())};
+
+    std::unique_ptr<any_completion_handler_impl, deleter> ptr(this, d);
+    Handler handler(BOOST_ASIO_MOVE_CAST(Handler)(handler_));
+    ptr.reset();
+
+    BOOST_ASIO_MOVE_CAST(Handler)(handler)(
+        BOOST_ASIO_MOVE_CAST(Args)(args)...);
+  }
+
+private:
+  Handler handler_;
+};
+
+template <typename Signature>
+class any_completion_handler_call_fn;
+
+template <typename R, typename... Args>
+class any_completion_handler_call_fn<R(Args...)>
+{
+public:
+  using type = void(*)(any_completion_handler_impl_base*, Args...);
+
+  constexpr any_completion_handler_call_fn(type fn)
+    : call_fn_(fn)
+  {
+  }
+
+  void call(any_completion_handler_impl_base* impl, Args... args) const
+  {
+    call_fn_(impl, BOOST_ASIO_MOVE_CAST(Args)(args)...);
+  }
+
+  template <typename Handler>
+  static void impl(any_completion_handler_impl_base* impl, Args... args)
+  {
+    static_cast<any_completion_handler_impl<Handler>*>(impl)->call(
+        BOOST_ASIO_MOVE_CAST(Args)(args)...);
+  }
+
+private:
+  type call_fn_;
+};
+
+template <typename... Signatures>
+class any_completion_handler_call_fns;
+
+template <typename Signature>
+class any_completion_handler_call_fns<Signature> :
+  public any_completion_handler_call_fn<Signature>
+{
+public:
+  using any_completion_handler_call_fn<
+    Signature>::any_completion_handler_call_fn;
+  using any_completion_handler_call_fn<Signature>::call;
+};
+
+template <typename Signature, typename... Signatures>
+class any_completion_handler_call_fns<Signature, Signatures...> :
+  public any_completion_handler_call_fn<Signature>,
+  public any_completion_handler_call_fns<Signatures...>
+{
+public:
+  template <typename CallFn, typename... CallFns>
+  constexpr any_completion_handler_call_fns(CallFn fn, CallFns... fns)
+    : any_completion_handler_call_fn<Signature>(fn),
+      any_completion_handler_call_fns<Signatures...>(fns...)
+  {
+  }
+
+  using any_completion_handler_call_fn<Signature>::call;
+  using any_completion_handler_call_fns<Signatures...>::call;
+};
+
+class any_completion_handler_destroy_fn
+{
+public:
+  using type = void(*)(any_completion_handler_impl_base*);
+
+  constexpr any_completion_handler_destroy_fn(type fn)
+    : destroy_fn_(fn)
+  {
+  }
+
+  void destroy(any_completion_handler_impl_base* impl) const
+  {
+    destroy_fn_(impl);
+  }
+
+  template <typename Handler>
+  static void impl(any_completion_handler_impl_base* impl)
+  {
+    static_cast<any_completion_handler_impl<Handler>*>(impl)->destroy();
+  }
+
+private:
+  type destroy_fn_;
+};
+
+class any_completion_handler_executor_fn
+{
+public:
+  using type = any_completion_executor(*)(
+      any_completion_handler_impl_base*, const any_completion_executor&);
+
+  constexpr any_completion_handler_executor_fn(type fn)
+    : executor_fn_(fn)
+  {
+  }
+
+  any_completion_executor executor(any_completion_handler_impl_base* impl,
+      const any_completion_executor& candidate) const
+  {
+    return executor_fn_(impl, candidate);
+  }
+
+  template <typename Handler>
+  static any_completion_executor impl(any_completion_handler_impl_base* impl,
+      const any_completion_executor& candidate)
+  {
+    return static_cast<any_completion_handler_impl<Handler>*>(impl)->executor(
+        candidate);
+  }
+
+private:
+  type executor_fn_;
+};
+
+class any_completion_handler_immediate_executor_fn
+{
+public:
+  using type = any_completion_executor(*)(
+      any_completion_handler_impl_base*, const any_io_executor&);
+
+  constexpr any_completion_handler_immediate_executor_fn(type fn)
+    : immediate_executor_fn_(fn)
+  {
+  }
+
+  any_completion_executor immediate_executor(
+      any_completion_handler_impl_base* impl,
+      const any_io_executor& candidate) const
+  {
+    return immediate_executor_fn_(impl, candidate);
+  }
+
+  template <typename Handler>
+  static any_completion_executor impl(any_completion_handler_impl_base* impl,
+      const any_io_executor& candidate)
+  {
+    return static_cast<any_completion_handler_impl<Handler>*>(
+        impl)->immediate_executor(candidate);
+  }
+
+private:
+  type immediate_executor_fn_;
+};
+
+class any_completion_handler_allocate_fn
+{
+public:
+  using type = void*(*)(any_completion_handler_impl_base*,
+      std::size_t, std::size_t);
+
+  constexpr any_completion_handler_allocate_fn(type fn)
+    : allocate_fn_(fn)
+  {
+  }
+
+  void* allocate(any_completion_handler_impl_base* impl,
+      std::size_t size, std::size_t align) const
+  {
+    return allocate_fn_(impl, size, align);
+  }
+
+  template <typename Handler>
+  static void* impl(any_completion_handler_impl_base* impl,
+      std::size_t size, std::size_t align)
+  {
+    return static_cast<any_completion_handler_impl<Handler>*>(impl)->allocate(
+        size, align);
+  }
+
+private:
+  type allocate_fn_;
+};
+
+class any_completion_handler_deallocate_fn
+{
+public:
+  using type = void(*)(any_completion_handler_impl_base*,
+      void*, std::size_t, std::size_t);
+
+  constexpr any_completion_handler_deallocate_fn(type fn)
+    : deallocate_fn_(fn)
+  {
+  }
+
+  void deallocate(any_completion_handler_impl_base* impl,
+      void* p, std::size_t size, std::size_t align) const
+  {
+    deallocate_fn_(impl, p, size, align);
+  }
+
+  template <typename Handler>
+  static void impl(any_completion_handler_impl_base* impl,
+      void* p, std::size_t size, std::size_t align)
+  {
+    static_cast<any_completion_handler_impl<Handler>*>(impl)->deallocate(
+        p, size, align);
+  }
+
+private:
+  type deallocate_fn_;
+};
+
+template <typename... Signatures>
+class any_completion_handler_fn_table
+  : private any_completion_handler_destroy_fn,
+    private any_completion_handler_executor_fn,
+    private any_completion_handler_immediate_executor_fn,
+    private any_completion_handler_allocate_fn,
+    private any_completion_handler_deallocate_fn,
+    private any_completion_handler_call_fns<Signatures...>
+{
+public:
+  template <typename... CallFns>
+  constexpr any_completion_handler_fn_table(
+      any_completion_handler_destroy_fn::type destroy_fn,
+      any_completion_handler_executor_fn::type executor_fn,
+      any_completion_handler_immediate_executor_fn::type immediate_executor_fn,
+      any_completion_handler_allocate_fn::type allocate_fn,
+      any_completion_handler_deallocate_fn::type deallocate_fn,
+      CallFns... call_fns)
+    : any_completion_handler_destroy_fn(destroy_fn),
+      any_completion_handler_executor_fn(executor_fn),
+      any_completion_handler_immediate_executor_fn(immediate_executor_fn),
+      any_completion_handler_allocate_fn(allocate_fn),
+      any_completion_handler_deallocate_fn(deallocate_fn),
+      any_completion_handler_call_fns<Signatures...>(call_fns...)
+  {
+  }
+
+  using any_completion_handler_destroy_fn::destroy;
+  using any_completion_handler_executor_fn::executor;
+  using any_completion_handler_immediate_executor_fn::immediate_executor;
+  using any_completion_handler_allocate_fn::allocate;
+  using any_completion_handler_deallocate_fn::deallocate;
+  using any_completion_handler_call_fns<Signatures...>::call;
+};
+
+template <typename Handler, typename... Signatures>
+struct any_completion_handler_fn_table_instance
+{
+  static constexpr any_completion_handler_fn_table<Signatures...>
+    value = any_completion_handler_fn_table<Signatures...>(
+        &any_completion_handler_destroy_fn::impl<Handler>,
+        &any_completion_handler_executor_fn::impl<Handler>,
+        &any_completion_handler_immediate_executor_fn::impl<Handler>,
+        &any_completion_handler_allocate_fn::impl<Handler>,
+        &any_completion_handler_deallocate_fn::impl<Handler>,
+        &any_completion_handler_call_fn<Signatures>::template impl<Handler>...);
+};
+
+template <typename Handler, typename... Signatures>
+constexpr any_completion_handler_fn_table<Signatures...>
+any_completion_handler_fn_table_instance<Handler, Signatures...>::value;
+
+} // namespace detail
+
+template <typename... Signatures>
+class any_completion_handler;
+
+/// An allocator type that forwards memory allocation operations through an
+/// instance of @c any_completion_handler.
+template <typename T, typename... Signatures>
+class any_completion_handler_allocator
+{
+private:
+  template <typename...>
+  friend class any_completion_handler;
+
+  template <typename, typename...>
+  friend class any_completion_handler_allocator;
+
+  const detail::any_completion_handler_fn_table<Signatures...>* fn_table_;
+  detail::any_completion_handler_impl_base* impl_;
+
+  constexpr any_completion_handler_allocator(int,
+      const any_completion_handler<Signatures...>& h) BOOST_ASIO_NOEXCEPT
+    : fn_table_(h.fn_table_),
+      impl_(h.impl_)
+  {
+  }
+
+public:
+  /// The type of objects that may be allocated by the allocator.
+  typedef T value_type;
+
+  /// Rebinds an allocator to another value type.
+  template <typename U>
+  struct rebind
+  {
+    /// Specifies the type of the rebound allocator.
+    typedef any_completion_handler_allocator<U, Signatures...> other;
+  };
+
+  /// Construct from another @c any_completion_handler_allocator.
+  template <typename U>
+  constexpr any_completion_handler_allocator(
+      const any_completion_handler_allocator<U, Signatures...>& a)
+    BOOST_ASIO_NOEXCEPT
+    : fn_table_(a.fn_table_),
+      impl_(a.impl_)
+  {
+  }
+
+  /// Equality operator.
+  constexpr bool operator==(
+      const any_completion_handler_allocator& other) const BOOST_ASIO_NOEXCEPT
+  {
+    return fn_table_ == other.fn_table_ && impl_ == other.impl_;
+  }
+
+  /// Inequality operator.
+  constexpr bool operator!=(
+      const any_completion_handler_allocator& other) const BOOST_ASIO_NOEXCEPT
+  {
+    return fn_table_ != other.fn_table_ || impl_ != other.impl_;
+  }
+
+  /// Allocate space for @c n objects of the allocator's value type.
+  T* allocate(std::size_t n) const
+  {
+    return static_cast<T*>(
+        fn_table_->allocate(
+          impl_, sizeof(T) * n, alignof(T)));
+  }
+
+  /// Deallocate space for @c n objects of the allocator's value type.
+  void deallocate(T* p, std::size_t n) const
+  {
+    fn_table_->deallocate(impl_, p, sizeof(T) * n, alignof(T));
+  }
+};
+
+/// A protoco-allocator type that may be rebound to obtain an allocator that
+/// forwards memory allocation operations through an instance of
+/// @c any_completion_handler.
+template <typename... Signatures>
+class any_completion_handler_allocator<void, Signatures...>
+{
+private:
+  template <typename...>
+  friend class any_completion_handler;
+
+  template <typename, typename...>
+  friend class any_completion_handler_allocator;
+
+  const detail::any_completion_handler_fn_table<Signatures...>* fn_table_;
+  detail::any_completion_handler_impl_base* impl_;
+
+  constexpr any_completion_handler_allocator(int,
+      const any_completion_handler<Signatures...>& h) BOOST_ASIO_NOEXCEPT
+    : fn_table_(h.fn_table_),
+      impl_(h.impl_)
+  {
+  }
+
+public:
+  /// @c void as no objects can be allocated through a proto-allocator.
+  typedef void value_type;
+
+  /// Rebinds an allocator to another value type.
+  template <typename U>
+  struct rebind
+  {
+    /// Specifies the type of the rebound allocator.
+    typedef any_completion_handler_allocator<U, Signatures...> other;
+  };
+
+  /// Construct from another @c any_completion_handler_allocator.
+  template <typename U>
+  constexpr any_completion_handler_allocator(
+      const any_completion_handler_allocator<U, Signatures...>& a)
+    BOOST_ASIO_NOEXCEPT
+    : fn_table_(a.fn_table_),
+      impl_(a.impl_)
+  {
+  }
+
+  /// Equality operator.
+  constexpr bool operator==(
+      const any_completion_handler_allocator& other) const BOOST_ASIO_NOEXCEPT
+  {
+    return fn_table_ == other.fn_table_ && impl_ == other.impl_;
+  }
+
+  /// Inequality operator.
+  constexpr bool operator!=(
+      const any_completion_handler_allocator& other) const BOOST_ASIO_NOEXCEPT
+  {
+    return fn_table_ != other.fn_table_ || impl_ != other.impl_;
+  }
+};
+
+/// Polymorphic wrapper for completion handlers.
+/**
+ * The @c any_completion_handler class template is a polymorphic wrapper for
+ * completion handlers that propagates the associated executor, associated
+ * allocator, and associated cancellation slot through a type-erasing interface.
+ *
+ * When using @c any_completion_handler, specify one or more completion
+ * signatures as template parameters. These will dictate the arguments that may
+ * be passed to the handler through the polymorphic interface.
+ *
+ * Typical uses for @c any_completion_handler include:
+ *
+ * @li Separate compilation of asynchronous operation implementations.
+ *
+ * @li Enabling interoperability between asynchronous operations and virtual
+ *     functions.
+ */
+template <typename... Signatures>
+class any_completion_handler
+{
+#if !defined(GENERATING_DOCUMENTATION)
+private:
+  template <typename, typename...>
+  friend class any_completion_handler_allocator;
+
+  template <typename, typename>
+  friend struct associated_executor;
+
+  template <typename, typename>
+  friend struct associated_immediate_executor;
+
+  const detail::any_completion_handler_fn_table<Signatures...>* fn_table_;
+  detail::any_completion_handler_impl_base* impl_;
+#endif // !defined(GENERATING_DOCUMENTATION)
+
+public:
+  /// The associated allocator type.
+  using allocator_type = any_completion_handler_allocator<void, Signatures...>;
+
+  /// The associated cancellation slot type.
+  using cancellation_slot_type = cancellation_slot;
+
+  /// Construct an @c any_completion_handler in an empty state, without a target
+  /// object.
+  constexpr any_completion_handler()
+    : fn_table_(nullptr),
+      impl_(nullptr)
+  {
+  }
+
+  /// Construct an @c any_completion_handler in an empty state, without a target
+  /// object.
+  constexpr any_completion_handler(nullptr_t)
+    : fn_table_(nullptr),
+      impl_(nullptr)
+  {
+  }
+
+  /// Construct an @c any_completion_handler to contain the specified target.
+  template <typename H, typename Handler = typename decay<H>::type>
+  any_completion_handler(H&& h,
+      typename constraint<
+        !is_same<typename decay<H>::type, any_completion_handler>::value
+      >::type = 0)
+    : fn_table_(
+        &detail::any_completion_handler_fn_table_instance<
+          Handler, Signatures...>::value),
+      impl_(detail::any_completion_handler_impl<Handler>::create(
+            (get_associated_cancellation_slot)(h), BOOST_ASIO_MOVE_CAST(H)(h)))
+  {
+  }
+
+  /// Move-construct an @c any_completion_handler from another.
+  /**
+   * After the operation, the moved-from object @c other has no target.
+   */
+  any_completion_handler(any_completion_handler&& other) BOOST_ASIO_NOEXCEPT
+    : fn_table_(other.fn_table_),
+      impl_(other.impl_)
+  {
+    other.fn_table_ = nullptr;
+    other.impl_ = nullptr;
+  }
+
+  /// Move-assign an @c any_completion_handler from another.
+  /**
+   * After the operation, the moved-from object @c other has no target.
+   */
+  any_completion_handler& operator=(
+      any_completion_handler&& other) BOOST_ASIO_NOEXCEPT
+  {
+    any_completion_handler(
+        BOOST_ASIO_MOVE_CAST(any_completion_handler)(other)).swap(*this);
+    return *this;
+  }
+
+  /// Assignment operator that sets the polymorphic wrapper to the empty state.
+  any_completion_handler& operator=(nullptr_t) BOOST_ASIO_NOEXCEPT
+  {
+    any_completion_handler().swap(*this);
+    return *this;
+  }
+
+  /// Destructor.
+  ~any_completion_handler()
+  {
+    if (impl_)
+      fn_table_->destroy(impl_);
+  }
+
+  /// Test if the polymorphic wrapper is empty.
+  constexpr explicit operator bool() const BOOST_ASIO_NOEXCEPT
+  {
+    return impl_ != nullptr;
+  }
+
+  /// Test if the polymorphic wrapper is non-empty.
+  constexpr bool operator!() const BOOST_ASIO_NOEXCEPT
+  {
+    return impl_ == nullptr;
+  }
+
+  /// Swap the content of an @c any_completion_handler with another.
+  void swap(any_completion_handler& other) BOOST_ASIO_NOEXCEPT
+  {
+    std::swap(fn_table_, other.fn_table_);
+    std::swap(impl_, other.impl_);
+  }
+
+  /// Get the associated allocator.
+  allocator_type get_allocator() const BOOST_ASIO_NOEXCEPT
+  {
+    return allocator_type(0, *this);
+  }
+
+  /// Get the associated cancellation slot.
+  cancellation_slot_type get_cancellation_slot() const BOOST_ASIO_NOEXCEPT
+  {
+    return impl_->get_cancellation_slot();
+  }
+
+  /// Function call operator.
+  /**
+   * Invokes target completion handler with the supplied arguments.
+   *
+   * This function may only be called once, as the target handler is moved from.
+   * The polymorphic wrapper is left in an empty state.
+   *
+   * Throws @c std::bad_function_call if the polymorphic wrapper is empty.
+   */
+  template <typename... Args>
+  auto operator()(Args&&... args)
+    -> decltype(fn_table_->call(impl_, BOOST_ASIO_MOVE_CAST(Args)(args)...))
+  {
+    if (detail::any_completion_handler_impl_base* impl = impl_)
+    {
+      impl_ = nullptr;
+      return fn_table_->call(impl, BOOST_ASIO_MOVE_CAST(Args)(args)...);
+    }
+    std::bad_function_call ex;
+    boost::asio::detail::throw_exception(ex);
+  }
+
+  /// Equality operator.
+  friend constexpr bool operator==(
+      const any_completion_handler& a, nullptr_t) BOOST_ASIO_NOEXCEPT
+  {
+    return a.impl_ == nullptr;
+  }
+
+  /// Equality operator.
+  friend constexpr bool operator==(
+      nullptr_t, const any_completion_handler& b) BOOST_ASIO_NOEXCEPT
+  {
+    return nullptr == b.impl_;
+  }
+
+  /// Inequality operator.
+  friend constexpr bool operator!=(
+      const any_completion_handler& a, nullptr_t) BOOST_ASIO_NOEXCEPT
+  {
+    return a.impl_ != nullptr;
+  }
+
+  /// Inequality operator.
+  friend constexpr bool operator!=(
+      nullptr_t, const any_completion_handler& b) BOOST_ASIO_NOEXCEPT
+  {
+    return nullptr != b.impl_;
+  }
+};
+
+template <typename... Signatures, typename Candidate>
+struct associated_executor<any_completion_handler<Signatures...>, Candidate>
+{
+  using type = any_completion_executor;
+
+  static type get(const any_completion_handler<Signatures...>& handler,
+      const Candidate& candidate = Candidate()) BOOST_ASIO_NOEXCEPT
+  {
+    return handler.fn_table_->executor(handler.impl_,
+        any_completion_executor(std::nothrow, candidate));
+  }
+};
+
+template <typename... Signatures, typename Candidate>
+struct associated_immediate_executor<
+    any_completion_handler<Signatures...>, Candidate>
+{
+  using type = any_completion_executor;
+
+  static type get(const any_completion_handler<Signatures...>& handler,
+      const Candidate& candidate = Candidate()) BOOST_ASIO_NOEXCEPT
+  {
+    return handler.fn_table_->immediate_executor(handler.impl_,
+        any_io_executor(std::nothrow, candidate));
+  }
+};
+
+} // namespace asio
+} // namespace boost
+
+#include <boost/asio/detail/pop_options.hpp>
+
+#endif // (defined(BOOST_ASIO_HAS_STD_TUPLE)
+       //     && defined(BOOST_ASIO_HAS_MOVE)
+       //     && defined(BOOST_ASIO_HAS_VARIADIC_TEMPLATES))
+       //   || defined(GENERATING_DOCUMENTATION)
+
+#endif // BOOST_ASIO_ANY_COMPLETION_HANDLER_HPP

linx64/include/boost/asio/any_io_executor.hpp

@@ -0,0 +1,361 @@
+//
+// any_io_executor.hpp
+// ~~~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2023 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef BOOST_ASIO_ANY_IO_EXECUTOR_HPP
+#define BOOST_ASIO_ANY_IO_EXECUTOR_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include <boost/asio/detail/config.hpp>
+#if defined(BOOST_ASIO_USE_TS_EXECUTOR_AS_DEFAULT)
+# include <boost/asio/executor.hpp>
+#else // defined(BOOST_ASIO_USE_TS_EXECUTOR_AS_DEFAULT)
+# include <boost/asio/execution.hpp>
+# include <boost/asio/execution_context.hpp>
+#endif // defined(BOOST_ASIO_USE_TS_EXECUTOR_AS_DEFAULT)
+
+#include <boost/asio/detail/push_options.hpp>
+
+namespace boost {
+namespace asio {
+
+#if defined(BOOST_ASIO_USE_TS_EXECUTOR_AS_DEFAULT)
+
+typedef executor any_io_executor;
+
+#else // defined(BOOST_ASIO_USE_TS_EXECUTOR_AS_DEFAULT)
+
+/// Polymorphic executor type for use with I/O objects.
+/**
+ * The @c any_io_executor type is a polymorphic executor that supports the set
+ * of properties required by I/O objects. It is defined as the
+ * execution::any_executor class template parameterised as follows:
+ * @code execution::any_executor<
+ *   execution::context_as_t<execution_context&>,
+ *   execution::blocking_t::never_t,
+ *   execution::prefer_only<execution::blocking_t::possibly_t>,
+ *   execution::prefer_only<execution::outstanding_work_t::tracked_t>,
+ *   execution::prefer_only<execution::outstanding_work_t::untracked_t>,
+ *   execution::prefer_only<execution::relationship_t::fork_t>,
+ *   execution::prefer_only<execution::relationship_t::continuation_t>
+ * > @endcode
+ */
+class any_io_executor :
+#if defined(GENERATING_DOCUMENTATION)
+  public execution::any_executor<...>
+#else // defined(GENERATING_DOCUMENTATION)
+  public execution::any_executor<
+      execution::context_as_t<execution_context&>,
+      execution::blocking_t::never_t,
+      execution::prefer_only<execution::blocking_t::possibly_t>,
+      execution::prefer_only<execution::outstanding_work_t::tracked_t>,
+      execution::prefer_only<execution::outstanding_work_t::untracked_t>,
+      execution::prefer_only<execution::relationship_t::fork_t>,
+      execution::prefer_only<execution::relationship_t::continuation_t>
+    >
+#endif // defined(GENERATING_DOCUMENTATION)
+{
+public:
+#if !defined(GENERATING_DOCUMENTATION)
+  typedef execution::any_executor<
+      execution::context_as_t<execution_context&>,
+      execution::blocking_t::never_t,
+      execution::prefer_only<execution::blocking_t::possibly_t>,
+      execution::prefer_only<execution::outstanding_work_t::tracked_t>,
+      execution::prefer_only<execution::outstanding_work_t::untracked_t>,
+      execution::prefer_only<execution::relationship_t::fork_t>,
+      execution::prefer_only<execution::relationship_t::continuation_t>
+    > base_type;
+
+  typedef void supportable_properties_type(
+      execution::context_as_t<execution_context&>,
+      execution::blocking_t::never_t,
+      execution::prefer_only<execution::blocking_t::possibly_t>,
+      execution::prefer_only<execution::outstanding_work_t::tracked_t>,
+      execution::prefer_only<execution::outstanding_work_t::untracked_t>,
+      execution::prefer_only<execution::relationship_t::fork_t>,
+      execution::prefer_only<execution::relationship_t::continuation_t>
+    );
+#endif // !defined(GENERATING_DOCUMENTATION)
+
+  /// Default constructor.
+  BOOST_ASIO_DECL any_io_executor() BOOST_ASIO_NOEXCEPT;
+
+  /// Construct in an empty state. Equivalent effects to default constructor.
+  BOOST_ASIO_DECL any_io_executor(nullptr_t) BOOST_ASIO_NOEXCEPT;
+
+  /// Copy constructor.
+  BOOST_ASIO_DECL any_io_executor(const any_io_executor& e) BOOST_ASIO_NOEXCEPT;
+
+#if defined(BOOST_ASIO_HAS_MOVE) || defined(GENERATING_DOCUMENTATION)
+  /// Move constructor.
+  BOOST_ASIO_DECL any_io_executor(any_io_executor&& e) BOOST_ASIO_NOEXCEPT;
+#endif // defined(BOOST_ASIO_HAS_MOVE) || defined(GENERATING_DOCUMENTATION)
+
+  /// Construct to point to the same target as another any_executor.
+#if defined(GENERATING_DOCUMENTATION)
+  template <class... OtherSupportableProperties>
+    any_io_executor(execution::any_executor<OtherSupportableProperties...> e);
+#else // defined(GENERATING_DOCUMENTATION)
+  template <typename OtherAnyExecutor>
+  any_io_executor(OtherAnyExecutor e,
+      typename constraint<
+        conditional<
+          !is_same<OtherAnyExecutor, any_io_executor>::value
+            && is_base_of<execution::detail::any_executor_base,
+              OtherAnyExecutor>::value,
+          typename execution::detail::supportable_properties<
+            0, supportable_properties_type>::template
+              is_valid_target<OtherAnyExecutor>,
+          false_type
+        >::type::value
+      >::type = 0)
+    : base_type(BOOST_ASIO_MOVE_CAST(OtherAnyExecutor)(e))
+  {
+  }
+#endif // defined(GENERATING_DOCUMENTATION)
+
+  /// Construct to point to the same target as another any_executor.
+#if defined(GENERATING_DOCUMENTATION)
+  template <class... OtherSupportableProperties>
+    any_io_executor(std::nothrow_t,
+      execution::any_executor<OtherSupportableProperties...> e);
+#else // defined(GENERATING_DOCUMENTATION)
+  template <typename OtherAnyExecutor>
+  any_io_executor(std::nothrow_t, OtherAnyExecutor e,
+      typename constraint<
+        conditional<
+          !is_same<OtherAnyExecutor, any_io_executor>::value
+            && is_base_of<execution::detail::any_executor_base,
+              OtherAnyExecutor>::value,
+          typename execution::detail::supportable_properties<
+            0, supportable_properties_type>::template
+              is_valid_target<OtherAnyExecutor>,
+          false_type
+        >::type::value
+      >::type = 0) BOOST_ASIO_NOEXCEPT
+    : base_type(std::nothrow, BOOST_ASIO_MOVE_CAST(OtherAnyExecutor)(e))
+  {
+  }
+#endif // defined(GENERATING_DOCUMENTATION)
+
+  /// Construct to point to the same target as another any_executor.
+  BOOST_ASIO_DECL any_io_executor(std::nothrow_t,
+      const any_io_executor& e) BOOST_ASIO_NOEXCEPT;
+
+#if defined(BOOST_ASIO_HAS_MOVE) || defined(GENERATING_DOCUMENTATION)
+  /// Construct to point to the same target as another any_executor.
+  BOOST_ASIO_DECL any_io_executor(std::nothrow_t,
+      any_io_executor&& e) BOOST_ASIO_NOEXCEPT;
+#endif // defined(BOOST_ASIO_HAS_MOVE) || defined(GENERATING_DOCUMENTATION)
+
+  /// Construct a polymorphic wrapper for the specified executor.
+#if defined(GENERATING_DOCUMENTATION)
+  template <BOOST_ASIO_EXECUTION_EXECUTOR Executor>
+  any_io_executor(Executor e);
+#else // defined(GENERATING_DOCUMENTATION)
+  template <BOOST_ASIO_EXECUTION_EXECUTOR Executor>
+  any_io_executor(Executor e,
+      typename constraint<
+        conditional<
+          !is_same<Executor, any_io_executor>::value
+            && !is_base_of<execution::detail::any_executor_base,
+              Executor>::value,
+          execution::detail::is_valid_target_executor<
+            Executor, supportable_properties_type>,
+          false_type
+        >::type::value
+      >::type = 0)
+    : base_type(BOOST_ASIO_MOVE_CAST(Executor)(e))
+  {
+  }
+#endif // defined(GENERATING_DOCUMENTATION)
+
+  /// Construct a polymorphic wrapper for the specified executor.
+#if defined(GENERATING_DOCUMENTATION)
+  template <BOOST_ASIO_EXECUTION_EXECUTOR Executor>
+  any_io_executor(std::nothrow_t, Executor e);
+#else // defined(GENERATING_DOCUMENTATION)
+  template <BOOST_ASIO_EXECUTION_EXECUTOR Executor>
+  any_io_executor(std::nothrow_t, Executor e,
+      typename constraint<
+        conditional<
+          !is_same<Executor, any_io_executor>::value
+            && !is_base_of<execution::detail::any_executor_base,
+              Executor>::value,
+          execution::detail::is_valid_target_executor<
+            Executor, supportable_properties_type>,
+          false_type
+        >::type::value
+      >::type = 0) BOOST_ASIO_NOEXCEPT
+    : base_type(std::nothrow, BOOST_ASIO_MOVE_CAST(Executor)(e))
+  {
+  }
+#endif // defined(GENERATING_DOCUMENTATION)
+
+  /// Assignment operator.
+  BOOST_ASIO_DECL any_io_executor& operator=(
+      const any_io_executor& e) BOOST_ASIO_NOEXCEPT;
+
+#if defined(BOOST_ASIO_HAS_MOVE) || defined(GENERATING_DOCUMENTATION)
+  /// Move assignment operator.
+  BOOST_ASIO_DECL any_io_executor& operator=(
+      any_io_executor&& e) BOOST_ASIO_NOEXCEPT;
+#endif // defined(BOOST_ASIO_HAS_MOVE) || defined(GENERATING_DOCUMENTATION)
+
+  /// Assignment operator that sets the polymorphic wrapper to the empty state.
+  BOOST_ASIO_DECL any_io_executor& operator=(nullptr_t);
+
+  /// Destructor.
+  BOOST_ASIO_DECL ~any_io_executor();
+
+  /// Swap targets with another polymorphic wrapper.
+  BOOST_ASIO_DECL void swap(any_io_executor& other) BOOST_ASIO_NOEXCEPT;
+
+  /// Obtain a polymorphic wrapper with the specified property.
+  /**
+   * Do not call this function directly. It is intended for use with the
+   * boost::asio::require and boost::asio::prefer customisation points.
+   *
+   * For example:
+   * @code any_io_executor ex = ...;
+   * auto ex2 = boost::asio::require(ex, execution::blocking.possibly); @endcode
+   */
+  template <typename Property>
+  any_io_executor require(const Property& p,
+      typename constraint<
+        traits::require_member<const base_type&, const Property&>::is_valid
+      >::type = 0) const
+  {
+    return static_cast<const base_type&>(*this).require(p);
+  }
+
+  /// Obtain a polymorphic wrapper with the specified property.
+  /**
+   * Do not call this function directly. It is intended for use with the
+   * boost::asio::prefer customisation point.
+   *
+   * For example:
+   * @code any_io_executor ex = ...;
+   * auto ex2 = boost::asio::prefer(ex, execution::blocking.possibly); @endcode
+   */
+  template <typename Property>
+  any_io_executor prefer(const Property& p,
+      typename constraint<
+        traits::prefer_member<const base_type&, const Property&>::is_valid
+      >::type = 0) const
+  {
+    return static_cast<const base_type&>(*this).prefer(p);
+  }
+};
+
+#if !defined(GENERATING_DOCUMENTATION)
+
+template <>
+BOOST_ASIO_DECL any_io_executor any_io_executor::require(
+    const execution::blocking_t::never_t&, int) const;
+
+template <>
+BOOST_ASIO_DECL any_io_executor any_io_executor::prefer(
+    const execution::blocking_t::possibly_t&, int) const;
+
+template <>
+BOOST_ASIO_DECL any_io_executor any_io_executor::prefer(
+    const execution::outstanding_work_t::tracked_t&, int) const;
+
+template <>
+BOOST_ASIO_DECL any_io_executor any_io_executor::prefer(
+    const execution::outstanding_work_t::untracked_t&, int) const;
+
+template <>
+BOOST_ASIO_DECL any_io_executor any_io_executor::prefer(
+    const execution::relationship_t::fork_t&, int) const;
+
+template <>
+BOOST_ASIO_DECL any_io_executor any_io_executor::prefer(
+    const execution::relationship_t::continuation_t&, int) const;
+
+namespace traits {
+
+#if !defined(BOOST_ASIO_HAS_DEDUCED_EQUALITY_COMPARABLE_TRAIT)
+
+template <>
+struct equality_comparable<any_io_executor>
+{
+  static const bool is_valid = true;
+  static const bool is_noexcept = true;
+};
+
+#endif // !defined(BOOST_ASIO_HAS_DEDUCED_EQUALITY_COMPARABLE_TRAIT)
+
+#if !defined(BOOST_ASIO_HAS_DEDUCED_EXECUTE_MEMBER_TRAIT)
+
+template <typename F>
+struct execute_member<any_io_executor, F>
+{
+  static const bool is_valid = true;
+  static const bool is_noexcept = false;
+  typedef void result_type;
+};
+
+#endif // !defined(BOOST_ASIO_HAS_DEDUCED_EXECUTE_MEMBER_TRAIT)
+
+#if !defined(BOOST_ASIO_HAS_DEDUCED_QUERY_MEMBER_TRAIT)
+
+template <typename Prop>
+struct query_member<any_io_executor, Prop> :
+  query_member<any_io_executor::base_type, Prop>
+{
+};
+
+#endif // !defined(BOOST_ASIO_HAS_DEDUCED_QUERY_MEMBER_TRAIT)
+
+#if !defined(BOOST_ASIO_HAS_DEDUCED_REQUIRE_MEMBER_TRAIT)
+
+template <typename Prop>
+struct require_member<any_io_executor, Prop> :
+  require_member<any_io_executor::base_type, Prop>
+{
+  typedef any_io_executor result_type;
+};
+
+#endif // !defined(BOOST_ASIO_HAS_DEDUCED_REQUIRE_MEMBER_TRAIT)
+
+#if !defined(BOOST_ASIO_HAS_DEDUCED_PREFER_MEMBER_TRAIT)
+
+template <typename Prop>
+struct prefer_member<any_io_executor, Prop> :
+  prefer_member<any_io_executor::base_type, Prop>
+{
+  typedef any_io_executor result_type;
+};
+
+#endif // !defined(BOOST_ASIO_HAS_DEDUCED_PREFER_MEMBER_TRAIT)
+
+} // namespace traits
+
+#endif // !defined(GENERATING_DOCUMENTATION)
+
+#endif // defined(BOOST_ASIO_USE_TS_EXECUTOR_AS_DEFAULT)
+
+} // namespace asio
+} // namespace boost
+
+#include <boost/asio/detail/pop_options.hpp>
+
+#if defined(BOOST_ASIO_HEADER_ONLY) \
+  && !defined(BOOST_ASIO_USE_TS_EXECUTOR_AS_DEFAULT)
+# include <boost/asio/impl/any_io_executor.ipp>
+#endif // defined(BOOST_ASIO_HEADER_ONLY)
+       //   && !defined(BOOST_ASIO_USE_TS_EXECUTOR_AS_DEFAULT)
+
+#endif // BOOST_ASIO_ANY_IO_EXECUTOR_HPP

linx64/include/boost/asio/append.hpp

@@ -0,0 +1,80 @@
+//
+// append.hpp
+// ~~~~~~~~~~
+//
+// Copyright (c) 2003-2023 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef BOOST_ASIO_APPEND_HPP
+#define BOOST_ASIO_APPEND_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include <boost/asio/detail/config.hpp>
+
+#if (defined(BOOST_ASIO_HAS_STD_TUPLE) \
+    && defined(BOOST_ASIO_HAS_VARIADIC_TEMPLATES)) \
+  || defined(GENERATING_DOCUMENTATION)
+
+#include <tuple>
+#include <boost/asio/detail/type_traits.hpp>
+
+#include <boost/asio/detail/push_options.hpp>
+
+namespace boost {
+namespace asio {
+
+/// Completion token type used to specify that the completion handler
+/// arguments should be passed additional values after the results of the
+/// operation.
+template <typename CompletionToken, typename... Values>
+class append_t
+{
+public:
+  /// Constructor.
+  template <typename T, typename... V>
+  BOOST_ASIO_CONSTEXPR explicit append_t(
+      BOOST_ASIO_MOVE_ARG(T) completion_token,
+      BOOST_ASIO_MOVE_ARG(V)... values)
+    : token_(BOOST_ASIO_MOVE_CAST(T)(completion_token)),
+      values_(BOOST_ASIO_MOVE_CAST(V)(values)...)
+  {
+  }
+
+//private:
+  CompletionToken token_;
+  std::tuple<Values...> values_;
+};
+
+/// Completion token type used to specify that the completion handler
+/// arguments should be passed additional values after the results of the
+/// operation.
+template <typename CompletionToken, typename... Values>
+BOOST_ASIO_NODISCARD inline BOOST_ASIO_CONSTEXPR append_t<
+  typename decay<CompletionToken>::type, typename decay<Values>::type...>
+append(BOOST_ASIO_MOVE_ARG(CompletionToken) completion_token,
+    BOOST_ASIO_MOVE_ARG(Values)... values)
+{
+  return append_t<
+    typename decay<CompletionToken>::type, typename decay<Values>::type...>(
+      BOOST_ASIO_MOVE_CAST(CompletionToken)(completion_token),
+      BOOST_ASIO_MOVE_CAST(Values)(values)...);
+}
+
+} // namespace asio
+} // namespace boost
+
+#include <boost/asio/detail/pop_options.hpp>
+
+#include <boost/asio/impl/append.hpp>
+
+#endif // (defined(BOOST_ASIO_HAS_STD_TUPLE)
+       //     && defined(BOOST_ASIO_HAS_VARIADIC_TEMPLATES))
+       //   || defined(GENERATING_DOCUMENTATION)
+
+#endif // BOOST_ASIO_APPEND_HPP

linx64/include/boost/asio/as_tuple.hpp

@@ -0,0 +1,141 @@
+//
+// as_tuple.hpp
+// ~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2023 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef BOOST_ASIO_AS_TUPLE_HPP
+#define BOOST_ASIO_AS_TUPLE_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include <boost/asio/detail/config.hpp>
+
+#if (defined(BOOST_ASIO_HAS_STD_TUPLE) \
+    && defined(BOOST_ASIO_HAS_VARIADIC_TEMPLATES)) \
+  || defined(GENERATING_DOCUMENTATION)
+
+#include <boost/asio/detail/type_traits.hpp>
+
+#include <boost/asio/detail/push_options.hpp>
+
+namespace boost {
+namespace asio {
+
+/// A @ref completion_token adapter used to specify that the completion handler
+/// arguments should be combined into a single tuple argument.
+/**
+ * The as_tuple_t class is used to indicate that any arguments to the
+ * completion handler should be combined and passed as a single tuple argument.
+ * The arguments are first moved into a @c std::tuple and that tuple is then
+ * passed to the completion handler.
+ */
+template <typename CompletionToken>
+class as_tuple_t
+{
+public:
+  /// Tag type used to prevent the "default" constructor from being used for
+  /// conversions.
+  struct default_constructor_tag {};
+
+  /// Default constructor.
+  /**
+   * This constructor is only valid if the underlying completion token is
+   * default constructible and move constructible. The underlying completion
+   * token is itself defaulted as an argument to allow it to capture a source
+   * location.
+   */
+  BOOST_ASIO_CONSTEXPR as_tuple_t(
+      default_constructor_tag = default_constructor_tag(),
+      CompletionToken token = CompletionToken())
+    : token_(BOOST_ASIO_MOVE_CAST(CompletionToken)(token))
+  {
+  }
+
+  /// Constructor.
+  template <typename T>
+  BOOST_ASIO_CONSTEXPR explicit as_tuple_t(
+      BOOST_ASIO_MOVE_ARG(T) completion_token)
+    : token_(BOOST_ASIO_MOVE_CAST(T)(completion_token))
+  {
+  }
+
+  /// Adapts an executor to add the @c as_tuple_t completion token as the
+  /// default.
+  template <typename InnerExecutor>
+  struct executor_with_default : InnerExecutor
+  {
+    /// Specify @c as_tuple_t as the default completion token type.
+    typedef as_tuple_t default_completion_token_type;
+
+    /// Construct the adapted executor from the inner executor type.
+    template <typename InnerExecutor1>
+    executor_with_default(const InnerExecutor1& ex,
+        typename constraint<
+          conditional<
+            !is_same<InnerExecutor1, executor_with_default>::value,
+            is_convertible<InnerExecutor1, InnerExecutor>,
+            false_type
+          >::type::value
+        >::type = 0) BOOST_ASIO_NOEXCEPT
+      : InnerExecutor(ex)
+    {
+    }
+  };
+
+  /// Type alias to adapt an I/O object to use @c as_tuple_t as its
+  /// default completion token type.
+#if defined(BOOST_ASIO_HAS_ALIAS_TEMPLATES) \
+  || defined(GENERATING_DOCUMENTATION)
+  template <typename T>
+  using as_default_on_t = typename T::template rebind_executor<
+      executor_with_default<typename T::executor_type> >::other;
+#endif // defined(BOOST_ASIO_HAS_ALIAS_TEMPLATES)
+       //   || defined(GENERATING_DOCUMENTATION)
+
+  /// Function helper to adapt an I/O object to use @c as_tuple_t as its
+  /// default completion token type.
+  template <typename T>
+  static typename decay<T>::type::template rebind_executor<
+      executor_with_default<typename decay<T>::type::executor_type>
+    >::other
+  as_default_on(BOOST_ASIO_MOVE_ARG(T) object)
+  {
+    return typename decay<T>::type::template rebind_executor<
+        executor_with_default<typename decay<T>::type::executor_type>
+      >::other(BOOST_ASIO_MOVE_CAST(T)(object));
+  }
+
+//private:
+  CompletionToken token_;
+};
+
+/// Adapt a @ref completion_token to specify that the completion handler
+/// arguments should be combined into a single tuple argument.
+template <typename CompletionToken>
+BOOST_ASIO_NODISCARD inline
+BOOST_ASIO_CONSTEXPR as_tuple_t<typename decay<CompletionToken>::type>
+as_tuple(BOOST_ASIO_MOVE_ARG(CompletionToken) completion_token)
+{
+  return as_tuple_t<typename decay<CompletionToken>::type>(
+      BOOST_ASIO_MOVE_CAST(CompletionToken)(completion_token));
+}
+
+} // namespace asio
+} // namespace boost
+
+#include <boost/asio/detail/pop_options.hpp>
+
+#include <boost/asio/impl/as_tuple.hpp>
+
+#endif // (defined(BOOST_ASIO_HAS_STD_TUPLE)
+       //     && defined(BOOST_ASIO_HAS_VARIADIC_TEMPLATES))
+       //   || defined(GENERATING_DOCUMENTATION)
+
+#endif // BOOST_ASIO_AS_TUPLE_HPP

linx64/include/boost/asio/associated_allocator.hpp

@@ -2,7 +2,7 @@
 // associated_allocator.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2019 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2023 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -17,41 +17,80 @@
 
 #include <boost/asio/detail/config.hpp>
 #include <memory>
+#include <boost/asio/associator.hpp>
+#include <boost/asio/detail/functional.hpp>
 #include <boost/asio/detail/type_traits.hpp>
 
 #include <boost/asio/detail/push_options.hpp>
 
 namespace boost {
 namespace asio {
+
+template <typename T, typename Allocator>
+struct associated_allocator;
+
 namespace detail {
 
-template <typename>
-struct associated_allocator_check
+template <typename T, typename = void>
+struct has_allocator_type : false_type
 {
-  typedef void type;
 };
 
-template <typename T, typename E, typename = void>
+template <typename T>
+struct has_allocator_type<T,
+  typename void_type<typename T::allocator_type>::type>
+    : true_type
+{
+};
+
+template <typename T, typename A, typename = void, typename = void>
 struct associated_allocator_impl
 {
-  typedef E type;
+  typedef void asio_associated_allocator_is_unspecialised;
 
-  static type get(const T&, const E& e) BOOST_ASIO_NOEXCEPT
+  typedef A type;
+
+  static type get(const T&) BOOST_ASIO_NOEXCEPT
   {
-    return e;
+    return type();
+  }
+
+  static const type& get(const T&, const A& a) BOOST_ASIO_NOEXCEPT
+  {
+    return a;
   }
 };
 
-template <typename T, typename E>
-struct associated_allocator_impl<T, E,
-  typename associated_allocator_check<typename T::allocator_type>::type>
+template <typename T, typename A>
+struct associated_allocator_impl<T, A,
+  typename void_type<typename T::allocator_type>::type>
 {
   typedef typename T::allocator_type type;
 
-  static type get(const T& t, const E&) BOOST_ASIO_NOEXCEPT
+  static BOOST_ASIO_AUTO_RETURN_TYPE_PREFIX(type) get(
+      const T& t) BOOST_ASIO_NOEXCEPT
+    BOOST_ASIO_AUTO_RETURN_TYPE_SUFFIX((t.get_allocator()))
   {
     return t.get_allocator();
   }
+
+  static BOOST_ASIO_AUTO_RETURN_TYPE_PREFIX(type) get(
+      const T& t, const A&) BOOST_ASIO_NOEXCEPT
+    BOOST_ASIO_AUTO_RETURN_TYPE_SUFFIX((t.get_allocator()))
+  {
+    return t.get_allocator();
+  }
+};
+
+template <typename T, typename A>
+struct associated_allocator_impl<T, A,
+  typename enable_if<
+    !has_allocator_type<T>::value
+  >::type,
+  typename void_type<
+    typename associator<associated_allocator, T, A>::type
+  >::type> : associator<associated_allocator, T, A>
+{
 };
 
 } // namespace detail
@@ -70,29 +109,32 @@ struct associated_allocator_impl<T, E,
  * Allocator requirements.
  *
  * @li Provide a noexcept static member function named @c get, callable as @c
- * get(t) and with return type @c type.
+ * get(t) and with return type @c type or a (possibly const) reference to @c
+ * type.
  *
  * @li Provide a noexcept static member function named @c get, callable as @c
- * get(t,a) and with return type @c type.
+ * get(t,a) and with return type @c type or a (possibly const) reference to @c
+ * type.
  */
 template <typename T, typename Allocator = std::allocator<void> >
 struct associated_allocator
+#if !defined(GENERATING_DOCUMENTATION)
+  : detail::associated_allocator_impl<T, Allocator>
+#endif // !defined(GENERATING_DOCUMENTATION)
 {
+#if defined(GENERATING_DOCUMENTATION)
   /// If @c T has a nested type @c allocator_type, <tt>T::allocator_type</tt>.
   /// Otherwise @c Allocator.
-#if defined(GENERATING_DOCUMENTATION)
   typedef see_below type;
-#else // defined(GENERATING_DOCUMENTATION)
-  typedef typename detail::associated_allocator_impl<T, Allocator>::type type;
-#endif // defined(GENERATING_DOCUMENTATION)
+
+  /// If @c T has a nested type @c allocator_type, returns
+  /// <tt>t.get_allocator()</tt>. Otherwise returns @c type().
+  static decltype(auto) get(const T& t) BOOST_ASIO_NOEXCEPT;
 
   /// If @c T has a nested type @c allocator_type, returns
   /// <tt>t.get_allocator()</tt>. Otherwise returns @c a.
-  static type get(const T& t,
-      const Allocator& a = Allocator()) BOOST_ASIO_NOEXCEPT
-  {
-    return detail::associated_allocator_impl<T, Allocator>::get(t, a);
-  }
+  static decltype(auto) get(const T& t, const Allocator& a) BOOST_ASIO_NOEXCEPT;
+#endif // defined(GENERATING_DOCUMENTATION)
 };
 
 /// Helper function to obtain an object's associated allocator.
@@ -100,7 +142,7 @@ struct associated_allocator
  * @returns <tt>associated_allocator<T>::get(t)</tt>
  */
 template <typename T>
-inline typename associated_allocator<T>::type
+BOOST_ASIO_NODISCARD inline typename associated_allocator<T>::type
 get_associated_allocator(const T& t) BOOST_ASIO_NOEXCEPT
 {
   return associated_allocator<T>::get(t);
@@ -111,8 +153,11 @@ get_associated_allocator(const T& t) BOOST_ASIO_NOEXCEPT
  * @returns <tt>associated_allocator<T, Allocator>::get(t, a)</tt>
  */
 template <typename T, typename Allocator>
-inline typename associated_allocator<T, Allocator>::type
+BOOST_ASIO_NODISCARD inline BOOST_ASIO_AUTO_RETURN_TYPE_PREFIX2(
+    typename associated_allocator<T, Allocator>::type)
 get_associated_allocator(const T& t, const Allocator& a) BOOST_ASIO_NOEXCEPT
+  BOOST_ASIO_AUTO_RETURN_TYPE_SUFFIX((
+    associated_allocator<T, Allocator>::get(t, a)))
 {
   return associated_allocator<T, Allocator>::get(t, a);
 }
@@ -125,6 +170,63 @@ using associated_allocator_t
 
 #endif // defined(BOOST_ASIO_HAS_ALIAS_TEMPLATES)
 
+namespace detail {
+
+template <typename T, typename A, typename = void>
+struct associated_allocator_forwarding_base
+{
+};
+
+template <typename T, typename A>
+struct associated_allocator_forwarding_base<T, A,
+    typename enable_if<
+      is_same<
+        typename associated_allocator<T,
+          A>::asio_associated_allocator_is_unspecialised,
+        void
+      >::value
+    >::type>
+{
+  typedef void asio_associated_allocator_is_unspecialised;
+};
+
+} // namespace detail
+
+#if defined(BOOST_ASIO_HAS_STD_REFERENCE_WRAPPER) \
+  || defined(GENERATING_DOCUMENTATION)
+
+/// Specialisation of associated_allocator for @c std::reference_wrapper.
+template <typename T, typename Allocator>
+struct associated_allocator<reference_wrapper<T>, Allocator>
+#if !defined(GENERATING_DOCUMENTATION)
+  : detail::associated_allocator_forwarding_base<T, Allocator>
+#endif // !defined(GENERATING_DOCUMENTATION)
+{
+  /// Forwards @c type to the associator specialisation for the unwrapped type
+  /// @c T.
+  typedef typename associated_allocator<T, Allocator>::type type;
+
+  /// Forwards the request to get the allocator to the associator specialisation
+  /// for the unwrapped type @c T.
+  static type get(reference_wrapper<T> t) BOOST_ASIO_NOEXCEPT
+  {
+    return associated_allocator<T, Allocator>::get(t.get());
+  }
+
+  /// Forwards the request to get the allocator to the associator specialisation
+  /// for the unwrapped type @c T.
+  static BOOST_ASIO_AUTO_RETURN_TYPE_PREFIX(type) get(
+      reference_wrapper<T> t, const Allocator& a) BOOST_ASIO_NOEXCEPT
+    BOOST_ASIO_AUTO_RETURN_TYPE_SUFFIX((
+      associated_allocator<T, Allocator>::get(t.get(), a)))
+  {
+    return associated_allocator<T, Allocator>::get(t.get(), a);
+  }
+};
+
+#endif // defined(BOOST_ASIO_HAS_STD_REFERENCE_WRAPPER)
+       //   || defined(GENERATING_DOCUMENTATION)
+
 } // namespace asio
 } // namespace boost
 

linx64/include/boost/asio/associated_cancellation_slot.hpp

@@ -0,0 +1,240 @@
+//
+// associated_cancellation_slot.hpp
+// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2023 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef BOOST_ASIO_ASSOCIATED_CANCELLATION_SLOT_HPP
+#define BOOST_ASIO_ASSOCIATED_CANCELLATION_SLOT_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include <boost/asio/detail/config.hpp>
+#include <boost/asio/associator.hpp>
+#include <boost/asio/cancellation_signal.hpp>
+#include <boost/asio/detail/functional.hpp>
+#include <boost/asio/detail/type_traits.hpp>
+
+#include <boost/asio/detail/push_options.hpp>
+
+namespace boost {
+namespace asio {
+
+template <typename T, typename CancellationSlot>
+struct associated_cancellation_slot;
+
+namespace detail {
+
+template <typename T, typename = void>
+struct has_cancellation_slot_type : false_type
+{
+};
+
+template <typename T>
+struct has_cancellation_slot_type<T,
+  typename void_type<typename T::cancellation_slot_type>::type>
+    : true_type
+{
+};
+
+template <typename T, typename S, typename = void, typename = void>
+struct associated_cancellation_slot_impl
+{
+  typedef void asio_associated_cancellation_slot_is_unspecialised;
+
+  typedef S type;
+
+  static type get(const T&) BOOST_ASIO_NOEXCEPT
+  {
+    return type();
+  }
+
+  static const type& get(const T&, const S& s) BOOST_ASIO_NOEXCEPT
+  {
+    return s;
+  }
+};
+
+template <typename T, typename S>
+struct associated_cancellation_slot_impl<T, S,
+  typename void_type<typename T::cancellation_slot_type>::type>
+{
+  typedef typename T::cancellation_slot_type type;
+
+  static BOOST_ASIO_AUTO_RETURN_TYPE_PREFIX(type) get(
+      const T& t) BOOST_ASIO_NOEXCEPT
+    BOOST_ASIO_AUTO_RETURN_TYPE_SUFFIX((t.get_cancellation_slot()))
+  {
+    return t.get_cancellation_slot();
+  }
+
+  static BOOST_ASIO_AUTO_RETURN_TYPE_PREFIX(type) get(
+      const T& t, const S&) BOOST_ASIO_NOEXCEPT
+    BOOST_ASIO_AUTO_RETURN_TYPE_SUFFIX((t.get_cancellation_slot()))
+  {
+    return t.get_cancellation_slot();
+  }
+};
+
+template <typename T, typename S>
+struct associated_cancellation_slot_impl<T, S,
+  typename enable_if<
+    !has_cancellation_slot_type<T>::value
+  >::type,
+  typename void_type<
+    typename associator<associated_cancellation_slot, T, S>::type
+  >::type> : associator<associated_cancellation_slot, T, S>
+{
+};
+
+} // namespace detail
+
+/// Traits type used to obtain the cancellation_slot associated with an object.
+/**
+ * A program may specialise this traits type if the @c T template parameter in
+ * the specialisation is a user-defined type. The template parameter @c
+ * CancellationSlot shall be a type meeting the CancellationSlot requirements.
+ *
+ * Specialisations shall meet the following requirements, where @c t is a const
+ * reference to an object of type @c T, and @c s is an object of type @c
+ * CancellationSlot.
+ *
+ * @li Provide a nested typedef @c type that identifies a type meeting the
+ * CancellationSlot requirements.
+ *
+ * @li Provide a noexcept static member function named @c get, callable as @c
+ * get(t) and with return type @c type or a (possibly const) reference to @c
+ * type.
+ *
+ * @li Provide a noexcept static member function named @c get, callable as @c
+ * get(t,s) and with return type @c type or a (possibly const) reference to @c
+ * type.
+ */
+template <typename T, typename CancellationSlot = cancellation_slot>
+struct associated_cancellation_slot
+#if !defined(GENERATING_DOCUMENTATION)
+  : detail::associated_cancellation_slot_impl<T, CancellationSlot>
+#endif // !defined(GENERATING_DOCUMENTATION)
+{
+#if defined(GENERATING_DOCUMENTATION)
+  /// If @c T has a nested type @c cancellation_slot_type,
+  /// <tt>T::cancellation_slot_type</tt>. Otherwise
+  /// @c CancellationSlot.
+  typedef see_below type;
+
+  /// If @c T has a nested type @c cancellation_slot_type, returns
+  /// <tt>t.get_cancellation_slot()</tt>. Otherwise returns @c type().
+  static decltype(auto) get(const T& t) BOOST_ASIO_NOEXCEPT;
+
+  /// If @c T has a nested type @c cancellation_slot_type, returns
+  /// <tt>t.get_cancellation_slot()</tt>. Otherwise returns @c s.
+  static decltype(auto) get(const T& t,
+      const CancellationSlot& s) BOOST_ASIO_NOEXCEPT;
+#endif // defined(GENERATING_DOCUMENTATION)
+};
+
+/// Helper function to obtain an object's associated cancellation_slot.
+/**
+ * @returns <tt>associated_cancellation_slot<T>::get(t)</tt>
+ */
+template <typename T>
+BOOST_ASIO_NODISCARD inline typename associated_cancellation_slot<T>::type
+get_associated_cancellation_slot(const T& t) BOOST_ASIO_NOEXCEPT
+{
+  return associated_cancellation_slot<T>::get(t);
+}
+
+/// Helper function to obtain an object's associated cancellation_slot.
+/**
+ * @returns <tt>associated_cancellation_slot<T,
+ * CancellationSlot>::get(t, st)</tt>
+ */
+template <typename T, typename CancellationSlot>
+BOOST_ASIO_NODISCARD inline BOOST_ASIO_AUTO_RETURN_TYPE_PREFIX2(
+    typename associated_cancellation_slot<T, CancellationSlot>::type)
+get_associated_cancellation_slot(const T& t,
+    const CancellationSlot& st) BOOST_ASIO_NOEXCEPT
+  BOOST_ASIO_AUTO_RETURN_TYPE_SUFFIX((
+    associated_cancellation_slot<T, CancellationSlot>::get(t, st)))
+{
+  return associated_cancellation_slot<T, CancellationSlot>::get(t, st);
+}
+
+#if defined(BOOST_ASIO_HAS_ALIAS_TEMPLATES)
+
+template <typename T, typename CancellationSlot = cancellation_slot>
+using associated_cancellation_slot_t =
+  typename associated_cancellation_slot<T, CancellationSlot>::type;
+
+#endif // defined(BOOST_ASIO_HAS_ALIAS_TEMPLATES)
+
+namespace detail {
+
+template <typename T, typename S, typename = void>
+struct associated_cancellation_slot_forwarding_base
+{
+};
+
+template <typename T, typename S>
+struct associated_cancellation_slot_forwarding_base<T, S,
+    typename enable_if<
+      is_same<
+        typename associated_cancellation_slot<T,
+          S>::asio_associated_cancellation_slot_is_unspecialised,
+        void
+      >::value
+    >::type>
+{
+  typedef void asio_associated_cancellation_slot_is_unspecialised;
+};
+
+} // namespace detail
+
+#if defined(BOOST_ASIO_HAS_STD_REFERENCE_WRAPPER) \
+  || defined(GENERATING_DOCUMENTATION)
+
+/// Specialisation of associated_cancellation_slot for @c
+/// std::reference_wrapper.
+template <typename T, typename CancellationSlot>
+struct associated_cancellation_slot<reference_wrapper<T>, CancellationSlot>
+#if !defined(GENERATING_DOCUMENTATION)
+  : detail::associated_cancellation_slot_forwarding_base<T, CancellationSlot>
+#endif // !defined(GENERATING_DOCUMENTATION)
+{
+  /// Forwards @c type to the associator specialisation for the unwrapped type
+  /// @c T.
+  typedef typename associated_cancellation_slot<T, CancellationSlot>::type type;
+
+  /// Forwards the request to get the cancellation slot to the associator
+  /// specialisation for the unwrapped type @c T.
+  static type get(reference_wrapper<T> t) BOOST_ASIO_NOEXCEPT
+  {
+    return associated_cancellation_slot<T, CancellationSlot>::get(t.get());
+  }
+
+  /// Forwards the request to get the cancellation slot to the associator
+  /// specialisation for the unwrapped type @c T.
+  static BOOST_ASIO_AUTO_RETURN_TYPE_PREFIX(type) get(reference_wrapper<T> t,
+      const CancellationSlot& s) BOOST_ASIO_NOEXCEPT
+    BOOST_ASIO_AUTO_RETURN_TYPE_SUFFIX((
+      associated_cancellation_slot<T, CancellationSlot>::get(t.get(), s)))
+  {
+    return associated_cancellation_slot<T, CancellationSlot>::get(t.get(), s);
+  }
+};
+
+#endif // defined(BOOST_ASIO_HAS_STD_REFERENCE_WRAPPER)
+       //   || defined(GENERATING_DOCUMENTATION)
+
+} // namespace asio
+} // namespace boost
+
+#include <boost/asio/detail/pop_options.hpp>
+
+#endif // BOOST_ASIO_ASSOCIATED_CANCELLATION_SLOT_HPP

linx64/include/boost/asio/associated_executor.hpp

@@ -2,7 +2,7 @@
 // associated_executor.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2019 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2023 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -16,7 +16,10 @@
 #endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
 
 #include <boost/asio/detail/config.hpp>
+#include <boost/asio/associator.hpp>
+#include <boost/asio/detail/functional.hpp>
 #include <boost/asio/detail/type_traits.hpp>
+#include <boost/asio/execution/executor.hpp>
 #include <boost/asio/is_executor.hpp>
 #include <boost/asio/system_executor.hpp>
 
@@ -24,20 +27,37 @@
 
 namespace boost {
 namespace asio {
+
+template <typename T, typename Executor>
+struct associated_executor;
+
 namespace detail {
 
-template <typename>
-struct associated_executor_check
+template <typename T, typename = void>
+struct has_executor_type : false_type
 {
-  typedef void type;
 };
 
-template <typename T, typename E, typename = void>
+template <typename T>
+struct has_executor_type<T,
+  typename void_type<typename T::executor_type>::type>
+    : true_type
+{
+};
+
+template <typename T, typename E, typename = void, typename = void>
 struct associated_executor_impl
 {
+  typedef void asio_associated_executor_is_unspecialised;
+
   typedef E type;
 
-  static type get(const T&, const E& e) BOOST_ASIO_NOEXCEPT
+  static type get(const T&) BOOST_ASIO_NOEXCEPT
+  {
+    return type();
+  }
+
+  static const type& get(const T&, const E& e) BOOST_ASIO_NOEXCEPT
   {
     return e;
   }
@@ -45,14 +65,34 @@ struct associated_executor_impl
 
 template <typename T, typename E>
 struct associated_executor_impl<T, E,
-  typename associated_executor_check<typename T::executor_type>::type>
+  typename void_type<typename T::executor_type>::type>
 {
   typedef typename T::executor_type type;
 
-  static type get(const T& t, const E&) BOOST_ASIO_NOEXCEPT
+  static BOOST_ASIO_AUTO_RETURN_TYPE_PREFIX(type) get(
+      const T& t) BOOST_ASIO_NOEXCEPT
+    BOOST_ASIO_AUTO_RETURN_TYPE_SUFFIX((t.get_executor()))
   {
     return t.get_executor();
   }
+
+  static BOOST_ASIO_AUTO_RETURN_TYPE_PREFIX(type) get(
+      const T& t, const E&) BOOST_ASIO_NOEXCEPT
+    BOOST_ASIO_AUTO_RETURN_TYPE_SUFFIX((t.get_executor()))
+  {
+    return t.get_executor();
+  }
+};
+
+template <typename T, typename E>
+struct associated_executor_impl<T, E,
+  typename enable_if<
+    !has_executor_type<T>::value
+  >::type,
+  typename void_type<
+    typename associator<associated_executor, T, E>::type
+  >::type> : associator<associated_executor, T, E>
+{
 };
 
 } // namespace detail
@@ -71,29 +111,32 @@ struct associated_executor_impl<T, E,
  * Executor requirements.
  *
  * @li Provide a noexcept static member function named @c get, callable as @c
- * get(t) and with return type @c type.
+ * get(t) and with return type @c type or a (possibly const) reference to @c
+ * type.
  *
  * @li Provide a noexcept static member function named @c get, callable as @c
- * get(t,e) and with return type @c type.
+ * get(t,e) and with return type @c type or a (possibly const) reference to @c
+ * type.
  */
 template <typename T, typename Executor = system_executor>
 struct associated_executor
+#if !defined(GENERATING_DOCUMENTATION)
+  : detail::associated_executor_impl<T, Executor>
+#endif // !defined(GENERATING_DOCUMENTATION)
 {
+#if defined(GENERATING_DOCUMENTATION)
   /// If @c T has a nested type @c executor_type, <tt>T::executor_type</tt>.
   /// Otherwise @c Executor.
-#if defined(GENERATING_DOCUMENTATION)
   typedef see_below type;
-#else // defined(GENERATING_DOCUMENTATION)
-  typedef typename detail::associated_executor_impl<T, Executor>::type type;
-#endif // defined(GENERATING_DOCUMENTATION)
+
+  /// If @c T has a nested type @c executor_type, returns
+  /// <tt>t.get_executor()</tt>. Otherwise returns @c type().
+  static decltype(auto) get(const T& t) BOOST_ASIO_NOEXCEPT;
 
   /// If @c T has a nested type @c executor_type, returns
   /// <tt>t.get_executor()</tt>. Otherwise returns @c ex.
-  static type get(const T& t,
-      const Executor& ex = Executor()) BOOST_ASIO_NOEXCEPT
-  {
-    return detail::associated_executor_impl<T, Executor>::get(t, ex);
-  }
+  static decltype(auto) get(const T& t, const Executor& ex) BOOST_ASIO_NOEXCEPT;
+#endif // defined(GENERATING_DOCUMENTATION)
 };
 
 /// Helper function to obtain an object's associated executor.
@@ -101,7 +144,7 @@ struct associated_executor
  * @returns <tt>associated_executor<T>::get(t)</tt>
  */
 template <typename T>
-inline typename associated_executor<T>::type
+BOOST_ASIO_NODISCARD inline typename associated_executor<T>::type
 get_associated_executor(const T& t) BOOST_ASIO_NOEXCEPT
 {
   return associated_executor<T>::get(t);
@@ -112,10 +155,14 @@ get_associated_executor(const T& t) BOOST_ASIO_NOEXCEPT
  * @returns <tt>associated_executor<T, Executor>::get(t, ex)</tt>
  */
 template <typename T, typename Executor>
-inline typename associated_executor<T, Executor>::type
+BOOST_ASIO_NODISCARD inline BOOST_ASIO_AUTO_RETURN_TYPE_PREFIX2(
+    typename associated_executor<T, Executor>::type)
 get_associated_executor(const T& t, const Executor& ex,
-    typename enable_if<is_executor<
-      Executor>::value>::type* = 0) BOOST_ASIO_NOEXCEPT
+    typename constraint<
+      is_executor<Executor>::value || execution::is_executor<Executor>::value
+    >::type = 0) BOOST_ASIO_NOEXCEPT
+  BOOST_ASIO_AUTO_RETURN_TYPE_SUFFIX((
+    associated_executor<T, Executor>::get(t, ex)))
 {
   return associated_executor<T, Executor>::get(t, ex);
 }
@@ -126,11 +173,11 @@ get_associated_executor(const T& t, const Executor& ex,
  * ExecutionContext::executor_type>::get(t, ctx.get_executor())</tt>
  */
 template <typename T, typename ExecutionContext>
-inline typename associated_executor<T,
-  typename ExecutionContext::executor_type>::type
+BOOST_ASIO_NODISCARD inline typename associated_executor<T,
+    typename ExecutionContext::executor_type>::type
 get_associated_executor(const T& t, ExecutionContext& ctx,
-    typename enable_if<is_convertible<ExecutionContext&,
-      execution_context&>::value>::type* = 0) BOOST_ASIO_NOEXCEPT
+    typename constraint<is_convertible<ExecutionContext&,
+      execution_context&>::value>::type = 0) BOOST_ASIO_NOEXCEPT
 {
   return associated_executor<T,
     typename ExecutionContext::executor_type>::get(t, ctx.get_executor());
@@ -143,6 +190,63 @@ using associated_executor_t = typename associated_executor<T, Executor>::type;
 
 #endif // defined(BOOST_ASIO_HAS_ALIAS_TEMPLATES)
 
+namespace detail {
+
+template <typename T, typename E, typename = void>
+struct associated_executor_forwarding_base
+{
+};
+
+template <typename T, typename E>
+struct associated_executor_forwarding_base<T, E,
+    typename enable_if<
+      is_same<
+        typename associated_executor<T,
+          E>::asio_associated_executor_is_unspecialised,
+        void
+      >::value
+    >::type>
+{
+  typedef void asio_associated_executor_is_unspecialised;
+};
+
+} // namespace detail
+
+#if defined(BOOST_ASIO_HAS_STD_REFERENCE_WRAPPER) \
+  || defined(GENERATING_DOCUMENTATION)
+
+/// Specialisation of associated_executor for @c std::reference_wrapper.
+template <typename T, typename Executor>
+struct associated_executor<reference_wrapper<T>, Executor>
+#if !defined(GENERATING_DOCUMENTATION)
+  : detail::associated_executor_forwarding_base<T, Executor>
+#endif // !defined(GENERATING_DOCUMENTATION)
+{
+  /// Forwards @c type to the associator specialisation for the unwrapped type
+  /// @c T.
+  typedef typename associated_executor<T, Executor>::type type;
+
+  /// Forwards the request to get the executor to the associator specialisation
+  /// for the unwrapped type @c T.
+  static type get(reference_wrapper<T> t) BOOST_ASIO_NOEXCEPT
+  {
+    return associated_executor<T, Executor>::get(t.get());
+  }
+
+  /// Forwards the request to get the executor to the associator specialisation
+  /// for the unwrapped type @c T.
+  static BOOST_ASIO_AUTO_RETURN_TYPE_PREFIX(type) get(
+      reference_wrapper<T> t, const Executor& ex) BOOST_ASIO_NOEXCEPT
+    BOOST_ASIO_AUTO_RETURN_TYPE_SUFFIX((
+      associated_executor<T, Executor>::get(t.get(), ex)))
+  {
+    return associated_executor<T, Executor>::get(t.get(), ex);
+  }
+};
+
+#endif // defined(BOOST_ASIO_HAS_STD_REFERENCE_WRAPPER)
+       //   || defined(GENERATING_DOCUMENTATION)
+
 } // namespace asio
 } // namespace boost
 

linx64/include/boost/asio/associated_immediate_executor.hpp

@@ -0,0 +1,299 @@
+//
+// associated_immediate_executor.hpp
+// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2023 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef BOOST_ASIO_ASSOCIATED_IMMEDIATE_EXECUTOR_HPP
+#define BOOST_ASIO_ASSOCIATED_IMMEDIATE_EXECUTOR_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include <boost/asio/detail/config.hpp>
+#include <boost/asio/associator.hpp>
+#include <boost/asio/detail/functional.hpp>
+#include <boost/asio/detail/type_traits.hpp>
+#include <boost/asio/execution/blocking.hpp>
+#include <boost/asio/execution/executor.hpp>
+#include <boost/asio/execution_context.hpp>
+#include <boost/asio/is_executor.hpp>
+#include <boost/asio/require.hpp>
+
+#include <boost/asio/detail/push_options.hpp>
+
+namespace boost {
+namespace asio {
+
+template <typename T, typename Executor>
+struct associated_immediate_executor;
+
+namespace detail {
+
+template <typename T, typename = void>
+struct has_immediate_executor_type : false_type
+{
+};
+
+template <typename T>
+struct has_immediate_executor_type<T,
+  typename void_type<typename T::immediate_executor_type>::type>
+    : true_type
+{
+};
+
+template <typename E, typename = void, typename = void>
+struct default_immediate_executor
+{
+  typedef typename require_result<E, execution::blocking_t::never_t>::type type;
+
+  static type get(const E& e) BOOST_ASIO_NOEXCEPT
+  {
+    return boost::asio::require(e, execution::blocking.never);
+  }
+};
+
+template <typename E>
+struct default_immediate_executor<E,
+  typename enable_if<
+    !execution::is_executor<E>::value
+  >::type,
+  typename enable_if<
+    is_executor<E>::value
+  >::type>
+{
+  class type : public E
+  {
+  public:
+    template <typename Executor1>
+    explicit type(const Executor1& e,
+        typename constraint<
+          conditional<
+            !is_same<Executor1, type>::value,
+            is_convertible<Executor1, E>,
+            false_type
+          >::type::value
+        >::type = 0) BOOST_ASIO_NOEXCEPT
+      : E(e)
+    {
+    }
+
+    type(const type& other) BOOST_ASIO_NOEXCEPT
+      : E(static_cast<const E&>(other))
+    {
+    }
+
+#if defined(BOOST_ASIO_HAS_MOVE)
+    type(type&& other) BOOST_ASIO_NOEXCEPT
+      : E(BOOST_ASIO_MOVE_CAST(E)(other))
+    {
+    }
+#endif // defined(BOOST_ASIO_HAS_MOVE)
+
+    template <typename Function, typename Allocator>
+    void dispatch(BOOST_ASIO_MOVE_ARG(Function) f, const Allocator& a) const
+    {
+      this->post(BOOST_ASIO_MOVE_CAST(Function)(f), a);
+    }
+
+    friend bool operator==(const type& a, const type& b) BOOST_ASIO_NOEXCEPT
+    {
+      return static_cast<const E&>(a) == static_cast<const E&>(b);
+    }
+
+    friend bool operator!=(const type& a, const type& b) BOOST_ASIO_NOEXCEPT
+    {
+      return static_cast<const E&>(a) != static_cast<const E&>(b);
+    }
+  };
+
+  static type get(const E& e) BOOST_ASIO_NOEXCEPT
+  {
+    return type(e);
+  }
+};
+
+template <typename T, typename E, typename = void, typename = void>
+struct associated_immediate_executor_impl
+{
+  typedef void asio_associated_immediate_executor_is_unspecialised;
+
+  typedef typename default_immediate_executor<E>::type type;
+
+  static BOOST_ASIO_AUTO_RETURN_TYPE_PREFIX(type) get(
+      const T&, const E& e) BOOST_ASIO_NOEXCEPT
+    BOOST_ASIO_AUTO_RETURN_TYPE_SUFFIX((default_immediate_executor<E>::get(e)))
+  {
+    return default_immediate_executor<E>::get(e);
+  }
+};
+
+template <typename T, typename E>
+struct associated_immediate_executor_impl<T, E,
+  typename void_type<typename T::immediate_executor_type>::type>
+{
+  typedef typename T::immediate_executor_type type;
+
+  static BOOST_ASIO_AUTO_RETURN_TYPE_PREFIX(type) get(
+      const T& t, const E&) BOOST_ASIO_NOEXCEPT
+    BOOST_ASIO_AUTO_RETURN_TYPE_SUFFIX((t.get_immediate_executor()))
+  {
+    return t.get_immediate_executor();
+  }
+};
+
+template <typename T, typename E>
+struct associated_immediate_executor_impl<T, E,
+  typename enable_if<
+    !has_immediate_executor_type<T>::value
+  >::type,
+  typename void_type<
+    typename associator<associated_immediate_executor, T, E>::type
+  >::type> : associator<associated_immediate_executor, T, E>
+{
+};
+
+} // namespace detail
+
+/// Traits type used to obtain the immediate executor associated with an object.
+/**
+ * A program may specialise this traits type if the @c T template parameter in
+ * the specialisation is a user-defined type. The template parameter @c
+ * Executor shall be a type meeting the Executor requirements.
+ *
+ * Specialisations shall meet the following requirements, where @c t is a const
+ * reference to an object of type @c T, and @c e is an object of type @c
+ * Executor.
+ *
+ * @li Provide a nested typedef @c type that identifies a type meeting the
+ * Executor requirements.
+ *
+ * @li Provide a noexcept static member function named @c get, callable as @c
+ * get(t) and with return type @c type or a (possibly const) reference to @c
+ * type.
+ *
+ * @li Provide a noexcept static member function named @c get, callable as @c
+ * get(t,e) and with return type @c type or a (possibly const) reference to @c
+ * type.
+ */
+template <typename T, typename Executor>
+struct associated_immediate_executor
+#if !defined(GENERATING_DOCUMENTATION)
+  : detail::associated_immediate_executor_impl<T, Executor>
+#endif // !defined(GENERATING_DOCUMENTATION)
+{
+#if defined(GENERATING_DOCUMENTATION)
+  /// If @c T has a nested type @c immediate_executor_type,
+  // <tt>T::immediate_executor_type</tt>. Otherwise @c Executor.
+  typedef see_below type;
+
+  /// If @c T has a nested type @c immediate_executor_type, returns
+  /// <tt>t.get_immediate_executor()</tt>. Otherwise returns
+  /// <tt>boost::asio::require(ex, boost::asio::execution::blocking.never)</tt>.
+  static decltype(auto) get(const T& t, const Executor& ex) BOOST_ASIO_NOEXCEPT;
+#endif // defined(GENERATING_DOCUMENTATION)
+};
+
+/// Helper function to obtain an object's associated executor.
+/**
+ * @returns <tt>associated_immediate_executor<T, Executor>::get(t, ex)</tt>
+ */
+template <typename T, typename Executor>
+BOOST_ASIO_NODISCARD inline BOOST_ASIO_AUTO_RETURN_TYPE_PREFIX2(
+    typename associated_immediate_executor<T, Executor>::type)
+get_associated_immediate_executor(const T& t, const Executor& ex,
+    typename constraint<
+      is_executor<Executor>::value || execution::is_executor<Executor>::value
+    >::type = 0) BOOST_ASIO_NOEXCEPT
+  BOOST_ASIO_AUTO_RETURN_TYPE_SUFFIX((
+    associated_immediate_executor<T, Executor>::get(t, ex)))
+{
+  return associated_immediate_executor<T, Executor>::get(t, ex);
+}
+
+/// Helper function to obtain an object's associated executor.
+/**
+ * @returns <tt>associated_immediate_executor<T, typename
+ * ExecutionContext::executor_type>::get(t, ctx.get_executor())</tt>
+ */
+template <typename T, typename ExecutionContext>
+BOOST_ASIO_NODISCARD inline typename associated_immediate_executor<T,
+    typename ExecutionContext::executor_type>::type
+get_associated_immediate_executor(const T& t, ExecutionContext& ctx,
+    typename constraint<is_convertible<ExecutionContext&,
+      execution_context&>::value>::type = 0) BOOST_ASIO_NOEXCEPT
+{
+  return associated_immediate_executor<T,
+    typename ExecutionContext::executor_type>::get(t, ctx.get_executor());
+}
+
+#if defined(BOOST_ASIO_HAS_ALIAS_TEMPLATES)
+
+template <typename T, typename Executor>
+using associated_immediate_executor_t =
+  typename associated_immediate_executor<T, Executor>::type;
+
+#endif // defined(BOOST_ASIO_HAS_ALIAS_TEMPLATES)
+
+namespace detail {
+
+template <typename T, typename E, typename = void>
+struct associated_immediate_executor_forwarding_base
+{
+};
+
+template <typename T, typename E>
+struct associated_immediate_executor_forwarding_base<T, E,
+    typename enable_if<
+      is_same<
+        typename associated_immediate_executor<T,
+          E>::asio_associated_immediate_executor_is_unspecialised,
+        void
+      >::value
+    >::type>
+{
+  typedef void asio_associated_immediate_executor_is_unspecialised;
+};
+
+} // namespace detail
+
+#if defined(BOOST_ASIO_HAS_STD_REFERENCE_WRAPPER) \
+  || defined(GENERATING_DOCUMENTATION)
+
+/// Specialisation of associated_immediate_executor for
+/// @c std::reference_wrapper.
+template <typename T, typename Executor>
+struct associated_immediate_executor<reference_wrapper<T>, Executor>
+#if !defined(GENERATING_DOCUMENTATION)
+  : detail::associated_immediate_executor_forwarding_base<T, Executor>
+#endif // !defined(GENERATING_DOCUMENTATION)
+{
+  /// Forwards @c type to the associator specialisation for the unwrapped type
+  /// @c T.
+  typedef typename associated_immediate_executor<T, Executor>::type type;
+
+  /// Forwards the request to get the executor to the associator specialisation
+  /// for the unwrapped type @c T.
+  static BOOST_ASIO_AUTO_RETURN_TYPE_PREFIX(type) get(
+      reference_wrapper<T> t, const Executor& ex) BOOST_ASIO_NOEXCEPT
+    BOOST_ASIO_AUTO_RETURN_TYPE_SUFFIX((
+      associated_immediate_executor<T, Executor>::get(t.get(), ex)))
+  {
+    return associated_immediate_executor<T, Executor>::get(t.get(), ex);
+  }
+};
+
+#endif // defined(BOOST_ASIO_HAS_STD_REFERENCE_WRAPPER)
+       //   || defined(GENERATING_DOCUMENTATION)
+
+} // namespace asio
+} // namespace boost
+
+#include <boost/asio/detail/pop_options.hpp>
+
+#endif // BOOST_ASIO_ASSOCIATED_IMMEDIATE_EXECUTOR_HPP

linx64/include/boost/asio/associator.hpp

@@ -0,0 +1,37 @@
+//
+// associator.hpp
+// ~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2023 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef BOOST_ASIO_ASSOCIATOR_HPP
+#define BOOST_ASIO_ASSOCIATOR_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include <boost/asio/detail/config.hpp>
+
+#include <boost/asio/detail/push_options.hpp>
+
+namespace boost {
+namespace asio {
+
+/// Used to generically specialise associators for a type.
+template <template <typename, typename> class Associator,
+    typename T, typename DefaultCandidate>
+struct associator
+{
+};
+
+} // namespace asio
+} // namespace boost
+
+#include <boost/asio/detail/pop_options.hpp>
+
+#endif // BOOST_ASIO_ASSOCIATOR_HPP

linx64/include/boost/asio/awaitable.hpp

@@ -2,7 +2,7 @@
 // awaitable.hpp
 // ~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2019 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2023 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -19,8 +19,14 @@
 
 #if defined(BOOST_ASIO_HAS_CO_AWAIT) || defined(GENERATING_DOCUMENTATION)
 
-#include <experimental/coroutine>
-#include <boost/asio/executor.hpp>
+#if defined(BOOST_ASIO_HAS_STD_COROUTINE)
+# include <coroutine>
+#else // defined(BOOST_ASIO_HAS_STD_COROUTINE)
+# include <experimental/coroutine>
+#endif // defined(BOOST_ASIO_HAS_STD_COROUTINE)
+
+#include <utility>
+#include <boost/asio/any_io_executor.hpp>
 
 #include <boost/asio/detail/push_options.hpp>
 
@@ -28,8 +34,13 @@ namespace boost {
 namespace asio {
 namespace detail {
 
+#if defined(BOOST_ASIO_HAS_STD_COROUTINE)
+using std::coroutine_handle;
+using std::suspend_always;
+#else // defined(BOOST_ASIO_HAS_STD_COROUTINE)
 using std::experimental::coroutine_handle;
 using std::experimental::suspend_always;
+#endif // defined(BOOST_ASIO_HAS_STD_COROUTINE)
 
 template <typename> class awaitable_thread;
 template <typename, typename> class awaitable_frame;
@@ -37,8 +48,8 @@ template <typename, typename> class awaitable_frame;
 } // namespace detail
 
 /// The return type of a coroutine or asynchronous operation.
-template <typename T, typename Executor = executor>
-class awaitable
+template <typename T, typename Executor = any_io_executor>
+class BOOST_ASIO_NODISCARD awaitable
 {
 public:
   /// The type of the awaited value.
@@ -66,6 +77,14 @@ public:
       frame_->destroy();
   }
 
+  /// Move assignment.
+  awaitable& operator=(awaitable&& other) noexcept
+  {
+    if (this != &other)
+      frame_ = std::exchange(other.frame_, nullptr);
+    return *this;
+  }
+
   /// Checks if the awaitable refers to a future result.
   bool valid() const noexcept
   {
@@ -91,7 +110,7 @@ public:
   // Support for co_await keyword.
   T await_resume()
   {
-    return frame_->get();
+    return awaitable(static_cast<awaitable&&>(*this)).frame_->get();
   }
 
 #endif // !defined(GENERATING_DOCUMENTATION)

linx64/include/boost/asio/basic_datagram_socket.hpp

@@ -2,7 +2,7 @@
 // basic_datagram_socket.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2019 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2023 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -33,7 +33,7 @@ namespace asio {
 #define BOOST_ASIO_BASIC_DATAGRAM_SOCKET_FWD_DECL
 
 // Forward declaration with defaulted arguments.
-template <typename Protocol, typename Executor = executor>
+template <typename Protocol, typename Executor = any_io_executor>
 class basic_datagram_socket;
 
 #endif // !defined(BOOST_ASIO_BASIC_DATAGRAM_SOCKET_FWD_DECL)
@@ -46,11 +46,24 @@ class basic_datagram_socket;
  * @par Thread Safety
  * @e Distinct @e objects: Safe.@n
  * @e Shared @e objects: Unsafe.
+ *
+ * Synchronous @c send, @c send_to, @c receive, @c receive_from, @c connect,
+ * and @c shutdown operations are thread safe with respect to each other, if
+ * the underlying operating system calls are also thread safe. This means that
+ * it is permitted to perform concurrent calls to these synchronous operations
+ * on a single socket object. Other synchronous operations, such as @c open or
+ * @c close, are not thread safe.
  */
 template <typename Protocol, typename Executor>
 class basic_datagram_socket
   : public basic_socket<Protocol, Executor>
 {
+private:
+  class initiate_async_send;
+  class initiate_async_send_to;
+  class initiate_async_receive;
+  class initiate_async_receive_from;
+
 public:
   /// The type of the executor associated with the object.
   typedef Executor executor_type;
@@ -101,9 +114,9 @@ public:
    */
   template <typename ExecutionContext>
   explicit basic_datagram_socket(ExecutionContext& context,
-      typename enable_if<
+      typename constraint<
         is_convertible<ExecutionContext&, execution_context&>::value
-      >::type* = 0)
+      >::type = 0)
     : basic_socket<Protocol, Executor>(context)
   {
   }
@@ -139,9 +152,10 @@ public:
   template <typename ExecutionContext>
   basic_datagram_socket(ExecutionContext& context,
       const protocol_type& protocol,
-      typename enable_if<
-        is_convertible<ExecutionContext&, execution_context&>::value
-      >::type* = 0)
+      typename constraint<
+        is_convertible<ExecutionContext&, execution_context&>::value,
+        defaulted_constraint
+      >::type = defaulted_constraint())
     : basic_socket<Protocol, Executor>(context, protocol)
   {
   }
@@ -185,9 +199,9 @@ public:
   template <typename ExecutionContext>
   basic_datagram_socket(ExecutionContext& context,
       const endpoint_type& endpoint,
-      typename enable_if<
+      typename constraint<
         is_convertible<ExecutionContext&, execution_context&>::value
-      >::type* = 0)
+      >::type = 0)
     : basic_socket<Protocol, Executor>(context, endpoint)
   {
   }
@@ -230,9 +244,9 @@ public:
   template <typename ExecutionContext>
   basic_datagram_socket(ExecutionContext& context,
       const protocol_type& protocol, const native_handle_type& native_socket,
-      typename enable_if<
+      typename constraint<
         is_convertible<ExecutionContext&, execution_context&>::value
-      >::type* = 0)
+      >::type = 0)
     : basic_socket<Protocol, Executor>(context, protocol, native_socket)
   {
   }
@@ -249,7 +263,7 @@ public:
    * constructed using the @c basic_datagram_socket(const executor_type&)
    * constructor.
    */
-  basic_datagram_socket(basic_datagram_socket&& other)
+  basic_datagram_socket(basic_datagram_socket&& other) BOOST_ASIO_NOEXCEPT
     : basic_socket<Protocol, Executor>(std::move(other))
   {
   }
@@ -286,10 +300,10 @@ public:
    */
   template <typename Protocol1, typename Executor1>
   basic_datagram_socket(basic_datagram_socket<Protocol1, Executor1>&& other,
-      typename enable_if<
+      typename constraint<
         is_convertible<Protocol1, Protocol>::value
           && is_convertible<Executor1, Executor>::value
-      >::type* = 0)
+      >::type = 0)
     : basic_socket<Protocol, Executor>(std::move(other))
   {
   }
@@ -308,7 +322,7 @@ public:
    * constructor.
    */
   template <typename Protocol1, typename Executor1>
-  typename enable_if<
+  typename constraint<
     is_convertible<Protocol1, Protocol>::value
       && is_convertible<Executor1, Executor>::value,
     basic_datagram_socket&
@@ -416,25 +430,31 @@ public:
   /// Start an asynchronous send on a connected socket.
   /**
    * This function is used to asynchronously send data on the datagram socket.
-   * The function call always returns immediately.
+   * It is an initiating function for an @ref asynchronous_operation, and always
+   * returns immediately.
    *
    * @param buffers One or more data buffers to be sent on the socket. Although
    * the buffers object may be copied as necessary, ownership of the underlying
    * memory blocks is retained by the caller, which must guarantee that they
-   * remain valid until the handler is called.
+   * remain valid until the completion handler is called.
    *
-   * @param handler The handler to be called when the send operation completes.
-   * Copies will be made of the handler as required. The function signature of
-   * the handler must be:
+   * @param token The @ref completion_token that will be used to produce a
+   * completion handler, which will be called when the send completes. Potential
+   * completion tokens include @ref use_future, @ref use_awaitable, @ref
+   * yield_context, or a function object with the correct completion signature.
+   * The function signature of the completion handler must be:
    * @code void handler(
    *   const boost::system::error_code& error, // Result of operation.
-   *   std::size_t bytes_transferred           // Number of bytes sent.
+   *   std::size_t bytes_transferred // Number of bytes sent.
    * ); @endcode
    * Regardless of whether the asynchronous operation completes immediately or
-   * not, the handler will not be invoked from within this function. On
-   * immediate completion, invocation of the handler will be performed in a
+   * not, the completion handler will not be invoked from within this function.
+   * On immediate completion, invocation of the handler will be performed in a
    * manner equivalent to using boost::asio::post().
    *
+   * @par Completion Signature
+   * @code void(boost::system::error_code, std::size_t) @endcode
+   *
    * @note The async_send operation can only be used with a connected socket.
    * Use the async_send_to function to send data on an unconnected datagram
    * socket.
@@ -447,57 +467,100 @@ public:
    * See the @ref buffer documentation for information on sending multiple
    * buffers in one go, and how to use it with arrays, boost::array or
    * std::vector.
+   *
+   * @par Per-Operation Cancellation
+   * On POSIX or Windows operating systems, this asynchronous operation supports
+   * cancellation for the following boost::asio::cancellation_type values:
+   *
+   * @li @c cancellation_type::terminal
+   *
+   * @li @c cancellation_type::partial
+   *
+   * @li @c cancellation_type::total
    */
-  template <typename ConstBufferSequence, typename WriteHandler>
-  BOOST_ASIO_INITFN_RESULT_TYPE(WriteHandler,
+  template <typename ConstBufferSequence,
+      BOOST_ASIO_COMPLETION_TOKEN_FOR(void (boost::system::error_code,
+        std::size_t)) WriteToken
+          BOOST_ASIO_DEFAULT_COMPLETION_TOKEN_TYPE(executor_type)>
+  BOOST_ASIO_INITFN_AUTO_RESULT_TYPE_PREFIX(WriteToken,
       void (boost::system::error_code, std::size_t))
   async_send(const ConstBufferSequence& buffers,
-      BOOST_ASIO_MOVE_ARG(WriteHandler) handler)
+      BOOST_ASIO_MOVE_ARG(WriteToken) token
+        BOOST_ASIO_DEFAULT_COMPLETION_TOKEN(executor_type))
+    BOOST_ASIO_INITFN_AUTO_RESULT_TYPE_SUFFIX((
+      async_initiate<WriteToken,
+        void (boost::system::error_code, std::size_t)>(
+          declval<initiate_async_send>(), token,
+          buffers, socket_base::message_flags(0))))
   {
-    return async_initiate<WriteHandler,
+    return async_initiate<WriteToken,
       void (boost::system::error_code, std::size_t)>(
-        initiate_async_send(), handler, this,
+        initiate_async_send(this), token,
         buffers, socket_base::message_flags(0));
   }
 
   /// Start an asynchronous send on a connected socket.
   /**
    * This function is used to asynchronously send data on the datagram socket.
-   * The function call always returns immediately.
+   * It is an initiating function for an @ref asynchronous_operation, and always
+   * returns immediately.
    *
    * @param buffers One or more data buffers to be sent on the socket. Although
    * the buffers object may be copied as necessary, ownership of the underlying
    * memory blocks is retained by the caller, which must guarantee that they
-   * remain valid until the handler is called.
+   * remain valid until the completion handler is called.
    *
    * @param flags Flags specifying how the send call is to be made.
    *
-   * @param handler The handler to be called when the send operation completes.
-   * Copies will be made of the handler as required. The function signature of
-   * the handler must be:
+   * @param token The @ref completion_token that will be used to produce a
+   * completion handler, which will be called when the send completes. Potential
+   * completion tokens include @ref use_future, @ref use_awaitable, @ref
+   * yield_context, or a function object with the correct completion signature.
+   * The function signature of the completion handler must be:
    * @code void handler(
    *   const boost::system::error_code& error, // Result of operation.
-   *   std::size_t bytes_transferred           // Number of bytes sent.
+   *   std::size_t bytes_transferred // Number of bytes sent.
    * ); @endcode
    * Regardless of whether the asynchronous operation completes immediately or
-   * not, the handler will not be invoked from within this function. On
-   * immediate completion, invocation of the handler will be performed in a
+   * not, the completion handler will not be invoked from within this function.
+   * On immediate completion, invocation of the handler will be performed in a
    * manner equivalent to using boost::asio::post().
    *
+   * @par Completion Signature
+   * @code void(boost::system::error_code, std::size_t) @endcode
+   *
    * @note The async_send operation can only be used with a connected socket.
    * Use the async_send_to function to send data on an unconnected datagram
    * socket.
+   *
+   * @par Per-Operation Cancellation
+   * On POSIX or Windows operating systems, this asynchronous operation supports
+   * cancellation for the following boost::asio::cancellation_type values:
+   *
+   * @li @c cancellation_type::terminal
+   *
+   * @li @c cancellation_type::partial
+   *
+   * @li @c cancellation_type::total
    */
-  template <typename ConstBufferSequence, typename WriteHandler>
-  BOOST_ASIO_INITFN_RESULT_TYPE(WriteHandler,
+  template <typename ConstBufferSequence,
+      BOOST_ASIO_COMPLETION_TOKEN_FOR(void (boost::system::error_code,
+        std::size_t)) WriteToken
+          BOOST_ASIO_DEFAULT_COMPLETION_TOKEN_TYPE(executor_type)>
+  BOOST_ASIO_INITFN_AUTO_RESULT_TYPE_PREFIX(WriteToken,
       void (boost::system::error_code, std::size_t))
   async_send(const ConstBufferSequence& buffers,
       socket_base::message_flags flags,
-      BOOST_ASIO_MOVE_ARG(WriteHandler) handler)
+      BOOST_ASIO_MOVE_ARG(WriteToken) token
+        BOOST_ASIO_DEFAULT_COMPLETION_TOKEN(executor_type))
+    BOOST_ASIO_INITFN_AUTO_RESULT_TYPE_SUFFIX((
+      async_initiate<WriteToken,
+        void (boost::system::error_code, std::size_t)>(
+          declval<initiate_async_send>(), token, buffers, flags)))
   {
-    return async_initiate<WriteHandler,
+    return async_initiate<WriteToken,
       void (boost::system::error_code, std::size_t)>(
-        initiate_async_send(), handler, this, buffers, flags);
+        initiate_async_send(this), token, buffers, flags);
   }
 
   /// Send a datagram to the specified endpoint.
@@ -591,28 +654,34 @@ public:
   /// Start an asynchronous send.
   /**
    * This function is used to asynchronously send a datagram to the specified
-   * remote endpoint. The function call always returns immediately.
+   * remote endpoint. It is an initiating function for an @ref
+   * asynchronous_operation, and always returns immediately.
    *
    * @param buffers One or more data buffers to be sent to the remote endpoint.
    * Although the buffers object may be copied as necessary, ownership of the
    * underlying memory blocks is retained by the caller, which must guarantee
-   * that they remain valid until the handler is called.
+   * that they remain valid until the completion handler is called.
    *
    * @param destination The remote endpoint to which the data will be sent.
    * Copies will be made of the endpoint as required.
    *
-   * @param handler The handler to be called when the send operation completes.
-   * Copies will be made of the handler as required. The function signature of
-   * the handler must be:
+   * @param token The @ref completion_token that will be used to produce a
+   * completion handler, which will be called when the send completes. Potential
+   * completion tokens include @ref use_future, @ref use_awaitable, @ref
+   * yield_context, or a function object with the correct completion signature.
+   * The function signature of the completion handler must be:
    * @code void handler(
    *   const boost::system::error_code& error, // Result of operation.
-   *   std::size_t bytes_transferred           // Number of bytes sent.
+   *   std::size_t bytes_transferred // Number of bytes sent.
    * ); @endcode
    * Regardless of whether the asynchronous operation completes immediately or
-   * not, the handler will not be invoked from within this function. On
-   * immediate completion, invocation of the handler will be performed in a
+   * not, the completion handler will not be invoked from within this function.
+   * On immediate completion, invocation of the handler will be performed in a
    * manner equivalent to using boost::asio::post().
    *
+   * @par Completion Signature
+   * @code void(boost::system::error_code, std::size_t) @endcode
+   *
    * @par Example
    * To send a single data buffer use the @ref buffer function as follows:
    * @code
@@ -624,57 +693,102 @@ public:
    * See the @ref buffer documentation for information on sending multiple
    * buffers in one go, and how to use it with arrays, boost::array or
    * std::vector.
+   *
+   * @par Per-Operation Cancellation
+   * On POSIX or Windows operating systems, this asynchronous operation supports
+   * cancellation for the following boost::asio::cancellation_type values:
+   *
+   * @li @c cancellation_type::terminal
+   *
+   * @li @c cancellation_type::partial
+   *
+   * @li @c cancellation_type::total
    */
-  template <typename ConstBufferSequence, typename WriteHandler>
-  BOOST_ASIO_INITFN_RESULT_TYPE(WriteHandler,
+  template <typename ConstBufferSequence,
+      BOOST_ASIO_COMPLETION_TOKEN_FOR(void (boost::system::error_code,
+        std::size_t)) WriteToken
+          BOOST_ASIO_DEFAULT_COMPLETION_TOKEN_TYPE(executor_type)>
+  BOOST_ASIO_INITFN_AUTO_RESULT_TYPE_PREFIX(WriteToken,
       void (boost::system::error_code, std::size_t))
   async_send_to(const ConstBufferSequence& buffers,
       const endpoint_type& destination,
-      BOOST_ASIO_MOVE_ARG(WriteHandler) handler)
+      BOOST_ASIO_MOVE_ARG(WriteToken) token
+        BOOST_ASIO_DEFAULT_COMPLETION_TOKEN(executor_type))
+    BOOST_ASIO_INITFN_AUTO_RESULT_TYPE_SUFFIX((
+      async_initiate<WriteToken,
+        void (boost::system::error_code, std::size_t)>(
+          declval<initiate_async_send_to>(), token, buffers,
+          destination, socket_base::message_flags(0))))
   {
-    return async_initiate<WriteHandler,
+    return async_initiate<WriteToken,
       void (boost::system::error_code, std::size_t)>(
-        initiate_async_send_to(), handler, this, buffers,
+        initiate_async_send_to(this), token, buffers,
         destination, socket_base::message_flags(0));
   }
 
   /// Start an asynchronous send.
   /**
    * This function is used to asynchronously send a datagram to the specified
-   * remote endpoint. The function call always returns immediately.
+   * remote endpoint. It is an initiating function for an @ref
+   * asynchronous_operation, and always returns immediately.
    *
    * @param buffers One or more data buffers to be sent to the remote endpoint.
    * Although the buffers object may be copied as necessary, ownership of the
    * underlying memory blocks is retained by the caller, which must guarantee
-   * that they remain valid until the handler is called.
+   * that they remain valid until the completion handler is called.
    *
    * @param flags Flags specifying how the send call is to be made.
    *
    * @param destination The remote endpoint to which the data will be sent.
    * Copies will be made of the endpoint as required.
    *
-   * @param handler The handler to be called when the send operation completes.
-   * Copies will be made of the handler as required. The function signature of
-   * the handler must be:
+   * @param token The @ref completion_token that will be used to produce a
+   * completion handler, which will be called when the send completes. Potential
+   * completion tokens include @ref use_future, @ref use_awaitable, @ref
+   * yield_context, or a function object with the correct completion signature.
+   * The function signature of the completion handler must be:
    * @code void handler(
    *   const boost::system::error_code& error, // Result of operation.
-   *   std::size_t bytes_transferred           // Number of bytes sent.
+   *   std::size_t bytes_transferred // Number of bytes sent.
    * ); @endcode
    * Regardless of whether the asynchronous operation completes immediately or
-   * not, the handler will not be invoked from within this function. On
-   * immediate completion, invocation of the handler will be performed in a
+   * not, the completion handler will not be invoked from within this function.
+   * On immediate completion, invocation of the handler will be performed in a
    * manner equivalent to using boost::asio::post().
+   *
+   * @par Completion Signature
+   * @code void(boost::system::error_code, std::size_t) @endcode
+   *
+   * @par Per-Operation Cancellation
+   * On POSIX or Windows operating systems, this asynchronous operation supports
+   * cancellation for the following boost::asio::cancellation_type values:
+   *
+   * @li @c cancellation_type::terminal
+   *
+   * @li @c cancellation_type::partial
+   *
+   * @li @c cancellation_type::total
    */
-  template <typename ConstBufferSequence, typename WriteHandler>
-  BOOST_ASIO_INITFN_RESULT_TYPE(WriteHandler,
+  template <typename ConstBufferSequence,
+      BOOST_ASIO_COMPLETION_TOKEN_FOR(void (boost::system::error_code,
+        std::size_t)) WriteToken
+          BOOST_ASIO_DEFAULT_COMPLETION_TOKEN_TYPE(executor_type)>
+  BOOST_ASIO_INITFN_AUTO_RESULT_TYPE_PREFIX(WriteToken,
       void (boost::system::error_code, std::size_t))
   async_send_to(const ConstBufferSequence& buffers,
       const endpoint_type& destination, socket_base::message_flags flags,
-      BOOST_ASIO_MOVE_ARG(WriteHandler) handler)
+      BOOST_ASIO_MOVE_ARG(WriteToken) token
+        BOOST_ASIO_DEFAULT_COMPLETION_TOKEN(executor_type))
+    BOOST_ASIO_INITFN_AUTO_RESULT_TYPE_SUFFIX((
+      async_initiate<WriteToken,
+        void (boost::system::error_code, std::size_t)>(
+          declval<initiate_async_send_to>(), token,
+          buffers, destination, flags)))
   {
-    return async_initiate<WriteHandler,
+    return async_initiate<WriteToken,
       void (boost::system::error_code, std::size_t)>(
-        initiate_async_send_to(), handler, this, buffers, destination, flags);
+        initiate_async_send_to(this), token,
+        buffers, destination, flags);
   }
 
   /// Receive some data on a connected socket.
@@ -769,25 +883,31 @@ public:
   /// Start an asynchronous receive on a connected socket.
   /**
    * This function is used to asynchronously receive data from the datagram
-   * socket. The function call always returns immediately.
+   * socket. It is an initiating function for an @ref asynchronous_operation,
+   * and always returns immediately.
    *
    * @param buffers One or more buffers into which the data will be received.
    * Although the buffers object may be copied as necessary, ownership of the
    * underlying memory blocks is retained by the caller, which must guarantee
-   * that they remain valid until the handler is called.
+   * that they remain valid until the completion handler is called.
    *
-   * @param handler The handler to be called when the receive operation
-   * completes. Copies will be made of the handler as required. The function
-   * signature of the handler must be:
+   * @param token The @ref completion_token that will be used to produce a
+   * completion handler, which will be called when the receive completes.
+   * Potential completion tokens include @ref use_future, @ref use_awaitable,
+   * @ref yield_context, or a function object with the correct completion
+   * signature. The function signature of the completion handler must be:
    * @code void handler(
    *   const boost::system::error_code& error, // Result of operation.
-   *   std::size_t bytes_transferred           // Number of bytes received.
+   *   std::size_t bytes_transferred // Number of bytes received.
    * ); @endcode
    * Regardless of whether the asynchronous operation completes immediately or
-   * not, the handler will not be invoked from within this function. On
-   * immediate completion, invocation of the handler will be performed in a
+   * not, the completion handler will not be invoked from within this function.
+   * On immediate completion, invocation of the handler will be performed in a
    * manner equivalent to using boost::asio::post().
    *
+   * @par Completion Signature
+   * @code void(boost::system::error_code, std::size_t) @endcode
+   *
    * @note The async_receive operation can only be used with a connected socket.
    * Use the async_receive_from function to receive data on an unconnected
    * datagram socket.
@@ -801,57 +921,100 @@ public:
    * See the @ref buffer documentation for information on receiving into
    * multiple buffers in one go, and how to use it with arrays, boost::array or
    * std::vector.
+   *
+   * @par Per-Operation Cancellation
+   * On POSIX or Windows operating systems, this asynchronous operation supports
+   * cancellation for the following boost::asio::cancellation_type values:
+   *
+   * @li @c cancellation_type::terminal
+   *
+   * @li @c cancellation_type::partial
+   *
+   * @li @c cancellation_type::total
    */
-  template <typename MutableBufferSequence, typename ReadHandler>
-  BOOST_ASIO_INITFN_RESULT_TYPE(ReadHandler,
+  template <typename MutableBufferSequence,
+      BOOST_ASIO_COMPLETION_TOKEN_FOR(void (boost::system::error_code,
+        std::size_t)) ReadToken
+          BOOST_ASIO_DEFAULT_COMPLETION_TOKEN_TYPE(executor_type)>
+  BOOST_ASIO_INITFN_AUTO_RESULT_TYPE_PREFIX(ReadToken,
       void (boost::system::error_code, std::size_t))
   async_receive(const MutableBufferSequence& buffers,
-      BOOST_ASIO_MOVE_ARG(ReadHandler) handler)
+      BOOST_ASIO_MOVE_ARG(ReadToken) token
+        BOOST_ASIO_DEFAULT_COMPLETION_TOKEN(executor_type))
+    BOOST_ASIO_INITFN_AUTO_RESULT_TYPE_SUFFIX((
+      async_initiate<ReadToken,
+        void (boost::system::error_code, std::size_t)>(
+          declval<initiate_async_receive>(), token,
+          buffers, socket_base::message_flags(0))))
   {
-    return async_initiate<ReadHandler,
+    return async_initiate<ReadToken,
       void (boost::system::error_code, std::size_t)>(
-        initiate_async_receive(), handler, this,
+        initiate_async_receive(this), token,
         buffers, socket_base::message_flags(0));
   }
 
   /// Start an asynchronous receive on a connected socket.
   /**
    * This function is used to asynchronously receive data from the datagram
-   * socket. The function call always returns immediately.
+   * socket. It is an initiating function for an @ref asynchronous_operation,
+   * and always returns immediately.
    *
    * @param buffers One or more buffers into which the data will be received.
    * Although the buffers object may be copied as necessary, ownership of the
    * underlying memory blocks is retained by the caller, which must guarantee
-   * that they remain valid until the handler is called.
+   * that they remain valid until the completion handler is called.
    *
    * @param flags Flags specifying how the receive call is to be made.
    *
-   * @param handler The handler to be called when the receive operation
-   * completes. Copies will be made of the handler as required. The function
-   * signature of the handler must be:
+   * @param token The @ref completion_token that will be used to produce a
+   * completion handler, which will be called when the receive completes.
+   * Potential completion tokens include @ref use_future, @ref use_awaitable,
+   * @ref yield_context, or a function object with the correct completion
+   * signature. The function signature of the completion handler must be:
    * @code void handler(
    *   const boost::system::error_code& error, // Result of operation.
-   *   std::size_t bytes_transferred           // Number of bytes received.
+   *   std::size_t bytes_transferred // Number of bytes received.
    * ); @endcode
    * Regardless of whether the asynchronous operation completes immediately or
-   * not, the handler will not be invoked from within this function. On
-   * immediate completion, invocation of the handler will be performed in a
+   * not, the completion handler will not be invoked from within this function.
+   * On immediate completion, invocation of the handler will be performed in a
    * manner equivalent to using boost::asio::post().
    *
+   * @par Completion Signature
+   * @code void(boost::system::error_code, std::size_t) @endcode
+   *
    * @note The async_receive operation can only be used with a connected socket.
    * Use the async_receive_from function to receive data on an unconnected
    * datagram socket.
+   *
+   * @par Per-Operation Cancellation
+   * On POSIX or Windows operating systems, this asynchronous operation supports
+   * cancellation for the following boost::asio::cancellation_type values:
+   *
+   * @li @c cancellation_type::terminal
+   *
+   * @li @c cancellation_type::partial
+   *
+   * @li @c cancellation_type::total
    */
-  template <typename MutableBufferSequence, typename ReadHandler>
-  BOOST_ASIO_INITFN_RESULT_TYPE(ReadHandler,
+  template <typename MutableBufferSequence,
+      BOOST_ASIO_COMPLETION_TOKEN_FOR(void (boost::system::error_code,
+        std::size_t)) ReadToken
+          BOOST_ASIO_DEFAULT_COMPLETION_TOKEN_TYPE(executor_type)>
+  BOOST_ASIO_INITFN_AUTO_RESULT_TYPE_PREFIX(ReadToken,
       void (boost::system::error_code, std::size_t))
   async_receive(const MutableBufferSequence& buffers,
       socket_base::message_flags flags,
-      BOOST_ASIO_MOVE_ARG(ReadHandler) handler)
+      BOOST_ASIO_MOVE_ARG(ReadToken) token
+        BOOST_ASIO_DEFAULT_COMPLETION_TOKEN(executor_type))
+    BOOST_ASIO_INITFN_AUTO_RESULT_TYPE_SUFFIX((
+      async_initiate<ReadToken,
+        void (boost::system::error_code, std::size_t)>(
+          declval<initiate_async_receive>(), token, buffers, flags)))
   {
-    return async_initiate<ReadHandler,
+    return async_initiate<ReadToken,
       void (boost::system::error_code, std::size_t)>(
-        initiate_async_receive(), handler, this, buffers, flags);
+        initiate_async_receive(this), token, buffers, flags);
   }
 
   /// Receive a datagram with the endpoint of the sender.
@@ -945,31 +1108,37 @@ public:
 
   /// Start an asynchronous receive.
   /**
-   * This function is used to asynchronously receive a datagram. The function
-   * call always returns immediately.
+   * This function is used to asynchronously receive a datagram. It is an
+   * initiating function for an @ref asynchronous_operation, and always returns
+   * immediately.
    *
    * @param buffers One or more buffers into which the data will be received.
    * Although the buffers object may be copied as necessary, ownership of the
    * underlying memory blocks is retained by the caller, which must guarantee
-   * that they remain valid until the handler is called.
+   * that they remain valid until the completion handler is called.
    *
    * @param sender_endpoint An endpoint object that receives the endpoint of
    * the remote sender of the datagram. Ownership of the sender_endpoint object
    * is retained by the caller, which must guarantee that it is valid until the
-   * handler is called.
+   * completion handler is called.
    *
-   * @param handler The handler to be called when the receive operation
-   * completes. Copies will be made of the handler as required. The function
-   * signature of the handler must be:
+   * @param token The @ref completion_token that will be used to produce a
+   * completion handler, which will be called when the receive completes.
+   * Potential completion tokens include @ref use_future, @ref use_awaitable,
+   * @ref yield_context, or a function object with the correct completion
+   * signature. The function signature of the completion handler must be:
    * @code void handler(
    *   const boost::system::error_code& error, // Result of operation.
-   *   std::size_t bytes_transferred           // Number of bytes received.
+   *   std::size_t bytes_transferred // Number of bytes received.
    * ); @endcode
    * Regardless of whether the asynchronous operation completes immediately or
-   * not, the handler will not be invoked from within this function. On
-   * immediate completion, invocation of the handler will be performed in a
+   * not, the completion handler will not be invoked from within this function.
+   * On immediate completion, invocation of the handler will be performed in a
    * manner equivalent to using boost::asio::post().
    *
+   * @par Completion Signature
+   * @code void(boost::system::error_code, std::size_t) @endcode
+   *
    * @par Example
    * To receive into a single data buffer use the @ref buffer function as
    * follows:
@@ -978,68 +1147,130 @@ public:
    * See the @ref buffer documentation for information on receiving into
    * multiple buffers in one go, and how to use it with arrays, boost::array or
    * std::vector.
+   *
+   * @par Per-Operation Cancellation
+   * On POSIX or Windows operating systems, this asynchronous operation supports
+   * cancellation for the following boost::asio::cancellation_type values:
+   *
+   * @li @c cancellation_type::terminal
+   *
+   * @li @c cancellation_type::partial
+   *
+   * @li @c cancellation_type::total
    */
-  template <typename MutableBufferSequence, typename ReadHandler>
-  BOOST_ASIO_INITFN_RESULT_TYPE(ReadHandler,
+  template <typename MutableBufferSequence,
+      BOOST_ASIO_COMPLETION_TOKEN_FOR(void (boost::system::error_code,
+        std::size_t)) ReadToken
+          BOOST_ASIO_DEFAULT_COMPLETION_TOKEN_TYPE(executor_type)>
+  BOOST_ASIO_INITFN_AUTO_RESULT_TYPE_PREFIX(ReadToken,
       void (boost::system::error_code, std::size_t))
   async_receive_from(const MutableBufferSequence& buffers,
       endpoint_type& sender_endpoint,
-      BOOST_ASIO_MOVE_ARG(ReadHandler) handler)
+      BOOST_ASIO_MOVE_ARG(ReadToken) token
+        BOOST_ASIO_DEFAULT_COMPLETION_TOKEN(executor_type))
+    BOOST_ASIO_INITFN_AUTO_RESULT_TYPE_SUFFIX((
+      async_initiate<ReadToken,
+        void (boost::system::error_code, std::size_t)>(
+          declval<initiate_async_receive_from>(), token, buffers,
+          &sender_endpoint, socket_base::message_flags(0))))
   {
-    return async_initiate<ReadHandler,
+    return async_initiate<ReadToken,
       void (boost::system::error_code, std::size_t)>(
-        initiate_async_receive_from(), handler, this, buffers,
+        initiate_async_receive_from(this), token, buffers,
         &sender_endpoint, socket_base::message_flags(0));
   }
 
   /// Start an asynchronous receive.
   /**
-   * This function is used to asynchronously receive a datagram. The function
-   * call always returns immediately.
+   * This function is used to asynchronously receive a datagram. It is an
+   * initiating function for an @ref asynchronous_operation, and always returns
+   * immediately.
    *
    * @param buffers One or more buffers into which the data will be received.
    * Although the buffers object may be copied as necessary, ownership of the
    * underlying memory blocks is retained by the caller, which must guarantee
-   * that they remain valid until the handler is called.
+   * that they remain valid until the completion handler is called.
    *
    * @param sender_endpoint An endpoint object that receives the endpoint of
    * the remote sender of the datagram. Ownership of the sender_endpoint object
    * is retained by the caller, which must guarantee that it is valid until the
-   * handler is called.
+   * completion handler is called.
    *
    * @param flags Flags specifying how the receive call is to be made.
    *
-   * @param handler The handler to be called when the receive operation
-   * completes. Copies will be made of the handler as required. The function
-   * signature of the handler must be:
+   * @param token The @ref completion_token that will be used to produce a
+   * completion handler, which will be called when the receive completes.
+   * Potential completion tokens include @ref use_future, @ref use_awaitable,
+   * @ref yield_context, or a function object with the correct completion
+   * signature. The function signature of the completion handler must be:
    * @code void handler(
    *   const boost::system::error_code& error, // Result of operation.
-   *   std::size_t bytes_transferred           // Number of bytes received.
+   *   std::size_t bytes_transferred // Number of bytes received.
    * ); @endcode
    * Regardless of whether the asynchronous operation completes immediately or
-   * not, the handler will not be invoked from within this function. On
-   * immediate completion, invocation of the handler will be performed in a
+   * not, the completion handler will not be invoked from within this function.
+   * On immediate completion, invocation of the handler will be performed in a
    * manner equivalent to using boost::asio::post().
+   *
+   * @par Completion Signature
+   * @code void(boost::system::error_code, std::size_t) @endcode
+   *
+   * @par Per-Operation Cancellation
+   * On POSIX or Windows operating systems, this asynchronous operation supports
+   * cancellation for the following boost::asio::cancellation_type values:
+   *
+   * @li @c cancellation_type::terminal
+   *
+   * @li @c cancellation_type::partial
+   *
+   * @li @c cancellation_type::total
    */
-  template <typename MutableBufferSequence, typename ReadHandler>
-  BOOST_ASIO_INITFN_RESULT_TYPE(ReadHandler,
+  template <typename MutableBufferSequence,
+      BOOST_ASIO_COMPLETION_TOKEN_FOR(void (boost::system::error_code,
+        std::size_t)) ReadToken
+          BOOST_ASIO_DEFAULT_COMPLETION_TOKEN_TYPE(executor_type)>
+  BOOST_ASIO_INITFN_AUTO_RESULT_TYPE_PREFIX(ReadToken,
       void (boost::system::error_code, std::size_t))
   async_receive_from(const MutableBufferSequence& buffers,
       endpoint_type& sender_endpoint, socket_base::message_flags flags,
-      BOOST_ASIO_MOVE_ARG(ReadHandler) handler)
+      BOOST_ASIO_MOVE_ARG(ReadToken) token
+        BOOST_ASIO_DEFAULT_COMPLETION_TOKEN(executor_type))
+    BOOST_ASIO_INITFN_AUTO_RESULT_TYPE_SUFFIX((
+      async_initiate<ReadToken,
+        void (boost::system::error_code, std::size_t)>(
+          declval<initiate_async_receive_from>(), token,
+          buffers, &sender_endpoint, flags)))
   {
-    return async_initiate<ReadHandler,
+    return async_initiate<ReadToken,
       void (boost::system::error_code, std::size_t)>(
-        initiate_async_receive_from(), handler,
-        this, buffers, &sender_endpoint, flags);
+        initiate_async_receive_from(this), token,
+        buffers, &sender_endpoint, flags);
   }
 
 private:
-  struct initiate_async_send
-  {
+  // Disallow copying and assignment.
+  basic_datagram_socket(const basic_datagram_socket&) BOOST_ASIO_DELETED;
+  basic_datagram_socket& operator=(
+      const basic_datagram_socket&) BOOST_ASIO_DELETED;
+
+  class initiate_async_send
+  { 
+  public:
+    typedef Executor executor_type;
+
+    explicit initiate_async_send(basic_datagram_socket* self)
+      : self_(self)
+    {
+    }
+
+    const executor_type& get_executor() const BOOST_ASIO_NOEXCEPT
+    {
+      return self_->get_executor();
+    }
+
     template <typename WriteHandler, typename ConstBufferSequence>
     void operator()(BOOST_ASIO_MOVE_ARG(WriteHandler) handler,
-        basic_datagram_socket* self, const ConstBufferSequence& buffers,
+        const ConstBufferSequence& buffers,
         socket_base::message_flags flags) const
     {
       // If you get an error on the following line it means that your handler
@@ -1047,18 +1278,33 @@ private:
       BOOST_ASIO_WRITE_HANDLER_CHECK(WriteHandler, handler) type_check;
 
       detail::non_const_lvalue<WriteHandler> handler2(handler);
-      self->impl_.get_service().async_send(
-          self->impl_.get_implementation(), buffers, flags,
-          handler2.value, self->impl_.get_implementation_executor());
+      self_->impl_.get_service().async_send(
+          self_->impl_.get_implementation(), buffers, flags,
+          handler2.value, self_->impl_.get_executor());
     }
+
+  private:
+    basic_datagram_socket* self_;
   };
 
-  struct initiate_async_send_to
+  class initiate_async_send_to
   {
+  public:
+    typedef Executor executor_type;
+
+    explicit initiate_async_send_to(basic_datagram_socket* self)
+      : self_(self)
+    {
+    }
+
+    const executor_type& get_executor() const BOOST_ASIO_NOEXCEPT
+    {
+      return self_->get_executor();
+    }
+
     template <typename WriteHandler, typename ConstBufferSequence>
     void operator()(BOOST_ASIO_MOVE_ARG(WriteHandler) handler,
-        basic_datagram_socket* self, const ConstBufferSequence& buffers,
-        const endpoint_type& destination,
+        const ConstBufferSequence& buffers, const endpoint_type& destination,
         socket_base::message_flags flags) const
     {
       // If you get an error on the following line it means that your handler
@@ -1066,17 +1312,33 @@ private:
       BOOST_ASIO_WRITE_HANDLER_CHECK(WriteHandler, handler) type_check;
 
       detail::non_const_lvalue<WriteHandler> handler2(handler);
-      self->impl_.get_service().async_send_to(
-          self->impl_.get_implementation(), buffers, destination, flags,
-          handler2.value, self->impl_.get_implementation_executor());
+      self_->impl_.get_service().async_send_to(
+          self_->impl_.get_implementation(), buffers, destination,
+          flags, handler2.value, self_->impl_.get_executor());
     }
+
+  private:
+    basic_datagram_socket* self_;
   };
 
-  struct initiate_async_receive
+  class initiate_async_receive
   {
+  public:
+    typedef Executor executor_type;
+
+    explicit initiate_async_receive(basic_datagram_socket* self)
+      : self_(self)
+    {
+    }
+
+    const executor_type& get_executor() const BOOST_ASIO_NOEXCEPT
+    {
+      return self_->get_executor();
+    }
+
     template <typename ReadHandler, typename MutableBufferSequence>
     void operator()(BOOST_ASIO_MOVE_ARG(ReadHandler) handler,
-        basic_datagram_socket* self, const MutableBufferSequence& buffers,
+        const MutableBufferSequence& buffers,
         socket_base::message_flags flags) const
     {
       // If you get an error on the following line it means that your handler
@@ -1084,28 +1346,47 @@ private:
       BOOST_ASIO_READ_HANDLER_CHECK(ReadHandler, handler) type_check;
 
       detail::non_const_lvalue<ReadHandler> handler2(handler);
-      self->impl_.get_service().async_receive(
-          self->impl_.get_implementation(), buffers, flags,
-          handler2.value, self->impl_.get_implementation_executor());
+      self_->impl_.get_service().async_receive(
+          self_->impl_.get_implementation(), buffers, flags,
+          handler2.value, self_->impl_.get_executor());
     }
+
+  private:
+    basic_datagram_socket* self_;
   };
 
-  struct initiate_async_receive_from
+  class initiate_async_receive_from
   {
+  public:
+    typedef Executor executor_type;
+
+    explicit initiate_async_receive_from(basic_datagram_socket* self)
+      : self_(self)
+    {
+    }
+
+    const executor_type& get_executor() const BOOST_ASIO_NOEXCEPT
+    {
+      return self_->get_executor();
+    }
+
     template <typename ReadHandler, typename MutableBufferSequence>
     void operator()(BOOST_ASIO_MOVE_ARG(ReadHandler) handler,
-        basic_datagram_socket* self, const MutableBufferSequence& buffers,
-        endpoint_type* sender_endpoint, socket_base::message_flags flags) const
+        const MutableBufferSequence& buffers, endpoint_type* sender_endpoint,
+        socket_base::message_flags flags) const
     {
       // If you get an error on the following line it means that your handler
       // does not meet the documented type requirements for a ReadHandler.
       BOOST_ASIO_READ_HANDLER_CHECK(ReadHandler, handler) type_check;
 
       detail::non_const_lvalue<ReadHandler> handler2(handler);
-      self->impl_.get_service().async_receive_from(
-          self->impl_.get_implementation(), buffers, *sender_endpoint, flags,
-          handler2.value, self->impl_.get_implementation_executor());
+      self_->impl_.get_service().async_receive_from(
+          self_->impl_.get_implementation(), buffers, *sender_endpoint,
+          flags, handler2.value, self_->impl_.get_executor());
     }
+
+  private:
+    basic_datagram_socket* self_;
   };
 };
 

linx64/include/boost/asio/basic_deadline_timer.hpp

@@ -2,7 +2,7 @@
 // basic_deadline_timer.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2019 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2023 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -21,6 +21,7 @@
   || defined(GENERATING_DOCUMENTATION)
 
 #include <cstddef>
+#include <boost/asio/any_io_executor.hpp>
 #include <boost/asio/detail/deadline_timer_service.hpp>
 #include <boost/asio/detail/handler_type_requirements.hpp>
 #include <boost/asio/detail/io_object_impl.hpp>
@@ -28,7 +29,6 @@
 #include <boost/asio/detail/throw_error.hpp>
 #include <boost/asio/error.hpp>
 #include <boost/asio/execution_context.hpp>
-#include <boost/asio/executor.hpp>
 #include <boost/asio/time_traits.hpp>
 
 #include <boost/asio/detail/push_options.hpp>
@@ -126,13 +126,24 @@ namespace asio {
  */
 template <typename Time,
     typename TimeTraits = boost::asio::time_traits<Time>,
-    typename Executor = executor>
+    typename Executor = any_io_executor>
 class basic_deadline_timer
 {
+private:
+  class initiate_async_wait;
+
 public:
   /// The type of the executor associated with the object.
   typedef Executor executor_type;
 
+  /// Rebinds the timer type to another executor.
+  template <typename Executor1>
+  struct rebind_executor
+  {
+    /// The timer type when rebound to the specified executor.
+    typedef basic_deadline_timer<Time, TimeTraits, Executor1> other;
+  };
+
   /// The time traits type.
   typedef TimeTraits traits_type;
 
@@ -152,7 +163,7 @@ public:
    * dispatch handlers for any asynchronous operations performed on the timer.
    */
   explicit basic_deadline_timer(const executor_type& ex)
-    : impl_(ex)
+    : impl_(0, ex)
   {
   }
 
@@ -168,10 +179,10 @@ public:
    */
   template <typename ExecutionContext>
   explicit basic_deadline_timer(ExecutionContext& context,
-      typename enable_if<
+      typename constraint<
         is_convertible<ExecutionContext&, execution_context&>::value
-      >::type* = 0)
-    : impl_(context)
+      >::type = 0)
+    : impl_(0, 0, context)
   {
   }
 
@@ -186,7 +197,7 @@ public:
    * as an absolute time.
    */
   basic_deadline_timer(const executor_type& ex, const time_type& expiry_time)
-    : impl_(ex)
+    : impl_(0, ex)
   {
     boost::system::error_code ec;
     impl_.get_service().expires_at(impl_.get_implementation(), expiry_time, ec);
@@ -206,10 +217,10 @@ public:
    */
   template <typename ExecutionContext>
   basic_deadline_timer(ExecutionContext& context, const time_type& expiry_time,
-      typename enable_if<
+      typename constraint<
         is_convertible<ExecutionContext&, execution_context&>::value
-      >::type* = 0)
-    : impl_(context)
+      >::type = 0)
+    : impl_(0, 0, context)
   {
     boost::system::error_code ec;
     impl_.get_service().expires_at(impl_.get_implementation(), expiry_time, ec);
@@ -228,7 +239,7 @@ public:
    */
   basic_deadline_timer(const executor_type& ex,
       const duration_type& expiry_time)
-    : impl_(ex)
+    : impl_(0, ex)
   {
     boost::system::error_code ec;
     impl_.get_service().expires_from_now(
@@ -250,10 +261,10 @@ public:
   template <typename ExecutionContext>
   basic_deadline_timer(ExecutionContext& context,
       const duration_type& expiry_time,
-      typename enable_if<
+      typename constraint<
         is_convertible<ExecutionContext&, execution_context&>::value
-      >::type* = 0)
-    : impl_(context)
+      >::type = 0)
+    : impl_(0, 0, context)
   {
     boost::system::error_code ec;
     impl_.get_service().expires_from_now(
@@ -307,7 +318,7 @@ public:
   }
 
   /// Get the executor associated with the object.
-  executor_type get_executor() BOOST_ASIO_NOEXCEPT
+  const executor_type& get_executor() BOOST_ASIO_NOEXCEPT
   {
     return impl_.get_executor();
   }
@@ -600,34 +611,57 @@ public:
   /// Start an asynchronous wait on the timer.
   /**
    * This function may be used to initiate an asynchronous wait against the
-   * timer. It always returns immediately.
+   * timer. It is an initiating function for an @ref asynchronous_operation,
+   * and always returns immediately.
    *
-   * For each call to async_wait(), the supplied handler will be called exactly
-   * once. The handler will be called when:
+   * For each call to async_wait(), the completion handler will be called
+   * exactly once. The completion handler will be called when:
    *
    * @li The timer has expired.
    *
    * @li The timer was cancelled, in which case the handler is passed the error
    * code boost::asio::error::operation_aborted.
    *
-   * @param handler The handler to be called when the timer expires. Copies
-   * will be made of the handler as required. The function signature of the
-   * handler must be:
+   * @param token The @ref completion_token that will be used to produce a
+   * completion handler, which will be called when the timer expires. Potential
+   * completion tokens include @ref use_future, @ref use_awaitable, @ref
+   * yield_context, or a function object with the correct completion signature.
+   * The function signature of the completion handler must be:
    * @code void handler(
    *   const boost::system::error_code& error // Result of operation.
    * ); @endcode
    * Regardless of whether the asynchronous operation completes immediately or
-   * not, the handler will not be invoked from within this function. On
-   * immediate completion, invocation of the handler will be performed in a
+   * not, the completion handler will not be invoked from within this function.
+   * On immediate completion, invocation of the handler will be performed in a
    * manner equivalent to using boost::asio::post().
+   *
+   * @par Completion Signature
+   * @code void(boost::system::error_code) @endcode
+   *
+   * @par Per-Operation Cancellation
+   * This asynchronous operation supports cancellation for the following
+   * boost::asio::cancellation_type values:
+   *
+   * @li @c cancellation_type::terminal
+   *
+   * @li @c cancellation_type::partial
+   *
+   * @li @c cancellation_type::total
    */
-  template <typename WaitHandler>
-  BOOST_ASIO_INITFN_RESULT_TYPE(WaitHandler,
+  template <
+      BOOST_ASIO_COMPLETION_TOKEN_FOR(void (boost::system::error_code))
+        WaitToken BOOST_ASIO_DEFAULT_COMPLETION_TOKEN_TYPE(executor_type)>
+  BOOST_ASIO_INITFN_AUTO_RESULT_TYPE_PREFIX(WaitToken,
       void (boost::system::error_code))
-  async_wait(BOOST_ASIO_MOVE_ARG(WaitHandler) handler)
+  async_wait(
+      BOOST_ASIO_MOVE_ARG(WaitToken) token
+        BOOST_ASIO_DEFAULT_COMPLETION_TOKEN(executor_type))
+    BOOST_ASIO_INITFN_AUTO_RESULT_TYPE_SUFFIX((
+      async_initiate<WaitToken, void (boost::system::error_code)>(
+          declval<initiate_async_wait>(), token)))
   {
-    return async_initiate<WaitHandler, void (boost::system::error_code)>(
-        initiate_async_wait(), handler, this);
+    return async_initiate<WaitToken, void (boost::system::error_code)>(
+        initiate_async_wait(this), token);
   }
 
 private:
@@ -636,21 +670,36 @@ private:
   basic_deadline_timer& operator=(
       const basic_deadline_timer&) BOOST_ASIO_DELETED;
 
-  struct initiate_async_wait
+  class initiate_async_wait
   {
+  public:
+    typedef Executor executor_type;
+
+    explicit initiate_async_wait(basic_deadline_timer* self)
+      : self_(self)
+    {
+    }
+
+    const executor_type& get_executor() const BOOST_ASIO_NOEXCEPT
+    {
+      return self_->get_executor();
+    }
+
     template <typename WaitHandler>
-    void operator()(BOOST_ASIO_MOVE_ARG(WaitHandler) handler,
-        basic_deadline_timer* self) const
+    void operator()(BOOST_ASIO_MOVE_ARG(WaitHandler) handler) const
     {
       // If you get an error on the following line it means that your handler
       // does not meet the documented type requirements for a WaitHandler.
       BOOST_ASIO_WAIT_HANDLER_CHECK(WaitHandler, handler) type_check;
 
       detail::non_const_lvalue<WaitHandler> handler2(handler);
-      self->impl_.get_service().async_wait(
-          self->impl_.get_implementation(), handler2.value,
-          self->impl_.get_implementation_executor());
+      self_->impl_.get_service().async_wait(
+          self_->impl_.get_implementation(),
+          handler2.value, self_->impl_.get_executor());
     }
+
+  private:
+    basic_deadline_timer* self_;
   };
 
   detail::io_object_impl<

linx64/include/boost/asio/basic_file.hpp

@@ -0,0 +1,831 @@
+//
+// basic_file.hpp
+// ~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2023 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef BOOST_ASIO_BASIC_FILE_HPP
+#define BOOST_ASIO_BASIC_FILE_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include <boost/asio/detail/config.hpp>
+
+#if defined(BOOST_ASIO_HAS_FILE) \
+  || defined(GENERATING_DOCUMENTATION)
+
+#include <string>
+#include <boost/asio/any_io_executor.hpp>
+#include <boost/asio/async_result.hpp>
+#include <boost/asio/detail/cstdint.hpp>
+#include <boost/asio/detail/handler_type_requirements.hpp>
+#include <boost/asio/detail/io_object_impl.hpp>
+#include <boost/asio/detail/non_const_lvalue.hpp>
+#include <boost/asio/detail/throw_error.hpp>
+#include <boost/asio/detail/type_traits.hpp>
+#include <boost/asio/error.hpp>
+#include <boost/asio/execution_context.hpp>
+#include <boost/asio/post.hpp>
+#include <boost/asio/file_base.hpp>
+#if defined(BOOST_ASIO_HAS_IOCP)
+# include <boost/asio/detail/win_iocp_file_service.hpp>
+#elif defined(BOOST_ASIO_HAS_IO_URING)
+# include <boost/asio/detail/io_uring_file_service.hpp>
+#endif
+
+#if defined(BOOST_ASIO_HAS_MOVE)
+# include <utility>
+#endif // defined(BOOST_ASIO_HAS_MOVE)
+
+#include <boost/asio/detail/push_options.hpp>
+
+namespace boost {
+namespace asio {
+
+#if !defined(BOOST_ASIO_BASIC_FILE_FWD_DECL)
+#define BOOST_ASIO_BASIC_FILE_FWD_DECL
+
+// Forward declaration with defaulted arguments.
+template <typename Executor = any_io_executor>
+class basic_file;
+
+#endif // !defined(BOOST_ASIO_BASIC_FILE_FWD_DECL)
+
+/// Provides file functionality.
+/**
+ * The basic_file class template provides functionality that is common to both
+ * stream-oriented and random-access files.
+ *
+ * @par Thread Safety
+ * @e Distinct @e objects: Safe.@n
+ * @e Shared @e objects: Unsafe.
+ */
+template <typename Executor>
+class basic_file
+  : public file_base
+{
+public:
+  /// The type of the executor associated with the object.
+  typedef Executor executor_type;
+
+  /// Rebinds the file type to another executor.
+  template <typename Executor1>
+  struct rebind_executor
+  {
+    /// The file type when rebound to the specified executor.
+    typedef basic_file<Executor1> other;
+  };
+
+  /// The native representation of a file.
+#if defined(GENERATING_DOCUMENTATION)
+  typedef implementation_defined native_handle_type;
+#elif defined(BOOST_ASIO_HAS_IOCP)
+  typedef detail::win_iocp_file_service::native_handle_type native_handle_type;
+#elif defined(BOOST_ASIO_HAS_IO_URING)
+  typedef detail::io_uring_file_service::native_handle_type native_handle_type;
+#endif
+
+  /// Construct a basic_file without opening it.
+  /**
+   * This constructor initialises a file without opening it.
+   *
+   * @param ex The I/O executor that the file will use, by default, to
+   * dispatch handlers for any asynchronous operations performed on the file.
+   */
+  explicit basic_file(const executor_type& ex)
+    : impl_(0, ex)
+  {
+  }
+
+  /// Construct a basic_file without opening it.
+  /**
+   * This constructor initialises a file without opening it.
+   *
+   * @param context An execution context which provides the I/O executor that
+   * the file will use, by default, to dispatch handlers for any asynchronous
+   * operations performed on the file.
+   */
+  template <typename ExecutionContext>
+  explicit basic_file(ExecutionContext& context,
+      typename constraint<
+        is_convertible<ExecutionContext&, execution_context&>::value,
+        defaulted_constraint
+      >::type = defaulted_constraint())
+    : impl_(0, 0, context)
+  {
+  }
+
+  /// Construct and open a basic_file.
+  /**
+   * This constructor initialises a file and opens it.
+   *
+   * @param ex The I/O executor that the file will use, by default, to
+   * dispatch handlers for any asynchronous operations performed on the file.
+   *
+   * @param path The path name identifying the file to be opened.
+   *
+   * @param open_flags A set of flags that determine how the file should be
+   * opened.
+   */
+  explicit basic_file(const executor_type& ex,
+      const char* path, file_base::flags open_flags)
+    : impl_(0, ex)
+  {
+    boost::system::error_code ec;
+    impl_.get_service().open(impl_.get_implementation(), path, open_flags, ec);
+    boost::asio::detail::throw_error(ec, "open");
+  }
+
+  /// Construct a basic_file without opening it.
+  /**
+   * This constructor initialises a file and opens it.
+   *
+   * @param context An execution context which provides the I/O executor that
+   * the file will use, by default, to dispatch handlers for any asynchronous
+   * operations performed on the file.
+   *
+   * @param path The path name identifying the file to be opened.
+   *
+   * @param open_flags A set of flags that determine how the file should be
+   * opened.
+   */
+  template <typename ExecutionContext>
+  explicit basic_file(ExecutionContext& context,
+      const char* path, file_base::flags open_flags,
+      typename constraint<
+        is_convertible<ExecutionContext&, execution_context&>::value,
+        defaulted_constraint
+      >::type = defaulted_constraint())
+    : impl_(0, 0, context)
+  {
+    boost::system::error_code ec;
+    impl_.get_service().open(impl_.get_implementation(), path, open_flags, ec);
+    boost::asio::detail::throw_error(ec, "open");
+  }
+
+  /// Construct and open a basic_file.
+  /**
+   * This constructor initialises a file and opens it.
+   *
+   * @param ex The I/O executor that the file will use, by default, to
+   * dispatch handlers for any asynchronous operations performed on the file.
+   *
+   * @param path The path name identifying the file to be opened.
+   *
+   * @param open_flags A set of flags that determine how the file should be
+   * opened.
+   */
+  explicit basic_file(const executor_type& ex,
+      const std::string& path, file_base::flags open_flags)
+    : impl_(0, ex)
+  {
+    boost::system::error_code ec;
+    impl_.get_service().open(impl_.get_implementation(),
+        path.c_str(), open_flags, ec);
+    boost::asio::detail::throw_error(ec, "open");
+  }
+
+  /// Construct a basic_file without opening it.
+  /**
+   * This constructor initialises a file and opens it.
+   *
+   * @param context An execution context which provides the I/O executor that
+   * the file will use, by default, to dispatch handlers for any asynchronous
+   * operations performed on the file.
+   *
+   * @param path The path name identifying the file to be opened.
+   *
+   * @param open_flags A set of flags that determine how the file should be
+   * opened.
+   */
+  template <typename ExecutionContext>
+  explicit basic_file(ExecutionContext& context,
+      const std::string& path, file_base::flags open_flags,
+      typename constraint<
+        is_convertible<ExecutionContext&, execution_context&>::value,
+        defaulted_constraint
+      >::type = defaulted_constraint())
+    : impl_(0, 0, context)
+  {
+    boost::system::error_code ec;
+    impl_.get_service().open(impl_.get_implementation(),
+        path.c_str(), open_flags, ec);
+    boost::asio::detail::throw_error(ec, "open");
+  }
+
+  /// Construct a basic_file on an existing native file handle.
+  /**
+   * This constructor initialises a file object to hold an existing native file.
+   *
+   * @param ex The I/O executor that the file will use, by default, to
+   * dispatch handlers for any asynchronous operations performed on the file.
+   *
+   * @param native_file A native file handle.
+   *
+   * @throws boost::system::system_error Thrown on failure.
+   */
+  basic_file(const executor_type& ex, const native_handle_type& native_file)
+    : impl_(0, ex)
+  {
+    boost::system::error_code ec;
+    impl_.get_service().assign(
+        impl_.get_implementation(), native_file, ec);
+    boost::asio::detail::throw_error(ec, "assign");
+  }
+
+  /// Construct a basic_file on an existing native file.
+  /**
+   * This constructor initialises a file object to hold an existing native file.
+   *
+   * @param context An execution context which provides the I/O executor that
+   * the file will use, by default, to dispatch handlers for any asynchronous
+   * operations performed on the file.
+   *
+   * @param native_file A native file.
+   *
+   * @throws boost::system::system_error Thrown on failure.
+   */
+  template <typename ExecutionContext>
+  basic_file(ExecutionContext& context, const native_handle_type& native_file,
+      typename constraint<
+        is_convertible<ExecutionContext&, execution_context&>::value,
+        defaulted_constraint
+      >::type = defaulted_constraint())
+    : impl_(0, 0, context)
+  {
+    boost::system::error_code ec;
+    impl_.get_service().assign(
+        impl_.get_implementation(), native_file, ec);
+    boost::asio::detail::throw_error(ec, "assign");
+  }
+
+#if defined(BOOST_ASIO_HAS_MOVE) || defined(GENERATING_DOCUMENTATION)
+  /// Move-construct a basic_file from another.
+  /**
+   * This constructor moves a file from one object to another.
+   *
+   * @param other The other basic_file object from which the move will
+   * occur.
+   *
+   * @note Following the move, the moved-from object is in the same state as if
+   * constructed using the @c basic_file(const executor_type&) constructor.
+   */
+  basic_file(basic_file&& other) BOOST_ASIO_NOEXCEPT
+    : impl_(std::move(other.impl_))
+  {
+  }
+
+  /// Move-assign a basic_file from another.
+  /**
+   * This assignment operator moves a file from one object to another.
+   *
+   * @param other The other basic_file object from which the move will
+   * occur.
+   *
+   * @note Following the move, the moved-from object is in the same state as if
+   * constructed using the @c basic_file(const executor_type&) constructor.
+   */
+  basic_file& operator=(basic_file&& other)
+  {
+    impl_ = std::move(other.impl_);
+    return *this;
+  }
+
+  // All files have access to each other's implementations.
+  template <typename Executor1>
+  friend class basic_file;
+
+  /// Move-construct a basic_file from a file of another executor type.
+  /**
+   * This constructor moves a file from one object to another.
+   *
+   * @param other The other basic_file object from which the move will
+   * occur.
+   *
+   * @note Following the move, the moved-from object is in the same state as if
+   * constructed using the @c basic_file(const executor_type&) constructor.
+   */
+  template <typename Executor1>
+  basic_file(basic_file<Executor1>&& other,
+      typename constraint<
+        is_convertible<Executor1, Executor>::value,
+        defaulted_constraint
+      >::type = defaulted_constraint())
+    : impl_(std::move(other.impl_))
+  {
+  }
+
+  /// Move-assign a basic_file from a file of another executor type.
+  /**
+   * This assignment operator moves a file from one object to another.
+   *
+   * @param other The other basic_file object from which the move will
+   * occur.
+   *
+   * @note Following the move, the moved-from object is in the same state as if
+   * constructed using the @c basic_file(const executor_type&) constructor.
+   */
+  template <typename Executor1>
+  typename constraint<
+    is_convertible<Executor1, Executor>::value,
+    basic_file&
+  >::type operator=(basic_file<Executor1>&& other)
+  {
+    basic_file tmp(std::move(other));
+    impl_ = std::move(tmp.impl_);
+    return *this;
+  }
+#endif // defined(BOOST_ASIO_HAS_MOVE) || defined(GENERATING_DOCUMENTATION)
+
+  /// Get the executor associated with the object.
+  const executor_type& get_executor() BOOST_ASIO_NOEXCEPT
+  {
+    return impl_.get_executor();
+  }
+
+  /// Open the file using the specified path.
+  /**
+   * This function opens the file so that it will use the specified path.
+   *
+   * @param path The path name identifying the file to be opened.
+   *
+   * @param open_flags A set of flags that determine how the file should be
+   * opened.
+   *
+   * @throws boost::system::system_error Thrown on failure.
+   *
+   * @par Example
+   * @code
+   * boost::asio::stream_file file(my_context);
+   * file.open("/path/to/my/file", boost::asio::stream_file::read_only);
+   * @endcode
+   */
+  void open(const char* path, file_base::flags open_flags)
+  {
+    boost::system::error_code ec;
+    impl_.get_service().open(impl_.get_implementation(), path, open_flags, ec);
+    boost::asio::detail::throw_error(ec, "open");
+  }
+
+  /// Open the file using the specified path.
+  /**
+   * This function opens the file so that it will use the specified path.
+   *
+   * @param path The path name identifying the file to be opened.
+   *
+   * @param open_flags A set of flags that determine how the file should be
+   * opened.
+   *
+   * @param ec Set to indicate what error occurred, if any.
+   *
+   * @par Example
+   * @code
+   * boost::asio::stream_file file(my_context);
+   * boost::system::error_code ec;
+   * file.open("/path/to/my/file", boost::asio::stream_file::read_only, ec);
+   * if (ec)
+   * {
+   *   // An error occurred.
+   * }
+   * @endcode
+   */
+  BOOST_ASIO_SYNC_OP_VOID open(const char* path,
+      file_base::flags open_flags, boost::system::error_code& ec)
+  {
+    impl_.get_service().open(impl_.get_implementation(), path, open_flags, ec);
+    BOOST_ASIO_SYNC_OP_VOID_RETURN(ec);
+  }
+
+  /// Open the file using the specified path.
+  /**
+   * This function opens the file so that it will use the specified path.
+   *
+   * @param path The path name identifying the file to be opened.
+   *
+   * @param open_flags A set of flags that determine how the file should be
+   * opened.
+   *
+   * @throws boost::system::system_error Thrown on failure.
+   *
+   * @par Example
+   * @code
+   * boost::asio::stream_file file(my_context);
+   * file.open("/path/to/my/file", boost::asio::stream_file::read_only);
+   * @endcode
+   */
+  void open(const std::string& path, file_base::flags open_flags)
+  {
+    boost::system::error_code ec;
+    impl_.get_service().open(impl_.get_implementation(),
+        path.c_str(), open_flags, ec);
+    boost::asio::detail::throw_error(ec, "open");
+  }
+
+  /// Open the file using the specified path.
+  /**
+   * This function opens the file so that it will use the specified path.
+   *
+   * @param path The path name identifying the file to be opened.
+   *
+   * @param open_flags A set of flags that determine how the file should be
+   * opened.
+   *
+   * @param ec Set to indicate what error occurred, if any.
+   *
+   * @par Example
+   * @code
+   * boost::asio::stream_file file(my_context);
+   * boost::system::error_code ec;
+   * file.open("/path/to/my/file", boost::asio::stream_file::read_only, ec);
+   * if (ec)
+   * {
+   *   // An error occurred.
+   * }
+   * @endcode
+   */
+  BOOST_ASIO_SYNC_OP_VOID open(const std::string& path,
+      file_base::flags open_flags, boost::system::error_code& ec)
+  {
+    impl_.get_service().open(impl_.get_implementation(),
+        path.c_str(), open_flags, ec);
+    BOOST_ASIO_SYNC_OP_VOID_RETURN(ec);
+  }
+
+  /// Assign an existing native file to the file.
+  /*
+   * This function opens the file to hold an existing native file.
+   *
+   * @param native_file A native file.
+   *
+   * @throws boost::system::system_error Thrown on failure.
+   */
+  void assign(const native_handle_type& native_file)
+  {
+    boost::system::error_code ec;
+    impl_.get_service().assign(
+        impl_.get_implementation(), native_file, ec);
+    boost::asio::detail::throw_error(ec, "assign");
+  }
+
+  /// Assign an existing native file to the file.
+  /*
+   * This function opens the file to hold an existing native file.
+   *
+   * @param native_file A native file.
+   *
+   * @param ec Set to indicate what error occurred, if any.
+   */
+  BOOST_ASIO_SYNC_OP_VOID assign(const native_handle_type& native_file,
+      boost::system::error_code& ec)
+  {
+    impl_.get_service().assign(
+        impl_.get_implementation(), native_file, ec);
+    BOOST_ASIO_SYNC_OP_VOID_RETURN(ec);
+  }
+
+  /// Determine whether the file is open.
+  bool is_open() const
+  {
+    return impl_.get_service().is_open(impl_.get_implementation());
+  }
+
+  /// Close the file.
+  /**
+   * This function is used to close the file. Any asynchronous read or write
+   * operations will be cancelled immediately, and will complete with the
+   * boost::asio::error::operation_aborted error.
+   *
+   * @throws boost::system::system_error Thrown on failure. Note that, even if
+   * the function indicates an error, the underlying descriptor is closed.
+   */
+  void close()
+  {
+    boost::system::error_code ec;
+    impl_.get_service().close(impl_.get_implementation(), ec);
+    boost::asio::detail::throw_error(ec, "close");
+  }
+
+  /// Close the file.
+  /**
+   * This function is used to close the file. Any asynchronous read or write
+   * operations will be cancelled immediately, and will complete with the
+   * boost::asio::error::operation_aborted error.
+   *
+   * @param ec Set to indicate what error occurred, if any. Note that, even if
+   * the function indicates an error, the underlying descriptor is closed.
+   *
+   * @par Example
+   * @code
+   * boost::asio::stream_file file(my_context);
+   * ...
+   * boost::system::error_code ec;
+   * file.close(ec);
+   * if (ec)
+   * {
+   *   // An error occurred.
+   * }
+   * @endcode
+   */
+  BOOST_ASIO_SYNC_OP_VOID close(boost::system::error_code& ec)
+  {
+    impl_.get_service().close(impl_.get_implementation(), ec);
+    BOOST_ASIO_SYNC_OP_VOID_RETURN(ec);
+  }
+
+  /// Release ownership of the underlying native file.
+  /**
+   * This function causes all outstanding asynchronous read and write
+   * operations to finish immediately, and the handlers for cancelled
+   * operations will be passed the boost::asio::error::operation_aborted error.
+   * Ownership of the native file is then transferred to the caller.
+   *
+   * @throws boost::system::system_error Thrown on failure.
+   *
+   * @note This function is unsupported on Windows versions prior to Windows
+   * 8.1, and will fail with boost::asio::error::operation_not_supported on
+   * these platforms.
+   */
+#if defined(BOOST_ASIO_MSVC) && (BOOST_ASIO_MSVC >= 1400) \
+  && (!defined(_WIN32_WINNT) || _WIN32_WINNT < 0x0603)
+  __declspec(deprecated("This function always fails with "
+        "operation_not_supported when used on Windows versions "
+        "prior to Windows 8.1."))
+#endif
+  native_handle_type release()
+  {
+    boost::system::error_code ec;
+    native_handle_type s = impl_.get_service().release(
+        impl_.get_implementation(), ec);
+    boost::asio::detail::throw_error(ec, "release");
+    return s;
+  }
+
+  /// Release ownership of the underlying native file.
+  /**
+   * This function causes all outstanding asynchronous read and write
+   * operations to finish immediately, and the handlers for cancelled
+   * operations will be passed the boost::asio::error::operation_aborted error.
+   * Ownership of the native file is then transferred to the caller.
+   *
+   * @param ec Set to indicate what error occurred, if any.
+   *
+   * @note This function is unsupported on Windows versions prior to Windows
+   * 8.1, and will fail with boost::asio::error::operation_not_supported on
+   * these platforms.
+   */
+#if defined(BOOST_ASIO_MSVC) && (BOOST_ASIO_MSVC >= 1400) \
+  && (!defined(_WIN32_WINNT) || _WIN32_WINNT < 0x0603)
+  __declspec(deprecated("This function always fails with "
+        "operation_not_supported when used on Windows versions "
+        "prior to Windows 8.1."))
+#endif
+  native_handle_type release(boost::system::error_code& ec)
+  {
+    return impl_.get_service().release(impl_.get_implementation(), ec);
+  }
+
+  /// Get the native file representation.
+  /**
+   * This function may be used to obtain the underlying representation of the
+   * file. This is intended to allow access to native file functionality
+   * that is not otherwise provided.
+   */
+  native_handle_type native_handle()
+  {
+    return impl_.get_service().native_handle(impl_.get_implementation());
+  }
+
+  /// Cancel all asynchronous operations associated with the file.
+  /**
+   * This function causes all outstanding asynchronous read and write
+   * operations to finish immediately, and the handlers for cancelled
+   * operations will be passed the boost::asio::error::operation_aborted error.
+   *
+   * @throws boost::system::system_error Thrown on failure.
+   *
+   * @note Calls to cancel() will always fail with
+   * boost::asio::error::operation_not_supported when run on Windows XP, Windows
+   * Server 2003, and earlier versions of Windows, unless
+   * BOOST_ASIO_ENABLE_CANCELIO is defined. However, the CancelIo function has
+   * two issues that should be considered before enabling its use:
+   *
+   * @li It will only cancel asynchronous operations that were initiated in the
+   * current thread.
+   *
+   * @li It can appear to complete without error, but the request to cancel the
+   * unfinished operations may be silently ignored by the operating system.
+   * Whether it works or not seems to depend on the drivers that are installed.
+   *
+   * For portable cancellation, consider using the close() function to
+   * simultaneously cancel the outstanding operations and close the file.
+   *
+   * When running on Windows Vista, Windows Server 2008, and later, the
+   * CancelIoEx function is always used. This function does not have the
+   * problems described above.
+   */
+#if defined(BOOST_ASIO_MSVC) && (BOOST_ASIO_MSVC >= 1400) \
+  && (!defined(_WIN32_WINNT) || _WIN32_WINNT < 0x0600) \
+  && !defined(BOOST_ASIO_ENABLE_CANCELIO)
+  __declspec(deprecated("By default, this function always fails with "
+        "operation_not_supported when used on Windows XP, Windows Server 2003, "
+        "or earlier. Consult documentation for details."))
+#endif
+  void cancel()
+  {
+    boost::system::error_code ec;
+    impl_.get_service().cancel(impl_.get_implementation(), ec);
+    boost::asio::detail::throw_error(ec, "cancel");
+  }
+
+  /// Cancel all asynchronous operations associated with the file.
+  /**
+   * This function causes all outstanding asynchronous read and write
+   * operations to finish immediately, and the handlers for cancelled
+   * operations will be passed the boost::asio::error::operation_aborted error.
+   *
+   * @param ec Set to indicate what error occurred, if any.
+   *
+   * @note Calls to cancel() will always fail with
+   * boost::asio::error::operation_not_supported when run on Windows XP, Windows
+   * Server 2003, and earlier versions of Windows, unless
+   * BOOST_ASIO_ENABLE_CANCELIO is defined. However, the CancelIo function has
+   * two issues that should be considered before enabling its use:
+   *
+   * @li It will only cancel asynchronous operations that were initiated in the
+   * current thread.
+   *
+   * @li It can appear to complete without error, but the request to cancel the
+   * unfinished operations may be silently ignored by the operating system.
+   * Whether it works or not seems to depend on the drivers that are installed.
+   *
+   * For portable cancellation, consider using the close() function to
+   * simultaneously cancel the outstanding operations and close the file.
+   *
+   * When running on Windows Vista, Windows Server 2008, and later, the
+   * CancelIoEx function is always used. This function does not have the
+   * problems described above.
+   */
+#if defined(BOOST_ASIO_MSVC) && (BOOST_ASIO_MSVC >= 1400) \
+  && (!defined(_WIN32_WINNT) || _WIN32_WINNT < 0x0600) \
+  && !defined(BOOST_ASIO_ENABLE_CANCELIO)
+  __declspec(deprecated("By default, this function always fails with "
+        "operation_not_supported when used on Windows XP, Windows Server 2003, "
+        "or earlier. Consult documentation for details."))
+#endif
+  BOOST_ASIO_SYNC_OP_VOID cancel(boost::system::error_code& ec)
+  {
+    impl_.get_service().cancel(impl_.get_implementation(), ec);
+    BOOST_ASIO_SYNC_OP_VOID_RETURN(ec);
+  }
+
+  /// Get the size of the file.
+  /**
+   * This function determines the size of the file, in bytes.
+   *
+   * @throws boost::system::system_error Thrown on failure.
+   */
+  uint64_t size() const
+  {
+    boost::system::error_code ec;
+    uint64_t s = impl_.get_service().size(impl_.get_implementation(), ec);
+    boost::asio::detail::throw_error(ec, "size");
+    return s;
+  }
+
+  /// Get the size of the file.
+  /**
+   * This function determines the size of the file, in bytes.
+   *
+   * @param ec Set to indicate what error occurred, if any.
+   */
+  uint64_t size(boost::system::error_code& ec) const
+  {
+    return impl_.get_service().size(impl_.get_implementation(), ec);
+  }
+
+  /// Alter the size of the file.
+  /**
+   * This function resizes the file to the specified size, in bytes. If the
+   * current file size exceeds @c n then any extra data is discarded. If the
+   * current size is less than @c n then the file is extended and filled with
+   * zeroes.
+   *
+   * @param n The new size for the file.
+   *
+   * @throws boost::system::system_error Thrown on failure.
+   */
+  void resize(uint64_t n)
+  {
+    boost::system::error_code ec;
+    impl_.get_service().resize(impl_.get_implementation(), n, ec);
+    boost::asio::detail::throw_error(ec, "resize");
+  }
+
+  /// Alter the size of the file.
+  /**
+   * This function resizes the file to the specified size, in bytes. If the
+   * current file size exceeds @c n then any extra data is discarded. If the
+   * current size is less than @c n then the file is extended and filled with
+   * zeroes.
+   *
+   * @param n The new size for the file.
+   *
+   * @param ec Set to indicate what error occurred, if any.
+   */
+  BOOST_ASIO_SYNC_OP_VOID resize(uint64_t n, boost::system::error_code& ec)
+  {
+    impl_.get_service().resize(impl_.get_implementation(), n, ec);
+    BOOST_ASIO_SYNC_OP_VOID_RETURN(ec);
+  }
+
+  /// Synchronise the file to disk.
+  /**
+   * This function synchronises the file data and metadata to disk. Note that
+   * the semantics of this synchronisation vary between operation systems.
+   *
+   * @throws boost::system::system_error Thrown on failure.
+   */
+  void sync_all()
+  {
+    boost::system::error_code ec;
+    impl_.get_service().sync_all(impl_.get_implementation(), ec);
+    boost::asio::detail::throw_error(ec, "sync_all");
+  }
+
+  /// Synchronise the file to disk.
+  /**
+   * This function synchronises the file data and metadata to disk. Note that
+   * the semantics of this synchronisation vary between operation systems.
+   *
+   * @param ec Set to indicate what error occurred, if any.
+   */
+  BOOST_ASIO_SYNC_OP_VOID sync_all(boost::system::error_code& ec)
+  {
+    impl_.get_service().sync_all(impl_.get_implementation(), ec);
+    BOOST_ASIO_SYNC_OP_VOID_RETURN(ec);
+  }
+
+  /// Synchronise the file data to disk.
+  /**
+   * This function synchronises the file data to disk. Note that the semantics
+   * of this synchronisation vary between operation systems.
+   *
+   * @throws boost::system::system_error Thrown on failure.
+   */
+  void sync_data()
+  {
+    boost::system::error_code ec;
+    impl_.get_service().sync_data(impl_.get_implementation(), ec);
+    boost::asio::detail::throw_error(ec, "sync_data");
+  }
+
+  /// Synchronise the file data to disk.
+  /**
+   * This function synchronises the file data to disk. Note that the semantics
+   * of this synchronisation vary between operation systems.
+   *
+   * @param ec Set to indicate what error occurred, if any.
+   */
+  BOOST_ASIO_SYNC_OP_VOID sync_data(boost::system::error_code& ec)
+  {
+    impl_.get_service().sync_data(impl_.get_implementation(), ec);
+    BOOST_ASIO_SYNC_OP_VOID_RETURN(ec);
+  }
+
+protected:
+  /// Protected destructor to prevent deletion through this type.
+  /**
+   * This function destroys the file, cancelling any outstanding asynchronous
+   * operations associated with the file as if by calling @c cancel.
+   */
+  ~basic_file()
+  {
+  }
+
+#if defined(BOOST_ASIO_HAS_IOCP)
+  detail::io_object_impl<detail::win_iocp_file_service, Executor> impl_;
+#elif defined(BOOST_ASIO_HAS_IO_URING)
+  detail::io_object_impl<detail::io_uring_file_service, Executor> impl_;
+#endif
+
+private:
+  // Disallow copying and assignment.
+  basic_file(const basic_file&) BOOST_ASIO_DELETED;
+  basic_file& operator=(const basic_file&) BOOST_ASIO_DELETED;
+};
+
+} // namespace asio
+} // namespace boost
+
+#include <boost/asio/detail/pop_options.hpp>
+
+#endif // defined(BOOST_ASIO_HAS_FILE)
+       //   || defined(GENERATING_DOCUMENTATION)
+
+#endif // BOOST_ASIO_BASIC_FILE_HPP

linx64/include/boost/asio/basic_io_object.hpp

@@ -2,7 +2,7 @@
 // basic_io_object.hpp
 // ~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2019 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2023 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

linx64/include/boost/asio/basic_random_access_file.hpp

@@ -0,0 +1,703 @@
+//
+// basic_random_access_file.hpp
+// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2023 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef BOOST_ASIO_BASIC_RANDOM_ACCESS_FILE_HPP
+#define BOOST_ASIO_BASIC_RANDOM_ACCESS_FILE_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include <boost/asio/detail/config.hpp>
+
+#if defined(BOOST_ASIO_HAS_FILE) \
+  || defined(GENERATING_DOCUMENTATION)
+
+#include <cstddef>
+#include <boost/asio/async_result.hpp>
+#include <boost/asio/basic_file.hpp>
+#include <boost/asio/detail/handler_type_requirements.hpp>
+#include <boost/asio/detail/non_const_lvalue.hpp>
+#include <boost/asio/detail/throw_error.hpp>
+#include <boost/asio/error.hpp>
+
+#include <boost/asio/detail/push_options.hpp>
+
+namespace boost {
+namespace asio {
+
+#if !defined(BOOST_ASIO_BASIC_RANDOM_ACCESS_FILE_FWD_DECL)
+#define BOOST_ASIO_BASIC_RANDOM_ACCESS_FILE_FWD_DECL
+
+// Forward declaration with defaulted arguments.
+template <typename Executor = any_io_executor>
+class basic_random_access_file;
+
+#endif // !defined(BOOST_ASIO_BASIC_RANDOM_ACCESS_FILE_FWD_DECL)
+
+/// Provides random-access file functionality.
+/**
+ * The basic_random_access_file class template provides asynchronous and
+ * blocking random-access file functionality.
+ *
+ * @par Thread Safety
+ * @e Distinct @e objects: Safe.@n
+ * @e Shared @e objects: Unsafe.
+ *
+ * Synchronous @c read_some_at and @c write_some_at operations are thread safe
+ * with respect to each other, if the underlying operating system calls are
+ * also thread safe. This means that it is permitted to perform concurrent
+ * calls to these synchronous operations on a single file object. Other
+ * synchronous operations, such as @c open or @c close, are not thread safe.
+ */
+template <typename Executor>
+class basic_random_access_file
+  : public basic_file<Executor>
+{
+private:
+  class initiate_async_write_some_at;
+  class initiate_async_read_some_at;
+
+public:
+  /// The type of the executor associated with the object.
+  typedef Executor executor_type;
+
+  /// Rebinds the file type to another executor.
+  template <typename Executor1>
+  struct rebind_executor
+  {
+    /// The file type when rebound to the specified executor.
+    typedef basic_random_access_file<Executor1> other;
+  };
+
+  /// The native representation of a file.
+#if defined(GENERATING_DOCUMENTATION)
+  typedef implementation_defined native_handle_type;
+#else
+  typedef typename basic_file<Executor>::native_handle_type native_handle_type;
+#endif
+
+  /// Construct a basic_random_access_file without opening it.
+  /**
+   * This constructor initialises a file without opening it. The file needs to
+   * be opened before data can be read from or or written to it.
+   *
+   * @param ex The I/O executor that the file will use, by default, to
+   * dispatch handlers for any asynchronous operations performed on the file.
+   */
+  explicit basic_random_access_file(const executor_type& ex)
+    : basic_file<Executor>(ex)
+  {
+  }
+
+  /// Construct a basic_random_access_file without opening it.
+  /**
+   * This constructor initialises a file without opening it. The file needs to
+   * be opened before data can be read from or or written to it.
+   *
+   * @param context An execution context which provides the I/O executor that
+   * the file will use, by default, to dispatch handlers for any asynchronous
+   * operations performed on the file.
+   */
+  template <typename ExecutionContext>
+  explicit basic_random_access_file(ExecutionContext& context,
+      typename constraint<
+        is_convertible<ExecutionContext&, execution_context&>::value,
+        defaulted_constraint
+      >::type = defaulted_constraint())
+    : basic_file<Executor>(context)
+  {
+  }
+
+  /// Construct and open a basic_random_access_file.
+  /**
+   * This constructor initialises and opens a file.
+   *
+   * @param ex The I/O executor that the file will use, by default, to
+   * dispatch handlers for any asynchronous operations performed on the file.
+   *
+   * @param path The path name identifying the file to be opened.
+   *
+   * @param open_flags A set of flags that determine how the file should be
+   * opened.
+   *
+   * @throws boost::system::system_error Thrown on failure.
+   */
+  basic_random_access_file(const executor_type& ex,
+      const char* path, file_base::flags open_flags)
+    : basic_file<Executor>(ex, path, open_flags)
+  {
+  }
+
+  /// Construct and open a basic_random_access_file.
+  /**
+   * This constructor initialises and opens a file.
+   *
+   * @param context An execution context which provides the I/O executor that
+   * the file will use, by default, to dispatch handlers for any asynchronous
+   * operations performed on the file.
+   *
+   * @param path The path name identifying the file to be opened.
+   *
+   * @param open_flags A set of flags that determine how the file should be
+   * opened.
+   *
+   * @throws boost::system::system_error Thrown on failure.
+   */
+  template <typename ExecutionContext>
+  basic_random_access_file(ExecutionContext& context,
+      const char* path, file_base::flags open_flags,
+      typename constraint<
+        is_convertible<ExecutionContext&, execution_context&>::value,
+        defaulted_constraint
+      >::type = defaulted_constraint())
+    : basic_file<Executor>(context, path, open_flags)
+  {
+  }
+
+  /// Construct and open a basic_random_access_file.
+  /**
+   * This constructor initialises and opens a file.
+   *
+   * @param ex The I/O executor that the file will use, by default, to
+   * dispatch handlers for any asynchronous operations performed on the file.
+   *
+   * @param path The path name identifying the file to be opened.
+   *
+   * @param open_flags A set of flags that determine how the file should be
+   * opened.
+   *
+   * @throws boost::system::system_error Thrown on failure.
+   */
+  basic_random_access_file(const executor_type& ex,
+      const std::string& path, file_base::flags open_flags)
+    : basic_file<Executor>(ex, path, open_flags)
+  {
+  }
+
+  /// Construct and open a basic_random_access_file.
+  /**
+   * This constructor initialises and opens a file.
+   *
+   * @param context An execution context which provides the I/O executor that
+   * the file will use, by default, to dispatch handlers for any asynchronous
+   * operations performed on the file.
+   *
+   * @param path The path name identifying the file to be opened.
+   *
+   * @param open_flags A set of flags that determine how the file should be
+   * opened.
+   *
+   * @throws boost::system::system_error Thrown on failure.
+   */
+  template <typename ExecutionContext>
+  basic_random_access_file(ExecutionContext& context,
+      const std::string& path, file_base::flags open_flags,
+      typename constraint<
+        is_convertible<ExecutionContext&, execution_context&>::value,
+        defaulted_constraint
+      >::type = defaulted_constraint())
+    : basic_file<Executor>(context, path, open_flags)
+  {
+  }
+
+  /// Construct a basic_random_access_file on an existing native file.
+  /**
+   * This constructor initialises a random-access file object to hold an
+   * existing native file.
+   *
+   * @param ex The I/O executor that the file will use, by default, to
+   * dispatch handlers for any asynchronous operations performed on the file.
+   *
+   * @param native_file The new underlying file implementation.
+   *
+   * @throws boost::system::system_error Thrown on failure.
+   */
+  basic_random_access_file(const executor_type& ex,
+      const native_handle_type& native_file)
+    : basic_file<Executor>(ex, native_file)
+  {
+  }
+
+  /// Construct a basic_random_access_file on an existing native file.
+  /**
+   * This constructor initialises a random-access file object to hold an
+   * existing native file.
+   *
+   * @param context An execution context which provides the I/O executor that
+   * the file will use, by default, to dispatch handlers for any asynchronous
+   * operations performed on the file.
+   *
+   * @param native_file The new underlying file implementation.
+   *
+   * @throws boost::system::system_error Thrown on failure.
+   */
+  template <typename ExecutionContext>
+  basic_random_access_file(ExecutionContext& context,
+      const native_handle_type& native_file,
+      typename constraint<
+        is_convertible<ExecutionContext&, execution_context&>::value,
+        defaulted_constraint
+      >::type = defaulted_constraint())
+    : basic_file<Executor>(context, native_file)
+  {
+  }
+
+#if defined(BOOST_ASIO_HAS_MOVE) || defined(GENERATING_DOCUMENTATION)
+  /// Move-construct a basic_random_access_file from another.
+  /**
+   * This constructor moves a random-access file from one object to another.
+   *
+   * @param other The other basic_random_access_file object from which the move
+   * will occur.
+   *
+   * @note Following the move, the moved-from object is in the same state as if
+   * constructed using the @c basic_random_access_file(const executor_type&)
+   * constructor.
+   */
+  basic_random_access_file(basic_random_access_file&& other) BOOST_ASIO_NOEXCEPT
+    : basic_file<Executor>(std::move(other))
+  {
+  }
+
+  /// Move-assign a basic_random_access_file from another.
+  /**
+   * This assignment operator moves a random-access file from one object to
+   * another.
+   *
+   * @param other The other basic_random_access_file object from which the move
+   * will occur.
+   *
+   * @note Following the move, the moved-from object is in the same state as if
+   * constructed using the @c basic_random_access_file(const executor_type&)
+   * constructor.
+   */
+  basic_random_access_file& operator=(basic_random_access_file&& other)
+  {
+    basic_file<Executor>::operator=(std::move(other));
+    return *this;
+  }
+
+  /// Move-construct a basic_random_access_file from a file of another executor
+  /// type.
+  /**
+   * This constructor moves a random-access file from one object to another.
+   *
+   * @param other The other basic_random_access_file object from which the move
+   * will occur.
+   *
+   * @note Following the move, the moved-from object is in the same state as if
+   * constructed using the @c basic_random_access_file(const executor_type&)
+   * constructor.
+   */
+  template <typename Executor1>
+  basic_random_access_file(basic_random_access_file<Executor1>&& other,
+      typename constraint<
+        is_convertible<Executor1, Executor>::value,
+        defaulted_constraint
+      >::type = defaulted_constraint())
+    : basic_file<Executor>(std::move(other))
+  {
+  }
+
+  /// Move-assign a basic_random_access_file from a file of another executor
+  /// type.
+  /**
+   * This assignment operator moves a random-access file from one object to
+   * another.
+   *
+   * @param other The other basic_random_access_file object from which the move
+   * will occur.
+   *
+   * @note Following the move, the moved-from object is in the same state as if
+   * constructed using the @c basic_random_access_file(const executor_type&)
+   * constructor.
+   */
+  template <typename Executor1>
+  typename constraint<
+    is_convertible<Executor1, Executor>::value,
+    basic_random_access_file&
+  >::type operator=(basic_random_access_file<Executor1>&& other)
+  {
+    basic_file<Executor>::operator=(std::move(other));
+    return *this;
+  }
+#endif // defined(BOOST_ASIO_HAS_MOVE) || defined(GENERATING_DOCUMENTATION)
+
+  /// Destroys the file.
+  /**
+   * This function destroys the file, cancelling any outstanding asynchronous
+   * operations associated with the file as if by calling @c cancel.
+   */
+  ~basic_random_access_file()
+  {
+  }
+
+  /// Write some data to the handle at the specified offset.
+  /**
+   * This function is used to write data to the random-access handle. The
+   * function call will block until one or more bytes of the data has been
+   * written successfully, or until an error occurs.
+   *
+   * @param offset The offset at which the data will be written.
+   *
+   * @param buffers One or more data buffers to be written to the handle.
+   *
+   * @returns The number of bytes written.
+   *
+   * @throws boost::system::system_error Thrown on failure. An error code of
+   * boost::asio::error::eof indicates that the end of the file was reached.
+   *
+   * @note The write_some_at operation may not write all of the data. Consider
+   * using the @ref write_at function if you need to ensure that all data is
+   * written before the blocking operation completes.
+   *
+   * @par Example
+   * To write a single data buffer use the @ref buffer function as follows:
+   * @code
+   * handle.write_some_at(42, boost::asio::buffer(data, size));
+   * @endcode
+   * See the @ref buffer documentation for information on writing multiple
+   * buffers in one go, and how to use it with arrays, boost::array or
+   * std::vector.
+   */
+  template <typename ConstBufferSequence>
+  std::size_t write_some_at(uint64_t offset,
+      const ConstBufferSequence& buffers)
+  {
+    boost::system::error_code ec;
+    std::size_t s = this->impl_.get_service().write_some_at(
+        this->impl_.get_implementation(), offset, buffers, ec);
+    boost::asio::detail::throw_error(ec, "write_some_at");
+    return s;
+  }
+
+  /// Write some data to the handle at the specified offset.
+  /**
+   * This function is used to write data to the random-access handle. The
+   * function call will block until one or more bytes of the data has been
+   * written successfully, or until an error occurs.
+   *
+   * @param offset The offset at which the data will be written.
+   *
+   * @param buffers One or more data buffers to be written to the handle.
+   *
+   * @param ec Set to indicate what error occurred, if any.
+   *
+   * @returns The number of bytes written. Returns 0 if an error occurred.
+   *
+   * @note The write_some operation may not write all of the data to the
+   * file. Consider using the @ref write_at function if you need to ensure that
+   * all data is written before the blocking operation completes.
+   */
+  template <typename ConstBufferSequence>
+  std::size_t write_some_at(uint64_t offset,
+      const ConstBufferSequence& buffers, boost::system::error_code& ec)
+  {
+    return this->impl_.get_service().write_some_at(
+        this->impl_.get_implementation(), offset, buffers, ec);
+  }
+
+  /// Start an asynchronous write at the specified offset.
+  /**
+   * This function is used to asynchronously write data to the random-access
+   * handle. It is an initiating function for an @ref asynchronous_operation,
+   * and always returns immediately.
+   *
+   * @param offset The offset at which the data will be written.
+   *
+   * @param buffers One or more data buffers to be written to the handle.
+   * Although the buffers object may be copied as necessary, ownership of the
+   * underlying memory blocks is retained by the caller, which must guarantee
+   * that they remain valid until the completion handler is called.
+   *
+   * @param token The @ref completion_token that will be used to produce a
+   * completion handler, which will be called when the write completes.
+   * Potential completion tokens include @ref use_future, @ref use_awaitable,
+   * @ref yield_context, or a function object with the correct completion
+   * signature. The function signature of the completion handler must be:
+   * @code void handler(
+   *   const boost::system::error_code& error, // Result of operation.
+   *   std::size_t bytes_transferred // Number of bytes written.
+   * ); @endcode
+   * Regardless of whether the asynchronous operation completes immediately or
+   * not, the completion handler will not be invoked from within this function.
+   * On immediate completion, invocation of the handler will be performed in a
+   * manner equivalent to using boost::asio::post().
+   *
+   * @par Completion Signature
+   * @code void(boost::system::error_code, std::size_t) @endcode
+   *
+   * @note The write operation may not write all of the data to the file.
+   * Consider using the @ref async_write_at function if you need to ensure that
+   * all data is written before the asynchronous operation completes.
+   *
+   * @par Example
+   * To write a single data buffer use the @ref buffer function as follows:
+   * @code
+   * handle.async_write_some_at(42, boost::asio::buffer(data, size), handler);
+   * @endcode
+   * See the @ref buffer documentation for information on writing multiple
+   * buffers in one go, and how to use it with arrays, boost::array or
+   * std::vector.
+   *
+   * @par Per-Operation Cancellation
+   * This asynchronous operation supports cancellation for the following
+   * boost::asio::cancellation_type values:
+   *
+   * @li @c cancellation_type::terminal
+   *
+   * @li @c cancellation_type::partial
+   *
+   * @li @c cancellation_type::total
+   */
+  template <typename ConstBufferSequence,
+      BOOST_ASIO_COMPLETION_TOKEN_FOR(void (boost::system::error_code,
+        std::size_t)) WriteToken
+          BOOST_ASIO_DEFAULT_COMPLETION_TOKEN_TYPE(executor_type)>
+  BOOST_ASIO_INITFN_AUTO_RESULT_TYPE_PREFIX(WriteToken,
+      void (boost::system::error_code, std::size_t))
+  async_write_some_at(uint64_t offset,
+      const ConstBufferSequence& buffers,
+      BOOST_ASIO_MOVE_ARG(WriteToken) token
+        BOOST_ASIO_DEFAULT_COMPLETION_TOKEN(executor_type))
+    BOOST_ASIO_INITFN_AUTO_RESULT_TYPE_SUFFIX((
+      async_initiate<WriteToken,
+        void (boost::system::error_code, std::size_t)>(
+          declval<initiate_async_write_some_at>(), token, offset, buffers)))
+  {
+    return async_initiate<WriteToken,
+      void (boost::system::error_code, std::size_t)>(
+        initiate_async_write_some_at(this), token, offset, buffers);
+  }
+
+  /// Read some data from the handle at the specified offset.
+  /**
+   * This function is used to read data from the random-access handle. The
+   * function call will block until one or more bytes of data has been read
+   * successfully, or until an error occurs.
+   *
+   * @param offset The offset at which the data will be read.
+   *
+   * @param buffers One or more buffers into which the data will be read.
+   *
+   * @returns The number of bytes read.
+   *
+   * @throws boost::system::system_error Thrown on failure. An error code of
+   * boost::asio::error::eof indicates that the end of the file was reached.
+   *
+   * @note The read_some operation may not read all of the requested number of
+   * bytes. Consider using the @ref read_at function if you need to ensure that
+   * the requested amount of data is read before the blocking operation
+   * completes.
+   *
+   * @par Example
+   * To read into a single data buffer use the @ref buffer function as follows:
+   * @code
+   * handle.read_some_at(42, boost::asio::buffer(data, size));
+   * @endcode
+   * See the @ref buffer documentation for information on reading into multiple
+   * buffers in one go, and how to use it with arrays, boost::array or
+   * std::vector.
+   */
+  template <typename MutableBufferSequence>
+  std::size_t read_some_at(uint64_t offset,
+      const MutableBufferSequence& buffers)
+  {
+    boost::system::error_code ec;
+    std::size_t s = this->impl_.get_service().read_some_at(
+        this->impl_.get_implementation(), offset, buffers, ec);
+    boost::asio::detail::throw_error(ec, "read_some_at");
+    return s;
+  }
+
+  /// Read some data from the handle at the specified offset.
+  /**
+   * This function is used to read data from the random-access handle. The
+   * function call will block until one or more bytes of data has been read
+   * successfully, or until an error occurs.
+   *
+   * @param offset The offset at which the data will be read.
+   *
+   * @param buffers One or more buffers into which the data will be read.
+   *
+   * @param ec Set to indicate what error occurred, if any.
+   *
+   * @returns The number of bytes read. Returns 0 if an error occurred.
+   *
+   * @note The read_some operation may not read all of the requested number of
+   * bytes. Consider using the @ref read_at function if you need to ensure that
+   * the requested amount of data is read before the blocking operation
+   * completes.
+   */
+  template <typename MutableBufferSequence>
+  std::size_t read_some_at(uint64_t offset,
+      const MutableBufferSequence& buffers, boost::system::error_code& ec)
+  {
+    return this->impl_.get_service().read_some_at(
+        this->impl_.get_implementation(), offset, buffers, ec);
+  }
+
+  /// Start an asynchronous read at the specified offset.
+  /**
+   * This function is used to asynchronously read data from the random-access
+   * handle. It is an initiating function for an @ref asynchronous_operation,
+   * and always returns immediately.
+   *
+   * @param offset The offset at which the data will be read.
+   *
+   * @param buffers One or more buffers into which the data will be read.
+   * Although the buffers object may be copied as necessary, ownership of the
+   * underlying memory blocks is retained by the caller, which must guarantee
+   * that they remain valid until the completion handler is called.
+   *
+   * @param token The @ref completion_token that will be used to produce a
+   * completion handler, which will be called when the read completes.
+   * Potential completion tokens include @ref use_future, @ref use_awaitable,
+   * @ref yield_context, or a function object with the correct completion
+   * signature. The function signature of the completion handler must be:
+   * @code void handler(
+   *   const boost::system::error_code& error, // Result of operation.
+   *   std::size_t bytes_transferred // Number of bytes read.
+   * ); @endcode
+   * Regardless of whether the asynchronous operation completes immediately or
+   * not, the completion handler will not be invoked from within this function.
+   * On immediate completion, invocation of the handler will be performed in a
+   * manner equivalent to using boost::asio::post().
+   *
+   * @par Completion Signature
+   * @code void(boost::system::error_code, std::size_t) @endcode
+   *
+   * @note The read operation may not read all of the requested number of bytes.
+   * Consider using the @ref async_read_at function if you need to ensure that
+   * the requested amount of data is read before the asynchronous operation
+   * completes.
+   *
+   * @par Example
+   * To read into a single data buffer use the @ref buffer function as follows:
+   * @code
+   * handle.async_read_some_at(42, boost::asio::buffer(data, size), handler);
+   * @endcode
+   * See the @ref buffer documentation for information on reading into multiple
+   * buffers in one go, and how to use it with arrays, boost::array or
+   * std::vector.
+   *
+   * @par Per-Operation Cancellation
+   * This asynchronous operation supports cancellation for the following
+   * boost::asio::cancellation_type values:
+   *
+   * @li @c cancellation_type::terminal
+   *
+   * @li @c cancellation_type::partial
+   *
+   * @li @c cancellation_type::total
+   */
+  template <typename MutableBufferSequence,
+      BOOST_ASIO_COMPLETION_TOKEN_FOR(void (boost::system::error_code,
+        std::size_t)) ReadToken
+          BOOST_ASIO_DEFAULT_COMPLETION_TOKEN_TYPE(executor_type)>
+  BOOST_ASIO_INITFN_AUTO_RESULT_TYPE_PREFIX(ReadToken,
+      void (boost::system::error_code, std::size_t))
+  async_read_some_at(uint64_t offset,
+      const MutableBufferSequence& buffers,
+      BOOST_ASIO_MOVE_ARG(ReadToken) token
+        BOOST_ASIO_DEFAULT_COMPLETION_TOKEN(executor_type))
+    BOOST_ASIO_INITFN_AUTO_RESULT_TYPE_SUFFIX((
+      async_initiate<ReadToken,
+        void (boost::system::error_code, std::size_t)>(
+          declval<initiate_async_read_some_at>(), token, offset, buffers)))
+  {
+    return async_initiate<ReadToken,
+      void (boost::system::error_code, std::size_t)>(
+        initiate_async_read_some_at(this), token, offset, buffers);
+  }
+
+private:
+  // Disallow copying and assignment.
+  basic_random_access_file(const basic_random_access_file&) BOOST_ASIO_DELETED;
+  basic_random_access_file& operator=(
+      const basic_random_access_file&) BOOST_ASIO_DELETED;
+
+  class initiate_async_write_some_at
+  {
+  public:
+    typedef Executor executor_type;
+
+    explicit initiate_async_write_some_at(basic_random_access_file* self)
+      : self_(self)
+    {
+    }
+
+    const executor_type& get_executor() const BOOST_ASIO_NOEXCEPT
+    {
+      return self_->get_executor();
+    }
+
+    template <typename WriteHandler, typename ConstBufferSequence>
+    void operator()(BOOST_ASIO_MOVE_ARG(WriteHandler) handler,
+        uint64_t offset, const ConstBufferSequence& buffers) const
+    {
+      // If you get an error on the following line it means that your handler
+      // does not meet the documented type requirements for a WriteHandler.
+      BOOST_ASIO_WRITE_HANDLER_CHECK(WriteHandler, handler) type_check;
+
+      detail::non_const_lvalue<WriteHandler> handler2(handler);
+      self_->impl_.get_service().async_write_some_at(
+          self_->impl_.get_implementation(), offset, buffers,
+          handler2.value, self_->impl_.get_executor());
+    }
+
+  private:
+    basic_random_access_file* self_;
+  };
+
+  class initiate_async_read_some_at
+  {
+  public:
+    typedef Executor executor_type;
+
+    explicit initiate_async_read_some_at(basic_random_access_file* self)
+      : self_(self)
+    {
+    }
+
+    const executor_type& get_executor() const BOOST_ASIO_NOEXCEPT
+    {
+      return self_->get_executor();
+    }
+
+    template <typename ReadHandler, typename MutableBufferSequence>
+    void operator()(BOOST_ASIO_MOVE_ARG(ReadHandler) handler,
+        uint64_t offset, const MutableBufferSequence& buffers) const
+    {
+      // If you get an error on the following line it means that your handler
+      // does not meet the documented type requirements for a ReadHandler.
+      BOOST_ASIO_READ_HANDLER_CHECK(ReadHandler, handler) type_check;
+
+      detail::non_const_lvalue<ReadHandler> handler2(handler);
+      self_->impl_.get_service().async_read_some_at(
+          self_->impl_.get_implementation(), offset, buffers,
+          handler2.value, self_->impl_.get_executor());
+    }
+
+  private:
+    basic_random_access_file* self_;
+  };
+};
+
+} // namespace asio
+} // namespace boost
+
+#include <boost/asio/detail/pop_options.hpp>
+
+#endif // defined(BOOST_ASIO_HAS_FILE)
+       //   || defined(GENERATING_DOCUMENTATION)
+
+#endif // BOOST_ASIO_BASIC_RANDOM_ACCESS_FILE_HPP

linx64/include/boost/asio/basic_raw_socket.hpp

@@ -2,7 +2,7 @@
 // basic_raw_socket.hpp
 // ~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2019 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2023 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -33,7 +33,7 @@ namespace asio {
 #define BOOST_ASIO_BASIC_RAW_SOCKET_FWD_DECL
 
 // Forward declaration with defaulted arguments.
-template <typename Protocol, typename Executor = executor>
+template <typename Protocol, typename Executor = any_io_executor>
 class basic_raw_socket;
 
 #endif // !defined(BOOST_ASIO_BASIC_RAW_SOCKET_FWD_DECL)
@@ -46,11 +46,24 @@ class basic_raw_socket;
  * @par Thread Safety
  * @e Distinct @e objects: Safe.@n
  * @e Shared @e objects: Unsafe.
+ *
+ * Synchronous @c send, @c send_to, @c receive, @c receive_from, @c connect,
+ * and @c shutdown operations are thread safe with respect to each other, if
+ * the underlying operating system calls are also thread safe. This means that
+ * it is permitted to perform concurrent calls to these synchronous operations
+ * on a single socket object. Other synchronous operations, such as @c open or
+ * @c close, are not thread safe.
  */
 template <typename Protocol, typename Executor>
 class basic_raw_socket
   : public basic_socket<Protocol, Executor>
 {
+private:
+  class initiate_async_send;
+  class initiate_async_send_to;
+  class initiate_async_receive;
+  class initiate_async_receive_from;
+
 public:
   /// The type of the executor associated with the object.
   typedef Executor executor_type;
@@ -101,9 +114,9 @@ public:
    */
   template <typename ExecutionContext>
   explicit basic_raw_socket(ExecutionContext& context,
-      typename enable_if<
+      typename constraint<
         is_convertible<ExecutionContext&, execution_context&>::value
-      >::type* = 0)
+      >::type = 0)
     : basic_socket<Protocol, Executor>(context)
   {
   }
@@ -138,9 +151,10 @@ public:
    */
   template <typename ExecutionContext>
   basic_raw_socket(ExecutionContext& context, const protocol_type& protocol,
-      typename enable_if<
-        is_convertible<ExecutionContext&, execution_context&>::value
-      >::type* = 0)
+      typename constraint<
+        is_convertible<ExecutionContext&, execution_context&>::value,
+        defaulted_constraint
+      >::type = defaulted_constraint())
     : basic_socket<Protocol, Executor>(context, protocol)
   {
   }
@@ -183,9 +197,9 @@ public:
    */
   template <typename ExecutionContext>
   basic_raw_socket(ExecutionContext& context, const endpoint_type& endpoint,
-      typename enable_if<
+      typename constraint<
         is_convertible<ExecutionContext&, execution_context&>::value
-      >::type* = 0)
+      >::type = 0)
     : basic_socket<Protocol, Executor>(context, endpoint)
   {
   }
@@ -228,9 +242,9 @@ public:
   template <typename ExecutionContext>
   basic_raw_socket(ExecutionContext& context,
       const protocol_type& protocol, const native_handle_type& native_socket,
-      typename enable_if<
+      typename constraint<
         is_convertible<ExecutionContext&, execution_context&>::value
-      >::type* = 0)
+      >::type = 0)
     : basic_socket<Protocol, Executor>(context, protocol, native_socket)
   {
   }
@@ -247,7 +261,7 @@ public:
    * constructed using the @c basic_raw_socket(const executor_type&)
    * constructor.
    */
-  basic_raw_socket(basic_raw_socket&& other)
+  basic_raw_socket(basic_raw_socket&& other) BOOST_ASIO_NOEXCEPT
     : basic_socket<Protocol, Executor>(std::move(other))
   {
   }
@@ -283,10 +297,10 @@ public:
    */
   template <typename Protocol1, typename Executor1>
   basic_raw_socket(basic_raw_socket<Protocol1, Executor1>&& other,
-      typename enable_if<
+      typename constraint<
         is_convertible<Protocol1, Protocol>::value
           && is_convertible<Executor1, Executor>::value
-      >::type* = 0)
+      >::type = 0)
     : basic_socket<Protocol, Executor>(std::move(other))
   {
   }
@@ -303,7 +317,7 @@ public:
    * constructor.
    */
   template <typename Protocol1, typename Executor1>
-  typename enable_if<
+  typename constraint<
     is_convertible<Protocol1, Protocol>::value
       && is_convertible<Executor1, Executor>::value,
     basic_raw_socket&
@@ -407,26 +421,32 @@ public:
 
   /// Start an asynchronous send on a connected socket.
   /**
-   * This function is used to send data on the raw socket. The function call
-   * will block until the data has been sent successfully or an error occurs.
+   * This function is used to asynchronously send data on the raw socket. It is
+   * an initiating function for an @ref asynchronous_operation, and always
+   * returns immediately.
    *
    * @param buffers One or more data buffers to be sent on the socket. Although
    * the buffers object may be copied as necessary, ownership of the underlying
    * memory blocks is retained by the caller, which must guarantee that they
-   * remain valid until the handler is called.
+   * remain valid until the completion handler is called.
    *
-   * @param handler The handler to be called when the send operation completes.
-   * Copies will be made of the handler as required. The function signature of
-   * the handler must be:
+   * @param token The @ref completion_token that will be used to produce a
+   * completion handler, which will be called when the send completes.
+   * Potential completion tokens include @ref use_future, @ref use_awaitable,
+   * @ref yield_context, or a function object with the correct completion
+   * signature. The function signature of the completion handler must be:
    * @code void handler(
    *   const boost::system::error_code& error, // Result of operation.
-   *   std::size_t bytes_transferred           // Number of bytes sent.
+   *   std::size_t bytes_transferred // Number of bytes sent.
    * ); @endcode
    * Regardless of whether the asynchronous operation completes immediately or
-   * not, the handler will not be invoked from within this function. On
-   * immediate completion, invocation of the handler will be performed in a
+   * not, the completion handler will not be invoked from within this function.
+   * On immediate completion, invocation of the handler will be performed in a
    * manner equivalent to using boost::asio::post().
    *
+   * @par Completion Signature
+   * @code void(boost::system::error_code, std::size_t) @endcode
+   *
    * @note The async_send operation can only be used with a connected socket.
    * Use the async_send_to function to send data on an unconnected raw
    * socket.
@@ -439,57 +459,100 @@ public:
    * See the @ref buffer documentation for information on sending multiple
    * buffers in one go, and how to use it with arrays, boost::array or
    * std::vector.
+   *
+   * @par Per-Operation Cancellation
+   * On POSIX or Windows operating systems, this asynchronous operation supports
+   * cancellation for the following boost::asio::cancellation_type values:
+   *
+   * @li @c cancellation_type::terminal
+   *
+   * @li @c cancellation_type::partial
+   *
+   * @li @c cancellation_type::total
    */
-  template <typename ConstBufferSequence, typename WriteHandler>
-  BOOST_ASIO_INITFN_RESULT_TYPE(WriteHandler,
+  template <typename ConstBufferSequence,
+      BOOST_ASIO_COMPLETION_TOKEN_FOR(void (boost::system::error_code,
+        std::size_t)) WriteToken
+          BOOST_ASIO_DEFAULT_COMPLETION_TOKEN_TYPE(executor_type)>
+  BOOST_ASIO_INITFN_AUTO_RESULT_TYPE_PREFIX(WriteToken,
       void (boost::system::error_code, std::size_t))
   async_send(const ConstBufferSequence& buffers,
-      BOOST_ASIO_MOVE_ARG(WriteHandler) handler)
+      BOOST_ASIO_MOVE_ARG(WriteToken) token
+        BOOST_ASIO_DEFAULT_COMPLETION_TOKEN(executor_type))
+    BOOST_ASIO_INITFN_AUTO_RESULT_TYPE_SUFFIX((
+      async_initiate<WriteToken,
+        void (boost::system::error_code, std::size_t)>(
+          declval<initiate_async_send>(), token,
+          buffers, socket_base::message_flags(0))))
   {
-    return async_initiate<WriteHandler,
+    return async_initiate<WriteToken,
       void (boost::system::error_code, std::size_t)>(
-        initiate_async_send(), handler, this,
+        initiate_async_send(this), token,
         buffers, socket_base::message_flags(0));
   }
 
   /// Start an asynchronous send on a connected socket.
   /**
-   * This function is used to send data on the raw socket. The function call
-   * will block until the data has been sent successfully or an error occurs.
+   * This function is used to asynchronously send data on the raw socket. It is
+   * an initiating function for an @ref asynchronous_operation, and always
+   * returns immediately.
    *
    * @param buffers One or more data buffers to be sent on the socket. Although
    * the buffers object may be copied as necessary, ownership of the underlying
    * memory blocks is retained by the caller, which must guarantee that they
-   * remain valid until the handler is called.
+   * remain valid until the completion handler is called.
    *
    * @param flags Flags specifying how the send call is to be made.
    *
-   * @param handler The handler to be called when the send operation completes.
-   * Copies will be made of the handler as required. The function signature of
-   * the handler must be:
+   * @param token The @ref completion_token that will be used to produce a
+   * completion handler, which will be called when the send completes.
+   * Potential completion tokens include @ref use_future, @ref use_awaitable,
+   * @ref yield_context, or a function object with the correct completion
+   * signature. The function signature of the completion handler must be:
    * @code void handler(
    *   const boost::system::error_code& error, // Result of operation.
-   *   std::size_t bytes_transferred           // Number of bytes sent.
+   *   std::size_t bytes_transferred // Number of bytes sent.
    * ); @endcode
    * Regardless of whether the asynchronous operation completes immediately or
-   * not, the handler will not be invoked from within this function. On
-   * immediate completion, invocation of the handler will be performed in a
+   * not, the completion handler will not be invoked from within this function.
+   * On immediate completion, invocation of the handler will be performed in a
    * manner equivalent to using boost::asio::post().
    *
+   * @par Completion Signature
+   * @code void(boost::system::error_code, std::size_t) @endcode
+   *
    * @note The async_send operation can only be used with a connected socket.
    * Use the async_send_to function to send data on an unconnected raw
    * socket.
+   *
+   * @par Per-Operation Cancellation
+   * On POSIX or Windows operating systems, this asynchronous operation supports
+   * cancellation for the following boost::asio::cancellation_type values:
+   *
+   * @li @c cancellation_type::terminal
+   *
+   * @li @c cancellation_type::partial
+   *
+   * @li @c cancellation_type::total
    */
-  template <typename ConstBufferSequence, typename WriteHandler>
-  BOOST_ASIO_INITFN_RESULT_TYPE(WriteHandler,
+  template <typename ConstBufferSequence,
+      BOOST_ASIO_COMPLETION_TOKEN_FOR(void (boost::system::error_code,
+        std::size_t)) WriteToken
+          BOOST_ASIO_DEFAULT_COMPLETION_TOKEN_TYPE(executor_type)>
+  BOOST_ASIO_INITFN_AUTO_RESULT_TYPE_PREFIX(WriteToken,
       void (boost::system::error_code, std::size_t))
   async_send(const ConstBufferSequence& buffers,
       socket_base::message_flags flags,
-      BOOST_ASIO_MOVE_ARG(WriteHandler) handler)
+      BOOST_ASIO_MOVE_ARG(WriteToken) token
+        BOOST_ASIO_DEFAULT_COMPLETION_TOKEN(executor_type))
+    BOOST_ASIO_INITFN_AUTO_RESULT_TYPE_SUFFIX((
+      async_initiate<WriteToken,
+        void (boost::system::error_code, std::size_t)>(
+          declval<initiate_async_send>(), token, buffers, flags)))
   {
-    return async_initiate<WriteHandler,
+    return async_initiate<WriteToken,
       void (boost::system::error_code, std::size_t)>(
-        initiate_async_send(), handler, this, buffers, flags);
+        initiate_async_send(this), token, buffers, flags);
   }
 
   /// Send raw data to the specified endpoint.
@@ -583,28 +646,34 @@ public:
   /// Start an asynchronous send.
   /**
    * This function is used to asynchronously send raw data to the specified
-   * remote endpoint. The function call always returns immediately.
+   * remote endpoint. It is an initiating function for an @ref
+   * asynchronous_operation, and always returns immediately.
    *
    * @param buffers One or more data buffers to be sent to the remote endpoint.
    * Although the buffers object may be copied as necessary, ownership of the
    * underlying memory blocks is retained by the caller, which must guarantee
-   * that they remain valid until the handler is called.
+   * that they remain valid until the completion handler is called.
    *
    * @param destination The remote endpoint to which the data will be sent.
    * Copies will be made of the endpoint as required.
    *
-   * @param handler The handler to be called when the send operation completes.
-   * Copies will be made of the handler as required. The function signature of
-   * the handler must be:
+   * @param token The @ref completion_token that will be used to produce a
+   * completion handler, which will be called when the send completes.
+   * Potential completion tokens include @ref use_future, @ref use_awaitable,
+   * @ref yield_context, or a function object with the correct completion
+   * signature. The function signature of the completion handler must be:
    * @code void handler(
    *   const boost::system::error_code& error, // Result of operation.
-   *   std::size_t bytes_transferred           // Number of bytes sent.
+   *   std::size_t bytes_transferred // Number of bytes sent.
    * ); @endcode
    * Regardless of whether the asynchronous operation completes immediately or
-   * not, the handler will not be invoked from within this function. On
-   * immediate completion, invocation of the handler will be performed in a
+   * not, the completion handler will not be invoked from within this function.
+   * On immediate completion, invocation of the handler will be performed in a
    * manner equivalent to using boost::asio::post().
    *
+   * @par Completion Signature
+   * @code void(boost::system::error_code, std::size_t) @endcode
+   *
    * @par Example
    * To send a single data buffer use the @ref buffer function as follows:
    * @code
@@ -616,57 +685,102 @@ public:
    * See the @ref buffer documentation for information on sending multiple
    * buffers in one go, and how to use it with arrays, boost::array or
    * std::vector.
+   *
+   * @par Per-Operation Cancellation
+   * On POSIX or Windows operating systems, this asynchronous operation supports
+   * cancellation for the following boost::asio::cancellation_type values:
+   *
+   * @li @c cancellation_type::terminal
+   *
+   * @li @c cancellation_type::partial
+   *
+   * @li @c cancellation_type::total
    */
-  template <typename ConstBufferSequence, typename WriteHandler>
-  BOOST_ASIO_INITFN_RESULT_TYPE(WriteHandler,
+  template <typename ConstBufferSequence,
+      BOOST_ASIO_COMPLETION_TOKEN_FOR(void (boost::system::error_code,
+        std::size_t)) WriteToken
+          BOOST_ASIO_DEFAULT_COMPLETION_TOKEN_TYPE(executor_type)>
+  BOOST_ASIO_INITFN_AUTO_RESULT_TYPE_PREFIX(WriteToken,
       void (boost::system::error_code, std::size_t))
   async_send_to(const ConstBufferSequence& buffers,
       const endpoint_type& destination,
-      BOOST_ASIO_MOVE_ARG(WriteHandler) handler)
+      BOOST_ASIO_MOVE_ARG(WriteToken) token
+        BOOST_ASIO_DEFAULT_COMPLETION_TOKEN(executor_type))
+    BOOST_ASIO_INITFN_AUTO_RESULT_TYPE_SUFFIX((
+      async_initiate<WriteToken,
+        void (boost::system::error_code, std::size_t)>(
+          declval<initiate_async_send_to>(), token, buffers,
+          destination, socket_base::message_flags(0))))
   {
-    return async_initiate<WriteHandler,
+    return async_initiate<WriteToken,
       void (boost::system::error_code, std::size_t)>(
-        initiate_async_send_to(), handler, this, buffers,
+        initiate_async_send_to(this), token, buffers,
         destination, socket_base::message_flags(0));
   }
 
   /// Start an asynchronous send.
   /**
    * This function is used to asynchronously send raw data to the specified
-   * remote endpoint. The function call always returns immediately.
+   * remote endpoint. It is an initiating function for an @ref
+   * asynchronous_operation, and always returns immediately.
    *
    * @param buffers One or more data buffers to be sent to the remote endpoint.
    * Although the buffers object may be copied as necessary, ownership of the
    * underlying memory blocks is retained by the caller, which must guarantee
-   * that they remain valid until the handler is called.
+   * that they remain valid until the completion handler is called.
    *
    * @param flags Flags specifying how the send call is to be made.
    *
    * @param destination The remote endpoint to which the data will be sent.
    * Copies will be made of the endpoint as required.
    *
-   * @param handler The handler to be called when the send operation completes.
-   * Copies will be made of the handler as required. The function signature of
-   * the handler must be:
+   * @param token The @ref completion_token that will be used to produce a
+   * completion handler, which will be called when the send completes.
+   * Potential completion tokens include @ref use_future, @ref use_awaitable,
+   * @ref yield_context, or a function object with the correct completion
+   * signature. The function signature of the completion handler must be:
    * @code void handler(
    *   const boost::system::error_code& error, // Result of operation.
-   *   std::size_t bytes_transferred           // Number of bytes sent.
+   *   std::size_t bytes_transferred // Number of bytes sent.
    * ); @endcode
    * Regardless of whether the asynchronous operation completes immediately or
-   * not, the handler will not be invoked from within this function. On
-   * immediate completion, invocation of the handler will be performed in a
+   * not, the completion handler will not be invoked from within this function.
+   * On immediate completion, invocation of the handler will be performed in a
    * manner equivalent to using boost::asio::post().
+   *
+   * @par Completion Signature
+   * @code void(boost::system::error_code, std::size_t) @endcode
+   *
+   * @par Per-Operation Cancellation
+   * On POSIX or Windows operating systems, this asynchronous operation supports
+   * cancellation for the following boost::asio::cancellation_type values:
+   *
+   * @li @c cancellation_type::terminal
+   *
+   * @li @c cancellation_type::partial
+   *
+   * @li @c cancellation_type::total
    */
-  template <typename ConstBufferSequence, typename WriteHandler>
-  BOOST_ASIO_INITFN_RESULT_TYPE(WriteHandler,
+  template <typename ConstBufferSequence,
+      BOOST_ASIO_COMPLETION_TOKEN_FOR(void (boost::system::error_code,
+        std::size_t)) WriteToken
+          BOOST_ASIO_DEFAULT_COMPLETION_TOKEN_TYPE(executor_type)>
+  BOOST_ASIO_INITFN_AUTO_RESULT_TYPE_PREFIX(WriteToken,
       void (boost::system::error_code, std::size_t))
   async_send_to(const ConstBufferSequence& buffers,
       const endpoint_type& destination, socket_base::message_flags flags,
-      BOOST_ASIO_MOVE_ARG(WriteHandler) handler)
+      BOOST_ASIO_MOVE_ARG(WriteToken) token
+        BOOST_ASIO_DEFAULT_COMPLETION_TOKEN(executor_type))
+    BOOST_ASIO_INITFN_AUTO_RESULT_TYPE_SUFFIX((
+      async_initiate<WriteToken,
+        void (boost::system::error_code, std::size_t)>(
+          declval<initiate_async_send_to>(), token,
+          buffers, destination, flags)))
   {
-    return async_initiate<WriteHandler,
+    return async_initiate<WriteToken,
       void (boost::system::error_code, std::size_t)>(
-        initiate_async_send_to(), handler, this, buffers, destination, flags);
+        initiate_async_send_to(this), token,
+        buffers, destination, flags);
   }
 
   /// Receive some data on a connected socket.
@@ -761,25 +875,31 @@ public:
   /// Start an asynchronous receive on a connected socket.
   /**
    * This function is used to asynchronously receive data from the raw
-   * socket. The function call always returns immediately.
+   * socket. It is an initiating function for an @ref asynchronous_operation,
+   * and always returns immediately.
    *
    * @param buffers One or more buffers into which the data will be received.
    * Although the buffers object may be copied as necessary, ownership of the
    * underlying memory blocks is retained by the caller, which must guarantee
-   * that they remain valid until the handler is called.
+   * that they remain valid until the completion handler is called.
    *
-   * @param handler The handler to be called when the receive operation
-   * completes. Copies will be made of the handler as required. The function
-   * signature of the handler must be:
+   * @param token The @ref completion_token that will be used to produce a
+   * completion handler, which will be called when the receive completes.
+   * Potential completion tokens include @ref use_future, @ref use_awaitable,
+   * @ref yield_context, or a function object with the correct completion
+   * signature. The function signature of the completion handler must be:
    * @code void handler(
    *   const boost::system::error_code& error, // Result of operation.
-   *   std::size_t bytes_transferred           // Number of bytes received.
+   *   std::size_t bytes_transferred // Number of bytes received.
    * ); @endcode
    * Regardless of whether the asynchronous operation completes immediately or
-   * not, the handler will not be invoked from within this function. On
-   * immediate completion, invocation of the handler will be performed in a
+   * not, the completion handler will not be invoked from within this function.
+   * On immediate completion, invocation of the handler will be performed in a
    * manner equivalent to using boost::asio::post().
    *
+   * @par Completion Signature
+   * @code void(boost::system::error_code, std::size_t) @endcode
+   *
    * @note The async_receive operation can only be used with a connected socket.
    * Use the async_receive_from function to receive data on an unconnected
    * raw socket.
@@ -793,57 +913,100 @@ public:
    * See the @ref buffer documentation for information on receiving into
    * multiple buffers in one go, and how to use it with arrays, boost::array or
    * std::vector.
+   *
+   * @par Per-Operation Cancellation
+   * On POSIX or Windows operating systems, this asynchronous operation supports
+   * cancellation for the following boost::asio::cancellation_type values:
+   *
+   * @li @c cancellation_type::terminal
+   *
+   * @li @c cancellation_type::partial
+   *
+   * @li @c cancellation_type::total
    */
-  template <typename MutableBufferSequence, typename ReadHandler>
-  BOOST_ASIO_INITFN_RESULT_TYPE(ReadHandler,
+  template <typename MutableBufferSequence,
+      BOOST_ASIO_COMPLETION_TOKEN_FOR(void (boost::system::error_code,
+        std::size_t)) ReadToken
+          BOOST_ASIO_DEFAULT_COMPLETION_TOKEN_TYPE(executor_type)>
+  BOOST_ASIO_INITFN_AUTO_RESULT_TYPE_PREFIX(ReadToken,
       void (boost::system::error_code, std::size_t))
   async_receive(const MutableBufferSequence& buffers,
-      BOOST_ASIO_MOVE_ARG(ReadHandler) handler)
+      BOOST_ASIO_MOVE_ARG(ReadToken) token
+        BOOST_ASIO_DEFAULT_COMPLETION_TOKEN(executor_type))
+    BOOST_ASIO_INITFN_AUTO_RESULT_TYPE_SUFFIX((
+      async_initiate<ReadToken,
+        void (boost::system::error_code, std::size_t)>(
+          declval<initiate_async_receive>(), token,
+          buffers, socket_base::message_flags(0))))
   {
-    return async_initiate<ReadHandler,
+    return async_initiate<ReadToken,
       void (boost::system::error_code, std::size_t)>(
-        initiate_async_receive(), handler, this,
+        initiate_async_receive(this), token,
         buffers, socket_base::message_flags(0));
   }
 
   /// Start an asynchronous receive on a connected socket.
   /**
    * This function is used to asynchronously receive data from the raw
-   * socket. The function call always returns immediately.
+   * socket. It is an initiating function for an @ref asynchronous_operation,
+   * and always returns immediately.
    *
    * @param buffers One or more buffers into which the data will be received.
    * Although the buffers object may be copied as necessary, ownership of the
    * underlying memory blocks is retained by the caller, which must guarantee
-   * that they remain valid until the handler is called.
+   * that they remain valid until the completion handler is called.
    *
    * @param flags Flags specifying how the receive call is to be made.
    *
-   * @param handler The handler to be called when the receive operation
-   * completes. Copies will be made of the handler as required. The function
-   * signature of the handler must be:
+   * @param token The @ref completion_token that will be used to produce a
+   * completion handler, which will be called when the receive completes.
+   * Potential completion tokens include @ref use_future, @ref use_awaitable,
+   * @ref yield_context, or a function object with the correct completion
+   * signature. The function signature of the completion handler must be:
    * @code void handler(
    *   const boost::system::error_code& error, // Result of operation.
-   *   std::size_t bytes_transferred           // Number of bytes received.
+   *   std::size_t bytes_transferred // Number of bytes received.
    * ); @endcode
    * Regardless of whether the asynchronous operation completes immediately or
-   * not, the handler will not be invoked from within this function. On
-   * immediate completion, invocation of the handler will be performed in a
+   * not, the completion handler will not be invoked from within this function.
+   * On immediate completion, invocation of the handler will be performed in a
    * manner equivalent to using boost::asio::post().
    *
+   * @par Completion Signature
+   * @code void(boost::system::error_code, std::size_t) @endcode
+   *
    * @note The async_receive operation can only be used with a connected socket.
    * Use the async_receive_from function to receive data on an unconnected
    * raw socket.
+   *
+   * @par Per-Operation Cancellation
+   * On POSIX or Windows operating systems, this asynchronous operation supports
+   * cancellation for the following boost::asio::cancellation_type values:
+   *
+   * @li @c cancellation_type::terminal
+   *
+   * @li @c cancellation_type::partial
+   *
+   * @li @c cancellation_type::total
    */
-  template <typename MutableBufferSequence, typename ReadHandler>
-  BOOST_ASIO_INITFN_RESULT_TYPE(ReadHandler,
+  template <typename MutableBufferSequence,
+      BOOST_ASIO_COMPLETION_TOKEN_FOR(void (boost::system::error_code,
+        std::size_t)) ReadToken
+          BOOST_ASIO_DEFAULT_COMPLETION_TOKEN_TYPE(executor_type)>
+  BOOST_ASIO_INITFN_AUTO_RESULT_TYPE_PREFIX(ReadToken,
       void (boost::system::error_code, std::size_t))
   async_receive(const MutableBufferSequence& buffers,
       socket_base::message_flags flags,
-      BOOST_ASIO_MOVE_ARG(ReadHandler) handler)
+      BOOST_ASIO_MOVE_ARG(ReadToken) token
+        BOOST_ASIO_DEFAULT_COMPLETION_TOKEN(executor_type))
+    BOOST_ASIO_INITFN_AUTO_RESULT_TYPE_SUFFIX((
+      async_initiate<ReadToken,
+        void (boost::system::error_code, std::size_t)>(
+          declval<initiate_async_receive>(), token, buffers, flags)))
   {
-    return async_initiate<ReadHandler,
+    return async_initiate<ReadToken,
       void (boost::system::error_code, std::size_t)>(
-        initiate_async_receive(), handler, this, buffers, flags);
+        initiate_async_receive(this), token, buffers, flags);
   }
 
   /// Receive raw data with the endpoint of the sender.
@@ -937,31 +1100,37 @@ public:
 
   /// Start an asynchronous receive.
   /**
-   * This function is used to asynchronously receive raw data. The function
-   * call always returns immediately.
+   * This function is used to asynchronously receive raw data. It is an
+   * initiating function for an @ref asynchronous_operation, and always returns
+   * immediately.
    *
    * @param buffers One or more buffers into which the data will be received.
    * Although the buffers object may be copied as necessary, ownership of the
    * underlying memory blocks is retained by the caller, which must guarantee
-   * that they remain valid until the handler is called.
+   * that they remain valid until the completion handler is called.
    *
    * @param sender_endpoint An endpoint object that receives the endpoint of
    * the remote sender of the data. Ownership of the sender_endpoint object
    * is retained by the caller, which must guarantee that it is valid until the
-   * handler is called.
+   * completion handler is called.
    *
-   * @param handler The handler to be called when the receive operation
-   * completes. Copies will be made of the handler as required. The function
-   * signature of the handler must be:
+   * @param token The @ref completion_token that will be used to produce a
+   * completion handler, which will be called when the receive completes.
+   * Potential completion tokens include @ref use_future, @ref use_awaitable,
+   * @ref yield_context, or a function object with the correct completion
+   * signature. The function signature of the completion handler must be:
    * @code void handler(
    *   const boost::system::error_code& error, // Result of operation.
-   *   std::size_t bytes_transferred           // Number of bytes received.
+   *   std::size_t bytes_transferred // Number of bytes received.
    * ); @endcode
    * Regardless of whether the asynchronous operation completes immediately or
-   * not, the handler will not be invoked from within this function. On
-   * immediate completion, invocation of the handler will be performed in a
+   * not, the completion handler will not be invoked from within this function.
+   * On immediate completion, invocation of the handler will be performed in a
    * manner equivalent to using boost::asio::post().
    *
+   * @par Completion Signature
+   * @code void(boost::system::error_code, std::size_t) @endcode
+   *
    * @par Example
    * To receive into a single data buffer use the @ref buffer function as
    * follows:
@@ -970,68 +1139,129 @@ public:
    * See the @ref buffer documentation for information on receiving into
    * multiple buffers in one go, and how to use it with arrays, boost::array or
    * std::vector.
+   *
+   * @par Per-Operation Cancellation
+   * On POSIX or Windows operating systems, this asynchronous operation supports
+   * cancellation for the following boost::asio::cancellation_type values:
+   *
+   * @li @c cancellation_type::terminal
+   *
+   * @li @c cancellation_type::partial
+   *
+   * @li @c cancellation_type::total
    */
-  template <typename MutableBufferSequence, typename ReadHandler>
-  BOOST_ASIO_INITFN_RESULT_TYPE(ReadHandler,
+  template <typename MutableBufferSequence,
+      BOOST_ASIO_COMPLETION_TOKEN_FOR(void (boost::system::error_code,
+        std::size_t)) ReadToken
+          BOOST_ASIO_DEFAULT_COMPLETION_TOKEN_TYPE(executor_type)>
+  BOOST_ASIO_INITFN_AUTO_RESULT_TYPE_PREFIX(ReadToken,
       void (boost::system::error_code, std::size_t))
   async_receive_from(const MutableBufferSequence& buffers,
       endpoint_type& sender_endpoint,
-      BOOST_ASIO_MOVE_ARG(ReadHandler) handler)
+      BOOST_ASIO_MOVE_ARG(ReadToken) token
+        BOOST_ASIO_DEFAULT_COMPLETION_TOKEN(executor_type))
+    BOOST_ASIO_INITFN_AUTO_RESULT_TYPE_SUFFIX((
+      async_initiate<ReadToken,
+        void (boost::system::error_code, std::size_t)>(
+          declval<initiate_async_receive_from>(), token, buffers,
+          &sender_endpoint, socket_base::message_flags(0))))
   {
-    return async_initiate<ReadHandler,
+    return async_initiate<ReadToken,
       void (boost::system::error_code, std::size_t)>(
-        initiate_async_receive_from(), handler, this, buffers,
+        initiate_async_receive_from(this), token, buffers,
         &sender_endpoint, socket_base::message_flags(0));
   }
 
   /// Start an asynchronous receive.
   /**
-   * This function is used to asynchronously receive raw data. The function
-   * call always returns immediately.
+   * This function is used to asynchronously receive raw data. It is an
+   * initiating function for an @ref asynchronous_operation, and always returns
+   * immediately.
    *
    * @param buffers One or more buffers into which the data will be received.
    * Although the buffers object may be copied as necessary, ownership of the
    * underlying memory blocks is retained by the caller, which must guarantee
-   * that they remain valid until the handler is called.
+   * that they remain valid until the completion handler is called.
    *
    * @param sender_endpoint An endpoint object that receives the endpoint of
    * the remote sender of the data. Ownership of the sender_endpoint object
    * is retained by the caller, which must guarantee that it is valid until the
-   * handler is called.
+   * completion handler is called.
    *
    * @param flags Flags specifying how the receive call is to be made.
    *
-   * @param handler The handler to be called when the receive operation
-   * completes. Copies will be made of the handler as required. The function
-   * signature of the handler must be:
+   * @param token The @ref completion_token that will be used to produce a
+   * completion handler, which will be called when the receive completes.
+   * Potential completion tokens include @ref use_future, @ref use_awaitable,
+   * @ref yield_context, or a function object with the correct completion
+   * signature. The function signature of the completion handler must be:
    * @code void handler(
    *   const boost::system::error_code& error, // Result of operation.
-   *   std::size_t bytes_transferred           // Number of bytes received.
+   *   std::size_t bytes_transferred // Number of bytes received.
    * ); @endcode
    * Regardless of whether the asynchronous operation completes immediately or
-   * not, the handler will not be invoked from within this function. On
-   * immediate completion, invocation of the handler will be performed in a
+   * not, the completion handler will not be invoked from within this function.
+   * On immediate completion, invocation of the handler will be performed in a
    * manner equivalent to using boost::asio::post().
+   *
+   * @par Completion Signature
+   * @code void(boost::system::error_code, std::size_t) @endcode
+   *
+   * @par Per-Operation Cancellation
+   * On POSIX or Windows operating systems, this asynchronous operation supports
+   * cancellation for the following boost::asio::cancellation_type values:
+   *
+   * @li @c cancellation_type::terminal
+   *
+   * @li @c cancellation_type::partial
+   *
+   * @li @c cancellation_type::total
    */
-  template <typename MutableBufferSequence, typename ReadHandler>
-  BOOST_ASIO_INITFN_RESULT_TYPE(ReadHandler,
+  template <typename MutableBufferSequence,
+      BOOST_ASIO_COMPLETION_TOKEN_FOR(void (boost::system::error_code,
+        std::size_t)) ReadToken
+          BOOST_ASIO_DEFAULT_COMPLETION_TOKEN_TYPE(executor_type)>
+  BOOST_ASIO_INITFN_AUTO_RESULT_TYPE_PREFIX(ReadToken,
       void (boost::system::error_code, std::size_t))
   async_receive_from(const MutableBufferSequence& buffers,
       endpoint_type& sender_endpoint, socket_base::message_flags flags,
-      BOOST_ASIO_MOVE_ARG(ReadHandler) handler)
+      BOOST_ASIO_MOVE_ARG(ReadToken) token
+        BOOST_ASIO_DEFAULT_COMPLETION_TOKEN(executor_type))
+    BOOST_ASIO_INITFN_AUTO_RESULT_TYPE_SUFFIX((
+      async_initiate<ReadToken,
+        void (boost::system::error_code, std::size_t)>(
+          declval<initiate_async_receive_from>(), token,
+          buffers, &sender_endpoint, flags)))
   {
-    return async_initiate<ReadHandler,
+    return async_initiate<ReadToken,
       void (boost::system::error_code, std::size_t)>(
-        initiate_async_receive_from(), handler,
-        this, buffers, &sender_endpoint, flags);
+        initiate_async_receive_from(this), token,
+        buffers, &sender_endpoint, flags);
   }
 
 private:
-  struct initiate_async_send
+  // Disallow copying and assignment.
+  basic_raw_socket(const basic_raw_socket&) BOOST_ASIO_DELETED;
+  basic_raw_socket& operator=(const basic_raw_socket&) BOOST_ASIO_DELETED;
+
+  class initiate_async_send
   {
+  public:
+    typedef Executor executor_type;
+
+    explicit initiate_async_send(basic_raw_socket* self)
+      : self_(self)
+    {
+    }
+
+    const executor_type& get_executor() const BOOST_ASIO_NOEXCEPT
+    {
+      return self_->get_executor();
+    }
+
     template <typename WriteHandler, typename ConstBufferSequence>
     void operator()(BOOST_ASIO_MOVE_ARG(WriteHandler) handler,
-        basic_raw_socket* self, const ConstBufferSequence& buffers,
+        const ConstBufferSequence& buffers,
         socket_base::message_flags flags) const
     {
       // If you get an error on the following line it means that your handler
@@ -1039,18 +1269,33 @@ private:
       BOOST_ASIO_WRITE_HANDLER_CHECK(WriteHandler, handler) type_check;
 
       detail::non_const_lvalue<WriteHandler> handler2(handler);
-      self->impl_.get_service().async_send(
-          self->impl_.get_implementation(), buffers, flags,
-          handler2.value, self->impl_.get_implementation_executor());
+      self_->impl_.get_service().async_send(
+          self_->impl_.get_implementation(), buffers, flags,
+          handler2.value, self_->impl_.get_executor());
     }
+
+  private:
+    basic_raw_socket* self_;
   };
 
-  struct initiate_async_send_to
+  class initiate_async_send_to
   {
+  public:
+    typedef Executor executor_type;
+
+    explicit initiate_async_send_to(basic_raw_socket* self)
+      : self_(self)
+    {
+    }
+
+    const executor_type& get_executor() const BOOST_ASIO_NOEXCEPT
+    {
+      return self_->get_executor();
+    }
+
     template <typename WriteHandler, typename ConstBufferSequence>
     void operator()(BOOST_ASIO_MOVE_ARG(WriteHandler) handler,
-        basic_raw_socket* self, const ConstBufferSequence& buffers,
-        const endpoint_type& destination,
+        const ConstBufferSequence& buffers, const endpoint_type& destination,
         socket_base::message_flags flags) const
     {
       // If you get an error on the following line it means that your handler
@@ -1058,17 +1303,33 @@ private:
       BOOST_ASIO_WRITE_HANDLER_CHECK(WriteHandler, handler) type_check;
 
       detail::non_const_lvalue<WriteHandler> handler2(handler);
-      self->impl_.get_service().async_send_to(
-          self->impl_.get_implementation(), buffers, destination, flags,
-          handler2.value, self->impl_.get_implementation_executor());
+      self_->impl_.get_service().async_send_to(
+          self_->impl_.get_implementation(), buffers, destination,
+          flags, handler2.value, self_->impl_.get_executor());
     }
+
+  private:
+    basic_raw_socket* self_;
   };
 
-  struct initiate_async_receive
+  class initiate_async_receive
   {
+  public:
+    typedef Executor executor_type;
+
+    explicit initiate_async_receive(basic_raw_socket* self)
+      : self_(self)
+    {
+    }
+
+    const executor_type& get_executor() const BOOST_ASIO_NOEXCEPT
+    {
+      return self_->get_executor();
+    }
+
     template <typename ReadHandler, typename MutableBufferSequence>
     void operator()(BOOST_ASIO_MOVE_ARG(ReadHandler) handler,
-        basic_raw_socket* self, const MutableBufferSequence& buffers,
+        const MutableBufferSequence& buffers,
         socket_base::message_flags flags) const
     {
       // If you get an error on the following line it means that your handler
@@ -1076,28 +1337,47 @@ private:
       BOOST_ASIO_READ_HANDLER_CHECK(ReadHandler, handler) type_check;
 
       detail::non_const_lvalue<ReadHandler> handler2(handler);
-      self->impl_.get_service().async_receive(
-          self->impl_.get_implementation(), buffers, flags,
-          handler2.value, self->impl_.get_implementation_executor());
+      self_->impl_.get_service().async_receive(
+          self_->impl_.get_implementation(), buffers, flags,
+          handler2.value, self_->impl_.get_executor());
     }
+
+  private:
+    basic_raw_socket* self_;
   };
 
-  struct initiate_async_receive_from
+  class initiate_async_receive_from
   {
+  public:
+    typedef Executor executor_type;
+
+    explicit initiate_async_receive_from(basic_raw_socket* self)
+      : self_(self)
+    {
+    }
+
+    const executor_type& get_executor() const BOOST_ASIO_NOEXCEPT
+    {
+      return self_->get_executor();
+    }
+
     template <typename ReadHandler, typename MutableBufferSequence>
     void operator()(BOOST_ASIO_MOVE_ARG(ReadHandler) handler,
-        basic_raw_socket* self, const MutableBufferSequence& buffers,
-        endpoint_type* sender_endpoint, socket_base::message_flags flags) const
+        const MutableBufferSequence& buffers, endpoint_type* sender_endpoint,
+        socket_base::message_flags flags) const
     {
       // If you get an error on the following line it means that your handler
       // does not meet the documented type requirements for a ReadHandler.
       BOOST_ASIO_READ_HANDLER_CHECK(ReadHandler, handler) type_check;
 
       detail::non_const_lvalue<ReadHandler> handler2(handler);
-      self->impl_.get_service().async_receive_from(
-          self->impl_.get_implementation(), buffers, *sender_endpoint, flags,
-          handler2.value, self->impl_.get_implementation_executor());
+      self_->impl_.get_service().async_receive_from(
+          self_->impl_.get_implementation(), buffers, *sender_endpoint,
+          flags, handler2.value, self_->impl_.get_executor());
     }
+
+  private:
+    basic_raw_socket* self_;
   };
 };
 

linx64/include/boost/asio/basic_readable_pipe.hpp

@@ -0,0 +1,637 @@
+//
+// basic_readable_pipe.hpp
+// ~~~~~~~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2023 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef BOOST_ASIO_BASIC_READABLE_PIPE_HPP
+#define BOOST_ASIO_BASIC_READABLE_PIPE_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include <boost/asio/detail/config.hpp>
+
+#if defined(BOOST_ASIO_HAS_PIPE) \
+  || defined(GENERATING_DOCUMENTATION)
+
+#include <string>
+#include <boost/asio/any_io_executor.hpp>
+#include <boost/asio/async_result.hpp>
+#include <boost/asio/detail/handler_type_requirements.hpp>
+#include <boost/asio/detail/io_object_impl.hpp>
+#include <boost/asio/detail/non_const_lvalue.hpp>
+#include <boost/asio/detail/throw_error.hpp>
+#include <boost/asio/detail/type_traits.hpp>
+#include <boost/asio/error.hpp>
+#include <boost/asio/execution_context.hpp>
+#if defined(BOOST_ASIO_HAS_IOCP)
+# include <boost/asio/detail/win_iocp_handle_service.hpp>
+#elif defined(BOOST_ASIO_HAS_IO_URING_AS_DEFAULT)
+# include <boost/asio/detail/io_uring_descriptor_service.hpp>
+#else
+# include <boost/asio/detail/reactive_descriptor_service.hpp>
+#endif
+
+#if defined(BOOST_ASIO_HAS_MOVE)
+# include <utility>
+#endif // defined(BOOST_ASIO_HAS_MOVE)
+
+#include <boost/asio/detail/push_options.hpp>
+
+namespace boost {
+namespace asio {
+
+/// Provides pipe functionality.
+/**
+ * The basic_readable_pipe class provides a wrapper over pipe
+ * functionality.
+ *
+ * @par Thread Safety
+ * @e Distinct @e objects: Safe.@n
+ * @e Shared @e objects: Unsafe.
+ */
+template <typename Executor = any_io_executor>
+class basic_readable_pipe
+{
+private:
+  class initiate_async_read_some;
+
+public:
+  /// The type of the executor associated with the object.
+  typedef Executor executor_type;
+
+  /// Rebinds the pipe type to another executor.
+  template <typename Executor1>
+  struct rebind_executor
+  {
+    /// The pipe type when rebound to the specified executor.
+    typedef basic_readable_pipe<Executor1> other;
+  };
+
+  /// The native representation of a pipe.
+#if defined(GENERATING_DOCUMENTATION)
+  typedef implementation_defined native_handle_type;
+#elif defined(BOOST_ASIO_HAS_IOCP)
+  typedef detail::win_iocp_handle_service::native_handle_type
+    native_handle_type;
+#elif defined(BOOST_ASIO_HAS_IO_URING_AS_DEFAULT)
+  typedef detail::io_uring_descriptor_service::native_handle_type
+    native_handle_type;
+#else
+  typedef detail::reactive_descriptor_service::native_handle_type
+    native_handle_type;
+#endif
+
+  /// A basic_readable_pipe is always the lowest layer.
+  typedef basic_readable_pipe lowest_layer_type;
+
+  /// Construct a basic_readable_pipe without opening it.
+  /**
+   * This constructor creates a pipe without opening it.
+   *
+   * @param ex The I/O executor that the pipe will use, by default, to dispatch
+   * handlers for any asynchronous operations performed on the pipe.
+   */
+  explicit basic_readable_pipe(const executor_type& ex)
+    : impl_(0, ex)
+  {
+  }
+
+  /// Construct a basic_readable_pipe without opening it.
+  /**
+   * This constructor creates a pipe without opening it.
+   *
+   * @param context An execution context which provides the I/O executor that
+   * the pipe will use, by default, to dispatch handlers for any asynchronous
+   * operations performed on the pipe.
+   */
+  template <typename ExecutionContext>
+  explicit basic_readable_pipe(ExecutionContext& context,
+      typename constraint<
+        is_convertible<ExecutionContext&, execution_context&>::value,
+        defaulted_constraint
+      >::type = defaulted_constraint())
+    : impl_(0, 0, context)
+  {
+  }
+
+  /// Construct a basic_readable_pipe on an existing native pipe.
+  /**
+   * This constructor creates a pipe object to hold an existing native
+   * pipe.
+   *
+   * @param ex The I/O executor that the pipe will use, by default, to
+   * dispatch handlers for any asynchronous operations performed on the
+   * pipe.
+   *
+   * @param native_pipe A native pipe.
+   *
+   * @throws boost::system::system_error Thrown on failure.
+   */
+  basic_readable_pipe(const executor_type& ex,
+      const native_handle_type& native_pipe)
+    : impl_(0, ex)
+  {
+    boost::system::error_code ec;
+    impl_.get_service().assign(impl_.get_implementation(),
+        native_pipe, ec);
+    boost::asio::detail::throw_error(ec, "assign");
+  }
+
+  /// Construct a basic_readable_pipe on an existing native pipe.
+  /**
+   * This constructor creates a pipe object to hold an existing native
+   * pipe.
+   *
+   * @param context An execution context which provides the I/O executor that
+   * the pipe will use, by default, to dispatch handlers for any
+   * asynchronous operations performed on the pipe.
+   *
+   * @param native_pipe A native pipe.
+   *
+   * @throws boost::system::system_error Thrown on failure.
+   */
+  template <typename ExecutionContext>
+  basic_readable_pipe(ExecutionContext& context,
+      const native_handle_type& native_pipe,
+      typename constraint<
+        is_convertible<ExecutionContext&, execution_context&>::value
+      >::type = 0)
+    : impl_(0, 0, context)
+  {
+    boost::system::error_code ec;
+    impl_.get_service().assign(impl_.get_implementation(),
+        native_pipe, ec);
+    boost::asio::detail::throw_error(ec, "assign");
+  }
+
+#if defined(BOOST_ASIO_HAS_MOVE) || defined(GENERATING_DOCUMENTATION)
+  /// Move-construct a basic_readable_pipe from another.
+  /**
+   * This constructor moves a pipe from one object to another.
+   *
+   * @param other The other basic_readable_pipe object from which the move will
+   * occur.
+   *
+   * @note Following the move, the moved-from object is in the same state as if
+   * constructed using the @c basic_readable_pipe(const executor_type&)
+   * constructor.
+   */
+  basic_readable_pipe(basic_readable_pipe&& other)
+    : impl_(std::move(other.impl_))
+  {
+  }
+
+  /// Move-assign a basic_readable_pipe from another.
+  /**
+   * This assignment operator moves a pipe from one object to another.
+   *
+   * @param other The other basic_readable_pipe object from which the move will
+   * occur.
+   *
+   * @note Following the move, the moved-from object is in the same state as if
+   * constructed using the @c basic_readable_pipe(const executor_type&)
+   * constructor.
+   */
+  basic_readable_pipe& operator=(basic_readable_pipe&& other)
+  {
+    impl_ = std::move(other.impl_);
+    return *this;
+  }
+
+  // All pipes have access to each other's implementations.
+  template <typename Executor1>
+  friend class basic_readable_pipe;
+
+  /// Move-construct a basic_readable_pipe from a pipe of another executor type.
+  /**
+   * This constructor moves a pipe from one object to another.
+   *
+   * @param other The other basic_readable_pipe object from which the move will
+   * occur.
+   *
+   * @note Following the move, the moved-from object is in the same state as if
+   * constructed using the @c basic_readable_pipe(const executor_type&)
+   * constructor.
+   */
+  template <typename Executor1>
+  basic_readable_pipe(basic_readable_pipe<Executor1>&& other,
+      typename constraint<
+        is_convertible<Executor1, Executor>::value,
+        defaulted_constraint
+      >::type = defaulted_constraint())
+    : impl_(std::move(other.impl_))
+  {
+  }
+
+  /// Move-assign a basic_readable_pipe from a pipe of another executor type.
+  /**
+   * This assignment operator moves a pipe from one object to another.
+   *
+   * @param other The other basic_readable_pipe object from which the move will
+   * occur.
+   *
+   * @note Following the move, the moved-from object is in the same state as if
+   * constructed using the @c basic_readable_pipe(const executor_type&)
+   * constructor.
+   */
+  template <typename Executor1>
+  typename constraint<
+    is_convertible<Executor1, Executor>::value,
+    basic_readable_pipe&
+  >::type operator=(basic_readable_pipe<Executor1>&& other)
+  {
+    basic_readable_pipe tmp(std::move(other));
+    impl_ = std::move(tmp.impl_);
+    return *this;
+  }
+#endif // defined(BOOST_ASIO_HAS_MOVE) || defined(GENERATING_DOCUMENTATION)
+
+  /// Destroys the pipe.
+  /**
+   * This function destroys the pipe, cancelling any outstanding
+   * asynchronous wait operations associated with the pipe as if by
+   * calling @c cancel.
+   */
+  ~basic_readable_pipe()
+  {
+  }
+
+  /// Get the executor associated with the object.
+  const executor_type& get_executor() BOOST_ASIO_NOEXCEPT
+  {
+    return impl_.get_executor();
+  }
+
+  /// Get a reference to the lowest layer.
+  /**
+   * This function returns a reference to the lowest layer in a stack of
+   * layers. Since a basic_readable_pipe cannot contain any further layers, it
+   * simply returns a reference to itself.
+   *
+   * @return A reference to the lowest layer in the stack of layers. Ownership
+   * is not transferred to the caller.
+   */
+  lowest_layer_type& lowest_layer()
+  {
+    return *this;
+  }
+
+  /// Get a const reference to the lowest layer.
+  /**
+   * This function returns a const reference to the lowest layer in a stack of
+   * layers. Since a basic_readable_pipe cannot contain any further layers, it
+   * simply returns a reference to itself.
+   *
+   * @return A const reference to the lowest layer in the stack of layers.
+   * Ownership is not transferred to the caller.
+   */
+  const lowest_layer_type& lowest_layer() const
+  {
+    return *this;
+  }
+
+  /// Assign an existing native pipe to the pipe.
+  /*
+   * This function opens the pipe to hold an existing native pipe.
+   *
+   * @param native_pipe A native pipe.
+   *
+   * @throws boost::system::system_error Thrown on failure.
+   */
+  void assign(const native_handle_type& native_pipe)
+  {
+    boost::system::error_code ec;
+    impl_.get_service().assign(impl_.get_implementation(), native_pipe, ec);
+    boost::asio::detail::throw_error(ec, "assign");
+  }
+
+  /// Assign an existing native pipe to the pipe.
+  /*
+   * This function opens the pipe to hold an existing native pipe.
+   *
+   * @param native_pipe A native pipe.
+   *
+   * @param ec Set to indicate what error occurred, if any.
+   */
+  BOOST_ASIO_SYNC_OP_VOID assign(const native_handle_type& native_pipe,
+      boost::system::error_code& ec)
+  {
+    impl_.get_service().assign(impl_.get_implementation(), native_pipe, ec);
+    BOOST_ASIO_SYNC_OP_VOID_RETURN(ec);
+  }
+
+  /// Determine whether the pipe is open.
+  bool is_open() const
+  {
+    return impl_.get_service().is_open(impl_.get_implementation());
+  }
+
+  /// Close the pipe.
+  /**
+   * This function is used to close the pipe. Any asynchronous read operations
+   * will be cancelled immediately, and will complete with the
+   * boost::asio::error::operation_aborted error.
+   *
+   * @throws boost::system::system_error Thrown on failure.
+   */
+  void close()
+  {
+    boost::system::error_code ec;
+    impl_.get_service().close(impl_.get_implementation(), ec);
+    boost::asio::detail::throw_error(ec, "close");
+  }
+
+  /// Close the pipe.
+  /**
+   * This function is used to close the pipe. Any asynchronous read operations
+   * will be cancelled immediately, and will complete with the
+   * boost::asio::error::operation_aborted error.
+   *
+   * @param ec Set to indicate what error occurred, if any.
+   */
+  BOOST_ASIO_SYNC_OP_VOID close(boost::system::error_code& ec)
+  {
+    impl_.get_service().close(impl_.get_implementation(), ec);
+    BOOST_ASIO_SYNC_OP_VOID_RETURN(ec);
+  }
+
+  /// Release ownership of the underlying native pipe.
+  /**
+   * This function causes all outstanding asynchronous read operations to
+   * finish immediately, and the handlers for cancelled operations will be
+   * passed the boost::asio::error::operation_aborted error. Ownership of the
+   * native pipe is then transferred to the caller.
+   *
+   * @throws boost::system::system_error Thrown on failure.
+   *
+   * @note This function is unsupported on Windows versions prior to Windows
+   * 8.1, and will fail with boost::asio::error::operation_not_supported on
+   * these platforms.
+   */
+#if defined(BOOST_ASIO_MSVC) && (BOOST_ASIO_MSVC >= 1400) \
+  && (!defined(_WIN32_WINNT) || _WIN32_WINNT < 0x0603)
+  __declspec(deprecated("This function always fails with "
+        "operation_not_supported when used on Windows versions "
+        "prior to Windows 8.1."))
+#endif
+  native_handle_type release()
+  {
+    boost::system::error_code ec;
+    native_handle_type s = impl_.get_service().release(
+        impl_.get_implementation(), ec);
+    boost::asio::detail::throw_error(ec, "release");
+    return s;
+  }
+
+  /// Release ownership of the underlying native pipe.
+  /**
+   * This function causes all outstanding asynchronous read operations to
+   * finish immediately, and the handlers for cancelled operations will be
+   * passed the boost::asio::error::operation_aborted error. Ownership of the
+   * native pipe is then transferred to the caller.
+   *
+   * @param ec Set to indicate what error occurred, if any.
+   *
+   * @note This function is unsupported on Windows versions prior to Windows
+   * 8.1, and will fail with boost::asio::error::operation_not_supported on
+   * these platforms.
+   */
+#if defined(BOOST_ASIO_MSVC) && (BOOST_ASIO_MSVC >= 1400) \
+  && (!defined(_WIN32_WINNT) || _WIN32_WINNT < 0x0603)
+  __declspec(deprecated("This function always fails with "
+        "operation_not_supported when used on Windows versions "
+        "prior to Windows 8.1."))
+#endif
+  native_handle_type release(boost::system::error_code& ec)
+  {
+    return impl_.get_service().release(impl_.get_implementation(), ec);
+  }
+
+  /// Get the native pipe representation.
+  /**
+   * This function may be used to obtain the underlying representation of the
+   * pipe. This is intended to allow access to native pipe
+   * functionality that is not otherwise provided.
+   */
+  native_handle_type native_handle()
+  {
+    return impl_.get_service().native_handle(impl_.get_implementation());
+  }
+
+  /// Cancel all asynchronous operations associated with the pipe.
+  /**
+   * This function causes all outstanding asynchronous read operations to finish
+   * immediately, and the handlers for cancelled operations will be passed the
+   * boost::asio::error::operation_aborted error.
+   *
+   * @throws boost::system::system_error Thrown on failure.
+   */
+  void cancel()
+  {
+    boost::system::error_code ec;
+    impl_.get_service().cancel(impl_.get_implementation(), ec);
+    boost::asio::detail::throw_error(ec, "cancel");
+  }
+
+  /// Cancel all asynchronous operations associated with the pipe.
+  /**
+   * This function causes all outstanding asynchronous read operations to finish
+   * immediately, and the handlers for cancelled operations will be passed the
+   * boost::asio::error::operation_aborted error.
+   *
+   * @param ec Set to indicate what error occurred, if any.
+   */
+  BOOST_ASIO_SYNC_OP_VOID cancel(boost::system::error_code& ec)
+  {
+    impl_.get_service().cancel(impl_.get_implementation(), ec);
+    BOOST_ASIO_SYNC_OP_VOID_RETURN(ec);
+  }
+
+  /// Read some data from the pipe.
+  /**
+   * This function is used to read data from the pipe. The function call will
+   * block until one or more bytes of data has been read successfully, or until
+   * an error occurs.
+   *
+   * @param buffers One or more buffers into which the data will be read.
+   *
+   * @returns The number of bytes read.
+   *
+   * @throws boost::system::system_error Thrown on failure. An error code of
+   * boost::asio::error::eof indicates that the connection was closed by the
+   * peer.
+   *
+   * @note The read_some operation may not read all of the requested number of
+   * bytes. Consider using the @ref read function if you need to ensure that
+   * the requested amount of data is read before the blocking operation
+   * completes.
+   *
+   * @par Example
+   * To read into a single data buffer use the @ref buffer function as follows:
+   * @code
+   * basic_readable_pipe.read_some(boost::asio::buffer(data, size));
+   * @endcode
+   * See the @ref buffer documentation for information on reading into multiple
+   * buffers in one go, and how to use it with arrays, boost::array or
+   * std::vector.
+   */
+  template <typename MutableBufferSequence>
+  std::size_t read_some(const MutableBufferSequence& buffers)
+  {
+    boost::system::error_code ec;
+    std::size_t s = impl_.get_service().read_some(
+        impl_.get_implementation(), buffers, ec);
+    boost::asio::detail::throw_error(ec, "read_some");
+    return s;
+  }
+
+  /// Read some data from the pipe.
+  /**
+   * This function is used to read data from the pipe. The function call will
+   * block until one or more bytes of data has been read successfully, or until
+   * an error occurs.
+   *
+   * @param buffers One or more buffers into which the data will be read.
+   *
+   * @param ec Set to indicate what error occurred, if any.
+   *
+   * @returns The number of bytes read. Returns 0 if an error occurred.
+   *
+   * @note The read_some operation may not read all of the requested number of
+   * bytes. Consider using the @ref read function if you need to ensure that
+   * the requested amount of data is read before the blocking operation
+   * completes.
+   */
+  template <typename MutableBufferSequence>
+  std::size_t read_some(const MutableBufferSequence& buffers,
+      boost::system::error_code& ec)
+  {
+    return impl_.get_service().read_some(
+        impl_.get_implementation(), buffers, ec);
+  }
+
+  /// Start an asynchronous read.
+  /**
+   * This function is used to asynchronously read data from the pipe. It is an
+   * initiating function for an @ref asynchronous_operation, and always returns
+   * immediately.
+   *
+   * @param buffers One or more buffers into which the data will be read.
+   * Although the buffers object may be copied as necessary, ownership of the
+   * underlying memory blocks is retained by the caller, which must guarantee
+   * that they remain valid until the completion handler is called.
+   *
+   * @param token The @ref completion_token that will be used to produce a
+   * completion handler, which will be called when the read completes.
+   * Potential completion tokens include @ref use_future, @ref use_awaitable,
+   * @ref yield_context, or a function object with the correct completion
+   * signature. The function signature of the completion handler must be:
+   * @code void handler(
+   *   const boost::system::error_code& error, // Result of operation.
+   *   std::size_t bytes_transferred // Number of bytes read.
+   * ); @endcode
+   * Regardless of whether the asynchronous operation completes immediately or
+   * not, the completion handler will not be invoked from within this function.
+   * On immediate completion, invocation of the handler will be performed in a
+   * manner equivalent to using boost::asio::post().
+   *
+   * @par Completion Signature
+   * @code void(boost::system::error_code, std::size_t) @endcode
+   *
+   * @note The read operation may not read all of the requested number of bytes.
+   * Consider using the @ref async_read function if you need to ensure that the
+   * requested amount of data is read before the asynchronous operation
+   * completes.
+   *
+   * @par Example
+   * To read into a single data buffer use the @ref buffer function as follows:
+   * @code
+   * basic_readable_pipe.async_read_some(
+   *     boost::asio::buffer(data, size), handler);
+   * @endcode
+   * See the @ref buffer documentation for information on reading into multiple
+   * buffers in one go, and how to use it with arrays, boost::array or
+   * std::vector.
+   */
+  template <typename MutableBufferSequence,
+      BOOST_ASIO_COMPLETION_TOKEN_FOR(void (boost::system::error_code,
+        std::size_t)) ReadToken
+          BOOST_ASIO_DEFAULT_COMPLETION_TOKEN_TYPE(executor_type)>
+  BOOST_ASIO_INITFN_AUTO_RESULT_TYPE_PREFIX(ReadToken,
+      void (boost::system::error_code, std::size_t))
+  async_read_some(const MutableBufferSequence& buffers,
+      BOOST_ASIO_MOVE_ARG(ReadToken) token
+        BOOST_ASIO_DEFAULT_COMPLETION_TOKEN(executor_type))
+    BOOST_ASIO_INITFN_AUTO_RESULT_TYPE_SUFFIX((
+      async_initiate<ReadToken,
+        void (boost::system::error_code, std::size_t)>(
+          declval<initiate_async_read_some>(), token, buffers)))
+  {
+    return async_initiate<ReadToken,
+      void (boost::system::error_code, std::size_t)>(
+        initiate_async_read_some(this), token, buffers);
+  }
+
+private:
+  // Disallow copying and assignment.
+  basic_readable_pipe(const basic_readable_pipe&) BOOST_ASIO_DELETED;
+  basic_readable_pipe& operator=(const basic_readable_pipe&) BOOST_ASIO_DELETED;
+
+  class initiate_async_read_some
+  {
+  public:
+    typedef Executor executor_type;
+
+    explicit initiate_async_read_some(basic_readable_pipe* self)
+      : self_(self)
+    {
+    }
+
+    const executor_type& get_executor() const BOOST_ASIO_NOEXCEPT
+    {
+      return self_->get_executor();
+    }
+
+    template <typename ReadHandler, typename MutableBufferSequence>
+    void operator()(BOOST_ASIO_MOVE_ARG(ReadHandler) handler,
+        const MutableBufferSequence& buffers) const
+    {
+      // If you get an error on the following line it means that your handler
+      // does not meet the documented type requirements for a ReadHandler.
+      BOOST_ASIO_READ_HANDLER_CHECK(ReadHandler, handler) type_check;
+
+      detail::non_const_lvalue<ReadHandler> handler2(handler);
+      self_->impl_.get_service().async_read_some(
+          self_->impl_.get_implementation(), buffers,
+          handler2.value, self_->impl_.get_executor());
+    }
+
+  private:
+    basic_readable_pipe* self_;
+  };
+
+#if defined(BOOST_ASIO_HAS_IOCP)
+  detail::io_object_impl<detail::win_iocp_handle_service, Executor> impl_;
+#elif defined(BOOST_ASIO_HAS_IO_URING_AS_DEFAULT)
+  detail::io_object_impl<detail::io_uring_descriptor_service, Executor> impl_;
+#else
+  detail::io_object_impl<detail::reactive_descriptor_service, Executor> impl_;
+#endif
+};
+
+} // namespace asio
+} // namespace boost
+
+#include <boost/asio/detail/pop_options.hpp>
+
+#endif // defined(BOOST_ASIO_HAS_PIPE)
+       //   || defined(GENERATING_DOCUMENTATION)
+
+#endif // BOOST_ASIO_BASIC_READABLE_PIPE_HPP

linx64/include/boost/asio/basic_seq_packet_socket.hpp

@@ -2,7 +2,7 @@
 // basic_seq_packet_socket.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2019 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2023 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -31,7 +31,7 @@ namespace asio {
 #define BOOST_ASIO_BASIC_SEQ_PACKET_SOCKET_FWD_DECL
 
 // Forward declaration with defaulted arguments.
-template <typename Protocol, typename Executor = executor>
+template <typename Protocol, typename Executor = any_io_executor>
 class basic_seq_packet_socket;
 
 #endif // !defined(BOOST_ASIO_BASIC_SEQ_PACKET_SOCKET_FWD_DECL)
@@ -44,11 +44,22 @@ class basic_seq_packet_socket;
  * @par Thread Safety
  * @e Distinct @e objects: Safe.@n
  * @e Shared @e objects: Unsafe.
+ *
+ * Synchronous @c send, @c receive, @c connect, and @c shutdown operations are
+ * thread safe with respect to each other, if the underlying operating system
+ * calls are also thread safe. This means that it is permitted to perform
+ * concurrent calls to these synchronous operations on a single socket object.
+ * Other synchronous operations, such as @c open or @c close, are not thread
+ * safe.
  */
 template <typename Protocol, typename Executor>
 class basic_seq_packet_socket
   : public basic_socket<Protocol, Executor>
 {
+private:
+  class initiate_async_send;
+  class initiate_async_receive_with_flags;
+
 public:
   /// The type of the executor associated with the object.
   typedef Executor executor_type;
@@ -101,9 +112,9 @@ public:
    */
   template <typename ExecutionContext>
   explicit basic_seq_packet_socket(ExecutionContext& context,
-      typename enable_if<
+      typename constraint<
         is_convertible<ExecutionContext&, execution_context&>::value
-      >::type* = 0)
+      >::type = 0)
     : basic_socket<Protocol, Executor>(context)
   {
   }
@@ -144,9 +155,10 @@ public:
   template <typename ExecutionContext>
   basic_seq_packet_socket(ExecutionContext& context,
       const protocol_type& protocol,
-      typename enable_if<
-        is_convertible<ExecutionContext&, execution_context&>::value
-      >::type* = 0)
+      typename constraint<
+        is_convertible<ExecutionContext&, execution_context&>::value,
+        defaulted_constraint
+      >::type = defaulted_constraint())
     : basic_socket<Protocol, Executor>(context, protocol)
   {
   }
@@ -191,9 +203,9 @@ public:
   template <typename ExecutionContext>
   basic_seq_packet_socket(ExecutionContext& context,
       const endpoint_type& endpoint,
-      typename enable_if<
+      typename constraint<
         is_convertible<ExecutionContext&, execution_context&>::value
-      >::type* = 0)
+      >::type = 0)
     : basic_socket<Protocol, Executor>(context, endpoint)
   {
   }
@@ -236,9 +248,9 @@ public:
   template <typename ExecutionContext>
   basic_seq_packet_socket(ExecutionContext& context,
       const protocol_type& protocol, const native_handle_type& native_socket,
-      typename enable_if<
+      typename constraint<
         is_convertible<ExecutionContext&, execution_context&>::value
-      >::type* = 0)
+      >::type = 0)
     : basic_socket<Protocol, Executor>(context, protocol, native_socket)
   {
   }
@@ -256,7 +268,7 @@ public:
    * constructed using the @c basic_seq_packet_socket(const executor_type&)
    * constructor.
    */
-  basic_seq_packet_socket(basic_seq_packet_socket&& other)
+  basic_seq_packet_socket(basic_seq_packet_socket&& other) BOOST_ASIO_NOEXCEPT
     : basic_socket<Protocol, Executor>(std::move(other))
   {
   }
@@ -294,10 +306,10 @@ public:
    */
   template <typename Protocol1, typename Executor1>
   basic_seq_packet_socket(basic_seq_packet_socket<Protocol1, Executor1>&& other,
-      typename enable_if<
+      typename constraint<
         is_convertible<Protocol1, Protocol>::value
           && is_convertible<Executor1, Executor>::value
-      >::type* = 0)
+      >::type = 0)
     : basic_socket<Protocol, Executor>(std::move(other))
   {
   }
@@ -316,7 +328,7 @@ public:
    * constructor.
    */
   template <typename Protocol1, typename Executor1>
-  typename enable_if<
+  typename constraint<
     is_convertible<Protocol1, Protocol>::value
       && is_convertible<Executor1, Executor>::value,
     basic_seq_packet_socket&
@@ -399,27 +411,33 @@ public:
   /// Start an asynchronous send.
   /**
    * This function is used to asynchronously send data on the sequenced packet
-   * socket. The function call always returns immediately.
+   * socket. It is an initiating function for an @ref asynchronous_operation,
+   * and always returns immediately.
    *
    * @param buffers One or more data buffers to be sent on the socket. Although
    * the buffers object may be copied as necessary, ownership of the underlying
    * memory blocks is retained by the caller, which must guarantee that they
-   * remain valid until the handler is called.
+   * remain valid until the completion handler is called.
    *
    * @param flags Flags specifying how the send call is to be made.
    *
-   * @param handler The handler to be called when the send operation completes.
-   * Copies will be made of the handler as required. The function signature of
-   * the handler must be:
+   * @param token The @ref completion_token that will be used to produce a
+   * completion handler, which will be called when the send completes.
+   * Potential completion tokens include @ref use_future, @ref use_awaitable,
+   * @ref yield_context, or a function object with the correct completion
+   * signature. The function signature of the completion handler must be:
    * @code void handler(
    *   const boost::system::error_code& error, // Result of operation.
-   *   std::size_t bytes_transferred           // Number of bytes sent.
+   *   std::size_t bytes_transferred // Number of bytes sent.
    * ); @endcode
    * Regardless of whether the asynchronous operation completes immediately or
-   * not, the handler will not be invoked from within this function. On
-   * immediate completion, invocation of the handler will be performed in a
+   * not, the completion handler will not be invoked from within this function.
+   * On immediate completion, invocation of the handler will be performed in a
    * manner equivalent to using boost::asio::post().
    *
+   * @par Completion Signature
+   * @code void(boost::system::error_code, std::size_t) @endcode
+   *
    * @par Example
    * To send a single data buffer use the @ref buffer function as follows:
    * @code
@@ -428,17 +446,35 @@ public:
    * See the @ref buffer documentation for information on sending multiple
    * buffers in one go, and how to use it with arrays, boost::array or
    * std::vector.
+   *
+   * @par Per-Operation Cancellation
+   * On POSIX or Windows operating systems, this asynchronous operation supports
+   * cancellation for the following boost::asio::cancellation_type values:
+   *
+   * @li @c cancellation_type::terminal
+   *
+   * @li @c cancellation_type::partial
+   *
+   * @li @c cancellation_type::total
    */
-  template <typename ConstBufferSequence, typename WriteHandler>
-  BOOST_ASIO_INITFN_RESULT_TYPE(WriteHandler,
+  template <typename ConstBufferSequence,
+      BOOST_ASIO_COMPLETION_TOKEN_FOR(void (boost::system::error_code,
+        std::size_t)) WriteToken
+          BOOST_ASIO_DEFAULT_COMPLETION_TOKEN_TYPE(executor_type)>
+  BOOST_ASIO_INITFN_AUTO_RESULT_TYPE_PREFIX(WriteToken,
       void (boost::system::error_code, std::size_t))
   async_send(const ConstBufferSequence& buffers,
       socket_base::message_flags flags,
-      BOOST_ASIO_MOVE_ARG(WriteHandler) handler)
+      BOOST_ASIO_MOVE_ARG(WriteToken) token
+        BOOST_ASIO_DEFAULT_COMPLETION_TOKEN(executor_type))
+    BOOST_ASIO_INITFN_AUTO_RESULT_TYPE_SUFFIX((
+      async_initiate<WriteToken,
+        void (boost::system::error_code, std::size_t)>(
+          declval<initiate_async_send>(), token, buffers, flags)))
   {
-    return async_initiate<WriteHandler,
+    return async_initiate<WriteToken,
       void (boost::system::error_code, std::size_t)>(
-        initiate_async_send(), handler, this, buffers, flags);
+        initiate_async_send(this), token, buffers, flags);
   }
 
   /// Receive some data on the socket.
@@ -563,31 +599,37 @@ public:
   /// Start an asynchronous receive.
   /**
    * This function is used to asynchronously receive data from the sequenced
-   * packet socket. The function call always returns immediately.
+   * packet socket. It is an initiating function for an @ref
+   * asynchronous_operation, and always returns immediately.
    *
    * @param buffers One or more buffers into which the data will be received.
    * Although the buffers object may be copied as necessary, ownership of the
    * underlying memory blocks is retained by the caller, which must guarantee
-   * that they remain valid until the handler is called.
+   * that they remain valid until the completion handler is called.
    *
    * @param out_flags Once the asynchronous operation completes, contains flags
    * associated with the received data. For example, if the
    * socket_base::message_end_of_record bit is set then the received data marks
    * the end of a record. The caller must guarantee that the referenced
-   * variable remains valid until the handler is called.
+   * variable remains valid until the completion handler is called.
    *
-   * @param handler The handler to be called when the receive operation
-   * completes. Copies will be made of the handler as required. The function
-   * signature of the handler must be:
+   * @param token The @ref completion_token that will be used to produce a
+   * completion handler, which will be called when the receive completes.
+   * Potential completion tokens include @ref use_future, @ref use_awaitable,
+   * @ref yield_context, or a function object with the correct completion
+   * signature. The function signature of the completion handler must be:
    * @code void handler(
    *   const boost::system::error_code& error, // Result of operation.
-   *   std::size_t bytes_transferred           // Number of bytes received.
+   *   std::size_t bytes_transferred // Number of bytes received.
    * ); @endcode
    * Regardless of whether the asynchronous operation completes immediately or
-   * not, the handler will not be invoked from within this function. On
-   * immediate completion, invocation of the handler will be performed in a
+   * not, the completion handler will not be invoked from within this function.
+   * On immediate completion, invocation of the handler will be performed in a
    * manner equivalent to using boost::asio::post().
    *
+   * @par Completion Signature
+   * @code void(boost::system::error_code, std::size_t) @endcode
+   *
    * @par Example
    * To receive into a single data buffer use the @ref buffer function as
    * follows:
@@ -597,29 +639,49 @@ public:
    * See the @ref buffer documentation for information on receiving into
    * multiple buffers in one go, and how to use it with arrays, boost::array or
    * std::vector.
+   *
+   * @par Per-Operation Cancellation
+   * On POSIX or Windows operating systems, this asynchronous operation supports
+   * cancellation for the following boost::asio::cancellation_type values:
+   *
+   * @li @c cancellation_type::terminal
+   *
+   * @li @c cancellation_type::partial
+   *
+   * @li @c cancellation_type::total
    */
-  template <typename MutableBufferSequence, typename ReadHandler>
-  BOOST_ASIO_INITFN_RESULT_TYPE(ReadHandler,
+  template <typename MutableBufferSequence,
+      BOOST_ASIO_COMPLETION_TOKEN_FOR(void (boost::system::error_code,
+        std::size_t)) ReadToken
+          BOOST_ASIO_DEFAULT_COMPLETION_TOKEN_TYPE(executor_type)>
+  BOOST_ASIO_INITFN_AUTO_RESULT_TYPE_PREFIX(ReadToken,
       void (boost::system::error_code, std::size_t))
   async_receive(const MutableBufferSequence& buffers,
       socket_base::message_flags& out_flags,
-      BOOST_ASIO_MOVE_ARG(ReadHandler) handler)
+      BOOST_ASIO_MOVE_ARG(ReadToken) token
+        BOOST_ASIO_DEFAULT_COMPLETION_TOKEN(executor_type))
+    BOOST_ASIO_INITFN_AUTO_RESULT_TYPE_SUFFIX((
+      async_initiate<ReadToken,
+        void (boost::system::error_code, std::size_t)>(
+          declval<initiate_async_receive_with_flags>(), token,
+          buffers, socket_base::message_flags(0), &out_flags)))
   {
-    return async_initiate<ReadHandler,
+    return async_initiate<ReadToken,
       void (boost::system::error_code, std::size_t)>(
-        initiate_async_receive_with_flags(), handler, this,
+        initiate_async_receive_with_flags(this), token,
         buffers, socket_base::message_flags(0), &out_flags);
   }
 
   /// Start an asynchronous receive.
   /**
    * This function is used to asynchronously receive data from the sequenced
-   * data socket. The function call always returns immediately.
+   * data socket. It is an initiating function for an @ref
+   * asynchronous_operation, and always returns immediately.
    *
    * @param buffers One or more buffers into which the data will be received.
    * Although the buffers object may be copied as necessary, ownership of the
    * underlying memory blocks is retained by the caller, which must guarantee
-   * that they remain valid until the handler is called.
+   * that they remain valid until the completion handler is called.
    *
    * @param in_flags Flags specifying how the receive call is to be made.
    *
@@ -627,20 +689,25 @@ public:
    * associated with the received data. For example, if the
    * socket_base::message_end_of_record bit is set then the received data marks
    * the end of a record. The caller must guarantee that the referenced
-   * variable remains valid until the handler is called.
+   * variable remains valid until the completion handler is called.
    *
-   * @param handler The handler to be called when the receive operation
-   * completes. Copies will be made of the handler as required. The function
-   * signature of the handler must be:
+   * @param token The @ref completion_token that will be used to produce a
+   * completion handler, which will be called when the receive completes.
+   * Potential completion tokens include @ref use_future, @ref use_awaitable,
+   * @ref yield_context, or a function object with the correct completion
+   * signature. The function signature of the completion handler must be:
    * @code void handler(
    *   const boost::system::error_code& error, // Result of operation.
-   *   std::size_t bytes_transferred           // Number of bytes received.
+   *   std::size_t bytes_transferred // Number of bytes received.
    * ); @endcode
    * Regardless of whether the asynchronous operation completes immediately or
-   * not, the handler will not be invoked from within this function. On
-   * immediate completion, invocation of the handler will be performed in a
+   * not, the completion handler will not be invoked from within this function.
+   * On immediate completion, invocation of the handler will be performed in a
    * manner equivalent to using boost::asio::post().
    *
+   * @par Completion Signature
+   * @code void(boost::system::error_code, std::size_t) @endcode
+   *
    * @par Example
    * To receive into a single data buffer use the @ref buffer function as
    * follows:
@@ -652,27 +719,64 @@ public:
    * See the @ref buffer documentation for information on receiving into
    * multiple buffers in one go, and how to use it with arrays, boost::array or
    * std::vector.
+   *
+   * @par Per-Operation Cancellation
+   * On POSIX or Windows operating systems, this asynchronous operation supports
+   * cancellation for the following boost::asio::cancellation_type values:
+   *
+   * @li @c cancellation_type::terminal
+   *
+   * @li @c cancellation_type::partial
+   *
+   * @li @c cancellation_type::total
    */
-  template <typename MutableBufferSequence, typename ReadHandler>
-  BOOST_ASIO_INITFN_RESULT_TYPE(ReadHandler,
+  template <typename MutableBufferSequence,
+      BOOST_ASIO_COMPLETION_TOKEN_FOR(void (boost::system::error_code,
+        std::size_t)) ReadToken
+          BOOST_ASIO_DEFAULT_COMPLETION_TOKEN_TYPE(executor_type)>
+  BOOST_ASIO_INITFN_AUTO_RESULT_TYPE_PREFIX(ReadToken,
       void (boost::system::error_code, std::size_t))
   async_receive(const MutableBufferSequence& buffers,
       socket_base::message_flags in_flags,
       socket_base::message_flags& out_flags,
-      BOOST_ASIO_MOVE_ARG(ReadHandler) handler)
+      BOOST_ASIO_MOVE_ARG(ReadToken) token
+        BOOST_ASIO_DEFAULT_COMPLETION_TOKEN(executor_type))
+    BOOST_ASIO_INITFN_AUTO_RESULT_TYPE_SUFFIX((
+      async_initiate<ReadToken,
+        void (boost::system::error_code, std::size_t)>(
+          declval<initiate_async_receive_with_flags>(),
+          token, buffers, in_flags, &out_flags)))
   {
-    return async_initiate<ReadHandler,
+    return async_initiate<ReadToken,
       void (boost::system::error_code, std::size_t)>(
-        initiate_async_receive_with_flags(), handler,
-        this, buffers, in_flags, &out_flags);
+        initiate_async_receive_with_flags(this),
+        token, buffers, in_flags, &out_flags);
   }
 
 private:
-  struct initiate_async_send
+  // Disallow copying and assignment.
+  basic_seq_packet_socket(const basic_seq_packet_socket&) BOOST_ASIO_DELETED;
+  basic_seq_packet_socket& operator=(
+      const basic_seq_packet_socket&) BOOST_ASIO_DELETED;
+
+  class initiate_async_send
   {
+  public:
+    typedef Executor executor_type;
+
+    explicit initiate_async_send(basic_seq_packet_socket* self)
+      : self_(self)
+    {
+    }
+
+    const executor_type& get_executor() const BOOST_ASIO_NOEXCEPT
+    {
+      return self_->get_executor();
+    }
+
     template <typename WriteHandler, typename ConstBufferSequence>
     void operator()(BOOST_ASIO_MOVE_ARG(WriteHandler) handler,
-        basic_seq_packet_socket* self, const ConstBufferSequence& buffers,
+        const ConstBufferSequence& buffers,
         socket_base::message_flags flags) const
     {
       // If you get an error on the following line it means that your handler
@@ -680,17 +784,33 @@ private:
       BOOST_ASIO_WRITE_HANDLER_CHECK(WriteHandler, handler) type_check;
 
       detail::non_const_lvalue<WriteHandler> handler2(handler);
-      self->impl_.get_service().async_send(
-          self->impl_.get_implementation(), buffers, flags,
-          handler2.value, self->impl_.get_implementation_executor());
+      self_->impl_.get_service().async_send(
+          self_->impl_.get_implementation(), buffers, flags,
+          handler2.value, self_->impl_.get_executor());
     }
+
+  private:
+    basic_seq_packet_socket* self_;
   };
 
-  struct initiate_async_receive_with_flags
+  class initiate_async_receive_with_flags
   {
+  public:
+    typedef Executor executor_type;
+
+    explicit initiate_async_receive_with_flags(basic_seq_packet_socket* self)
+      : self_(self)
+    {
+    }
+
+    const executor_type& get_executor() const BOOST_ASIO_NOEXCEPT
+    {
+      return self_->get_executor();
+    }
+
     template <typename ReadHandler, typename MutableBufferSequence>
     void operator()(BOOST_ASIO_MOVE_ARG(ReadHandler) handler,
-        basic_seq_packet_socket* self, const MutableBufferSequence& buffers,
+        const MutableBufferSequence& buffers,
         socket_base::message_flags in_flags,
         socket_base::message_flags* out_flags) const
     {
@@ -699,10 +819,13 @@ private:
       BOOST_ASIO_READ_HANDLER_CHECK(ReadHandler, handler) type_check;
 
       detail::non_const_lvalue<ReadHandler> handler2(handler);
-      self->impl_.get_service().async_receive_with_flags(
-          self->impl_.get_implementation(), buffers, in_flags, *out_flags,
-          handler2.value, self->impl_.get_implementation_executor());
+      self_->impl_.get_service().async_receive_with_flags(
+          self_->impl_.get_implementation(), buffers, in_flags,
+          *out_flags, handler2.value, self_->impl_.get_executor());
     }
+
+  private:
+    basic_seq_packet_socket* self_;
   };
 };
 

linx64/include/boost/asio/basic_serial_port.hpp

@@ -2,7 +2,7 @@
 // basic_serial_port.hpp
 // ~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2019 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2023 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 // Copyright (c) 2008 Rep Invariant Systems, Inc. (info@repinvariant.com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
@@ -22,6 +22,7 @@
   || defined(GENERATING_DOCUMENTATION)
 
 #include <string>
+#include <boost/asio/any_io_executor.hpp>
 #include <boost/asio/async_result.hpp>
 #include <boost/asio/detail/handler_type_requirements.hpp>
 #include <boost/asio/detail/io_object_impl.hpp>
@@ -30,12 +31,11 @@
 #include <boost/asio/detail/type_traits.hpp>
 #include <boost/asio/error.hpp>
 #include <boost/asio/execution_context.hpp>
-#include <boost/asio/executor.hpp>
 #include <boost/asio/serial_port_base.hpp>
 #if defined(BOOST_ASIO_HAS_IOCP)
 # include <boost/asio/detail/win_iocp_serial_port_service.hpp>
 #else
-# include <boost/asio/detail/reactive_serial_port_service.hpp>
+# include <boost/asio/detail/posix_serial_port_service.hpp>
 #endif
 
 #if defined(BOOST_ASIO_HAS_MOVE)
@@ -56,14 +56,26 @@ namespace asio {
  * @e Distinct @e objects: Safe.@n
  * @e Shared @e objects: Unsafe.
  */
-template <typename Executor = executor>
+template <typename Executor = any_io_executor>
 class basic_serial_port
   : public serial_port_base
 {
+private:
+  class initiate_async_write_some;
+  class initiate_async_read_some;
+
 public:
   /// The type of the executor associated with the object.
   typedef Executor executor_type;
 
+  /// Rebinds the serial port type to another executor.
+  template <typename Executor1>
+  struct rebind_executor
+  {
+    /// The serial port type when rebound to the specified executor.
+    typedef basic_serial_port<Executor1> other;
+  };
+
   /// The native representation of a serial port.
 #if defined(GENERATING_DOCUMENTATION)
   typedef implementation_defined native_handle_type;
@@ -71,7 +83,7 @@ public:
   typedef detail::win_iocp_serial_port_service::native_handle_type
     native_handle_type;
 #else
-  typedef detail::reactive_serial_port_service::native_handle_type
+  typedef detail::posix_serial_port_service::native_handle_type
     native_handle_type;
 #endif
 
@@ -87,7 +99,7 @@ public:
    * serial port.
    */
   explicit basic_serial_port(const executor_type& ex)
-    : impl_(ex)
+    : impl_(0, ex)
   {
   }
 
@@ -101,11 +113,11 @@ public:
    */
   template <typename ExecutionContext>
   explicit basic_serial_port(ExecutionContext& context,
-      typename enable_if<
+      typename constraint<
         is_convertible<ExecutionContext&, execution_context&>::value,
-        basic_serial_port
-      >::type* = 0)
-    : impl_(context)
+        defaulted_constraint
+      >::type = defaulted_constraint())
+    : impl_(0, 0, context)
   {
   }
 
@@ -122,7 +134,7 @@ public:
    * port.
    */
   basic_serial_port(const executor_type& ex, const char* device)
-    : impl_(ex)
+    : impl_(0, ex)
   {
     boost::system::error_code ec;
     impl_.get_service().open(impl_.get_implementation(), device, ec);
@@ -143,10 +155,10 @@ public:
    */
   template <typename ExecutionContext>
   basic_serial_port(ExecutionContext& context, const char* device,
-      typename enable_if<
+      typename constraint<
         is_convertible<ExecutionContext&, execution_context&>::value
-      >::type* = 0)
-    : impl_(context)
+      >::type = 0)
+    : impl_(0, 0, context)
   {
     boost::system::error_code ec;
     impl_.get_service().open(impl_.get_implementation(), device, ec);
@@ -166,7 +178,7 @@ public:
    * port.
    */
   basic_serial_port(const executor_type& ex, const std::string& device)
-    : impl_(ex)
+    : impl_(0, ex)
   {
     boost::system::error_code ec;
     impl_.get_service().open(impl_.get_implementation(), device, ec);
@@ -187,10 +199,10 @@ public:
    */
   template <typename ExecutionContext>
   basic_serial_port(ExecutionContext& context, const std::string& device,
-      typename enable_if<
+      typename constraint<
         is_convertible<ExecutionContext&, execution_context&>::value
-      >::type* = 0)
-    : impl_(context)
+      >::type = 0)
+    : impl_(0, 0, context)
   {
     boost::system::error_code ec;
     impl_.get_service().open(impl_.get_implementation(), device, ec);
@@ -212,7 +224,7 @@ public:
    */
   basic_serial_port(const executor_type& ex,
       const native_handle_type& native_serial_port)
-    : impl_(ex)
+    : impl_(0, ex)
   {
     boost::system::error_code ec;
     impl_.get_service().assign(impl_.get_implementation(),
@@ -236,10 +248,10 @@ public:
   template <typename ExecutionContext>
   basic_serial_port(ExecutionContext& context,
       const native_handle_type& native_serial_port,
-      typename enable_if<
+      typename constraint<
         is_convertible<ExecutionContext&, execution_context&>::value
-      >::type* = 0)
-    : impl_(context)
+      >::type = 0)
+    : impl_(0, 0, context)
   {
     boost::system::error_code ec;
     impl_.get_service().assign(impl_.get_implementation(),
@@ -280,6 +292,55 @@ public:
     impl_ = std::move(other.impl_);
     return *this;
   }
+
+  // All serial ports have access to each other's implementations.
+  template <typename Executor1>
+  friend class basic_serial_port;
+
+  /// Move-construct a basic_serial_port from a serial port of another executor
+  /// type.
+  /**
+   * This constructor moves a serial port from one object to another.
+   *
+   * @param other The other basic_serial_port object from which the move will
+   * occur.
+   *
+   * @note Following the move, the moved-from object is in the same state as if
+   * constructed using the @c basic_serial_port(const executor_type&)
+   * constructor.
+   */
+  template <typename Executor1>
+  basic_serial_port(basic_serial_port<Executor1>&& other,
+      typename constraint<
+        is_convertible<Executor1, Executor>::value,
+        defaulted_constraint
+      >::type = defaulted_constraint())
+    : impl_(std::move(other.impl_))
+  {
+  }
+
+  /// Move-assign a basic_serial_port from a serial port of another executor
+  /// type.
+  /**
+   * This assignment operator moves a serial port from one object to another.
+   *
+   * @param other The other basic_serial_port object from which the move will
+   * occur.
+   *
+   * @note Following the move, the moved-from object is in the same state as if
+   * constructed using the @c basic_serial_port(const executor_type&)
+   * constructor.
+   */
+  template <typename Executor1>
+  typename constraint<
+    is_convertible<Executor1, Executor>::value,
+    basic_serial_port&
+  >::type operator=(basic_serial_port<Executor1>&& other)
+  {
+    basic_serial_port tmp(std::move(other));
+    impl_ = std::move(tmp.impl_);
+    return *this;
+  }
 #endif // defined(BOOST_ASIO_HAS_MOVE) || defined(GENERATING_DOCUMENTATION)
 
   /// Destroys the serial port.
@@ -293,7 +354,7 @@ public:
   }
 
   /// Get the executor associated with the object.
-  executor_type get_executor() BOOST_ASIO_NOEXCEPT
+  const executor_type& get_executor() BOOST_ASIO_NOEXCEPT
   {
     return impl_.get_executor();
   }
@@ -554,7 +615,7 @@ public:
    * boost::asio::serial_port_base::character_size
    */
   template <typename GettableSerialPortOption>
-  void get_option(GettableSerialPortOption& option)
+  void get_option(GettableSerialPortOption& option) const
   {
     boost::system::error_code ec;
     impl_.get_service().get_option(impl_.get_implementation(), option, ec);
@@ -579,7 +640,7 @@ public:
    */
   template <typename GettableSerialPortOption>
   BOOST_ASIO_SYNC_OP_VOID get_option(GettableSerialPortOption& option,
-      boost::system::error_code& ec)
+      boost::system::error_code& ec) const
   {
     impl_.get_service().get_option(impl_.get_implementation(), option, ec);
     BOOST_ASIO_SYNC_OP_VOID_RETURN(ec);
@@ -649,25 +710,31 @@ public:
   /// Start an asynchronous write.
   /**
    * This function is used to asynchronously write data to the serial port.
-   * The function call always returns immediately.
+   * It is an initiating function for an @ref asynchronous_operation, and always
+   * returns immediately.
    *
    * @param buffers One or more data buffers to be written to the serial port.
    * Although the buffers object may be copied as necessary, ownership of the
    * underlying memory blocks is retained by the caller, which must guarantee
-   * that they remain valid until the handler is called.
+   * that they remain valid until the completion handler is called.
    *
-   * @param handler The handler to be called when the write operation completes.
-   * Copies will be made of the handler as required. The function signature of
-   * the handler must be:
+   * @param token The @ref completion_token that will be used to produce a
+   * completion handler, which will be called when the write completes.
+   * Potential completion tokens include @ref use_future, @ref use_awaitable,
+   * @ref yield_context, or a function object with the correct completion
+   * signature. The function signature of the completion handler must be:
    * @code void handler(
    *   const boost::system::error_code& error, // Result of operation.
-   *   std::size_t bytes_transferred           // Number of bytes written.
+   *   std::size_t bytes_transferred // Number of bytes written.
    * ); @endcode
    * Regardless of whether the asynchronous operation completes immediately or
-   * not, the handler will not be invoked from within this function. On
-   * immediate completion, invocation of the handler will be performed in a
+   * not, the completion handler will not be invoked from within this function.
+   * On immediate completion, invocation of the handler will be performed in a
    * manner equivalent to using boost::asio::post().
    *
+   * @par Completion Signature
+   * @code void(boost::system::error_code, std::size_t) @endcode
+   *
    * @note The write operation may not transmit all of the data to the peer.
    * Consider using the @ref async_write function if you need to ensure that all
    * data is written before the asynchronous operation completes.
@@ -681,16 +748,34 @@ public:
    * See the @ref buffer documentation for information on writing multiple
    * buffers in one go, and how to use it with arrays, boost::array or
    * std::vector.
+   *
+   * @par Per-Operation Cancellation
+   * On POSIX or Windows operating systems, this asynchronous operation supports
+   * cancellation for the following boost::asio::cancellation_type values:
+   *
+   * @li @c cancellation_type::terminal
+   *
+   * @li @c cancellation_type::partial
+   *
+   * @li @c cancellation_type::total
    */
-  template <typename ConstBufferSequence, typename WriteHandler>
-  BOOST_ASIO_INITFN_RESULT_TYPE(WriteHandler,
+  template <typename ConstBufferSequence,
+      BOOST_ASIO_COMPLETION_TOKEN_FOR(void (boost::system::error_code,
+        std::size_t)) WriteToken
+          BOOST_ASIO_DEFAULT_COMPLETION_TOKEN_TYPE(executor_type)>
+  BOOST_ASIO_INITFN_AUTO_RESULT_TYPE_PREFIX(WriteToken,
       void (boost::system::error_code, std::size_t))
   async_write_some(const ConstBufferSequence& buffers,
-      BOOST_ASIO_MOVE_ARG(WriteHandler) handler)
+      BOOST_ASIO_MOVE_ARG(WriteToken) token
+        BOOST_ASIO_DEFAULT_COMPLETION_TOKEN(executor_type))
+    BOOST_ASIO_INITFN_AUTO_RESULT_TYPE_SUFFIX((
+      async_initiate<WriteToken,
+        void (boost::system::error_code, std::size_t)>(
+          declval<initiate_async_write_some>(), token, buffers)))
   {
-    return async_initiate<WriteHandler,
+    return async_initiate<WriteToken,
       void (boost::system::error_code, std::size_t)>(
-        initiate_async_write_some(), handler, this, buffers);
+        initiate_async_write_some(this), token, buffers);
   }
 
   /// Read some data from the serial port.
@@ -759,25 +844,31 @@ public:
   /// Start an asynchronous read.
   /**
    * This function is used to asynchronously read data from the serial port.
-   * The function call always returns immediately.
+   * It is an initiating function for an @ref asynchronous_operation, and always
+   * returns immediately.
    *
    * @param buffers One or more buffers into which the data will be read.
    * Although the buffers object may be copied as necessary, ownership of the
    * underlying memory blocks is retained by the caller, which must guarantee
-   * that they remain valid until the handler is called.
+   * that they remain valid until the completion handler is called.
    *
-   * @param handler The handler to be called when the read operation completes.
-   * Copies will be made of the handler as required. The function signature of
-   * the handler must be:
+   * @param token The @ref completion_token that will be used to produce a
+   * completion handler, which will be called when the read completes.
+   * Potential completion tokens include @ref use_future, @ref use_awaitable,
+   * @ref yield_context, or a function object with the correct completion
+   * signature. The function signature of the completion handler must be:
    * @code void handler(
    *   const boost::system::error_code& error, // Result of operation.
-   *   std::size_t bytes_transferred           // Number of bytes read.
+   *   std::size_t bytes_transferred // Number of bytes read.
    * ); @endcode
    * Regardless of whether the asynchronous operation completes immediately or
-   * not, the handler will not be invoked from within this function. On
-   * immediate completion, invocation of the handler will be performed in a
+   * not, the completion handler will not be invoked from within this function.
+   * On immediate completion, invocation of the handler will be performed in a
    * manner equivalent to using boost::asio::post().
    *
+   * @par Completion Signature
+   * @code void(boost::system::error_code, std::size_t) @endcode
+   *
    * @note The read operation may not read all of the requested number of bytes.
    * Consider using the @ref async_read function if you need to ensure that the
    * requested amount of data is read before the asynchronous operation
@@ -792,16 +883,34 @@ public:
    * See the @ref buffer documentation for information on reading into multiple
    * buffers in one go, and how to use it with arrays, boost::array or
    * std::vector.
+   *
+   * @par Per-Operation Cancellation
+   * On POSIX or Windows operating systems, this asynchronous operation supports
+   * cancellation for the following boost::asio::cancellation_type values:
+   *
+   * @li @c cancellation_type::terminal
+   *
+   * @li @c cancellation_type::partial
+   *
+   * @li @c cancellation_type::total
    */
-  template <typename MutableBufferSequence, typename ReadHandler>
-  BOOST_ASIO_INITFN_RESULT_TYPE(ReadHandler,
+  template <typename MutableBufferSequence,
+      BOOST_ASIO_COMPLETION_TOKEN_FOR(void (boost::system::error_code,
+        std::size_t)) ReadToken
+          BOOST_ASIO_DEFAULT_COMPLETION_TOKEN_TYPE(executor_type)>
+  BOOST_ASIO_INITFN_AUTO_RESULT_TYPE_PREFIX(ReadToken,
       void (boost::system::error_code, std::size_t))
   async_read_some(const MutableBufferSequence& buffers,
-      BOOST_ASIO_MOVE_ARG(ReadHandler) handler)
+      BOOST_ASIO_MOVE_ARG(ReadToken) token
+        BOOST_ASIO_DEFAULT_COMPLETION_TOKEN(executor_type))
+    BOOST_ASIO_INITFN_AUTO_RESULT_TYPE_SUFFIX((
+      async_initiate<ReadToken,
+        void (boost::system::error_code, std::size_t)>(
+          declval<initiate_async_read_some>(), token, buffers)))
   {
-    return async_initiate<ReadHandler,
+    return async_initiate<ReadToken,
       void (boost::system::error_code, std::size_t)>(
-        initiate_async_read_some(), handler, this, buffers);
+        initiate_async_read_some(this), token, buffers);
   }
 
 private:
@@ -809,44 +918,76 @@ private:
   basic_serial_port(const basic_serial_port&) BOOST_ASIO_DELETED;
   basic_serial_port& operator=(const basic_serial_port&) BOOST_ASIO_DELETED;
 
-  struct initiate_async_write_some
+  class initiate_async_write_some
   {
+  public:
+    typedef Executor executor_type;
+
+    explicit initiate_async_write_some(basic_serial_port* self)
+      : self_(self)
+    {
+    }
+
+    const executor_type& get_executor() const BOOST_ASIO_NOEXCEPT
+    {
+      return self_->get_executor();
+    }
+
     template <typename WriteHandler, typename ConstBufferSequence>
     void operator()(BOOST_ASIO_MOVE_ARG(WriteHandler) handler,
-        basic_serial_port* self, const ConstBufferSequence& buffers) const
+        const ConstBufferSequence& buffers) const
     {
       // If you get an error on the following line it means that your handler
       // does not meet the documented type requirements for a WriteHandler.
       BOOST_ASIO_WRITE_HANDLER_CHECK(WriteHandler, handler) type_check;
 
       detail::non_const_lvalue<WriteHandler> handler2(handler);
-      self->impl_.get_service().async_write_some(
-          self->impl_.get_implementation(), buffers, handler2.value,
-          self->impl_.get_implementation_executor());
+      self_->impl_.get_service().async_write_some(
+          self_->impl_.get_implementation(), buffers,
+          handler2.value, self_->impl_.get_executor());
     }
+
+  private:
+    basic_serial_port* self_;
   };
 
-  struct initiate_async_read_some
+  class initiate_async_read_some
   {
+  public:
+    typedef Executor executor_type;
+
+    explicit initiate_async_read_some(basic_serial_port* self)
+      : self_(self)
+    {
+    }
+
+    const executor_type& get_executor() const BOOST_ASIO_NOEXCEPT
+    {
+      return self_->get_executor();
+    }
+
     template <typename ReadHandler, typename MutableBufferSequence>
     void operator()(BOOST_ASIO_MOVE_ARG(ReadHandler) handler,
-        basic_serial_port* self, const MutableBufferSequence& buffers) const
+        const MutableBufferSequence& buffers) const
     {
       // If you get an error on the following line it means that your handler
       // does not meet the documented type requirements for a ReadHandler.
       BOOST_ASIO_READ_HANDLER_CHECK(ReadHandler, handler) type_check;
 
       detail::non_const_lvalue<ReadHandler> handler2(handler);
-      self->impl_.get_service().async_read_some(
-          self->impl_.get_implementation(), buffers, handler2.value,
-          self->impl_.get_implementation_executor());
+      self_->impl_.get_service().async_read_some(
+          self_->impl_.get_implementation(), buffers,
+          handler2.value, self_->impl_.get_executor());
     }
+
+  private:
+    basic_serial_port* self_;
   };
 
 #if defined(BOOST_ASIO_HAS_IOCP)
   detail::io_object_impl<detail::win_iocp_serial_port_service, Executor> impl_;
 #else
-  detail::io_object_impl<detail::reactive_serial_port_service, Executor> impl_;
+  detail::io_object_impl<detail::posix_serial_port_service, Executor> impl_;
 #endif
 };
 

linx64/include/boost/asio/basic_signal_set.hpp

@@ -2,7 +2,7 @@
 // basic_signal_set.hpp
 // ~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2019 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2023 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -17,6 +17,7 @@
 
 #include <boost/asio/detail/config.hpp>
 
+#include <boost/asio/any_io_executor.hpp>
 #include <boost/asio/async_result.hpp>
 #include <boost/asio/detail/handler_type_requirements.hpp>
 #include <boost/asio/detail/io_object_impl.hpp>
@@ -26,7 +27,9 @@
 #include <boost/asio/detail/type_traits.hpp>
 #include <boost/asio/error.hpp>
 #include <boost/asio/execution_context.hpp>
-#include <boost/asio/executor.hpp>
+#include <boost/asio/signal_set_base.hpp>
+
+#include <boost/asio/detail/push_options.hpp>
 
 namespace boost {
 namespace asio {
@@ -91,13 +94,24 @@ namespace asio {
  * that any signals registered using signal_set objects are unblocked in at
  * least one thread.
  */
-template <typename Executor = executor>
-class basic_signal_set
+template <typename Executor = any_io_executor>
+class basic_signal_set : public signal_set_base
 {
+private:
+  class initiate_async_wait;
+
 public:
   /// The type of the executor associated with the object.
   typedef Executor executor_type;
 
+  /// Rebinds the signal set type to another executor.
+  template <typename Executor1>
+  struct rebind_executor
+  {
+    /// The signal set type when rebound to the specified executor.
+    typedef basic_signal_set<Executor1> other;
+  };
+
   /// Construct a signal set without adding any signals.
   /**
    * This constructor creates a signal set without registering for any signals.
@@ -107,7 +121,7 @@ public:
    * signal set.
    */
   explicit basic_signal_set(const executor_type& ex)
-    : impl_(ex)
+    : impl_(0, ex)
   {
   }
 
@@ -121,10 +135,11 @@ public:
    */
   template <typename ExecutionContext>
   explicit basic_signal_set(ExecutionContext& context,
-      typename enable_if<
-        is_convertible<ExecutionContext&, execution_context&>::value
-      >::type* = 0)
-    : impl_(context)
+      typename constraint<
+        is_convertible<ExecutionContext&, execution_context&>::value,
+        defaulted_constraint
+      >::type = defaulted_constraint())
+    : impl_(0, 0, context)
   {
   }
 
@@ -143,7 +158,7 @@ public:
    * signals.add(signal_number_1); @endcode
    */
   basic_signal_set(const executor_type& ex, int signal_number_1)
-    : impl_(ex)
+    : impl_(0, ex)
   {
     boost::system::error_code ec;
     impl_.get_service().add(impl_.get_implementation(), signal_number_1, ec);
@@ -166,10 +181,11 @@ public:
    */
   template <typename ExecutionContext>
   basic_signal_set(ExecutionContext& context, int signal_number_1,
-      typename enable_if<
-        is_convertible<ExecutionContext&, execution_context&>::value
-      >::type* = 0)
-    : impl_(context)
+      typename constraint<
+        is_convertible<ExecutionContext&, execution_context&>::value,
+        defaulted_constraint
+      >::type = defaulted_constraint())
+    : impl_(0, 0, context)
   {
     boost::system::error_code ec;
     impl_.get_service().add(impl_.get_implementation(), signal_number_1, ec);
@@ -195,7 +211,7 @@ public:
    */
   basic_signal_set(const executor_type& ex, int signal_number_1,
       int signal_number_2)
-    : impl_(ex)
+    : impl_(0, ex)
   {
     boost::system::error_code ec;
     impl_.get_service().add(impl_.get_implementation(), signal_number_1, ec);
@@ -224,10 +240,11 @@ public:
   template <typename ExecutionContext>
   basic_signal_set(ExecutionContext& context, int signal_number_1,
       int signal_number_2,
-      typename enable_if<
-        is_convertible<ExecutionContext&, execution_context&>::value
-      >::type* = 0)
-    : impl_(context)
+      typename constraint<
+        is_convertible<ExecutionContext&, execution_context&>::value,
+        defaulted_constraint
+      >::type = defaulted_constraint())
+    : impl_(0, 0, context)
   {
     boost::system::error_code ec;
     impl_.get_service().add(impl_.get_implementation(), signal_number_1, ec);
@@ -258,7 +275,7 @@ public:
    */
   basic_signal_set(const executor_type& ex, int signal_number_1,
       int signal_number_2, int signal_number_3)
-    : impl_(ex)
+    : impl_(0, ex)
   {
     boost::system::error_code ec;
     impl_.get_service().add(impl_.get_implementation(), signal_number_1, ec);
@@ -292,10 +309,11 @@ public:
   template <typename ExecutionContext>
   basic_signal_set(ExecutionContext& context, int signal_number_1,
       int signal_number_2, int signal_number_3,
-      typename enable_if<
-        is_convertible<ExecutionContext&, execution_context&>::value
-      >::type* = 0)
-    : impl_(context)
+      typename constraint<
+        is_convertible<ExecutionContext&, execution_context&>::value,
+        defaulted_constraint
+      >::type = defaulted_constraint())
+    : impl_(0, 0, context)
   {
     boost::system::error_code ec;
     impl_.get_service().add(impl_.get_implementation(), signal_number_1, ec);
@@ -317,7 +335,7 @@ public:
   }
 
   /// Get the executor associated with the object.
-  executor_type get_executor() BOOST_ASIO_NOEXCEPT
+  const executor_type& get_executor() BOOST_ASIO_NOEXCEPT
   {
     return impl_.get_executor();
   }
@@ -354,6 +372,58 @@ public:
     BOOST_ASIO_SYNC_OP_VOID_RETURN(ec);
   }
 
+  /// Add a signal to a signal_set with the specified flags.
+  /**
+   * This function adds the specified signal to the set. It has no effect if the
+   * signal is already in the set.
+   *
+   * Flags other than flags::dont_care require OS support for the @c sigaction
+   * call, and this function will fail with @c error::operation_not_supported if
+   * this is unavailable.
+   *
+   * The specified flags will conflict with a prior, active registration of the
+   * same signal, if either specified a flags value other than flags::dont_care.
+   * In this case, the @c add will fail with @c error::invalid_argument.
+   *
+   * @param signal_number The signal to be added to the set.
+   *
+   * @param f Flags to modify the behaviour of the specified signal.
+   *
+   * @throws boost::system::system_error Thrown on failure.
+   */
+  void add(int signal_number, flags_t f)
+  {
+    boost::system::error_code ec;
+    impl_.get_service().add(impl_.get_implementation(), signal_number, f, ec);
+    boost::asio::detail::throw_error(ec, "add");
+  }
+
+  /// Add a signal to a signal_set with the specified flags.
+  /**
+   * This function adds the specified signal to the set. It has no effect if the
+   * signal is already in the set.
+   *
+   * Flags other than flags::dont_care require OS support for the @c sigaction
+   * call, and this function will fail with @c error::operation_not_supported if
+   * this is unavailable.
+   *
+   * The specified flags will conflict with a prior, active registration of the
+   * same signal, if either specified a flags value other than flags::dont_care.
+   * In this case, the @c add will fail with @c error::invalid_argument.
+   *
+   * @param signal_number The signal to be added to the set.
+   *
+   * @param f Flags to modify the behaviour of the specified signal.
+   *
+   * @param ec Set to indicate what error occurred, if any.
+   */
+  BOOST_ASIO_SYNC_OP_VOID add(int signal_number, flags_t f,
+      boost::system::error_code& ec)
+  {
+    impl_.get_service().add(impl_.get_implementation(), signal_number, f, ec);
+    BOOST_ASIO_SYNC_OP_VOID_RETURN(ec);
+  }
+
   /// Remove a signal from a signal_set.
   /**
    * This function removes the specified signal from the set. It has no effect
@@ -481,35 +551,58 @@ public:
   /// Start an asynchronous operation to wait for a signal to be delivered.
   /**
    * This function may be used to initiate an asynchronous wait against the
-   * signal set. It always returns immediately.
+   * signal set. It is an initiating function for an @ref
+   * asynchronous_operation, and always returns immediately.
    *
-   * For each call to async_wait(), the supplied handler will be called exactly
-   * once. The handler will be called when:
+   * For each call to async_wait(), the completion handler will be called
+   * exactly once. The completion handler will be called when:
    *
    * @li One of the registered signals in the signal set occurs; or
    *
    * @li The signal set was cancelled, in which case the handler is passed the
    * error code boost::asio::error::operation_aborted.
    *
-   * @param handler The handler to be called when the signal occurs. Copies
-   * will be made of the handler as required. The function signature of the
-   * handler must be:
+   * @param token The @ref completion_token that will be used to produce a
+   * completion handler, which will be called when the wait completes.
+   * Potential completion tokens include @ref use_future, @ref use_awaitable,
+   * @ref yield_context, or a function object with the correct completion
+   * signature. The function signature of the completion handler must be:
    * @code void handler(
    *   const boost::system::error_code& error, // Result of operation.
    *   int signal_number // Indicates which signal occurred.
    * ); @endcode
    * Regardless of whether the asynchronous operation completes immediately or
-   * not, the handler will not be invoked from within this function. On
-   * immediate completion, invocation of the handler will be performed in a
+   * not, the completion handler will not be invoked from within this function.
+   * On immediate completion, invocation of the handler will be performed in a
    * manner equivalent to using boost::asio::post().
+   *
+   * @par Completion Signature
+   * @code void(boost::system::error_code, int) @endcode
+   *
+   * @par Per-Operation Cancellation
+   * This asynchronous operation supports cancellation for the following
+   * boost::asio::cancellation_type values:
+   *
+   * @li @c cancellation_type::terminal
+   *
+   * @li @c cancellation_type::partial
+   *
+   * @li @c cancellation_type::total
    */
-  template <typename SignalHandler>
-  BOOST_ASIO_INITFN_RESULT_TYPE(SignalHandler,
+  template <
+    BOOST_ASIO_COMPLETION_TOKEN_FOR(void (boost::system::error_code, int))
+      SignalToken BOOST_ASIO_DEFAULT_COMPLETION_TOKEN_TYPE(executor_type)>
+  BOOST_ASIO_INITFN_AUTO_RESULT_TYPE_PREFIX(SignalToken,
       void (boost::system::error_code, int))
-  async_wait(BOOST_ASIO_MOVE_ARG(SignalHandler) handler)
+  async_wait(
+      BOOST_ASIO_MOVE_ARG(SignalToken) token
+        BOOST_ASIO_DEFAULT_COMPLETION_TOKEN(executor_type))
+    BOOST_ASIO_INITFN_AUTO_RESULT_TYPE_SUFFIX((
+      async_initiate<SignalToken, void (boost::system::error_code, int)>(
+          declval<initiate_async_wait>(), token)))
   {
-    return async_initiate<SignalHandler, void (boost::system::error_code, int)>(
-        initiate_async_wait(), handler, this);
+    return async_initiate<SignalToken, void (boost::system::error_code, int)>(
+        initiate_async_wait(this), token);
   }
 
 private:
@@ -517,21 +610,36 @@ private:
   basic_signal_set(const basic_signal_set&) BOOST_ASIO_DELETED;
   basic_signal_set& operator=(const basic_signal_set&) BOOST_ASIO_DELETED;
 
-  struct initiate_async_wait
+  class initiate_async_wait
   {
+  public:
+    typedef Executor executor_type;
+
+    explicit initiate_async_wait(basic_signal_set* self)
+      : self_(self)
+    {
+    }
+
+    const executor_type& get_executor() const BOOST_ASIO_NOEXCEPT
+    {
+      return self_->get_executor();
+    }
+
     template <typename SignalHandler>
-    void operator()(BOOST_ASIO_MOVE_ARG(SignalHandler) handler,
-        basic_signal_set* self) const
+    void operator()(BOOST_ASIO_MOVE_ARG(SignalHandler) handler) const
     {
       // If you get an error on the following line it means that your handler
       // does not meet the documented type requirements for a SignalHandler.
       BOOST_ASIO_SIGNAL_HANDLER_CHECK(SignalHandler, handler) type_check;
 
       detail::non_const_lvalue<SignalHandler> handler2(handler);
-      self->impl_.get_service().async_wait(
-          self->impl_.get_implementation(), handler2.value,
-          self->impl_.get_implementation_executor());
+      self_->impl_.get_service().async_wait(
+          self_->impl_.get_implementation(),
+          handler2.value, self_->impl_.get_executor());
     }
+
+  private:
+    basic_signal_set* self_;
   };
 
   detail::io_object_impl<detail::signal_set_service, Executor> impl_;
@@ -540,4 +648,6 @@ private:
 } // namespace asio
 } // namespace boost
 
+#include <boost/asio/detail/pop_options.hpp>
+
 #endif // BOOST_ASIO_BASIC_SIGNAL_SET_HPP

linx64/include/boost/asio/basic_socket.hpp

@@ -2,7 +2,7 @@
 // basic_socket.hpp
 // ~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2019 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2023 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -15,6 +15,7 @@
 # pragma once
 #endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
 
+#include <boost/asio/any_io_executor.hpp>
 #include <boost/asio/detail/config.hpp>
 #include <boost/asio/async_result.hpp>
 #include <boost/asio/detail/handler_type_requirements.hpp>
@@ -24,7 +25,6 @@
 #include <boost/asio/detail/type_traits.hpp>
 #include <boost/asio/error.hpp>
 #include <boost/asio/execution_context.hpp>
-#include <boost/asio/executor.hpp>
 #include <boost/asio/post.hpp>
 #include <boost/asio/socket_base.hpp>
 
@@ -32,6 +32,8 @@
 # include <boost/asio/detail/null_socket_service.hpp>
 #elif defined(BOOST_ASIO_HAS_IOCP)
 # include <boost/asio/detail/win_iocp_socket_service.hpp>
+#elif defined(BOOST_ASIO_HAS_IO_URING_AS_DEFAULT)
+# include <boost/asio/detail/io_uring_socket_service.hpp>
 #else
 # include <boost/asio/detail/reactive_socket_service.hpp>
 #endif
@@ -49,7 +51,7 @@ namespace asio {
 #define BOOST_ASIO_BASIC_SOCKET_FWD_DECL
 
 // Forward declaration with defaulted arguments.
-template <typename Protocol, typename Executor = executor>
+template <typename Protocol, typename Executor = any_io_executor>
 class basic_socket;
 
 #endif // !defined(BOOST_ASIO_BASIC_SOCKET_FWD_DECL)
@@ -67,6 +69,10 @@ template <typename Protocol, typename Executor>
 class basic_socket
   : public socket_base
 {
+private:
+  class initiate_async_connect;
+  class initiate_async_wait;
+
 public:
   /// The type of the executor associated with the object.
   typedef Executor executor_type;
@@ -88,6 +94,9 @@ public:
 #elif defined(BOOST_ASIO_HAS_IOCP)
   typedef typename detail::win_iocp_socket_service<
     Protocol>::native_handle_type native_handle_type;
+#elif defined(BOOST_ASIO_HAS_IO_URING_AS_DEFAULT)
+  typedef typename detail::io_uring_socket_service<
+    Protocol>::native_handle_type native_handle_type;
 #else
   typedef typename detail::reactive_socket_service<
     Protocol>::native_handle_type native_handle_type;
@@ -112,7 +121,7 @@ public:
    * dispatch handlers for any asynchronous operations performed on the socket.
    */
   explicit basic_socket(const executor_type& ex)
-    : impl_(ex)
+    : impl_(0, ex)
   {
   }
 
@@ -126,10 +135,10 @@ public:
    */
   template <typename ExecutionContext>
   explicit basic_socket(ExecutionContext& context,
-      typename enable_if<
+      typename constraint<
         is_convertible<ExecutionContext&, execution_context&>::value
-      >::type* = 0)
-    : impl_(context)
+      >::type = 0)
+    : impl_(0, 0, context)
   {
   }
 
@@ -145,7 +154,7 @@ public:
    * @throws boost::system::system_error Thrown on failure.
    */
   basic_socket(const executor_type& ex, const protocol_type& protocol)
-    : impl_(ex)
+    : impl_(0, ex)
   {
     boost::system::error_code ec;
     impl_.get_service().open(impl_.get_implementation(), protocol, ec);
@@ -166,10 +175,11 @@ public:
    */
   template <typename ExecutionContext>
   basic_socket(ExecutionContext& context, const protocol_type& protocol,
-      typename enable_if<
-        is_convertible<ExecutionContext&, execution_context&>::value
-      >::type* = 0)
-    : impl_(context)
+      typename constraint<
+        is_convertible<ExecutionContext&, execution_context&>::value,
+        defaulted_constraint
+      >::type = defaulted_constraint())
+    : impl_(0, 0, context)
   {
     boost::system::error_code ec;
     impl_.get_service().open(impl_.get_implementation(), protocol, ec);
@@ -192,7 +202,7 @@ public:
    * @throws boost::system::system_error Thrown on failure.
    */
   basic_socket(const executor_type& ex, const endpoint_type& endpoint)
-    : impl_(ex)
+    : impl_(0, ex)
   {
     boost::system::error_code ec;
     const protocol_type protocol = endpoint.protocol();
@@ -220,10 +230,10 @@ public:
    */
   template <typename ExecutionContext>
   basic_socket(ExecutionContext& context, const endpoint_type& endpoint,
-      typename enable_if<
+      typename constraint<
         is_convertible<ExecutionContext&, execution_context&>::value
-      >::type* = 0)
-    : impl_(context)
+      >::type = 0)
+    : impl_(0, 0, context)
   {
     boost::system::error_code ec;
     const protocol_type protocol = endpoint.protocol();
@@ -248,7 +258,7 @@ public:
    */
   basic_socket(const executor_type& ex, const protocol_type& protocol,
       const native_handle_type& native_socket)
-    : impl_(ex)
+    : impl_(0, ex)
   {
     boost::system::error_code ec;
     impl_.get_service().assign(impl_.get_implementation(),
@@ -273,10 +283,10 @@ public:
   template <typename ExecutionContext>
   basic_socket(ExecutionContext& context, const protocol_type& protocol,
       const native_handle_type& native_socket,
-      typename enable_if<
+      typename constraint<
         is_convertible<ExecutionContext&, execution_context&>::value
-      >::type* = 0)
-    : impl_(context)
+      >::type = 0)
+    : impl_(0, 0, context)
   {
     boost::system::error_code ec;
     impl_.get_service().assign(impl_.get_implementation(),
@@ -295,7 +305,7 @@ public:
    * @note Following the move, the moved-from object is in the same state as if
    * constructed using the @c basic_socket(const executor_type&) constructor.
    */
-  basic_socket(basic_socket&& other)
+  basic_socket(basic_socket&& other) BOOST_ASIO_NOEXCEPT
     : impl_(std::move(other.impl_))
   {
   }
@@ -332,10 +342,10 @@ public:
    */
   template <typename Protocol1, typename Executor1>
   basic_socket(basic_socket<Protocol1, Executor1>&& other,
-      typename enable_if<
+      typename constraint<
         is_convertible<Protocol1, Protocol>::value
           && is_convertible<Executor1, Executor>::value
-      >::type* = 0)
+      >::type = 0)
     : impl_(std::move(other.impl_))
   {
   }
@@ -351,11 +361,11 @@ public:
    * constructed using the @c basic_socket(const executor_type&) constructor.
    */
   template <typename Protocol1, typename Executor1>
-  typename enable_if<
+  typename constraint<
     is_convertible<Protocol1, Protocol>::value
       && is_convertible<Executor1, Executor>::value,
     basic_socket&
-  >::type operator=(basic_socket<Protocol1, Executor1> && other)
+  >::type operator=(basic_socket<Protocol1, Executor1>&& other)
   {
     basic_socket tmp(std::move(other));
     impl_ = std::move(tmp.impl_);
@@ -364,7 +374,7 @@ public:
 #endif // defined(BOOST_ASIO_HAS_MOVE) || defined(GENERATING_DOCUMENTATION)
 
   /// Get the executor associated with the object.
-  executor_type get_executor() BOOST_ASIO_NOEXCEPT
+  const executor_type& get_executor() BOOST_ASIO_NOEXCEPT
   {
     return impl_.get_executor();
   }
@@ -902,7 +912,8 @@ public:
   /// Start an asynchronous connect.
   /**
    * This function is used to asynchronously connect a socket to the specified
-   * remote endpoint. The function call always returns immediately.
+   * remote endpoint. It is an initiating function for an @ref
+   * asynchronous_operation, and always returns immediately.
    *
    * The socket is automatically opened if it is not already open. If the
    * connect fails, and the socket was automatically opened, the socket is
@@ -911,17 +922,22 @@ public:
    * @param peer_endpoint The remote endpoint to which the socket will be
    * connected. Copies will be made of the endpoint object as required.
    *
-   * @param handler The handler to be called when the connection operation
-   * completes. Copies will be made of the handler as required. The function
-   * signature of the handler must be:
+   * @param token The @ref completion_token that will be used to produce a
+   * completion handler, which will be called when the connect completes.
+   * Potential completion tokens include @ref use_future, @ref use_awaitable,
+   * @ref yield_context, or a function object with the correct completion
+   * signature. The function signature of the completion handler must be:
    * @code void handler(
-   *   const boost::system::error_code& error // Result of operation
+   *   const boost::system::error_code& error // Result of operation.
    * ); @endcode
    * Regardless of whether the asynchronous operation completes immediately or
-   * not, the handler will not be invoked from within this function. On
-   * immediate completion, invocation of the handler will be performed in a
+   * not, the completion handler will not be invoked from within this function.
+   * On immediate completion, invocation of the handler will be performed in a
    * manner equivalent to using boost::asio::post().
    *
+   * @par Completion Signature
+   * @code void(boost::system::error_code) @endcode
+   *
    * @par Example
    * @code
    * void connect_handler(const boost::system::error_code& error)
@@ -939,12 +955,29 @@ public:
    *     boost::asio::ip::address::from_string("1.2.3.4"), 12345);
    * socket.async_connect(endpoint, connect_handler);
    * @endcode
+   *
+   * @par Per-Operation Cancellation
+   * On POSIX or Windows operating systems, this asynchronous operation supports
+   * cancellation for the following boost::asio::cancellation_type values:
+   *
+   * @li @c cancellation_type::terminal
+   *
+   * @li @c cancellation_type::partial
+   *
+   * @li @c cancellation_type::total
    */
-  template <typename ConnectHandler>
-  BOOST_ASIO_INITFN_RESULT_TYPE(ConnectHandler,
+  template <
+      BOOST_ASIO_COMPLETION_TOKEN_FOR(void (boost::system::error_code))
+        ConnectToken BOOST_ASIO_DEFAULT_COMPLETION_TOKEN_TYPE(executor_type)>
+  BOOST_ASIO_INITFN_AUTO_RESULT_TYPE_PREFIX(ConnectToken,
       void (boost::system::error_code))
   async_connect(const endpoint_type& peer_endpoint,
-      BOOST_ASIO_MOVE_ARG(ConnectHandler) handler)
+      BOOST_ASIO_MOVE_ARG(ConnectToken) token
+        BOOST_ASIO_DEFAULT_COMPLETION_TOKEN(executor_type))
+    BOOST_ASIO_INITFN_AUTO_RESULT_TYPE_SUFFIX((
+      async_initiate<ConnectToken, void (boost::system::error_code)>(
+          declval<initiate_async_connect>(), token,
+          peer_endpoint, declval<boost::system::error_code&>())))
   {
     boost::system::error_code open_ec;
     if (!is_open())
@@ -953,8 +986,8 @@ public:
       impl_.get_service().open(impl_.get_implementation(), protocol, open_ec);
     }
 
-    return async_initiate<ConnectHandler, void (boost::system::error_code)>(
-        initiate_async_connect(), handler, this, peer_endpoint, open_ec);
+    return async_initiate<ConnectToken, void (boost::system::error_code)>(
+        initiate_async_connect(this), token, peer_endpoint, open_ec);
   }
 
   /// Set an option on the socket.
@@ -1738,21 +1771,28 @@ public:
   /// write, or to have pending error conditions.
   /**
    * This function is used to perform an asynchronous wait for a socket to enter
-   * a ready to read, write or error condition state.
+   * a ready to read, write or error condition state. It is an initiating
+   * function for an @ref asynchronous_operation, and always returns
+   * immediately.
    *
    * @param w Specifies the desired socket state.
    *
-   * @param handler The handler to be called when the wait operation completes.
-   * Copies will be made of the handler as required. The function signature of
-   * the handler must be:
+   * @param token The @ref completion_token that will be used to produce a
+   * completion handler, which will be called when the wait completes. Potential
+   * completion tokens include @ref use_future, @ref use_awaitable, @ref
+   * yield_context, or a function object with the correct completion signature.
+   * The function signature of the completion handler must be:
    * @code void handler(
-   *   const boost::system::error_code& error // Result of operation
+   *   const boost::system::error_code& error // Result of operation.
    * ); @endcode
    * Regardless of whether the asynchronous operation completes immediately or
-   * not, the handler will not be invoked from within this function. On
-   * immediate completion, invocation of the handler will be performed in a
+   * not, the completion handler will not be invoked from within this function.
+   * On immediate completion, invocation of the handler will be performed in a
    * manner equivalent to using boost::asio::post().
    *
+   * @par Completion Signature
+   * @code void(boost::system::error_code) @endcode
+   *
    * @par Example
    * @code
    * void wait_handler(const boost::system::error_code& error)
@@ -1769,14 +1809,31 @@ public:
    * ...
    * socket.async_wait(boost::asio::ip::tcp::socket::wait_read, wait_handler);
    * @endcode
+   *
+   * @par Per-Operation Cancellation
+   * On POSIX or Windows operating systems, this asynchronous operation supports
+   * cancellation for the following boost::asio::cancellation_type values:
+   *
+   * @li @c cancellation_type::terminal
+   *
+   * @li @c cancellation_type::partial
+   *
+   * @li @c cancellation_type::total
    */
-  template <typename WaitHandler>
-  BOOST_ASIO_INITFN_RESULT_TYPE(WaitHandler,
+  template <
+      BOOST_ASIO_COMPLETION_TOKEN_FOR(void (boost::system::error_code))
+        WaitToken BOOST_ASIO_DEFAULT_COMPLETION_TOKEN_TYPE(executor_type)>
+  BOOST_ASIO_INITFN_AUTO_RESULT_TYPE_PREFIX(WaitToken,
       void (boost::system::error_code))
-  async_wait(wait_type w, BOOST_ASIO_MOVE_ARG(WaitHandler) handler)
+  async_wait(wait_type w,
+      BOOST_ASIO_MOVE_ARG(WaitToken) token
+        BOOST_ASIO_DEFAULT_COMPLETION_TOKEN(executor_type))
+    BOOST_ASIO_INITFN_AUTO_RESULT_TYPE_SUFFIX((
+      async_initiate<WaitToken, void (boost::system::error_code)>(
+          declval<initiate_async_wait>(), token, w)))
   {
-    return async_initiate<WaitHandler, void (boost::system::error_code)>(
-        initiate_async_wait(), handler, this, w);
+    return async_initiate<WaitToken, void (boost::system::error_code)>(
+        initiate_async_wait(this), token, w);
   }
 
 protected:
@@ -1795,6 +1852,9 @@ protected:
 #elif defined(BOOST_ASIO_HAS_IOCP)
   detail::io_object_impl<
     detail::win_iocp_socket_service<Protocol>, Executor> impl_;
+#elif defined(BOOST_ASIO_HAS_IO_URING_AS_DEFAULT)
+  detail::io_object_impl<
+    detail::io_uring_socket_service<Protocol>, Executor> impl_;
 #else
   detail::io_object_impl<
     detail::reactive_socket_service<Protocol>, Executor> impl_;
@@ -1805,11 +1865,24 @@ private:
   basic_socket(const basic_socket&) BOOST_ASIO_DELETED;
   basic_socket& operator=(const basic_socket&) BOOST_ASIO_DELETED;
 
-  struct initiate_async_connect
+  class initiate_async_connect
   {
+  public:
+    typedef Executor executor_type;
+
+    explicit initiate_async_connect(basic_socket* self)
+      : self_(self)
+    {
+    }
+
+    const executor_type& get_executor() const BOOST_ASIO_NOEXCEPT
+    {
+      return self_->get_executor();
+    }
+
     template <typename ConnectHandler>
     void operator()(BOOST_ASIO_MOVE_ARG(ConnectHandler) handler,
-        basic_socket* self, const endpoint_type& peer_endpoint,
+        const endpoint_type& peer_endpoint,
         const boost::system::error_code& open_ec) const
     {
       // If you get an error on the following line it means that your handler
@@ -1818,35 +1891,53 @@ private:
 
       if (open_ec)
       {
-          boost::asio::post(self->impl_.get_executor(),
+          boost::asio::post(self_->impl_.get_executor(),
               boost::asio::detail::bind_handler(
                 BOOST_ASIO_MOVE_CAST(ConnectHandler)(handler), open_ec));
       }
       else
       {
         detail::non_const_lvalue<ConnectHandler> handler2(handler);
-        self->impl_.get_service().async_connect(
-            self->impl_.get_implementation(), peer_endpoint,
-            handler2.value, self->impl_.get_implementation_executor());
+        self_->impl_.get_service().async_connect(
+            self_->impl_.get_implementation(), peer_endpoint,
+            handler2.value, self_->impl_.get_executor());
       }
     }
+
+  private:
+    basic_socket* self_;
   };
 
-  struct initiate_async_wait
+  class initiate_async_wait
   {
+  public:
+    typedef Executor executor_type;
+
+    explicit initiate_async_wait(basic_socket* self)
+      : self_(self)
+    {
+    }
+
+    const executor_type& get_executor() const BOOST_ASIO_NOEXCEPT
+    {
+      return self_->get_executor();
+    }
+
     template <typename WaitHandler>
-    void operator()(BOOST_ASIO_MOVE_ARG(WaitHandler) handler,
-        basic_socket* self, wait_type w) const
+    void operator()(BOOST_ASIO_MOVE_ARG(WaitHandler) handler, wait_type w) const
     {
       // If you get an error on the following line it means that your handler
       // does not meet the documented type requirements for a WaitHandler.
       BOOST_ASIO_WAIT_HANDLER_CHECK(WaitHandler, handler) type_check;
 
       detail::non_const_lvalue<WaitHandler> handler2(handler);
-      self->impl_.get_service().async_wait(
-          self->impl_.get_implementation(), w, handler2.value,
-          self->impl_.get_implementation_executor());
+      self_->impl_.get_service().async_wait(
+          self_->impl_.get_implementation(), w,
+          handler2.value, self_->impl_.get_executor());
     }
+
+  private:
+    basic_socket* self_;
   };
 };
 

linx64/include/boost/asio/basic_socket_iostream.hpp

@@ -2,7 +2,7 @@
 // basic_socket_iostream.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2019 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2023 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

linx64/include/boost/asio/basic_socket_streambuf.hpp

@@ -2,7 +2,7 @@
 // basic_socket_streambuf.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2019 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2023 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

linx64/include/boost/asio/basic_stream_file.hpp

@@ -0,0 +1,756 @@
+//
+// basic_stream_file.hpp
+// ~~~~~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2023 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef BOOST_ASIO_BASIC_STREAM_FILE_HPP
+#define BOOST_ASIO_BASIC_STREAM_FILE_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include <boost/asio/detail/config.hpp>
+
+#if defined(BOOST_ASIO_HAS_FILE) \
+  || defined(GENERATING_DOCUMENTATION)
+
+#include <cstddef>
+#include <boost/asio/async_result.hpp>
+#include <boost/asio/basic_file.hpp>
+#include <boost/asio/detail/handler_type_requirements.hpp>
+#include <boost/asio/detail/non_const_lvalue.hpp>
+#include <boost/asio/detail/throw_error.hpp>
+#include <boost/asio/error.hpp>
+
+#include <boost/asio/detail/push_options.hpp>
+
+namespace boost {
+namespace asio {
+
+#if !defined(BOOST_ASIO_BASIC_STREAM_FILE_FWD_DECL)
+#define BOOST_ASIO_BASIC_STREAM_FILE_FWD_DECL
+
+// Forward declaration with defaulted arguments.
+template <typename Executor = any_io_executor>
+class basic_stream_file;
+
+#endif // !defined(BOOST_ASIO_BASIC_STREAM_FILE_FWD_DECL)
+
+/// Provides stream-oriented file functionality.
+/**
+ * The basic_stream_file class template provides asynchronous and blocking
+ * stream-oriented file functionality.
+ *
+ * @par Thread Safety
+ * @e Distinct @e objects: Safe.@n
+ * @e Shared @e objects: Unsafe.
+ *
+ * @par Concepts:
+ * AsyncReadStream, AsyncWriteStream, Stream, SyncReadStream, SyncWriteStream.
+ */
+template <typename Executor>
+class basic_stream_file
+  : public basic_file<Executor>
+{
+private:
+  class initiate_async_write_some;
+  class initiate_async_read_some;
+
+public:
+  /// The type of the executor associated with the object.
+  typedef Executor executor_type;
+
+  /// Rebinds the file type to another executor.
+  template <typename Executor1>
+  struct rebind_executor
+  {
+    /// The file type when rebound to the specified executor.
+    typedef basic_stream_file<Executor1> other;
+  };
+
+  /// The native representation of a file.
+#if defined(GENERATING_DOCUMENTATION)
+  typedef implementation_defined native_handle_type;
+#else
+  typedef typename basic_file<Executor>::native_handle_type native_handle_type;
+#endif
+
+  /// Construct a basic_stream_file without opening it.
+  /**
+   * This constructor initialises a file without opening it. The file needs to
+   * be opened before data can be read from or or written to it.
+   *
+   * @param ex The I/O executor that the file will use, by default, to
+   * dispatch handlers for any asynchronous operations performed on the file.
+   */
+  explicit basic_stream_file(const executor_type& ex)
+    : basic_file<Executor>(ex)
+  {
+    this->impl_.get_service().set_is_stream(
+        this->impl_.get_implementation(), true);
+  }
+
+  /// Construct a basic_stream_file without opening it.
+  /**
+   * This constructor initialises a file without opening it. The file needs to
+   * be opened before data can be read from or or written to it.
+   *
+   * @param context An execution context which provides the I/O executor that
+   * the file will use, by default, to dispatch handlers for any asynchronous
+   * operations performed on the file.
+   */
+  template <typename ExecutionContext>
+  explicit basic_stream_file(ExecutionContext& context,
+      typename constraint<
+        is_convertible<ExecutionContext&, execution_context&>::value,
+        defaulted_constraint
+      >::type = defaulted_constraint())
+    : basic_file<Executor>(context)
+  {
+    this->impl_.get_service().set_is_stream(
+        this->impl_.get_implementation(), true);
+  }
+
+  /// Construct and open a basic_stream_file.
+  /**
+   * This constructor initialises and opens a file.
+   *
+   * @param ex The I/O executor that the file will use, by default, to
+   * dispatch handlers for any asynchronous operations performed on the file.
+   *
+   * @param path The path name identifying the file to be opened.
+   *
+   * @param open_flags A set of flags that determine how the file should be
+   * opened.
+   *
+   * @throws boost::system::system_error Thrown on failure.
+   */
+  basic_stream_file(const executor_type& ex,
+      const char* path, file_base::flags open_flags)
+    : basic_file<Executor>(ex)
+  {
+    boost::system::error_code ec;
+    this->impl_.get_service().set_is_stream(
+        this->impl_.get_implementation(), true);
+    this->impl_.get_service().open(
+        this->impl_.get_implementation(),
+        path, open_flags, ec);
+    boost::asio::detail::throw_error(ec, "open");
+  }
+
+  /// Construct and open a basic_stream_file.
+  /**
+   * This constructor initialises and opens a file.
+   *
+   * @param context An execution context which provides the I/O executor that
+   * the file will use, by default, to dispatch handlers for any asynchronous
+   * operations performed on the file.
+   *
+   * @param path The path name identifying the file to be opened.
+   *
+   * @param open_flags A set of flags that determine how the file should be
+   * opened.
+   *
+   * @throws boost::system::system_error Thrown on failure.
+   */
+  template <typename ExecutionContext>
+  basic_stream_file(ExecutionContext& context,
+      const char* path, file_base::flags open_flags,
+      typename constraint<
+        is_convertible<ExecutionContext&, execution_context&>::value,
+        defaulted_constraint
+      >::type = defaulted_constraint())
+    : basic_file<Executor>(context)
+  {
+    boost::system::error_code ec;
+    this->impl_.get_service().set_is_stream(
+        this->impl_.get_implementation(), true);
+    this->impl_.get_service().open(
+        this->impl_.get_implementation(),
+        path, open_flags, ec);
+    boost::asio::detail::throw_error(ec, "open");
+  }
+
+  /// Construct and open a basic_stream_file.
+  /**
+   * This constructor initialises and opens a file.
+   *
+   * @param ex The I/O executor that the file will use, by default, to
+   * dispatch handlers for any asynchronous operations performed on the file.
+   *
+   * @param path The path name identifying the file to be opened.
+   *
+   * @param open_flags A set of flags that determine how the file should be
+   * opened.
+   *
+   * @throws boost::system::system_error Thrown on failure.
+   */
+  basic_stream_file(const executor_type& ex,
+      const std::string& path, file_base::flags open_flags)
+    : basic_file<Executor>(ex)
+  {
+    boost::system::error_code ec;
+    this->impl_.get_service().set_is_stream(
+        this->impl_.get_implementation(), true);
+    this->impl_.get_service().open(
+        this->impl_.get_implementation(),
+        path.c_str(), open_flags, ec);
+    boost::asio::detail::throw_error(ec, "open");
+  }
+
+  /// Construct and open a basic_stream_file.
+  /**
+   * This constructor initialises and opens a file.
+   *
+   * @param context An execution context which provides the I/O executor that
+   * the file will use, by default, to dispatch handlers for any asynchronous
+   * operations performed on the file.
+   *
+   * @param path The path name identifying the file to be opened.
+   *
+   * @param open_flags A set of flags that determine how the file should be
+   * opened.
+   *
+   * @throws boost::system::system_error Thrown on failure.
+   */
+  template <typename ExecutionContext>
+  basic_stream_file(ExecutionContext& context,
+      const std::string& path, file_base::flags open_flags,
+      typename constraint<
+        is_convertible<ExecutionContext&, execution_context&>::value,
+        defaulted_constraint
+      >::type = defaulted_constraint())
+    : basic_file<Executor>(context)
+  {
+    boost::system::error_code ec;
+    this->impl_.get_service().set_is_stream(
+        this->impl_.get_implementation(), true);
+    this->impl_.get_service().open(
+        this->impl_.get_implementation(),
+        path.c_str(), open_flags, ec);
+    boost::asio::detail::throw_error(ec, "open");
+  }
+
+  /// Construct a basic_stream_file on an existing native file.
+  /**
+   * This constructor initialises a stream file object to hold an existing
+   * native file.
+   *
+   * @param ex The I/O executor that the file will use, by default, to
+   * dispatch handlers for any asynchronous operations performed on the file.
+   *
+   * @param native_file The new underlying file implementation.
+   *
+   * @throws boost::system::system_error Thrown on failure.
+   */
+  basic_stream_file(const executor_type& ex,
+      const native_handle_type& native_file)
+    : basic_file<Executor>(ex, native_file)
+  {
+    this->impl_.get_service().set_is_stream(
+        this->impl_.get_implementation(), true);
+  }
+
+  /// Construct a basic_stream_file on an existing native file.
+  /**
+   * This constructor initialises a stream file object to hold an existing
+   * native file.
+   *
+   * @param context An execution context which provides the I/O executor that
+   * the file will use, by default, to dispatch handlers for any asynchronous
+   * operations performed on the file.
+   *
+   * @param native_file The new underlying file implementation.
+   *
+   * @throws boost::system::system_error Thrown on failure.
+   */
+  template <typename ExecutionContext>
+  basic_stream_file(ExecutionContext& context,
+      const native_handle_type& native_file,
+      typename constraint<
+        is_convertible<ExecutionContext&, execution_context&>::value,
+        defaulted_constraint
+      >::type = defaulted_constraint())
+    : basic_file<Executor>(context, native_file)
+  {
+    this->impl_.get_service().set_is_stream(
+        this->impl_.get_implementation(), true);
+  }
+
+#if defined(BOOST_ASIO_HAS_MOVE) || defined(GENERATING_DOCUMENTATION)
+  /// Move-construct a basic_stream_file from another.
+  /**
+   * This constructor moves a stream file from one object to another.
+   *
+   * @param other The other basic_stream_file object from which the move
+   * will occur.
+   *
+   * @note Following the move, the moved-from object is in the same state as if
+   * constructed using the @c basic_stream_file(const executor_type&)
+   * constructor.
+   */
+  basic_stream_file(basic_stream_file&& other) BOOST_ASIO_NOEXCEPT
+    : basic_file<Executor>(std::move(other))
+  {
+  }
+
+  /// Move-assign a basic_stream_file from another.
+  /**
+   * This assignment operator moves a stream file from one object to another.
+   *
+   * @param other The other basic_stream_file object from which the move
+   * will occur.
+   *
+   * @note Following the move, the moved-from object is in the same state as if
+   * constructed using the @c basic_stream_file(const executor_type&)
+   * constructor.
+   */
+  basic_stream_file& operator=(basic_stream_file&& other)
+  {
+    basic_file<Executor>::operator=(std::move(other));
+    return *this;
+  }
+
+  /// Move-construct a basic_stream_file from a file of another executor
+  /// type.
+  /**
+   * This constructor moves a stream file from one object to another.
+   *
+   * @param other The other basic_stream_file object from which the move
+   * will occur.
+   *
+   * @note Following the move, the moved-from object is in the same state as if
+   * constructed using the @c basic_stream_file(const executor_type&)
+   * constructor.
+   */
+  template <typename Executor1>
+  basic_stream_file(basic_stream_file<Executor1>&& other,
+      typename constraint<
+        is_convertible<Executor1, Executor>::value,
+        defaulted_constraint
+      >::type = defaulted_constraint())
+    : basic_file<Executor>(std::move(other))
+  {
+  }
+
+  /// Move-assign a basic_stream_file from a file of another executor type.
+  /**
+   * This assignment operator moves a stream file from one object to another.
+   *
+   * @param other The other basic_stream_file object from which the move
+   * will occur.
+   *
+   * @note Following the move, the moved-from object is in the same state as if
+   * constructed using the @c basic_stream_file(const executor_type&)
+   * constructor.
+   */
+  template <typename Executor1>
+  typename constraint<
+    is_convertible<Executor1, Executor>::value,
+    basic_stream_file&
+  >::type operator=(basic_stream_file<Executor1>&& other)
+  {
+    basic_file<Executor>::operator=(std::move(other));
+    return *this;
+  }
+#endif // defined(BOOST_ASIO_HAS_MOVE) || defined(GENERATING_DOCUMENTATION)
+
+  /// Destroys the file.
+  /**
+   * This function destroys the file, cancelling any outstanding asynchronous
+   * operations associated with the file as if by calling @c cancel.
+   */
+  ~basic_stream_file()
+  {
+  }
+
+  /// Seek to a position in the file.
+  /**
+   * This function updates the current position in the file.
+   *
+   * @param offset The requested position in the file, relative to @c whence.
+   *
+   * @param whence One of @c seek_set, @c seek_cur or @c seek_end.
+   *
+   * @returns The new position relative to the beginning of the file.
+   *
+   * @throws boost::system::system_error Thrown on failure.
+   */
+  uint64_t seek(int64_t offset, file_base::seek_basis whence)
+  {
+    boost::system::error_code ec;
+    uint64_t n = this->impl_.get_service().seek(
+        this->impl_.get_implementation(), offset, whence, ec);
+    boost::asio::detail::throw_error(ec, "seek");
+    return n;
+  }
+
+  /// Seek to a position in the file.
+  /**
+   * This function updates the current position in the file.
+   *
+   * @param offset The requested position in the file, relative to @c whence.
+   *
+   * @param whence One of @c seek_set, @c seek_cur or @c seek_end.
+   *
+   * @param ec Set to indicate what error occurred, if any.
+   *
+   * @returns The new position relative to the beginning of the file.
+   */
+  uint64_t seek(int64_t offset, file_base::seek_basis whence,
+      boost::system::error_code& ec)
+  {
+    return this->impl_.get_service().seek(
+        this->impl_.get_implementation(), offset, whence, ec);
+  }
+
+  /// Write some data to the file.
+  /**
+   * This function is used to write data to the stream file. The function call
+   * will block until one or more bytes of the data has been written
+   * successfully, or until an error occurs.
+   *
+   * @param buffers One or more data buffers to be written to the file.
+   *
+   * @returns The number of bytes written.
+   *
+   * @throws boost::system::system_error Thrown on failure. An error code of
+   * boost::asio::error::eof indicates that the end of the file was reached.
+   *
+   * @note The write_some operation may not transmit all of the data to the
+   * peer. Consider using the @ref write function if you need to ensure that
+   * all data is written before the blocking operation completes.
+   *
+   * @par Example
+   * To write a single data buffer use the @ref buffer function as follows:
+   * @code
+   * file.write_some(boost::asio::buffer(data, size));
+   * @endcode
+   * See the @ref buffer documentation for information on writing multiple
+   * buffers in one go, and how to use it with arrays, boost::array or
+   * std::vector.
+   */
+  template <typename ConstBufferSequence>
+  std::size_t write_some(const ConstBufferSequence& buffers)
+  {
+    boost::system::error_code ec;
+    std::size_t s = this->impl_.get_service().write_some(
+        this->impl_.get_implementation(), buffers, ec);
+    boost::asio::detail::throw_error(ec, "write_some");
+    return s;
+  }
+
+  /// Write some data to the file.
+  /**
+   * This function is used to write data to the stream file. The function call
+   * will block until one or more bytes of the data has been written
+   * successfully, or until an error occurs.
+   *
+   * @param buffers One or more data buffers to be written to the file.
+   *
+   * @param ec Set to indicate what error occurred, if any.
+   *
+   * @returns The number of bytes written. Returns 0 if an error occurred.
+   *
+   * @note The write_some operation may not transmit all of the data to the
+   * peer. Consider using the @ref write function if you need to ensure that
+   * all data is written before the blocking operation completes.
+   */
+  template <typename ConstBufferSequence>
+  std::size_t write_some(const ConstBufferSequence& buffers,
+      boost::system::error_code& ec)
+  {
+    return this->impl_.get_service().write_some(
+        this->impl_.get_implementation(), buffers, ec);
+  }
+
+  /// Start an asynchronous write.
+  /**
+   * This function is used to asynchronously write data to the stream file.
+   * It is an initiating function for an @ref asynchronous_operation, and always
+   * returns immediately.
+   *
+   * @param buffers One or more data buffers to be written to the file.
+   * Although the buffers object may be copied as necessary, ownership of the
+   * underlying memory blocks is retained by the caller, which must guarantee
+   * that they remain valid until the completion handler is called.
+   *
+   * @param token The @ref completion_token that will be used to produce a
+   * completion handler, which will be called when the write completes.
+   * Potential completion tokens include @ref use_future, @ref use_awaitable,
+   * @ref yield_context, or a function object with the correct completion
+   * signature. The function signature of the completion handler must be:
+   * @code void handler(
+   *   const boost::system::error_code& error, // Result of operation.
+   *   std::size_t bytes_transferred // Number of bytes written.
+   * ); @endcode
+   * Regardless of whether the asynchronous operation completes immediately or
+   * not, the completion handler will not be invoked from within this function.
+   * On immediate completion, invocation of the handler will be performed in a
+   * manner equivalent to using boost::asio::post().
+   *
+   * @par Completion Signature
+   * @code void(boost::system::error_code, std::size_t) @endcode
+   *
+   * @note The write operation may not transmit all of the data to the peer.
+   * Consider using the @ref async_write function if you need to ensure that all
+   * data is written before the asynchronous operation completes.
+   *
+   * @par Example
+   * To write a single data buffer use the @ref buffer function as follows:
+   * @code
+   * file.async_write_some(boost::asio::buffer(data, size), handler);
+   * @endcode
+   * See the @ref buffer documentation for information on writing multiple
+   * buffers in one go, and how to use it with arrays, boost::array or
+   * std::vector.
+   *
+   * @par Per-Operation Cancellation
+   * On POSIX or Windows operating systems, this asynchronous operation supports
+   * cancellation for the following boost::asio::cancellation_type values:
+   *
+   * @li @c cancellation_type::terminal
+   *
+   * @li @c cancellation_type::partial
+   *
+   * @li @c cancellation_type::total
+   */
+  template <typename ConstBufferSequence,
+      BOOST_ASIO_COMPLETION_TOKEN_FOR(void (boost::system::error_code,
+        std::size_t)) WriteToken
+          BOOST_ASIO_DEFAULT_COMPLETION_TOKEN_TYPE(executor_type)>
+  BOOST_ASIO_INITFN_AUTO_RESULT_TYPE_PREFIX(WriteToken,
+      void (boost::system::error_code, std::size_t))
+  async_write_some(const ConstBufferSequence& buffers,
+      BOOST_ASIO_MOVE_ARG(WriteToken) token
+        BOOST_ASIO_DEFAULT_COMPLETION_TOKEN(executor_type))
+    BOOST_ASIO_INITFN_AUTO_RESULT_TYPE_SUFFIX((
+      async_initiate<WriteToken,
+        void (boost::system::error_code, std::size_t)>(
+          declval<initiate_async_write_some>(), token, buffers)))
+  {
+    return async_initiate<WriteToken,
+      void (boost::system::error_code, std::size_t)>(
+        initiate_async_write_some(this), token, buffers);
+  }
+
+  /// Read some data from the file.
+  /**
+   * This function is used to read data from the stream file. The function
+   * call will block until one or more bytes of data has been read successfully,
+   * or until an error occurs.
+   *
+   * @param buffers One or more buffers into which the data will be read.
+   *
+   * @returns The number of bytes read.
+   *
+   * @throws boost::system::system_error Thrown on failure. An error code of
+   * boost::asio::error::eof indicates that the end of the file was reached.
+   *
+   * @note The read_some operation may not read all of the requested number of
+   * bytes. Consider using the @ref read function if you need to ensure that
+   * the requested amount of data is read before the blocking operation
+   * completes.
+   *
+   * @par Example
+   * To read into a single data buffer use the @ref buffer function as follows:
+   * @code
+   * file.read_some(boost::asio::buffer(data, size));
+   * @endcode
+   * See the @ref buffer documentation for information on reading into multiple
+   * buffers in one go, and how to use it with arrays, boost::array or
+   * std::vector.
+   */
+  template <typename MutableBufferSequence>
+  std::size_t read_some(const MutableBufferSequence& buffers)
+  {
+    boost::system::error_code ec;
+    std::size_t s = this->impl_.get_service().read_some(
+        this->impl_.get_implementation(), buffers, ec);
+    boost::asio::detail::throw_error(ec, "read_some");
+    return s;
+  }
+
+  /// Read some data from the file.
+  /**
+   * This function is used to read data from the stream file. The function
+   * call will block until one or more bytes of data has been read successfully,
+   * or until an error occurs.
+   *
+   * @param buffers One or more buffers into which the data will be read.
+   *
+   * @param ec Set to indicate what error occurred, if any.
+   *
+   * @returns The number of bytes read. Returns 0 if an error occurred.
+   *
+   * @note The read_some operation may not read all of the requested number of
+   * bytes. Consider using the @ref read function if you need to ensure that
+   * the requested amount of data is read before the blocking operation
+   * completes.
+   */
+  template <typename MutableBufferSequence>
+  std::size_t read_some(const MutableBufferSequence& buffers,
+      boost::system::error_code& ec)
+  {
+    return this->impl_.get_service().read_some(
+        this->impl_.get_implementation(), buffers, ec);
+  }
+
+  /// Start an asynchronous read.
+  /**
+   * This function is used to asynchronously read data from the stream file.
+   * It is an initiating function for an @ref asynchronous_operation, and always
+   * returns immediately.
+   *
+   * @param buffers One or more buffers into which the data will be read.
+   * Although the buffers object may be copied as necessary, ownership of the
+   * underlying memory blocks is retained by the caller, which must guarantee
+   * that they remain valid until the completion handler is called.
+   *
+   * @param token The @ref completion_token that will be used to produce a
+   * completion handler, which will be called when the read completes.
+   * Potential completion tokens include @ref use_future, @ref use_awaitable,
+   * @ref yield_context, or a function object with the correct completion
+   * signature. The function signature of the completion handler must be:
+   * @code void handler(
+   *   const boost::system::error_code& error, // Result of operation.
+   *   std::size_t bytes_transferred // Number of bytes read.
+   * ); @endcode
+   * Regardless of whether the asynchronous operation completes immediately or
+   * not, the completion handler will not be invoked from within this function.
+   * On immediate completion, invocation of the handler will be performed in a
+   * manner equivalent to using boost::asio::post().
+   *
+   * @par Completion Signature
+   * @code void(boost::system::error_code, std::size_t) @endcode
+   *
+   * @note The read operation may not read all of the requested number of bytes.
+   * Consider using the @ref async_read function if you need to ensure that the
+   * requested amount of data is read before the asynchronous operation
+   * completes.
+   *
+   * @par Example
+   * To read into a single data buffer use the @ref buffer function as follows:
+   * @code
+   * file.async_read_some(boost::asio::buffer(data, size), handler);
+   * @endcode
+   * See the @ref buffer documentation for information on reading into multiple
+   * buffers in one go, and how to use it with arrays, boost::array or
+   * std::vector.
+   *
+   * @par Per-Operation Cancellation
+   * On POSIX or Windows operating systems, this asynchronous operation supports
+   * cancellation for the following boost::asio::cancellation_type values:
+   *
+   * @li @c cancellation_type::terminal
+   *
+   * @li @c cancellation_type::partial
+   *
+   * @li @c cancellation_type::total
+   */
+  template <typename MutableBufferSequence,
+      BOOST_ASIO_COMPLETION_TOKEN_FOR(void (boost::system::error_code,
+        std::size_t)) ReadToken
+          BOOST_ASIO_DEFAULT_COMPLETION_TOKEN_TYPE(executor_type)>
+  BOOST_ASIO_INITFN_AUTO_RESULT_TYPE_PREFIX(ReadToken,
+      void (boost::system::error_code, std::size_t))
+  async_read_some(const MutableBufferSequence& buffers,
+      BOOST_ASIO_MOVE_ARG(ReadToken) token
+        BOOST_ASIO_DEFAULT_COMPLETION_TOKEN(executor_type))
+    BOOST_ASIO_INITFN_AUTO_RESULT_TYPE_SUFFIX((
+      async_initiate<ReadToken,
+        void (boost::system::error_code, std::size_t)>(
+          declval<initiate_async_read_some>(), token, buffers)))
+  {
+    return async_initiate<ReadToken,
+      void (boost::system::error_code, std::size_t)>(
+        initiate_async_read_some(this), token, buffers);
+  }
+
+private:
+  // Disallow copying and assignment.
+  basic_stream_file(const basic_stream_file&) BOOST_ASIO_DELETED;
+  basic_stream_file& operator=(const basic_stream_file&) BOOST_ASIO_DELETED;
+
+  class initiate_async_write_some
+  {
+  public:
+    typedef Executor executor_type;
+
+    explicit initiate_async_write_some(basic_stream_file* self)
+      : self_(self)
+    {
+    }
+
+    const executor_type& get_executor() const BOOST_ASIO_NOEXCEPT
+    {
+      return self_->get_executor();
+    }
+
+    template <typename WriteHandler, typename ConstBufferSequence>
+    void operator()(BOOST_ASIO_MOVE_ARG(WriteHandler) handler,
+        const ConstBufferSequence& buffers) const
+    {
+      // If you get an error on the following line it means that your handler
+      // does not meet the documented type requirements for a WriteHandler.
+      BOOST_ASIO_WRITE_HANDLER_CHECK(WriteHandler, handler) type_check;
+
+      detail::non_const_lvalue<WriteHandler> handler2(handler);
+      self_->impl_.get_service().async_write_some(
+          self_->impl_.get_implementation(), buffers,
+          handler2.value, self_->impl_.get_executor());
+    }
+
+  private:
+    basic_stream_file* self_;
+  };
+
+  class initiate_async_read_some
+  {
+  public:
+    typedef Executor executor_type;
+
+    explicit initiate_async_read_some(basic_stream_file* self)
+      : self_(self)
+    {
+    }
+
+    const executor_type& get_executor() const BOOST_ASIO_NOEXCEPT
+    {
+      return self_->get_executor();
+    }
+
+    template <typename ReadHandler, typename MutableBufferSequence>
+    void operator()(BOOST_ASIO_MOVE_ARG(ReadHandler) handler,
+        const MutableBufferSequence& buffers) const
+    {
+      // If you get an error on the following line it means that your handler
+      // does not meet the documented type requirements for a ReadHandler.
+      BOOST_ASIO_READ_HANDLER_CHECK(ReadHandler, handler) type_check;
+
+      detail::non_const_lvalue<ReadHandler> handler2(handler);
+      self_->impl_.get_service().async_read_some(
+          self_->impl_.get_implementation(), buffers,
+          handler2.value, self_->impl_.get_executor());
+    }
+
+  private:
+    basic_stream_file* self_;
+  };
+};
+
+} // namespace asio
+} // namespace boost
+
+#include <boost/asio/detail/pop_options.hpp>
+
+#endif // defined(BOOST_ASIO_HAS_FILE)
+       //   || defined(GENERATING_DOCUMENTATION)
+
+#endif // BOOST_ASIO_BASIC_STREAM_FILE_HPP

linx64/include/boost/asio/basic_stream_socket.hpp

@@ -2,7 +2,7 @@
 // basic_stream_socket.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2019 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2023 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -33,7 +33,7 @@ namespace asio {
 #define BOOST_ASIO_BASIC_STREAM_SOCKET_FWD_DECL
 
 // Forward declaration with defaulted arguments.
-template <typename Protocol, typename Executor = executor>
+template <typename Protocol, typename Executor = any_io_executor>
 class basic_stream_socket;
 
 #endif // !defined(BOOST_ASIO_BASIC_STREAM_SOCKET_FWD_DECL)
@@ -47,6 +47,13 @@ class basic_stream_socket;
  * @e Distinct @e objects: Safe.@n
  * @e Shared @e objects: Unsafe.
  *
+ * Synchronous @c send, @c receive, @c connect, and @c shutdown operations are
+ * thread safe with respect to each other, if the underlying operating system
+ * calls are also thread safe. This means that it is permitted to perform
+ * concurrent calls to these synchronous operations on a single socket object.
+ * Other synchronous operations, such as @c open or @c close, are not thread
+ * safe.
+ *
  * @par Concepts:
  * AsyncReadStream, AsyncWriteStream, Stream, SyncReadStream, SyncWriteStream.
  */
@@ -54,6 +61,10 @@ template <typename Protocol, typename Executor>
 class basic_stream_socket
   : public basic_socket<Protocol, Executor>
 {
+private:
+  class initiate_async_send;
+  class initiate_async_receive;
+
 public:
   /// The type of the executor associated with the object.
   typedef Executor executor_type;
@@ -106,9 +117,9 @@ public:
    */
   template <typename ExecutionContext>
   explicit basic_stream_socket(ExecutionContext& context,
-      typename enable_if<
+      typename constraint<
         is_convertible<ExecutionContext&, execution_context&>::value
-      >::type* = 0)
+      >::type = 0)
     : basic_socket<Protocol, Executor>(context)
   {
   }
@@ -145,9 +156,10 @@ public:
    */
   template <typename ExecutionContext>
   basic_stream_socket(ExecutionContext& context, const protocol_type& protocol,
-      typename enable_if<
-        is_convertible<ExecutionContext&, execution_context&>::value
-      >::type* = 0)
+      typename constraint<
+        is_convertible<ExecutionContext&, execution_context&>::value,
+        defaulted_constraint
+      >::type = defaulted_constraint())
     : basic_socket<Protocol, Executor>(context, protocol)
   {
   }
@@ -190,9 +202,9 @@ public:
    */
   template <typename ExecutionContext>
   basic_stream_socket(ExecutionContext& context, const endpoint_type& endpoint,
-      typename enable_if<
+      typename constraint<
         is_convertible<ExecutionContext&, execution_context&>::value
-      >::type* = 0)
+      >::type = 0)
     : basic_socket<Protocol, Executor>(context, endpoint)
   {
   }
@@ -235,9 +247,9 @@ public:
   template <typename ExecutionContext>
   basic_stream_socket(ExecutionContext& context,
       const protocol_type& protocol, const native_handle_type& native_socket,
-      typename enable_if<
+      typename constraint<
         is_convertible<ExecutionContext&, execution_context&>::value
-      >::type* = 0)
+      >::type = 0)
     : basic_socket<Protocol, Executor>(context, protocol, native_socket)
   {
   }
@@ -254,7 +266,7 @@ public:
    * constructed using the @c basic_stream_socket(const executor_type&)
    * constructor.
    */
-  basic_stream_socket(basic_stream_socket&& other)
+  basic_stream_socket(basic_stream_socket&& other) BOOST_ASIO_NOEXCEPT
     : basic_socket<Protocol, Executor>(std::move(other))
   {
   }
@@ -290,10 +302,10 @@ public:
    */
   template <typename Protocol1, typename Executor1>
   basic_stream_socket(basic_stream_socket<Protocol1, Executor1>&& other,
-      typename enable_if<
+      typename constraint<
         is_convertible<Protocol1, Protocol>::value
           && is_convertible<Executor1, Executor>::value
-      >::type* = 0)
+      >::type = 0)
     : basic_socket<Protocol, Executor>(std::move(other))
   {
   }
@@ -310,7 +322,7 @@ public:
    * constructor.
    */
   template <typename Protocol1, typename Executor1>
-  typename enable_if<
+  typename constraint<
     is_convertible<Protocol1, Protocol>::value
       && is_convertible<Executor1, Executor>::value,
     basic_stream_socket&
@@ -432,25 +444,31 @@ public:
   /// Start an asynchronous send.
   /**
    * This function is used to asynchronously send data on the stream socket.
-   * The function call always returns immediately.
+   * It is an initiating function for an @ref asynchronous_operation, and always
+   * returns immediately.
    *
    * @param buffers One or more data buffers to be sent on the socket. Although
    * the buffers object may be copied as necessary, ownership of the underlying
    * memory blocks is retained by the caller, which must guarantee that they
-   * remain valid until the handler is called.
+   * remain valid until the completion handler is called.
    *
-   * @param handler The handler to be called when the send operation completes.
-   * Copies will be made of the handler as required. The function signature of
-   * the handler must be:
+   * @param token The @ref completion_token that will be used to produce a
+   * completion handler, which will be called when the send completes.
+   * Potential completion tokens include @ref use_future, @ref use_awaitable,
+   * @ref yield_context, or a function object with the correct completion
+   * signature. The function signature of the completion handler must be:
    * @code void handler(
    *   const boost::system::error_code& error, // Result of operation.
-   *   std::size_t bytes_transferred           // Number of bytes sent.
+   *   std::size_t bytes_transferred // Number of bytes sent.
    * ); @endcode
    * Regardless of whether the asynchronous operation completes immediately or
-   * not, the handler will not be invoked from within this function. On
-   * immediate completion, invocation of the handler will be performed in a
+   * not, the completion handler will not be invoked from within this function.
+   * On immediate completion, invocation of the handler will be performed in a
    * manner equivalent to using boost::asio::post().
    *
+   * @par Completion Signature
+   * @code void(boost::system::error_code, std::size_t) @endcode
+   *
    * @note The send operation may not transmit all of the data to the peer.
    * Consider using the @ref async_write function if you need to ensure that all
    * data is written before the asynchronous operation completes.
@@ -463,43 +481,68 @@ public:
    * See the @ref buffer documentation for information on sending multiple
    * buffers in one go, and how to use it with arrays, boost::array or
    * std::vector.
+   *
+   * @par Per-Operation Cancellation
+   * On POSIX or Windows operating systems, this asynchronous operation supports
+   * cancellation for the following boost::asio::cancellation_type values:
+   *
+   * @li @c cancellation_type::terminal
+   *
+   * @li @c cancellation_type::partial
+   *
+   * @li @c cancellation_type::total
    */
-  template <typename ConstBufferSequence, typename WriteHandler>
-  BOOST_ASIO_INITFN_RESULT_TYPE(WriteHandler,
+  template <typename ConstBufferSequence,
+      BOOST_ASIO_COMPLETION_TOKEN_FOR(void (boost::system::error_code,
+        std::size_t)) WriteToken
+          BOOST_ASIO_DEFAULT_COMPLETION_TOKEN_TYPE(executor_type)>
+  BOOST_ASIO_INITFN_AUTO_RESULT_TYPE_PREFIX(WriteToken,
       void (boost::system::error_code, std::size_t))
   async_send(const ConstBufferSequence& buffers,
-      BOOST_ASIO_MOVE_ARG(WriteHandler) handler)
+      BOOST_ASIO_MOVE_ARG(WriteToken) token
+        BOOST_ASIO_DEFAULT_COMPLETION_TOKEN(executor_type))
+    BOOST_ASIO_INITFN_AUTO_RESULT_TYPE_SUFFIX((
+      async_initiate<WriteToken,
+        void (boost::system::error_code, std::size_t)>(
+          declval<initiate_async_send>(), token,
+          buffers, socket_base::message_flags(0))))
   {
-    return async_initiate<WriteHandler,
+    return async_initiate<WriteToken,
       void (boost::system::error_code, std::size_t)>(
-        initiate_async_send(), handler, this,
+        initiate_async_send(this), token,
         buffers, socket_base::message_flags(0));
   }
 
   /// Start an asynchronous send.
   /**
    * This function is used to asynchronously send data on the stream socket.
-   * The function call always returns immediately.
+   * It is an initiating function for an @ref asynchronous_operation, and always
+   * returns immediately.
    *
    * @param buffers One or more data buffers to be sent on the socket. Although
    * the buffers object may be copied as necessary, ownership of the underlying
    * memory blocks is retained by the caller, which must guarantee that they
-   * remain valid until the handler is called.
+   * remain valid until the completion handler is called.
    *
    * @param flags Flags specifying how the send call is to be made.
    *
-   * @param handler The handler to be called when the send operation completes.
-   * Copies will be made of the handler as required. The function signature of
-   * the handler must be:
+   * @param token The @ref completion_token that will be used to produce a
+   * completion handler, which will be called when the send completes.
+   * Potential completion tokens include @ref use_future, @ref use_awaitable,
+   * @ref yield_context, or a function object with the correct completion
+   * signature. The function signature of the completion handler must be:
    * @code void handler(
    *   const boost::system::error_code& error, // Result of operation.
-   *   std::size_t bytes_transferred           // Number of bytes sent.
+   *   std::size_t bytes_transferred // Number of bytes sent.
    * ); @endcode
    * Regardless of whether the asynchronous operation completes immediately or
-   * not, the handler will not be invoked from within this function. On
-   * immediate completion, invocation of the handler will be performed in a
+   * not, the completion handler will not be invoked from within this function.
+   * On immediate completion, invocation of the handler will be performed in a
    * manner equivalent to using boost::asio::post().
    *
+   * @par Completion Signature
+   * @code void(boost::system::error_code, std::size_t) @endcode
+   *
    * @note The send operation may not transmit all of the data to the peer.
    * Consider using the @ref async_write function if you need to ensure that all
    * data is written before the asynchronous operation completes.
@@ -512,17 +555,35 @@ public:
    * See the @ref buffer documentation for information on sending multiple
    * buffers in one go, and how to use it with arrays, boost::array or
    * std::vector.
+   *
+   * @par Per-Operation Cancellation
+   * On POSIX or Windows operating systems, this asynchronous operation supports
+   * cancellation for the following boost::asio::cancellation_type values:
+   *
+   * @li @c cancellation_type::terminal
+   *
+   * @li @c cancellation_type::partial
+   *
+   * @li @c cancellation_type::total
    */
-  template <typename ConstBufferSequence, typename WriteHandler>
-  BOOST_ASIO_INITFN_RESULT_TYPE(WriteHandler,
+  template <typename ConstBufferSequence,
+      BOOST_ASIO_COMPLETION_TOKEN_FOR(void (boost::system::error_code,
+        std::size_t)) WriteToken
+          BOOST_ASIO_DEFAULT_COMPLETION_TOKEN_TYPE(executor_type)>
+  BOOST_ASIO_INITFN_AUTO_RESULT_TYPE_PREFIX(WriteToken,
       void (boost::system::error_code, std::size_t))
   async_send(const ConstBufferSequence& buffers,
       socket_base::message_flags flags,
-      BOOST_ASIO_MOVE_ARG(WriteHandler) handler)
+      BOOST_ASIO_MOVE_ARG(WriteToken) token
+        BOOST_ASIO_DEFAULT_COMPLETION_TOKEN(executor_type))
+    BOOST_ASIO_INITFN_AUTO_RESULT_TYPE_SUFFIX((
+      async_initiate<WriteToken,
+        void (boost::system::error_code, std::size_t)>(
+          declval<initiate_async_send>(), token, buffers, flags)))
   {
-    return async_initiate<WriteHandler,
+    return async_initiate<WriteToken,
       void (boost::system::error_code, std::size_t)>(
-        initiate_async_send(), handler, this, buffers, flags);
+        initiate_async_send(this), token, buffers, flags);
   }
 
   /// Receive some data on the socket.
@@ -633,25 +694,31 @@ public:
   /// Start an asynchronous receive.
   /**
    * This function is used to asynchronously receive data from the stream
-   * socket. The function call always returns immediately.
+   * socket. It is an initiating function for an @ref asynchronous_operation,
+   * and always returns immediately.
    *
    * @param buffers One or more buffers into which the data will be received.
    * Although the buffers object may be copied as necessary, ownership of the
    * underlying memory blocks is retained by the caller, which must guarantee
-   * that they remain valid until the handler is called.
+   * that they remain valid until the completion handler is called.
    *
-   * @param handler The handler to be called when the receive operation
-   * completes. Copies will be made of the handler as required. The function
-   * signature of the handler must be:
+   * @param token The @ref completion_token that will be used to produce a
+   * completion handler, which will be called when the receive completes.
+   * Potential completion tokens include @ref use_future, @ref use_awaitable,
+   * @ref yield_context, or a function object with the correct completion
+   * signature. The function signature of the completion handler must be:
    * @code void handler(
    *   const boost::system::error_code& error, // Result of operation.
-   *   std::size_t bytes_transferred           // Number of bytes received.
+   *   std::size_t bytes_transferred // Number of bytes received.
    * ); @endcode
    * Regardless of whether the asynchronous operation completes immediately or
-   * not, the handler will not be invoked from within this function. On
-   * immediate completion, invocation of the handler will be performed in a
+   * not, the completion handler will not be invoked from within this function.
+   * On immediate completion, invocation of the handler will be performed in a
    * manner equivalent to using boost::asio::post().
    *
+   * @par Completion Signature
+   * @code void(boost::system::error_code, std::size_t) @endcode
+   *
    * @note The receive operation may not receive all of the requested number of
    * bytes. Consider using the @ref async_read function if you need to ensure
    * that the requested amount of data is received before the asynchronous
@@ -666,43 +733,68 @@ public:
    * See the @ref buffer documentation for information on receiving into
    * multiple buffers in one go, and how to use it with arrays, boost::array or
    * std::vector.
+   *
+   * @par Per-Operation Cancellation
+   * On POSIX or Windows operating systems, this asynchronous operation supports
+   * cancellation for the following boost::asio::cancellation_type values:
+   *
+   * @li @c cancellation_type::terminal
+   *
+   * @li @c cancellation_type::partial
+   *
+   * @li @c cancellation_type::total
    */
-  template <typename MutableBufferSequence, typename ReadHandler>
-  BOOST_ASIO_INITFN_RESULT_TYPE(ReadHandler,
+  template <typename MutableBufferSequence,
+      BOOST_ASIO_COMPLETION_TOKEN_FOR(void (boost::system::error_code,
+        std::size_t)) ReadToken
+          BOOST_ASIO_DEFAULT_COMPLETION_TOKEN_TYPE(executor_type)>
+  BOOST_ASIO_INITFN_AUTO_RESULT_TYPE_PREFIX(ReadToken,
       void (boost::system::error_code, std::size_t))
   async_receive(const MutableBufferSequence& buffers,
-      BOOST_ASIO_MOVE_ARG(ReadHandler) handler)
+      BOOST_ASIO_MOVE_ARG(ReadToken) token
+        BOOST_ASIO_DEFAULT_COMPLETION_TOKEN(executor_type))
+    BOOST_ASIO_INITFN_AUTO_RESULT_TYPE_SUFFIX((
+      async_initiate<ReadToken,
+        void (boost::system::error_code, std::size_t)>(
+          declval<initiate_async_receive>(), token,
+          buffers, socket_base::message_flags(0))))
   {
-    return async_initiate<ReadHandler,
+    return async_initiate<ReadToken,
       void (boost::system::error_code, std::size_t)>(
-        initiate_async_receive(), handler, this,
+        initiate_async_receive(this), token,
         buffers, socket_base::message_flags(0));
   }
 
   /// Start an asynchronous receive.
   /**
    * This function is used to asynchronously receive data from the stream
-   * socket. The function call always returns immediately.
+   * socket. It is an initiating function for an @ref asynchronous_operation,
+   * and always returns immediately.
    *
    * @param buffers One or more buffers into which the data will be received.
    * Although the buffers object may be copied as necessary, ownership of the
    * underlying memory blocks is retained by the caller, which must guarantee
-   * that they remain valid until the handler is called.
+   * that they remain valid until the completion handler is called.
    *
    * @param flags Flags specifying how the receive call is to be made.
    *
-   * @param handler The handler to be called when the receive operation
-   * completes. Copies will be made of the handler as required. The function
-   * signature of the handler must be:
+   * @param token The @ref completion_token that will be used to produce a
+   * completion handler, which will be called when the receive completes.
+   * Potential completion tokens include @ref use_future, @ref use_awaitable,
+   * @ref yield_context, or a function object with the correct completion
+   * signature. The function signature of the completion handler must be:
    * @code void handler(
    *   const boost::system::error_code& error, // Result of operation.
-   *   std::size_t bytes_transferred           // Number of bytes received.
+   *   std::size_t bytes_transferred // Number of bytes received.
    * ); @endcode
    * Regardless of whether the asynchronous operation completes immediately or
-   * not, the handler will not be invoked from within this function. On
-   * immediate completion, invocation of the handler will be performed in a
+   * not, the completion handler will not be invoked from within this function.
+   * On immediate completion, invocation of the handler will be performed in a
    * manner equivalent to using boost::asio::post().
    *
+   * @par Completion Signature
+   * @code void(boost::system::error_code, std::size_t) @endcode
+   *
    * @note The receive operation may not receive all of the requested number of
    * bytes. Consider using the @ref async_read function if you need to ensure
    * that the requested amount of data is received before the asynchronous
@@ -717,17 +809,35 @@ public:
    * See the @ref buffer documentation for information on receiving into
    * multiple buffers in one go, and how to use it with arrays, boost::array or
    * std::vector.
+   *
+   * @par Per-Operation Cancellation
+   * On POSIX or Windows operating systems, this asynchronous operation supports
+   * cancellation for the following boost::asio::cancellation_type values:
+   *
+   * @li @c cancellation_type::terminal
+   *
+   * @li @c cancellation_type::partial
+   *
+   * @li @c cancellation_type::total
    */
-  template <typename MutableBufferSequence, typename ReadHandler>
-  BOOST_ASIO_INITFN_RESULT_TYPE(ReadHandler,
+  template <typename MutableBufferSequence,
+      BOOST_ASIO_COMPLETION_TOKEN_FOR(void (boost::system::error_code,
+        std::size_t)) ReadToken
+          BOOST_ASIO_DEFAULT_COMPLETION_TOKEN_TYPE(executor_type)>
+  BOOST_ASIO_INITFN_AUTO_RESULT_TYPE_PREFIX(ReadToken,
       void (boost::system::error_code, std::size_t))
   async_receive(const MutableBufferSequence& buffers,
       socket_base::message_flags flags,
-      BOOST_ASIO_MOVE_ARG(ReadHandler) handler)
+      BOOST_ASIO_MOVE_ARG(ReadToken) token
+        BOOST_ASIO_DEFAULT_COMPLETION_TOKEN(executor_type))
+    BOOST_ASIO_INITFN_AUTO_RESULT_TYPE_SUFFIX((
+      async_initiate<ReadToken,
+        void (boost::system::error_code, std::size_t)>(
+          declval<initiate_async_receive>(), token, buffers, flags)))
   {
-    return async_initiate<ReadHandler,
+    return async_initiate<ReadToken,
       void (boost::system::error_code, std::size_t)>(
-        initiate_async_receive(), handler, this, buffers, flags);
+        initiate_async_receive(this), token, buffers, flags);
   }
 
   /// Write some data to the socket.
@@ -794,25 +904,31 @@ public:
   /// Start an asynchronous write.
   /**
    * This function is used to asynchronously write data to the stream socket.
-   * The function call always returns immediately.
+   * It is an initiating function for an @ref asynchronous_operation, and always
+   * returns immediately.
    *
    * @param buffers One or more data buffers to be written to the socket.
    * Although the buffers object may be copied as necessary, ownership of the
    * underlying memory blocks is retained by the caller, which must guarantee
-   * that they remain valid until the handler is called.
+   * that they remain valid until the completion handler is called.
    *
-   * @param handler The handler to be called when the write operation completes.
-   * Copies will be made of the handler as required. The function signature of
-   * the handler must be:
+   * @param token The @ref completion_token that will be used to produce a
+   * completion handler, which will be called when the write completes.
+   * Potential completion tokens include @ref use_future, @ref use_awaitable,
+   * @ref yield_context, or a function object with the correct completion
+   * signature. The function signature of the completion handler must be:
    * @code void handler(
    *   const boost::system::error_code& error, // Result of operation.
-   *   std::size_t bytes_transferred           // Number of bytes written.
+   *   std::size_t bytes_transferred // Number of bytes written.
    * ); @endcode
    * Regardless of whether the asynchronous operation completes immediately or
-   * not, the handler will not be invoked from within this function. On
-   * immediate completion, invocation of the handler will be performed in a
+   * not, the completion handler will not be invoked from within this function.
+   * On immediate completion, invocation of the handler will be performed in a
    * manner equivalent to using boost::asio::post().
    *
+   * @par Completion Signature
+   * @code void(boost::system::error_code, std::size_t) @endcode
+   *
    * @note The write operation may not transmit all of the data to the peer.
    * Consider using the @ref async_write function if you need to ensure that all
    * data is written before the asynchronous operation completes.
@@ -825,16 +941,35 @@ public:
    * See the @ref buffer documentation for information on writing multiple
    * buffers in one go, and how to use it with arrays, boost::array or
    * std::vector.
+   *
+   * @par Per-Operation Cancellation
+   * On POSIX or Windows operating systems, this asynchronous operation supports
+   * cancellation for the following boost::asio::cancellation_type values:
+   *
+   * @li @c cancellation_type::terminal
+   *
+   * @li @c cancellation_type::partial
+   *
+   * @li @c cancellation_type::total
    */
-  template <typename ConstBufferSequence, typename WriteHandler>
-  BOOST_ASIO_INITFN_RESULT_TYPE(WriteHandler,
+  template <typename ConstBufferSequence,
+      BOOST_ASIO_COMPLETION_TOKEN_FOR(void (boost::system::error_code,
+        std::size_t)) WriteToken
+          BOOST_ASIO_DEFAULT_COMPLETION_TOKEN_TYPE(executor_type)>
+  BOOST_ASIO_INITFN_AUTO_RESULT_TYPE_PREFIX(WriteToken,
       void (boost::system::error_code, std::size_t))
   async_write_some(const ConstBufferSequence& buffers,
-      BOOST_ASIO_MOVE_ARG(WriteHandler) handler)
+      BOOST_ASIO_MOVE_ARG(WriteToken) token
+        BOOST_ASIO_DEFAULT_COMPLETION_TOKEN(executor_type))
+    BOOST_ASIO_INITFN_AUTO_RESULT_TYPE_SUFFIX((
+      async_initiate<WriteToken,
+        void (boost::system::error_code, std::size_t)>(
+          declval<initiate_async_send>(), token,
+          buffers, socket_base::message_flags(0))))
   {
-    return async_initiate<WriteHandler,
+    return async_initiate<WriteToken,
       void (boost::system::error_code, std::size_t)>(
-        initiate_async_send(), handler, this,
+        initiate_async_send(this), token,
         buffers, socket_base::message_flags(0));
   }
 
@@ -904,25 +1039,31 @@ public:
   /// Start an asynchronous read.
   /**
    * This function is used to asynchronously read data from the stream socket.
-   * The function call always returns immediately.
+   * socket. It is an initiating function for an @ref asynchronous_operation,
+   * and always returns immediately.
    *
    * @param buffers One or more buffers into which the data will be read.
    * Although the buffers object may be copied as necessary, ownership of the
    * underlying memory blocks is retained by the caller, which must guarantee
-   * that they remain valid until the handler is called.
+   * that they remain valid until the completion handler is called.
    *
-   * @param handler The handler to be called when the read operation completes.
-   * Copies will be made of the handler as required. The function signature of
-   * the handler must be:
+   * @param token The @ref completion_token that will be used to produce a
+   * completion handler, which will be called when the read completes.
+   * Potential completion tokens include @ref use_future, @ref use_awaitable,
+   * @ref yield_context, or a function object with the correct completion
+   * signature. The function signature of the completion handler must be:
    * @code void handler(
    *   const boost::system::error_code& error, // Result of operation.
-   *   std::size_t bytes_transferred           // Number of bytes read.
+   *   std::size_t bytes_transferred // Number of bytes read.
    * ); @endcode
    * Regardless of whether the asynchronous operation completes immediately or
-   * not, the handler will not be invoked from within this function. On
-   * immediate completion, invocation of the handler will be performed in a
+   * not, the completion handler will not be invoked from within this function.
+   * On immediate completion, invocation of the handler will be performed in a
    * manner equivalent to using boost::asio::post().
    *
+   * @par Completion Signature
+   * @code void(boost::system::error_code, std::size_t) @endcode
+   *
    * @note The read operation may not read all of the requested number of bytes.
    * Consider using the @ref async_read function if you need to ensure that the
    * requested amount of data is read before the asynchronous operation
@@ -936,25 +1077,61 @@ public:
    * See the @ref buffer documentation for information on reading into multiple
    * buffers in one go, and how to use it with arrays, boost::array or
    * std::vector.
+   *
+   * @par Per-Operation Cancellation
+   * On POSIX or Windows operating systems, this asynchronous operation supports
+   * cancellation for the following boost::asio::cancellation_type values:
+   *
+   * @li @c cancellation_type::terminal
+   *
+   * @li @c cancellation_type::partial
+   *
+   * @li @c cancellation_type::total
    */
-  template <typename MutableBufferSequence, typename ReadHandler>
-  BOOST_ASIO_INITFN_RESULT_TYPE(ReadHandler,
+  template <typename MutableBufferSequence,
+      BOOST_ASIO_COMPLETION_TOKEN_FOR(void (boost::system::error_code,
+        std::size_t)) ReadToken
+          BOOST_ASIO_DEFAULT_COMPLETION_TOKEN_TYPE(executor_type)>
+  BOOST_ASIO_INITFN_AUTO_RESULT_TYPE_PREFIX(ReadToken,
       void (boost::system::error_code, std::size_t))
   async_read_some(const MutableBufferSequence& buffers,
-      BOOST_ASIO_MOVE_ARG(ReadHandler) handler)
+      BOOST_ASIO_MOVE_ARG(ReadToken) token
+        BOOST_ASIO_DEFAULT_COMPLETION_TOKEN(executor_type))
+    BOOST_ASIO_INITFN_AUTO_RESULT_TYPE_SUFFIX((
+      async_initiate<ReadToken,
+        void (boost::system::error_code, std::size_t)>(
+          declval<initiate_async_receive>(), token,
+          buffers, socket_base::message_flags(0))))
   {
-    return async_initiate<ReadHandler,
+    return async_initiate<ReadToken,
       void (boost::system::error_code, std::size_t)>(
-        initiate_async_receive(), handler, this,
+        initiate_async_receive(this), token,
         buffers, socket_base::message_flags(0));
   }
 
 private:
-  struct initiate_async_send
+  // Disallow copying and assignment.
+  basic_stream_socket(const basic_stream_socket&) BOOST_ASIO_DELETED;
+  basic_stream_socket& operator=(const basic_stream_socket&) BOOST_ASIO_DELETED;
+
+  class initiate_async_send
   {
+  public:
+    typedef Executor executor_type;
+
+    explicit initiate_async_send(basic_stream_socket* self)
+      : self_(self)
+    {
+    }
+
+    const executor_type& get_executor() const BOOST_ASIO_NOEXCEPT
+    {
+      return self_->get_executor();
+    }
+
     template <typename WriteHandler, typename ConstBufferSequence>
     void operator()(BOOST_ASIO_MOVE_ARG(WriteHandler) handler,
-        basic_stream_socket* self, const ConstBufferSequence& buffers,
+        const ConstBufferSequence& buffers,
         socket_base::message_flags flags) const
     {
       // If you get an error on the following line it means that your handler
@@ -962,17 +1139,33 @@ private:
       BOOST_ASIO_WRITE_HANDLER_CHECK(WriteHandler, handler) type_check;
 
       detail::non_const_lvalue<WriteHandler> handler2(handler);
-      self->impl_.get_service().async_send(
-          self->impl_.get_implementation(), buffers, flags,
-          handler2.value, self->impl_.get_implementation_executor());
+      self_->impl_.get_service().async_send(
+          self_->impl_.get_implementation(), buffers, flags,
+          handler2.value, self_->impl_.get_executor());
     }
+
+  private:
+    basic_stream_socket* self_;
   };
 
-  struct initiate_async_receive
+  class initiate_async_receive
   {
+  public:
+    typedef Executor executor_type;
+
+    explicit initiate_async_receive(basic_stream_socket* self)
+      : self_(self)
+    {
+    }
+
+    const executor_type& get_executor() const BOOST_ASIO_NOEXCEPT
+    {
+      return self_->get_executor();
+    }
+
     template <typename ReadHandler, typename MutableBufferSequence>
     void operator()(BOOST_ASIO_MOVE_ARG(ReadHandler) handler,
-        basic_stream_socket* self, const MutableBufferSequence& buffers,
+        const MutableBufferSequence& buffers,
         socket_base::message_flags flags) const
     {
       // If you get an error on the following line it means that your handler
@@ -980,10 +1173,13 @@ private:
       BOOST_ASIO_READ_HANDLER_CHECK(ReadHandler, handler) type_check;
 
       detail::non_const_lvalue<ReadHandler> handler2(handler);
-      self->impl_.get_service().async_receive(
-          self->impl_.get_implementation(), buffers, flags,
-          handler2.value, self->impl_.get_implementation_executor());
+      self_->impl_.get_service().async_receive(
+          self_->impl_.get_implementation(), buffers, flags,
+          handler2.value, self_->impl_.get_executor());
     }
+
+  private:
+    basic_stream_socket* self_;
   };
 };
 

linx64/include/boost/asio/basic_streambuf.hpp

@@ -2,7 +2,7 @@
 // basic_streambuf.hpp
 // ~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2019 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2023 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

linx64/include/boost/asio/basic_streambuf_fwd.hpp

@@ -2,7 +2,7 @@
 // basic_streambuf_fwd.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2019 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2023 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

linx64/include/boost/asio/basic_waitable_timer.hpp

@@ -2,7 +2,7 @@
 // basic_waitable_timer.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2019 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2023 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -17,6 +17,7 @@
 
 #include <boost/asio/detail/config.hpp>
 #include <cstddef>
+#include <boost/asio/any_io_executor.hpp>
 #include <boost/asio/detail/chrono_time_traits.hpp>
 #include <boost/asio/detail/deadline_timer_service.hpp>
 #include <boost/asio/detail/handler_type_requirements.hpp>
@@ -24,7 +25,6 @@
 #include <boost/asio/detail/non_const_lvalue.hpp>
 #include <boost/asio/detail/throw_error.hpp>
 #include <boost/asio/error.hpp>
-#include <boost/asio/executor.hpp>
 #include <boost/asio/wait_traits.hpp>
 
 #if defined(BOOST_ASIO_HAS_MOVE)
@@ -42,7 +42,7 @@ namespace asio {
 // Forward declaration with defaulted arguments.
 template <typename Clock,
     typename WaitTraits = boost::asio::wait_traits<Clock>,
-    typename Executor = executor>
+    typename Executor = any_io_executor>
 class basic_waitable_timer;
 
 #endif // !defined(BOOST_ASIO_BASIC_WAITABLE_TIMER_FWD_DECL)
@@ -142,10 +142,21 @@ class basic_waitable_timer;
 template <typename Clock, typename WaitTraits, typename Executor>
 class basic_waitable_timer
 {
+private:
+  class initiate_async_wait;
+
 public:
   /// The type of the executor associated with the object.
   typedef Executor executor_type;
 
+  /// Rebinds the timer type to another executor.
+  template <typename Executor1>
+  struct rebind_executor
+  {
+    /// The timer type when rebound to the specified executor.
+    typedef basic_waitable_timer<Clock, WaitTraits, Executor1> other;
+  };
+
   /// The clock type.
   typedef Clock clock_type;
 
@@ -168,7 +179,7 @@ public:
    * dispatch handlers for any asynchronous operations performed on the timer.
    */
   explicit basic_waitable_timer(const executor_type& ex)
-    : impl_(ex)
+    : impl_(0, ex)
   {
   }
 
@@ -184,10 +195,10 @@ public:
    */
   template <typename ExecutionContext>
   explicit basic_waitable_timer(ExecutionContext& context,
-      typename enable_if<
+      typename constraint<
         is_convertible<ExecutionContext&, execution_context&>::value
-      >::type* = 0)
-    : impl_(context)
+      >::type = 0)
+    : impl_(0, 0, context)
   {
   }
 
@@ -202,7 +213,7 @@ public:
    * as an absolute time.
    */
   basic_waitable_timer(const executor_type& ex, const time_point& expiry_time)
-    : impl_(ex)
+    : impl_(0, ex)
   {
     boost::system::error_code ec;
     impl_.get_service().expires_at(impl_.get_implementation(), expiry_time, ec);
@@ -223,10 +234,10 @@ public:
   template <typename ExecutionContext>
   explicit basic_waitable_timer(ExecutionContext& context,
       const time_point& expiry_time,
-      typename enable_if<
+      typename constraint<
         is_convertible<ExecutionContext&, execution_context&>::value
-      >::type* = 0)
-    : impl_(context)
+      >::type = 0)
+    : impl_(0, 0, context)
   {
     boost::system::error_code ec;
     impl_.get_service().expires_at(impl_.get_implementation(), expiry_time, ec);
@@ -244,7 +255,7 @@ public:
    * now.
    */
   basic_waitable_timer(const executor_type& ex, const duration& expiry_time)
-    : impl_(ex)
+    : impl_(0, ex)
   {
     boost::system::error_code ec;
     impl_.get_service().expires_after(
@@ -266,10 +277,10 @@ public:
   template <typename ExecutionContext>
   explicit basic_waitable_timer(ExecutionContext& context,
       const duration& expiry_time,
-      typename enable_if<
+      typename constraint<
         is_convertible<ExecutionContext&, execution_context&>::value
-      >::type* = 0)
-    : impl_(context)
+      >::type = 0)
+    : impl_(0, 0, context)
   {
     boost::system::error_code ec;
     impl_.get_service().expires_after(
@@ -311,6 +322,54 @@ public:
     impl_ = std::move(other.impl_);
     return *this;
   }
+
+  // All timers have access to each other's implementations.
+  template <typename Clock1, typename WaitTraits1, typename Executor1>
+  friend class basic_waitable_timer;
+
+  /// Move-construct a basic_waitable_timer from another.
+  /**
+   * This constructor moves a timer from one object to another.
+   *
+   * @param other The other basic_waitable_timer object from which the move will
+   * occur.
+   *
+   * @note Following the move, the moved-from object is in the same state as if
+   * constructed using the @c basic_waitable_timer(const executor_type&)
+   * constructor.
+   */
+  template <typename Executor1>
+  basic_waitable_timer(
+      basic_waitable_timer<Clock, WaitTraits, Executor1>&& other,
+      typename constraint<
+        is_convertible<Executor1, Executor>::value
+      >::type = 0)
+    : impl_(std::move(other.impl_))
+  {
+  }
+
+  /// Move-assign a basic_waitable_timer from another.
+  /**
+   * This assignment operator moves a timer from one object to another. Cancels
+   * any outstanding asynchronous operations associated with the target object.
+   *
+   * @param other The other basic_waitable_timer object from which the move will
+   * occur.
+   *
+   * @note Following the move, the moved-from object is in the same state as if
+   * constructed using the @c basic_waitable_timer(const executor_type&)
+   * constructor.
+   */
+  template <typename Executor1>
+  typename constraint<
+    is_convertible<Executor1, Executor>::value,
+    basic_waitable_timer&
+  >::type operator=(basic_waitable_timer<Clock, WaitTraits, Executor1>&& other)
+  {
+    basic_waitable_timer tmp(std::move(other));
+    impl_ = std::move(tmp.impl_);
+    return *this;
+  }
 #endif // defined(BOOST_ASIO_HAS_MOVE) || defined(GENERATING_DOCUMENTATION)
 
   /// Destroys the timer.
@@ -323,7 +382,7 @@ public:
   }
 
   /// Get the executor associated with the object.
-  executor_type get_executor() BOOST_ASIO_NOEXCEPT
+  const executor_type& get_executor() BOOST_ASIO_NOEXCEPT
   {
     return impl_.get_executor();
   }
@@ -671,34 +730,57 @@ public:
   /// Start an asynchronous wait on the timer.
   /**
    * This function may be used to initiate an asynchronous wait against the
-   * timer. It always returns immediately.
+   * timer. It is an initiating function for an @ref asynchronous_operation,
+   * and always returns immediately.
    *
-   * For each call to async_wait(), the supplied handler will be called exactly
-   * once. The handler will be called when:
+   * For each call to async_wait(), the completion handler will be called
+   * exactly once. The completion handler will be called when:
    *
    * @li The timer has expired.
    *
    * @li The timer was cancelled, in which case the handler is passed the error
    * code boost::asio::error::operation_aborted.
    *
-   * @param handler The handler to be called when the timer expires. Copies
-   * will be made of the handler as required. The function signature of the
-   * handler must be:
+   * @param token The @ref completion_token that will be used to produce a
+   * completion handler, which will be called when the timer expires. Potential
+   * completion tokens include @ref use_future, @ref use_awaitable, @ref
+   * yield_context, or a function object with the correct completion signature.
+   * The function signature of the completion handler must be:
    * @code void handler(
    *   const boost::system::error_code& error // Result of operation.
    * ); @endcode
    * Regardless of whether the asynchronous operation completes immediately or
-   * not, the handler will not be invoked from within this function. On
-   * immediate completion, invocation of the handler will be performed in a
+   * not, the completion handler will not be invoked from within this function.
+   * On immediate completion, invocation of the handler will be performed in a
    * manner equivalent to using boost::asio::post().
+   *
+   * @par Completion Signature
+   * @code void(boost::system::error_code) @endcode
+   *
+   * @par Per-Operation Cancellation
+   * This asynchronous operation supports cancellation for the following
+   * boost::asio::cancellation_type values:
+   *
+   * @li @c cancellation_type::terminal
+   *
+   * @li @c cancellation_type::partial
+   *
+   * @li @c cancellation_type::total
    */
-  template <typename WaitHandler>
-  BOOST_ASIO_INITFN_RESULT_TYPE(WaitHandler,
-      void (boost::system::error_code))
-  async_wait(BOOST_ASIO_MOVE_ARG(WaitHandler) handler)
+  template <
+      BOOST_ASIO_COMPLETION_TOKEN_FOR(void (boost::system::error_code))
+        WaitToken BOOST_ASIO_DEFAULT_COMPLETION_TOKEN_TYPE(executor_type)>
+  BOOST_ASIO_INITFN_AUTO_RESULT_TYPE_PREFIX(
+      WaitToken, void (boost::system::error_code))
+  async_wait(
+      BOOST_ASIO_MOVE_ARG(WaitToken) token
+        BOOST_ASIO_DEFAULT_COMPLETION_TOKEN(executor_type))
+    BOOST_ASIO_INITFN_AUTO_RESULT_TYPE_SUFFIX((
+      async_initiate<WaitToken, void (boost::system::error_code)>(
+          declval<initiate_async_wait>(), token)))
   {
-    return async_initiate<WaitHandler, void (boost::system::error_code)>(
-        initiate_async_wait(), handler, this);
+    return async_initiate<WaitToken, void (boost::system::error_code)>(
+        initiate_async_wait(this), token);
   }
 
 private:
@@ -707,21 +789,36 @@ private:
   basic_waitable_timer& operator=(
       const basic_waitable_timer&) BOOST_ASIO_DELETED;
 
-  struct initiate_async_wait
+  class initiate_async_wait
   {
+  public:
+    typedef Executor executor_type;
+
+    explicit initiate_async_wait(basic_waitable_timer* self)
+      : self_(self)
+    {
+    }
+
+    const executor_type& get_executor() const BOOST_ASIO_NOEXCEPT
+    {
+      return self_->get_executor();
+    }
+
     template <typename WaitHandler>
-    void operator()(BOOST_ASIO_MOVE_ARG(WaitHandler) handler,
-        basic_waitable_timer* self) const
+    void operator()(BOOST_ASIO_MOVE_ARG(WaitHandler) handler) const
     {
       // If you get an error on the following line it means that your handler
       // does not meet the documented type requirements for a WaitHandler.
       BOOST_ASIO_WAIT_HANDLER_CHECK(WaitHandler, handler) type_check;
 
       detail::non_const_lvalue<WaitHandler> handler2(handler);
-      self->impl_.get_service().async_wait(
-          self->impl_.get_implementation(), handler2.value,
-          self->impl_.get_implementation_executor());
+      self_->impl_.get_service().async_wait(
+          self_->impl_.get_implementation(),
+          handler2.value, self_->impl_.get_executor());
     }
+
+  private:
+    basic_waitable_timer* self_;
   };
 
   detail::io_object_impl<

linx64/include/boost/asio/basic_writable_pipe.hpp

@@ -0,0 +1,633 @@
+//
+// basic_writable_pipe.hpp
+// ~~~~~~~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2023 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef BOOST_ASIO_BASIC_WRITABLE_PIPE_HPP
+#define BOOST_ASIO_BASIC_WRITABLE_PIPE_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include <boost/asio/detail/config.hpp>
+
+#if defined(BOOST_ASIO_HAS_PIPE) \
+  || defined(GENERATING_DOCUMENTATION)
+
+#include <string>
+#include <boost/asio/any_io_executor.hpp>
+#include <boost/asio/async_result.hpp>
+#include <boost/asio/detail/handler_type_requirements.hpp>
+#include <boost/asio/detail/io_object_impl.hpp>
+#include <boost/asio/detail/non_const_lvalue.hpp>
+#include <boost/asio/detail/throw_error.hpp>
+#include <boost/asio/detail/type_traits.hpp>
+#include <boost/asio/error.hpp>
+#include <boost/asio/execution_context.hpp>
+#if defined(BOOST_ASIO_HAS_IOCP)
+# include <boost/asio/detail/win_iocp_handle_service.hpp>
+#elif defined(BOOST_ASIO_HAS_IO_URING_AS_DEFAULT)
+# include <boost/asio/detail/io_uring_descriptor_service.hpp>
+#else
+# include <boost/asio/detail/reactive_descriptor_service.hpp>
+#endif
+
+#if defined(BOOST_ASIO_HAS_MOVE)
+# include <utility>
+#endif // defined(BOOST_ASIO_HAS_MOVE)
+
+#include <boost/asio/detail/push_options.hpp>
+
+namespace boost {
+namespace asio {
+
+/// Provides pipe functionality.
+/**
+ * The basic_writable_pipe class provides a wrapper over pipe
+ * functionality.
+ *
+ * @par Thread Safety
+ * @e Distinct @e objects: Safe.@n
+ * @e Shared @e objects: Unsafe.
+ */
+template <typename Executor = any_io_executor>
+class basic_writable_pipe
+{
+private:
+  class initiate_async_write_some;
+
+public:
+  /// The type of the executor associated with the object.
+  typedef Executor executor_type;
+
+  /// Rebinds the pipe type to another executor.
+  template <typename Executor1>
+  struct rebind_executor
+  {
+    /// The pipe type when rebound to the specified executor.
+    typedef basic_writable_pipe<Executor1> other;
+  };
+
+  /// The native representation of a pipe.
+#if defined(GENERATING_DOCUMENTATION)
+  typedef implementation_defined native_handle_type;
+#elif defined(BOOST_ASIO_HAS_IOCP)
+  typedef detail::win_iocp_handle_service::native_handle_type
+    native_handle_type;
+#elif defined(BOOST_ASIO_HAS_IO_URING_AS_DEFAULT)
+  typedef detail::io_uring_descriptor_service::native_handle_type
+    native_handle_type;
+#else
+  typedef detail::reactive_descriptor_service::native_handle_type
+    native_handle_type;
+#endif
+
+  /// A basic_writable_pipe is always the lowest layer.
+  typedef basic_writable_pipe lowest_layer_type;
+
+  /// Construct a basic_writable_pipe without opening it.
+  /**
+   * This constructor creates a pipe without opening it.
+   *
+   * @param ex The I/O executor that the pipe will use, by default, to dispatch
+   * handlers for any asynchronous operations performed on the pipe.
+   */
+  explicit basic_writable_pipe(const executor_type& ex)
+    : impl_(0, ex)
+  {
+  }
+
+  /// Construct a basic_writable_pipe without opening it.
+  /**
+   * This constructor creates a pipe without opening it.
+   *
+   * @param context An execution context which provides the I/O executor that
+   * the pipe will use, by default, to dispatch handlers for any asynchronous
+   * operations performed on the pipe.
+   */
+  template <typename ExecutionContext>
+  explicit basic_writable_pipe(ExecutionContext& context,
+      typename constraint<
+        is_convertible<ExecutionContext&, execution_context&>::value,
+        defaulted_constraint
+      >::type = defaulted_constraint())
+    : impl_(0, 0, context)
+  {
+  }
+
+  /// Construct a basic_writable_pipe on an existing native pipe.
+  /**
+   * This constructor creates a pipe object to hold an existing native
+   * pipe.
+   *
+   * @param ex The I/O executor that the pipe will use, by default, to
+   * dispatch handlers for any asynchronous operations performed on the
+   * pipe.
+   *
+   * @param native_pipe A native pipe.
+   *
+   * @throws boost::system::system_error Thrown on failure.
+   */
+  basic_writable_pipe(const executor_type& ex,
+      const native_handle_type& native_pipe)
+    : impl_(0, ex)
+  {
+    boost::system::error_code ec;
+    impl_.get_service().assign(impl_.get_implementation(),
+        native_pipe, ec);
+    boost::asio::detail::throw_error(ec, "assign");
+  }
+
+  /// Construct a basic_writable_pipe on an existing native pipe.
+  /**
+   * This constructor creates a pipe object to hold an existing native
+   * pipe.
+   *
+   * @param context An execution context which provides the I/O executor that
+   * the pipe will use, by default, to dispatch handlers for any
+   * asynchronous operations performed on the pipe.
+   *
+   * @param native_pipe A native pipe.
+   *
+   * @throws boost::system::system_error Thrown on failure.
+   */
+  template <typename ExecutionContext>
+  basic_writable_pipe(ExecutionContext& context,
+      const native_handle_type& native_pipe,
+      typename constraint<
+        is_convertible<ExecutionContext&, execution_context&>::value
+      >::type = 0)
+    : impl_(0, 0, context)
+  {
+    boost::system::error_code ec;
+    impl_.get_service().assign(impl_.get_implementation(),
+        native_pipe, ec);
+    boost::asio::detail::throw_error(ec, "assign");
+  }
+
+#if defined(BOOST_ASIO_HAS_MOVE) || defined(GENERATING_DOCUMENTATION)
+  /// Move-construct a basic_writable_pipe from another.
+  /**
+   * This constructor moves a pipe from one object to another.
+   *
+   * @param other The other basic_writable_pipe object from which the move will
+   * occur.
+   *
+   * @note Following the move, the moved-from object is in the same state as if
+   * constructed using the @c basic_writable_pipe(const executor_type&)
+   * constructor.
+   */
+  basic_writable_pipe(basic_writable_pipe&& other)
+    : impl_(std::move(other.impl_))
+  {
+  }
+
+  /// Move-assign a basic_writable_pipe from another.
+  /**
+   * This assignment operator moves a pipe from one object to another.
+   *
+   * @param other The other basic_writable_pipe object from which the move will
+   * occur.
+   *
+   * @note Following the move, the moved-from object is in the same state as if
+   * constructed using the @c basic_writable_pipe(const executor_type&)
+   * constructor.
+   */
+  basic_writable_pipe& operator=(basic_writable_pipe&& other)
+  {
+    impl_ = std::move(other.impl_);
+    return *this;
+  }
+
+  // All pipes have access to each other's implementations.
+  template <typename Executor1>
+  friend class basic_writable_pipe;
+
+  /// Move-construct a basic_writable_pipe from a pipe of another executor type.
+  /**
+   * This constructor moves a pipe from one object to another.
+   *
+   * @param other The other basic_writable_pipe object from which the move will
+   * occur.
+   *
+   * @note Following the move, the moved-from object is in the same state as if
+   * constructed using the @c basic_writable_pipe(const executor_type&)
+   * constructor.
+   */
+  template <typename Executor1>
+  basic_writable_pipe(basic_writable_pipe<Executor1>&& other,
+      typename constraint<
+        is_convertible<Executor1, Executor>::value,
+        defaulted_constraint
+      >::type = defaulted_constraint())
+    : impl_(std::move(other.impl_))
+  {
+  }
+
+  /// Move-assign a basic_writable_pipe from a pipe of another executor type.
+  /**
+   * This assignment operator moves a pipe from one object to another.
+   *
+   * @param other The other basic_writable_pipe object from which the move will
+   * occur.
+   *
+   * @note Following the move, the moved-from object is in the same state as if
+   * constructed using the @c basic_writable_pipe(const executor_type&)
+   * constructor.
+   */
+  template <typename Executor1>
+  typename constraint<
+    is_convertible<Executor1, Executor>::value,
+    basic_writable_pipe&
+  >::type operator=(basic_writable_pipe<Executor1>&& other)
+  {
+    basic_writable_pipe tmp(std::move(other));
+    impl_ = std::move(tmp.impl_);
+    return *this;
+  }
+#endif // defined(BOOST_ASIO_HAS_MOVE) || defined(GENERATING_DOCUMENTATION)
+
+  /// Destroys the pipe.
+  /**
+   * This function destroys the pipe, cancelling any outstanding
+   * asynchronous wait operations associated with the pipe as if by
+   * calling @c cancel.
+   */
+  ~basic_writable_pipe()
+  {
+  }
+
+  /// Get the executor associated with the object.
+  const executor_type& get_executor() BOOST_ASIO_NOEXCEPT
+  {
+    return impl_.get_executor();
+  }
+
+  /// Get a reference to the lowest layer.
+  /**
+   * This function returns a reference to the lowest layer in a stack of
+   * layers. Since a basic_writable_pipe cannot contain any further layers, it
+   * simply returns a reference to itself.
+   *
+   * @return A reference to the lowest layer in the stack of layers. Ownership
+   * is not transferred to the caller.
+   */
+  lowest_layer_type& lowest_layer()
+  {
+    return *this;
+  }
+
+  /// Get a const reference to the lowest layer.
+  /**
+   * This function returns a const reference to the lowest layer in a stack of
+   * layers. Since a basic_writable_pipe cannot contain any further layers, it
+   * simply returns a reference to itself.
+   *
+   * @return A const reference to the lowest layer in the stack of layers.
+   * Ownership is not transferred to the caller.
+   */
+  const lowest_layer_type& lowest_layer() const
+  {
+    return *this;
+  }
+
+  /// Assign an existing native pipe to the pipe.
+  /*
+   * This function opens the pipe to hold an existing native pipe.
+   *
+   * @param native_pipe A native pipe.
+   *
+   * @throws boost::system::system_error Thrown on failure.
+   */
+  void assign(const native_handle_type& native_pipe)
+  {
+    boost::system::error_code ec;
+    impl_.get_service().assign(impl_.get_implementation(), native_pipe, ec);
+    boost::asio::detail::throw_error(ec, "assign");
+  }
+
+  /// Assign an existing native pipe to the pipe.
+  /*
+   * This function opens the pipe to hold an existing native pipe.
+   *
+   * @param native_pipe A native pipe.
+   *
+   * @param ec Set to indicate what error occurred, if any.
+   */
+  BOOST_ASIO_SYNC_OP_VOID assign(const native_handle_type& native_pipe,
+      boost::system::error_code& ec)
+  {
+    impl_.get_service().assign(impl_.get_implementation(), native_pipe, ec);
+    BOOST_ASIO_SYNC_OP_VOID_RETURN(ec);
+  }
+
+  /// Determine whether the pipe is open.
+  bool is_open() const
+  {
+    return impl_.get_service().is_open(impl_.get_implementation());
+  }
+
+  /// Close the pipe.
+  /**
+   * This function is used to close the pipe. Any asynchronous write operations
+   * will be cancelled immediately, and will complete with the
+   * boost::asio::error::operation_aborted error.
+   *
+   * @throws boost::system::system_error Thrown on failure.
+   */
+  void close()
+  {
+    boost::system::error_code ec;
+    impl_.get_service().close(impl_.get_implementation(), ec);
+    boost::asio::detail::throw_error(ec, "close");
+  }
+
+  /// Close the pipe.
+  /**
+   * This function is used to close the pipe. Any asynchronous write operations
+   * will be cancelled immediately, and will complete with the
+   * boost::asio::error::operation_aborted error.
+   *
+   * @param ec Set to indicate what error occurred, if any.
+   */
+  BOOST_ASIO_SYNC_OP_VOID close(boost::system::error_code& ec)
+  {
+    impl_.get_service().close(impl_.get_implementation(), ec);
+    BOOST_ASIO_SYNC_OP_VOID_RETURN(ec);
+  }
+
+  /// Release ownership of the underlying native pipe.
+  /**
+   * This function causes all outstanding asynchronous write operations to
+   * finish immediately, and the handlers for cancelled operations will be
+   * passed the boost::asio::error::operation_aborted error. Ownership of the
+   * native pipe is then transferred to the caller.
+   *
+   * @throws boost::system::system_error Thrown on failure.
+   *
+   * @note This function is unsupported on Windows versions prior to Windows
+   * 8.1, and will fail with boost::asio::error::operation_not_supported on
+   * these platforms.
+   */
+#if defined(BOOST_ASIO_MSVC) && (BOOST_ASIO_MSVC >= 1400) \
+  && (!defined(_WIN32_WINNT) || _WIN32_WINNT < 0x0603)
+  __declspec(deprecated("This function always fails with "
+        "operation_not_supported when used on Windows versions "
+        "prior to Windows 8.1."))
+#endif
+  native_handle_type release()
+  {
+    boost::system::error_code ec;
+    native_handle_type s = impl_.get_service().release(
+        impl_.get_implementation(), ec);
+    boost::asio::detail::throw_error(ec, "release");
+    return s;
+  }
+
+  /// Release ownership of the underlying native pipe.
+  /**
+   * This function causes all outstanding asynchronous write operations to
+   * finish immediately, and the handlers for cancelled operations will be
+   * passed the boost::asio::error::operation_aborted error. Ownership of the
+   * native pipe is then transferred to the caller.
+   *
+   * @param ec Set to indicate what error occurred, if any.
+   *
+   * @note This function is unsupported on Windows versions prior to Windows
+   * 8.1, and will fail with boost::asio::error::operation_not_supported on
+   * these platforms.
+   */
+#if defined(BOOST_ASIO_MSVC) && (BOOST_ASIO_MSVC >= 1400) \
+  && (!defined(_WIN32_WINNT) || _WIN32_WINNT < 0x0603)
+  __declspec(deprecated("This function always fails with "
+        "operation_not_supported when used on Windows versions "
+        "prior to Windows 8.1."))
+#endif
+  native_handle_type release(boost::system::error_code& ec)
+  {
+    return impl_.get_service().release(impl_.get_implementation(), ec);
+  }
+
+  /// Get the native pipe representation.
+  /**
+   * This function may be used to obtain the underlying representation of the
+   * pipe. This is intended to allow access to native pipe
+   * functionality that is not otherwise provided.
+   */
+  native_handle_type native_handle()
+  {
+    return impl_.get_service().native_handle(impl_.get_implementation());
+  }
+
+  /// Cancel all asynchronous operations associated with the pipe.
+  /**
+   * This function causes all outstanding asynchronous write operations to
+   * finish immediately, and the handlers for cancelled operations will be
+   * passed the boost::asio::error::operation_aborted error.
+   *
+   * @throws boost::system::system_error Thrown on failure.
+   */
+  void cancel()
+  {
+    boost::system::error_code ec;
+    impl_.get_service().cancel(impl_.get_implementation(), ec);
+    boost::asio::detail::throw_error(ec, "cancel");
+  }
+
+  /// Cancel all asynchronous operations associated with the pipe.
+  /**
+   * This function causes all outstanding asynchronous write operations to
+   * finish immediately, and the handlers for cancelled operations will be
+   * passed the boost::asio::error::operation_aborted error.
+   *
+   * @param ec Set to indicate what error occurred, if any.
+   */
+  BOOST_ASIO_SYNC_OP_VOID cancel(boost::system::error_code& ec)
+  {
+    impl_.get_service().cancel(impl_.get_implementation(), ec);
+    BOOST_ASIO_SYNC_OP_VOID_RETURN(ec);
+  }
+
+  /// Write some data to the pipe.
+  /**
+   * This function is used to write data to the pipe. The function call will
+   * block until one or more bytes of the data has been written successfully,
+   * or until an error occurs.
+   *
+   * @param buffers One or more data buffers to be written to the pipe.
+   *
+   * @returns The number of bytes written.
+   *
+   * @throws boost::system::system_error Thrown on failure. An error code of
+   * boost::asio::error::eof indicates that the connection was closed by the
+   * peer.
+   *
+   * @note The write_some operation may not transmit all of the data to the
+   * peer. Consider using the @ref write function if you need to ensure that
+   * all data is written before the blocking operation completes.
+   *
+   * @par Example
+   * To write a single data buffer use the @ref buffer function as follows:
+   * @code
+   * pipe.write_some(boost::asio::buffer(data, size));
+   * @endcode
+   * See the @ref buffer documentation for information on writing multiple
+   * buffers in one go, and how to use it with arrays, boost::array or
+   * std::vector.
+   */
+  template <typename ConstBufferSequence>
+  std::size_t write_some(const ConstBufferSequence& buffers)
+  {
+    boost::system::error_code ec;
+    std::size_t s = impl_.get_service().write_some(
+        impl_.get_implementation(), buffers, ec);
+    boost::asio::detail::throw_error(ec, "write_some");
+    return s;
+  }
+
+  /// Write some data to the pipe.
+  /**
+   * This function is used to write data to the pipe. The function call will
+   * block until one or more bytes of the data has been written successfully,
+   * or until an error occurs.
+   *
+   * @param buffers One or more data buffers to be written to the pipe.
+   *
+   * @param ec Set to indicate what error occurred, if any.
+   *
+   * @returns The number of bytes written. Returns 0 if an error occurred.
+   *
+   * @note The write_some operation may not transmit all of the data to the
+   * peer. Consider using the @ref write function if you need to ensure that
+   * all data is written before the blocking operation completes.
+   */
+  template <typename ConstBufferSequence>
+  std::size_t write_some(const ConstBufferSequence& buffers,
+      boost::system::error_code& ec)
+  {
+    return impl_.get_service().write_some(
+        impl_.get_implementation(), buffers, ec);
+  }
+
+  /// Start an asynchronous write.
+  /**
+   * This function is used to asynchronously write data to the pipe. It is an
+   * initiating function for an @ref asynchronous_operation, and always returns
+   * immediately.
+   *
+   * @param buffers One or more data buffers to be written to the pipe.
+   * Although the buffers object may be copied as necessary, ownership of the
+   * underlying memory blocks is retained by the caller, which must guarantee
+   * that they remain valid until the completion handler is called.
+   *
+   * @param token The @ref completion_token that will be used to produce a
+   * completion handler, which will be called when the write completes.
+   * Potential completion tokens include @ref use_future, @ref use_awaitable,
+   * @ref yield_context, or a function object with the correct completion
+   * signature. The function signature of the completion handler must be:
+   * @code void handler(
+   *   const boost::system::error_code& error, // Result of operation.
+   *   std::size_t bytes_transferred // Number of bytes written.
+   * ); @endcode
+   * Regardless of whether the asynchronous operation completes immediately or
+   * not, the completion handler will not be invoked from within this function.
+   * On immediate completion, invocation of the handler will be performed in a
+   * manner equivalent to using boost::asio::post().
+   *
+   * @par Completion Signature
+   * @code void(boost::system::error_code, std::size_t) @endcode
+   *
+   * @note The write operation may not transmit all of the data to the peer.
+   * Consider using the @ref async_write function if you need to ensure that all
+   * data is written before the asynchronous operation completes.
+   *
+   * @par Example
+   * To write a single data buffer use the @ref buffer function as follows:
+   * @code
+   * pipe.async_write_some(boost::asio::buffer(data, size), handler);
+   * @endcode
+   * See the @ref buffer documentation for information on writing multiple
+   * buffers in one go, and how to use it with arrays, boost::array or
+   * std::vector.
+   */
+  template <typename ConstBufferSequence,
+      BOOST_ASIO_COMPLETION_TOKEN_FOR(void (boost::system::error_code,
+        std::size_t)) WriteToken
+          BOOST_ASIO_DEFAULT_COMPLETION_TOKEN_TYPE(executor_type)>
+  BOOST_ASIO_INITFN_AUTO_RESULT_TYPE_PREFIX(WriteToken,
+      void (boost::system::error_code, std::size_t))
+  async_write_some(const ConstBufferSequence& buffers,
+      BOOST_ASIO_MOVE_ARG(WriteToken) token
+        BOOST_ASIO_DEFAULT_COMPLETION_TOKEN(executor_type))
+    BOOST_ASIO_INITFN_AUTO_RESULT_TYPE_SUFFIX((
+      async_initiate<WriteToken,
+        void (boost::system::error_code, std::size_t)>(
+          declval<initiate_async_write_some>(), token, buffers)))
+  {
+    return async_initiate<WriteToken,
+      void (boost::system::error_code, std::size_t)>(
+        initiate_async_write_some(this), token, buffers);
+  }
+
+private:
+  // Disallow copying and assignment.
+  basic_writable_pipe(const basic_writable_pipe&) BOOST_ASIO_DELETED;
+  basic_writable_pipe& operator=(const basic_writable_pipe&) BOOST_ASIO_DELETED;
+
+  class initiate_async_write_some
+  {
+  public:
+    typedef Executor executor_type;
+
+    explicit initiate_async_write_some(basic_writable_pipe* self)
+      : self_(self)
+    {
+    }
+
+    const executor_type& get_executor() const BOOST_ASIO_NOEXCEPT
+    {
+      return self_->get_executor();
+    }
+
+    template <typename WriteHandler, typename ConstBufferSequence>
+    void operator()(BOOST_ASIO_MOVE_ARG(WriteHandler) handler,
+        const ConstBufferSequence& buffers) const
+    {
+      // If you get an error on the following line it means that your handler
+      // does not meet the documented type requirements for a WriteHandler.
+      BOOST_ASIO_WRITE_HANDLER_CHECK(WriteHandler, handler) type_check;
+
+      detail::non_const_lvalue<WriteHandler> handler2(handler);
+      self_->impl_.get_service().async_write_some(
+          self_->impl_.get_implementation(), buffers,
+          handler2.value, self_->impl_.get_executor());
+    }
+
+  private:
+    basic_writable_pipe* self_;
+  };
+
+#if defined(BOOST_ASIO_HAS_IOCP)
+  detail::io_object_impl<detail::win_iocp_handle_service, Executor> impl_;
+#elif defined(BOOST_ASIO_HAS_IO_URING_AS_DEFAULT)
+  detail::io_object_impl<detail::io_uring_descriptor_service, Executor> impl_;
+#else
+  detail::io_object_impl<detail::reactive_descriptor_service, Executor> impl_;
+#endif
+};
+
+} // namespace asio
+} // namespace boost
+
+#include <boost/asio/detail/pop_options.hpp>
+
+#endif // defined(BOOST_ASIO_HAS_PIPE)
+       //   || defined(GENERATING_DOCUMENTATION)
+
+#endif // BOOST_ASIO_BASIC_WRITABLE_PIPE_HPP

linx64/include/boost/asio/bind_allocator.hpp

@@ -0,0 +1,751 @@
+//
+// bind_allocator.hpp
+// ~~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2023 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef BOOST_ASIO_BIND_ALLOCATOR_HPP
+#define BOOST_ASIO_BIND_ALLOCATOR_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include <boost/asio/detail/config.hpp>
+#include <boost/asio/detail/type_traits.hpp>
+#include <boost/asio/detail/variadic_templates.hpp>
+#include <boost/asio/associated_allocator.hpp>
+#include <boost/asio/associator.hpp>
+#include <boost/asio/async_result.hpp>
+
+#include <boost/asio/detail/push_options.hpp>
+
+namespace boost {
+namespace asio {
+namespace detail {
+
+// Helper to automatically define nested typedef result_type.
+
+template <typename T, typename = void>
+struct allocator_binder_result_type
+{
+protected:
+  typedef void result_type_or_void;
+};
+
+template <typename T>
+struct allocator_binder_result_type<T,
+  typename void_type<typename T::result_type>::type>
+{
+  typedef typename T::result_type result_type;
+protected:
+  typedef result_type result_type_or_void;
+};
+
+template <typename R>
+struct allocator_binder_result_type<R(*)()>
+{
+  typedef R result_type;
+protected:
+  typedef result_type result_type_or_void;
+};
+
+template <typename R>
+struct allocator_binder_result_type<R(&)()>
+{
+  typedef R result_type;
+protected:
+  typedef result_type result_type_or_void;
+};
+
+template <typename R, typename A1>
+struct allocator_binder_result_type<R(*)(A1)>
+{
+  typedef R result_type;
+protected:
+  typedef result_type result_type_or_void;
+};
+
+template <typename R, typename A1>
+struct allocator_binder_result_type<R(&)(A1)>
+{
+  typedef R result_type;
+protected:
+  typedef result_type result_type_or_void;
+};
+
+template <typename R, typename A1, typename A2>
+struct allocator_binder_result_type<R(*)(A1, A2)>
+{
+  typedef R result_type;
+protected:
+  typedef result_type result_type_or_void;
+};
+
+template <typename R, typename A1, typename A2>
+struct allocator_binder_result_type<R(&)(A1, A2)>
+{
+  typedef R result_type;
+protected:
+  typedef result_type result_type_or_void;
+};
+
+// Helper to automatically define nested typedef argument_type.
+
+template <typename T, typename = void>
+struct allocator_binder_argument_type {};
+
+template <typename T>
+struct allocator_binder_argument_type<T,
+  typename void_type<typename T::argument_type>::type>
+{
+  typedef typename T::argument_type argument_type;
+};
+
+template <typename R, typename A1>
+struct allocator_binder_argument_type<R(*)(A1)>
+{
+  typedef A1 argument_type;
+};
+
+template <typename R, typename A1>
+struct allocator_binder_argument_type<R(&)(A1)>
+{
+  typedef A1 argument_type;
+};
+
+// Helper to automatically define nested typedefs first_argument_type and
+// second_argument_type.
+
+template <typename T, typename = void>
+struct allocator_binder_argument_types {};
+
+template <typename T>
+struct allocator_binder_argument_types<T,
+  typename void_type<typename T::first_argument_type>::type>
+{
+  typedef typename T::first_argument_type first_argument_type;
+  typedef typename T::second_argument_type second_argument_type;
+};
+
+template <typename R, typename A1, typename A2>
+struct allocator_binder_argument_type<R(*)(A1, A2)>
+{
+  typedef A1 first_argument_type;
+  typedef A2 second_argument_type;
+};
+
+template <typename R, typename A1, typename A2>
+struct allocator_binder_argument_type<R(&)(A1, A2)>
+{
+  typedef A1 first_argument_type;
+  typedef A2 second_argument_type;
+};
+
+// Helper to enable SFINAE on zero-argument operator() below.
+
+template <typename T, typename = void>
+struct allocator_binder_result_of0
+{
+  typedef void type;
+};
+
+template <typename T>
+struct allocator_binder_result_of0<T,
+  typename void_type<typename result_of<T()>::type>::type>
+{
+  typedef typename result_of<T()>::type type;
+};
+
+} // namespace detail
+
+/// A call wrapper type to bind an allocator of type @c Allocator
+/// to an object of type @c T.
+template <typename T, typename Allocator>
+class allocator_binder
+#if !defined(GENERATING_DOCUMENTATION)
+  : public detail::allocator_binder_result_type<T>,
+    public detail::allocator_binder_argument_type<T>,
+    public detail::allocator_binder_argument_types<T>
+#endif // !defined(GENERATING_DOCUMENTATION)
+{
+public:
+  /// The type of the target object.
+  typedef T target_type;
+
+  /// The type of the associated allocator.
+  typedef Allocator allocator_type;
+
+#if defined(GENERATING_DOCUMENTATION)
+  /// The return type if a function.
+  /**
+   * The type of @c result_type is based on the type @c T of the wrapper's
+   * target object:
+   *
+   * @li if @c T is a pointer to function type, @c result_type is a synonym for
+   * the return type of @c T;
+   *
+   * @li if @c T is a class type with a member type @c result_type, then @c
+   * result_type is a synonym for @c T::result_type;
+   *
+   * @li otherwise @c result_type is not defined.
+   */
+  typedef see_below result_type;
+
+  /// The type of the function's argument.
+  /**
+   * The type of @c argument_type is based on the type @c T of the wrapper's
+   * target object:
+   *
+   * @li if @c T is a pointer to a function type accepting a single argument,
+   * @c argument_type is a synonym for the return type of @c T;
+   *
+   * @li if @c T is a class type with a member type @c argument_type, then @c
+   * argument_type is a synonym for @c T::argument_type;
+   *
+   * @li otherwise @c argument_type is not defined.
+   */
+  typedef see_below argument_type;
+
+  /// The type of the function's first argument.
+  /**
+   * The type of @c first_argument_type is based on the type @c T of the
+   * wrapper's target object:
+   *
+   * @li if @c T is a pointer to a function type accepting two arguments, @c
+   * first_argument_type is a synonym for the return type of @c T;
+   *
+   * @li if @c T is a class type with a member type @c first_argument_type,
+   * then @c first_argument_type is a synonym for @c T::first_argument_type;
+   *
+   * @li otherwise @c first_argument_type is not defined.
+   */
+  typedef see_below first_argument_type;
+
+  /// The type of the function's second argument.
+  /**
+   * The type of @c second_argument_type is based on the type @c T of the
+   * wrapper's target object:
+   *
+   * @li if @c T is a pointer to a function type accepting two arguments, @c
+   * second_argument_type is a synonym for the return type of @c T;
+   *
+   * @li if @c T is a class type with a member type @c first_argument_type,
+   * then @c second_argument_type is a synonym for @c T::second_argument_type;
+   *
+   * @li otherwise @c second_argument_type is not defined.
+   */
+  typedef see_below second_argument_type;
+#endif // defined(GENERATING_DOCUMENTATION)
+
+  /// Construct an allocator wrapper for the specified object.
+  /**
+   * This constructor is only valid if the type @c T is constructible from type
+   * @c U.
+   */
+  template <typename U>
+  allocator_binder(const allocator_type& s,
+      BOOST_ASIO_MOVE_ARG(U) u)
+    : allocator_(s),
+      target_(BOOST_ASIO_MOVE_CAST(U)(u))
+  {
+  }
+
+  /// Copy constructor.
+  allocator_binder(const allocator_binder& other)
+    : allocator_(other.get_allocator()),
+      target_(other.get())
+  {
+  }
+
+  /// Construct a copy, but specify a different allocator.
+  allocator_binder(const allocator_type& s,
+      const allocator_binder& other)
+    : allocator_(s),
+      target_(other.get())
+  {
+  }
+
+  /// Construct a copy of a different allocator wrapper type.
+  /**
+   * This constructor is only valid if the @c Allocator type is
+   * constructible from type @c OtherAllocator, and the type @c T is
+   * constructible from type @c U.
+   */
+  template <typename U, typename OtherAllocator>
+  allocator_binder(
+      const allocator_binder<U, OtherAllocator>& other)
+    : allocator_(other.get_allocator()),
+      target_(other.get())
+  {
+  }
+
+  /// Construct a copy of a different allocator wrapper type, but
+  /// specify a different allocator.
+  /**
+   * This constructor is only valid if the type @c T is constructible from type
+   * @c U.
+   */
+  template <typename U, typename OtherAllocator>
+  allocator_binder(const allocator_type& s,
+      const allocator_binder<U, OtherAllocator>& other)
+    : allocator_(s),
+      target_(other.get())
+  {
+  }
+
+#if defined(BOOST_ASIO_HAS_MOVE) || defined(GENERATING_DOCUMENTATION)
+
+  /// Move constructor.
+  allocator_binder(allocator_binder&& other)
+    : allocator_(BOOST_ASIO_MOVE_CAST(allocator_type)(
+          other.get_allocator())),
+      target_(BOOST_ASIO_MOVE_CAST(T)(other.get()))
+  {
+  }
+
+  /// Move construct the target object, but specify a different allocator.
+  allocator_binder(const allocator_type& s,
+      allocator_binder&& other)
+    : allocator_(s),
+      target_(BOOST_ASIO_MOVE_CAST(T)(other.get()))
+  {
+  }
+
+  /// Move construct from a different allocator wrapper type.
+  template <typename U, typename OtherAllocator>
+  allocator_binder(
+      allocator_binder<U, OtherAllocator>&& other)
+    : allocator_(BOOST_ASIO_MOVE_CAST(OtherAllocator)(
+          other.get_allocator())),
+      target_(BOOST_ASIO_MOVE_CAST(U)(other.get()))
+  {
+  }
+
+  /// Move construct from a different allocator wrapper type, but
+  /// specify a different allocator.
+  template <typename U, typename OtherAllocator>
+  allocator_binder(const allocator_type& s,
+      allocator_binder<U, OtherAllocator>&& other)
+    : allocator_(s),
+      target_(BOOST_ASIO_MOVE_CAST(U)(other.get()))
+  {
+  }
+
+#endif // defined(BOOST_ASIO_HAS_MOVE) || defined(GENERATING_DOCUMENTATION)
+
+  /// Destructor.
+  ~allocator_binder()
+  {
+  }
+
+  /// Obtain a reference to the target object.
+  target_type& get() BOOST_ASIO_NOEXCEPT
+  {
+    return target_;
+  }
+
+  /// Obtain a reference to the target object.
+  const target_type& get() const BOOST_ASIO_NOEXCEPT
+  {
+    return target_;
+  }
+
+  /// Obtain the associated allocator.
+  allocator_type get_allocator() const BOOST_ASIO_NOEXCEPT
+  {
+    return allocator_;
+  }
+
+#if defined(GENERATING_DOCUMENTATION)
+
+  template <typename... Args> auto operator()(Args&& ...);
+  template <typename... Args> auto operator()(Args&& ...) const;
+
+#elif defined(BOOST_ASIO_HAS_VARIADIC_TEMPLATES)
+
+  /// Forwarding function call operator.
+  template <typename... Args>
+  typename result_of<T(Args...)>::type operator()(
+      BOOST_ASIO_MOVE_ARG(Args)... args)
+  {
+    return target_(BOOST_ASIO_MOVE_CAST(Args)(args)...);
+  }
+
+  /// Forwarding function call operator.
+  template <typename... Args>
+  typename result_of<T(Args...)>::type operator()(
+      BOOST_ASIO_MOVE_ARG(Args)... args) const
+  {
+    return target_(BOOST_ASIO_MOVE_CAST(Args)(args)...);
+  }
+
+#elif defined(BOOST_ASIO_HAS_STD_TYPE_TRAITS) && !defined(_MSC_VER)
+
+  typename detail::allocator_binder_result_of0<T>::type operator()()
+  {
+    return target_();
+  }
+
+  typename detail::allocator_binder_result_of0<T>::type
+  operator()() const
+  {
+    return target_();
+  }
+
+#define BOOST_ASIO_PRIVATE_BINDER_CALL_DEF(n) \
+  template <BOOST_ASIO_VARIADIC_TPARAMS(n)> \
+  typename result_of<T(BOOST_ASIO_VARIADIC_TARGS(n))>::type operator()( \
+      BOOST_ASIO_VARIADIC_MOVE_PARAMS(n)) \
+  { \
+    return target_(BOOST_ASIO_VARIADIC_MOVE_ARGS(n)); \
+  } \
+  \
+  template <BOOST_ASIO_VARIADIC_TPARAMS(n)> \
+  typename result_of<T(BOOST_ASIO_VARIADIC_TARGS(n))>::type operator()( \
+      BOOST_ASIO_VARIADIC_MOVE_PARAMS(n)) const \
+  { \
+    return target_(BOOST_ASIO_VARIADIC_MOVE_ARGS(n)); \
+  } \
+  /**/
+  BOOST_ASIO_VARIADIC_GENERATE(BOOST_ASIO_PRIVATE_BINDER_CALL_DEF)
+#undef BOOST_ASIO_PRIVATE_BINDER_CALL_DEF
+
+#else // defined(BOOST_ASIO_HAS_STD_TYPE_TRAITS) && !defined(_MSC_VER)
+
+  typedef typename detail::allocator_binder_result_type<
+    T>::result_type_or_void result_type_or_void;
+
+  result_type_or_void operator()()
+  {
+    return target_();
+  }
+
+  result_type_or_void operator()() const
+  {
+    return target_();
+  }
+
+#define BOOST_ASIO_PRIVATE_BINDER_CALL_DEF(n) \
+  template <BOOST_ASIO_VARIADIC_TPARAMS(n)> \
+  result_type_or_void operator()( \
+      BOOST_ASIO_VARIADIC_MOVE_PARAMS(n)) \
+  { \
+    return target_(BOOST_ASIO_VARIADIC_MOVE_ARGS(n)); \
+  } \
+  \
+  template <BOOST_ASIO_VARIADIC_TPARAMS(n)> \
+  result_type_or_void operator()( \
+      BOOST_ASIO_VARIADIC_MOVE_PARAMS(n)) const \
+  { \
+    return target_(BOOST_ASIO_VARIADIC_MOVE_ARGS(n)); \
+  } \
+  /**/
+  BOOST_ASIO_VARIADIC_GENERATE(BOOST_ASIO_PRIVATE_BINDER_CALL_DEF)
+#undef BOOST_ASIO_PRIVATE_BINDER_CALL_DEF
+
+#endif // defined(BOOST_ASIO_HAS_STD_TYPE_TRAITS) && !defined(_MSC_VER)
+
+private:
+  Allocator allocator_;
+  T target_;
+};
+
+/// Associate an object of type @c T with an allocator of type
+/// @c Allocator.
+template <typename Allocator, typename T>
+BOOST_ASIO_NODISCARD inline allocator_binder<typename decay<T>::type, Allocator>
+bind_allocator(const Allocator& s, BOOST_ASIO_MOVE_ARG(T) t)
+{
+  return allocator_binder<
+    typename decay<T>::type, Allocator>(
+      s, BOOST_ASIO_MOVE_CAST(T)(t));
+}
+
+#if !defined(GENERATING_DOCUMENTATION)
+
+namespace detail {
+
+template <typename TargetAsyncResult,
+  typename Allocator, typename = void>
+class allocator_binder_completion_handler_async_result
+{
+public:
+  template <typename T>
+  explicit allocator_binder_completion_handler_async_result(T&)
+  {
+  }
+};
+
+template <typename TargetAsyncResult, typename Allocator>
+class allocator_binder_completion_handler_async_result<
+  TargetAsyncResult, Allocator,
+  typename void_type<
+    typename TargetAsyncResult::completion_handler_type
+  >::type>
+{
+public:
+  typedef allocator_binder<
+    typename TargetAsyncResult::completion_handler_type, Allocator>
+      completion_handler_type;
+
+  explicit allocator_binder_completion_handler_async_result(
+      typename TargetAsyncResult::completion_handler_type& handler)
+    : target_(handler)
+  {
+  }
+
+  typename TargetAsyncResult::return_type get()
+  {
+    return target_.get();
+  }
+
+private:
+  TargetAsyncResult target_;
+};
+
+template <typename TargetAsyncResult, typename = void>
+struct allocator_binder_async_result_return_type
+{
+};
+
+template <typename TargetAsyncResult>
+struct allocator_binder_async_result_return_type<
+  TargetAsyncResult,
+  typename void_type<
+    typename TargetAsyncResult::return_type
+  >::type>
+{
+  typedef typename TargetAsyncResult::return_type return_type;
+};
+
+} // namespace detail
+
+template <typename T, typename Allocator, typename Signature>
+class async_result<allocator_binder<T, Allocator>, Signature> :
+  public detail::allocator_binder_completion_handler_async_result<
+    async_result<T, Signature>, Allocator>,
+  public detail::allocator_binder_async_result_return_type<
+    async_result<T, Signature> >
+{
+public:
+  explicit async_result(allocator_binder<T, Allocator>& b)
+    : detail::allocator_binder_completion_handler_async_result<
+        async_result<T, Signature>, Allocator>(b.get())
+  {
+  }
+
+  template <typename Initiation>
+  struct init_wrapper
+  {
+    template <typename Init>
+    init_wrapper(const Allocator& allocator, BOOST_ASIO_MOVE_ARG(Init) init)
+      : allocator_(allocator),
+        initiation_(BOOST_ASIO_MOVE_CAST(Init)(init))
+    {
+    }
+
+#if defined(BOOST_ASIO_HAS_VARIADIC_TEMPLATES)
+
+    template <typename Handler, typename... Args>
+    void operator()(
+        BOOST_ASIO_MOVE_ARG(Handler) handler,
+        BOOST_ASIO_MOVE_ARG(Args)... args)
+    {
+      BOOST_ASIO_MOVE_CAST(Initiation)(initiation_)(
+          allocator_binder<
+            typename decay<Handler>::type, Allocator>(
+              allocator_, BOOST_ASIO_MOVE_CAST(Handler)(handler)),
+          BOOST_ASIO_MOVE_CAST(Args)(args)...);
+    }
+
+    template <typename Handler, typename... Args>
+    void operator()(
+        BOOST_ASIO_MOVE_ARG(Handler) handler,
+        BOOST_ASIO_MOVE_ARG(Args)... args) const
+    {
+      initiation_(
+          allocator_binder<
+            typename decay<Handler>::type, Allocator>(
+              allocator_, BOOST_ASIO_MOVE_CAST(Handler)(handler)),
+          BOOST_ASIO_MOVE_CAST(Args)(args)...);
+    }
+
+#else // defined(BOOST_ASIO_HAS_VARIADIC_TEMPLATES)
+
+    template <typename Handler>
+    void operator()(
+        BOOST_ASIO_MOVE_ARG(Handler) handler)
+    {
+      BOOST_ASIO_MOVE_CAST(Initiation)(initiation_)(
+          allocator_binder<
+            typename decay<Handler>::type, Allocator>(
+              allocator_, BOOST_ASIO_MOVE_CAST(Handler)(handler)));
+    }
+
+    template <typename Handler>
+    void operator()(
+        BOOST_ASIO_MOVE_ARG(Handler) handler) const
+    {
+      initiation_(
+          allocator_binder<
+            typename decay<Handler>::type, Allocator>(
+              allocator_, BOOST_ASIO_MOVE_CAST(Handler)(handler)));
+    }
+
+#define BOOST_ASIO_PRIVATE_INIT_WRAPPER_DEF(n) \
+    template <typename Handler, BOOST_ASIO_VARIADIC_TPARAMS(n)> \
+    void operator()( \
+        BOOST_ASIO_MOVE_ARG(Handler) handler, \
+        BOOST_ASIO_VARIADIC_MOVE_PARAMS(n)) \
+    { \
+      BOOST_ASIO_MOVE_CAST(Initiation)(initiation_)( \
+          allocator_binder< \
+            typename decay<Handler>::type, Allocator>( \
+              allocator_, BOOST_ASIO_MOVE_CAST(Handler)(handler)), \
+          BOOST_ASIO_VARIADIC_MOVE_ARGS(n)); \
+    } \
+    \
+    template <typename Handler, BOOST_ASIO_VARIADIC_TPARAMS(n)> \
+    void operator()( \
+        BOOST_ASIO_MOVE_ARG(Handler) handler, \
+        BOOST_ASIO_VARIADIC_MOVE_PARAMS(n)) const \
+    { \
+      initiation_( \
+          allocator_binder< \
+            typename decay<Handler>::type, Allocator>( \
+              allocator_, BOOST_ASIO_MOVE_CAST(Handler)(handler)), \
+          BOOST_ASIO_VARIADIC_MOVE_ARGS(n)); \
+    } \
+    /**/
+    BOOST_ASIO_VARIADIC_GENERATE(BOOST_ASIO_PRIVATE_INIT_WRAPPER_DEF)
+#undef BOOST_ASIO_PRIVATE_INIT_WRAPPER_DEF
+
+#endif // defined(BOOST_ASIO_HAS_VARIADIC_TEMPLATES)
+
+    Allocator allocator_;
+    Initiation initiation_;
+  };
+
+#if defined(BOOST_ASIO_HAS_VARIADIC_TEMPLATES)
+
+  template <typename Initiation, typename RawCompletionToken, typename... Args>
+  static BOOST_ASIO_INITFN_DEDUCED_RESULT_TYPE(T, Signature,
+    (async_initiate<T, Signature>(
+        declval<init_wrapper<typename decay<Initiation>::type> >(),
+        declval<RawCompletionToken>().get(),
+        declval<BOOST_ASIO_MOVE_ARG(Args)>()...)))
+  initiate(
+      BOOST_ASIO_MOVE_ARG(Initiation) initiation,
+      BOOST_ASIO_MOVE_ARG(RawCompletionToken) token,
+      BOOST_ASIO_MOVE_ARG(Args)... args)
+  {
+    return async_initiate<T, Signature>(
+        init_wrapper<typename decay<Initiation>::type>(
+          token.get_allocator(),
+          BOOST_ASIO_MOVE_CAST(Initiation)(initiation)),
+        token.get(), BOOST_ASIO_MOVE_CAST(Args)(args)...);
+  }
+
+#else // defined(BOOST_ASIO_HAS_VARIADIC_TEMPLATES)
+
+  template <typename Initiation, typename RawCompletionToken>
+  static BOOST_ASIO_INITFN_DEDUCED_RESULT_TYPE(T, Signature,
+    (async_initiate<T, Signature>(
+        declval<init_wrapper<typename decay<Initiation>::type> >(),
+        declval<RawCompletionToken>().get())))
+  initiate(
+      BOOST_ASIO_MOVE_ARG(Initiation) initiation,
+      BOOST_ASIO_MOVE_ARG(RawCompletionToken) token)
+  {
+    return async_initiate<T, Signature>(
+        init_wrapper<typename decay<Initiation>::type>(
+          token.get_allocator(),
+          BOOST_ASIO_MOVE_CAST(Initiation)(initiation)),
+        token.get());
+  }
+
+#define BOOST_ASIO_PRIVATE_INITIATE_DEF(n) \
+  template <typename Initiation, typename RawCompletionToken, \
+      BOOST_ASIO_VARIADIC_TPARAMS(n)> \
+  static BOOST_ASIO_INITFN_DEDUCED_RESULT_TYPE(T, Signature, \
+    (async_initiate<T, Signature>( \
+        declval<init_wrapper<typename decay<Initiation>::type> >(), \
+        declval<RawCompletionToken>().get(), \
+        BOOST_ASIO_VARIADIC_MOVE_DECLVAL(n)))) \
+  initiate( \
+      BOOST_ASIO_MOVE_ARG(Initiation) initiation, \
+      BOOST_ASIO_MOVE_ARG(RawCompletionToken) token, \
+      BOOST_ASIO_VARIADIC_MOVE_PARAMS(n)) \
+  { \
+    return async_initiate<T, Signature>( \
+        init_wrapper<typename decay<Initiation>::type>( \
+          token.get_allocator(), \
+          BOOST_ASIO_MOVE_CAST(Initiation)(initiation)), \
+        token.get(), BOOST_ASIO_VARIADIC_MOVE_ARGS(n)); \
+  } \
+  /**/
+  BOOST_ASIO_VARIADIC_GENERATE(BOOST_ASIO_PRIVATE_INITIATE_DEF)
+#undef BOOST_ASIO_PRIVATE_INITIATE_DEF
+
+#endif // defined(BOOST_ASIO_HAS_VARIADIC_TEMPLATES)
+
+private:
+  async_result(const async_result&) BOOST_ASIO_DELETED;
+  async_result& operator=(const async_result&) BOOST_ASIO_DELETED;
+
+  async_result<T, Signature> target_;
+};
+
+template <template <typename, typename> class Associator,
+    typename T, typename Allocator, typename DefaultCandidate>
+struct associator<Associator,
+    allocator_binder<T, Allocator>,
+    DefaultCandidate>
+  : Associator<T, DefaultCandidate>
+{
+  static typename Associator<T, DefaultCandidate>::type
+  get(const allocator_binder<T, Allocator>& b) BOOST_ASIO_NOEXCEPT
+  {
+    return Associator<T, DefaultCandidate>::get(b.get());
+  }
+
+  static BOOST_ASIO_AUTO_RETURN_TYPE_PREFIX2(
+      typename Associator<T, DefaultCandidate>::type)
+  get(const allocator_binder<T, Allocator>& b,
+      const DefaultCandidate& c) BOOST_ASIO_NOEXCEPT
+    BOOST_ASIO_AUTO_RETURN_TYPE_SUFFIX((
+      Associator<T, DefaultCandidate>::get(b.get(), c)))
+  {
+    return Associator<T, DefaultCandidate>::get(b.get(), c);
+  }
+};
+
+template <typename T, typename Allocator, typename Allocator1>
+struct associated_allocator<
+    allocator_binder<T, Allocator>,
+    Allocator1>
+{
+  typedef Allocator type;
+
+  static BOOST_ASIO_AUTO_RETURN_TYPE_PREFIX(type) get(
+      const allocator_binder<T, Allocator>& b,
+      const Allocator1& = Allocator1()) BOOST_ASIO_NOEXCEPT
+    BOOST_ASIO_AUTO_RETURN_TYPE_SUFFIX((b.get_allocator()))
+  {
+    return b.get_allocator();
+  }
+};
+
+#endif // !defined(GENERATING_DOCUMENTATION)
+
+} // namespace asio
+} // namespace boost
+
+#include <boost/asio/detail/pop_options.hpp>
+
+#endif // BOOST_ASIO_BIND_ALLOCATOR_HPP

linx64/include/boost/asio/bind_cancellation_slot.hpp

@@ -0,0 +1,754 @@
+//
+// bind_cancellation_slot.hpp
+// ~~~~~~~~~~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2023 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef BOOST_ASIO_BIND_CANCELLATION_SLOT_HPP
+#define BOOST_ASIO_BIND_CANCELLATION_SLOT_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include <boost/asio/detail/config.hpp>
+#include <boost/asio/detail/type_traits.hpp>
+#include <boost/asio/detail/variadic_templates.hpp>
+#include <boost/asio/associated_cancellation_slot.hpp>
+#include <boost/asio/associator.hpp>
+#include <boost/asio/async_result.hpp>
+
+#include <boost/asio/detail/push_options.hpp>
+
+namespace boost {
+namespace asio {
+namespace detail {
+
+// Helper to automatically define nested typedef result_type.
+
+template <typename T, typename = void>
+struct cancellation_slot_binder_result_type
+{
+protected:
+  typedef void result_type_or_void;
+};
+
+template <typename T>
+struct cancellation_slot_binder_result_type<T,
+  typename void_type<typename T::result_type>::type>
+{
+  typedef typename T::result_type result_type;
+protected:
+  typedef result_type result_type_or_void;
+};
+
+template <typename R>
+struct cancellation_slot_binder_result_type<R(*)()>
+{
+  typedef R result_type;
+protected:
+  typedef result_type result_type_or_void;
+};
+
+template <typename R>
+struct cancellation_slot_binder_result_type<R(&)()>
+{
+  typedef R result_type;
+protected:
+  typedef result_type result_type_or_void;
+};
+
+template <typename R, typename A1>
+struct cancellation_slot_binder_result_type<R(*)(A1)>
+{
+  typedef R result_type;
+protected:
+  typedef result_type result_type_or_void;
+};
+
+template <typename R, typename A1>
+struct cancellation_slot_binder_result_type<R(&)(A1)>
+{
+  typedef R result_type;
+protected:
+  typedef result_type result_type_or_void;
+};
+
+template <typename R, typename A1, typename A2>
+struct cancellation_slot_binder_result_type<R(*)(A1, A2)>
+{
+  typedef R result_type;
+protected:
+  typedef result_type result_type_or_void;
+};
+
+template <typename R, typename A1, typename A2>
+struct cancellation_slot_binder_result_type<R(&)(A1, A2)>
+{
+  typedef R result_type;
+protected:
+  typedef result_type result_type_or_void;
+};
+
+// Helper to automatically define nested typedef argument_type.
+
+template <typename T, typename = void>
+struct cancellation_slot_binder_argument_type {};
+
+template <typename T>
+struct cancellation_slot_binder_argument_type<T,
+  typename void_type<typename T::argument_type>::type>
+{
+  typedef typename T::argument_type argument_type;
+};
+
+template <typename R, typename A1>
+struct cancellation_slot_binder_argument_type<R(*)(A1)>
+{
+  typedef A1 argument_type;
+};
+
+template <typename R, typename A1>
+struct cancellation_slot_binder_argument_type<R(&)(A1)>
+{
+  typedef A1 argument_type;
+};
+
+// Helper to automatically define nested typedefs first_argument_type and
+// second_argument_type.
+
+template <typename T, typename = void>
+struct cancellation_slot_binder_argument_types {};
+
+template <typename T>
+struct cancellation_slot_binder_argument_types<T,
+  typename void_type<typename T::first_argument_type>::type>
+{
+  typedef typename T::first_argument_type first_argument_type;
+  typedef typename T::second_argument_type second_argument_type;
+};
+
+template <typename R, typename A1, typename A2>
+struct cancellation_slot_binder_argument_type<R(*)(A1, A2)>
+{
+  typedef A1 first_argument_type;
+  typedef A2 second_argument_type;
+};
+
+template <typename R, typename A1, typename A2>
+struct cancellation_slot_binder_argument_type<R(&)(A1, A2)>
+{
+  typedef A1 first_argument_type;
+  typedef A2 second_argument_type;
+};
+
+// Helper to enable SFINAE on zero-argument operator() below.
+
+template <typename T, typename = void>
+struct cancellation_slot_binder_result_of0
+{
+  typedef void type;
+};
+
+template <typename T>
+struct cancellation_slot_binder_result_of0<T,
+  typename void_type<typename result_of<T()>::type>::type>
+{
+  typedef typename result_of<T()>::type type;
+};
+
+} // namespace detail
+
+/// A call wrapper type to bind a cancellation slot of type @c CancellationSlot
+/// to an object of type @c T.
+template <typename T, typename CancellationSlot>
+class cancellation_slot_binder
+#if !defined(GENERATING_DOCUMENTATION)
+  : public detail::cancellation_slot_binder_result_type<T>,
+    public detail::cancellation_slot_binder_argument_type<T>,
+    public detail::cancellation_slot_binder_argument_types<T>
+#endif // !defined(GENERATING_DOCUMENTATION)
+{
+public:
+  /// The type of the target object.
+  typedef T target_type;
+
+  /// The type of the associated cancellation slot.
+  typedef CancellationSlot cancellation_slot_type;
+
+#if defined(GENERATING_DOCUMENTATION)
+  /// The return type if a function.
+  /**
+   * The type of @c result_type is based on the type @c T of the wrapper's
+   * target object:
+   *
+   * @li if @c T is a pointer to function type, @c result_type is a synonym for
+   * the return type of @c T;
+   *
+   * @li if @c T is a class type with a member type @c result_type, then @c
+   * result_type is a synonym for @c T::result_type;
+   *
+   * @li otherwise @c result_type is not defined.
+   */
+  typedef see_below result_type;
+
+  /// The type of the function's argument.
+  /**
+   * The type of @c argument_type is based on the type @c T of the wrapper's
+   * target object:
+   *
+   * @li if @c T is a pointer to a function type accepting a single argument,
+   * @c argument_type is a synonym for the return type of @c T;
+   *
+   * @li if @c T is a class type with a member type @c argument_type, then @c
+   * argument_type is a synonym for @c T::argument_type;
+   *
+   * @li otherwise @c argument_type is not defined.
+   */
+  typedef see_below argument_type;
+
+  /// The type of the function's first argument.
+  /**
+   * The type of @c first_argument_type is based on the type @c T of the
+   * wrapper's target object:
+   *
+   * @li if @c T is a pointer to a function type accepting two arguments, @c
+   * first_argument_type is a synonym for the return type of @c T;
+   *
+   * @li if @c T is a class type with a member type @c first_argument_type,
+   * then @c first_argument_type is a synonym for @c T::first_argument_type;
+   *
+   * @li otherwise @c first_argument_type is not defined.
+   */
+  typedef see_below first_argument_type;
+
+  /// The type of the function's second argument.
+  /**
+   * The type of @c second_argument_type is based on the type @c T of the
+   * wrapper's target object:
+   *
+   * @li if @c T is a pointer to a function type accepting two arguments, @c
+   * second_argument_type is a synonym for the return type of @c T;
+   *
+   * @li if @c T is a class type with a member type @c first_argument_type,
+   * then @c second_argument_type is a synonym for @c T::second_argument_type;
+   *
+   * @li otherwise @c second_argument_type is not defined.
+   */
+  typedef see_below second_argument_type;
+#endif // defined(GENERATING_DOCUMENTATION)
+
+  /// Construct a cancellation slot wrapper for the specified object.
+  /**
+   * This constructor is only valid if the type @c T is constructible from type
+   * @c U.
+   */
+  template <typename U>
+  cancellation_slot_binder(const cancellation_slot_type& s,
+      BOOST_ASIO_MOVE_ARG(U) u)
+    : slot_(s),
+      target_(BOOST_ASIO_MOVE_CAST(U)(u))
+  {
+  }
+
+  /// Copy constructor.
+  cancellation_slot_binder(const cancellation_slot_binder& other)
+    : slot_(other.get_cancellation_slot()),
+      target_(other.get())
+  {
+  }
+
+  /// Construct a copy, but specify a different cancellation slot.
+  cancellation_slot_binder(const cancellation_slot_type& s,
+      const cancellation_slot_binder& other)
+    : slot_(s),
+      target_(other.get())
+  {
+  }
+
+  /// Construct a copy of a different cancellation slot wrapper type.
+  /**
+   * This constructor is only valid if the @c CancellationSlot type is
+   * constructible from type @c OtherCancellationSlot, and the type @c T is
+   * constructible from type @c U.
+   */
+  template <typename U, typename OtherCancellationSlot>
+  cancellation_slot_binder(
+      const cancellation_slot_binder<U, OtherCancellationSlot>& other)
+    : slot_(other.get_cancellation_slot()),
+      target_(other.get())
+  {
+  }
+
+  /// Construct a copy of a different cancellation slot wrapper type, but
+  /// specify a different cancellation slot.
+  /**
+   * This constructor is only valid if the type @c T is constructible from type
+   * @c U.
+   */
+  template <typename U, typename OtherCancellationSlot>
+  cancellation_slot_binder(const cancellation_slot_type& s,
+      const cancellation_slot_binder<U, OtherCancellationSlot>& other)
+    : slot_(s),
+      target_(other.get())
+  {
+  }
+
+#if defined(BOOST_ASIO_HAS_MOVE) || defined(GENERATING_DOCUMENTATION)
+
+  /// Move constructor.
+  cancellation_slot_binder(cancellation_slot_binder&& other)
+    : slot_(BOOST_ASIO_MOVE_CAST(cancellation_slot_type)(
+          other.get_cancellation_slot())),
+      target_(BOOST_ASIO_MOVE_CAST(T)(other.get()))
+  {
+  }
+
+  /// Move construct the target object, but specify a different cancellation
+  /// slot.
+  cancellation_slot_binder(const cancellation_slot_type& s,
+      cancellation_slot_binder&& other)
+    : slot_(s),
+      target_(BOOST_ASIO_MOVE_CAST(T)(other.get()))
+  {
+  }
+
+  /// Move construct from a different cancellation slot wrapper type.
+  template <typename U, typename OtherCancellationSlot>
+  cancellation_slot_binder(
+      cancellation_slot_binder<U, OtherCancellationSlot>&& other)
+    : slot_(BOOST_ASIO_MOVE_CAST(OtherCancellationSlot)(
+          other.get_cancellation_slot())),
+      target_(BOOST_ASIO_MOVE_CAST(U)(other.get()))
+  {
+  }
+
+  /// Move construct from a different cancellation slot wrapper type, but
+  /// specify a different cancellation slot.
+  template <typename U, typename OtherCancellationSlot>
+  cancellation_slot_binder(const cancellation_slot_type& s,
+      cancellation_slot_binder<U, OtherCancellationSlot>&& other)
+    : slot_(s),
+      target_(BOOST_ASIO_MOVE_CAST(U)(other.get()))
+  {
+  }
+
+#endif // defined(BOOST_ASIO_HAS_MOVE) || defined(GENERATING_DOCUMENTATION)
+
+  /// Destructor.
+  ~cancellation_slot_binder()
+  {
+  }
+
+  /// Obtain a reference to the target object.
+  target_type& get() BOOST_ASIO_NOEXCEPT
+  {
+    return target_;
+  }
+
+  /// Obtain a reference to the target object.
+  const target_type& get() const BOOST_ASIO_NOEXCEPT
+  {
+    return target_;
+  }
+
+  /// Obtain the associated cancellation slot.
+  cancellation_slot_type get_cancellation_slot() const BOOST_ASIO_NOEXCEPT
+  {
+    return slot_;
+  }
+
+#if defined(GENERATING_DOCUMENTATION)
+
+  template <typename... Args> auto operator()(Args&& ...);
+  template <typename... Args> auto operator()(Args&& ...) const;
+
+#elif defined(BOOST_ASIO_HAS_VARIADIC_TEMPLATES)
+
+  /// Forwarding function call operator.
+  template <typename... Args>
+  typename result_of<T(Args...)>::type operator()(
+      BOOST_ASIO_MOVE_ARG(Args)... args)
+  {
+    return target_(BOOST_ASIO_MOVE_CAST(Args)(args)...);
+  }
+
+  /// Forwarding function call operator.
+  template <typename... Args>
+  typename result_of<T(Args...)>::type operator()(
+      BOOST_ASIO_MOVE_ARG(Args)... args) const
+  {
+    return target_(BOOST_ASIO_MOVE_CAST(Args)(args)...);
+  }
+
+#elif defined(BOOST_ASIO_HAS_STD_TYPE_TRAITS) && !defined(_MSC_VER)
+
+  typename detail::cancellation_slot_binder_result_of0<T>::type operator()()
+  {
+    return target_();
+  }
+
+  typename detail::cancellation_slot_binder_result_of0<T>::type
+  operator()() const
+  {
+    return target_();
+  }
+
+#define BOOST_ASIO_PRIVATE_BINDER_CALL_DEF(n) \
+  template <BOOST_ASIO_VARIADIC_TPARAMS(n)> \
+  typename result_of<T(BOOST_ASIO_VARIADIC_TARGS(n))>::type operator()( \
+      BOOST_ASIO_VARIADIC_MOVE_PARAMS(n)) \
+  { \
+    return target_(BOOST_ASIO_VARIADIC_MOVE_ARGS(n)); \
+  } \
+  \
+  template <BOOST_ASIO_VARIADIC_TPARAMS(n)> \
+  typename result_of<T(BOOST_ASIO_VARIADIC_TARGS(n))>::type operator()( \
+      BOOST_ASIO_VARIADIC_MOVE_PARAMS(n)) const \
+  { \
+    return target_(BOOST_ASIO_VARIADIC_MOVE_ARGS(n)); \
+  } \
+  /**/
+  BOOST_ASIO_VARIADIC_GENERATE(BOOST_ASIO_PRIVATE_BINDER_CALL_DEF)
+#undef BOOST_ASIO_PRIVATE_BINDER_CALL_DEF
+
+#else // defined(BOOST_ASIO_HAS_STD_TYPE_TRAITS) && !defined(_MSC_VER)
+
+  typedef typename detail::cancellation_slot_binder_result_type<
+    T>::result_type_or_void result_type_or_void;
+
+  result_type_or_void operator()()
+  {
+    return target_();
+  }
+
+  result_type_or_void operator()() const
+  {
+    return target_();
+  }
+
+#define BOOST_ASIO_PRIVATE_BINDER_CALL_DEF(n) \
+  template <BOOST_ASIO_VARIADIC_TPARAMS(n)> \
+  result_type_or_void operator()( \
+      BOOST_ASIO_VARIADIC_MOVE_PARAMS(n)) \
+  { \
+    return target_(BOOST_ASIO_VARIADIC_MOVE_ARGS(n)); \
+  } \
+  \
+  template <BOOST_ASIO_VARIADIC_TPARAMS(n)> \
+  result_type_or_void operator()( \
+      BOOST_ASIO_VARIADIC_MOVE_PARAMS(n)) const \
+  { \
+    return target_(BOOST_ASIO_VARIADIC_MOVE_ARGS(n)); \
+  } \
+  /**/
+  BOOST_ASIO_VARIADIC_GENERATE(BOOST_ASIO_PRIVATE_BINDER_CALL_DEF)
+#undef BOOST_ASIO_PRIVATE_BINDER_CALL_DEF
+
+#endif // defined(BOOST_ASIO_HAS_STD_TYPE_TRAITS) && !defined(_MSC_VER)
+
+private:
+  CancellationSlot slot_;
+  T target_;
+};
+
+/// Associate an object of type @c T with a cancellation slot of type
+/// @c CancellationSlot.
+template <typename CancellationSlot, typename T>
+BOOST_ASIO_NODISCARD inline
+cancellation_slot_binder<typename decay<T>::type, CancellationSlot>
+bind_cancellation_slot(const CancellationSlot& s, BOOST_ASIO_MOVE_ARG(T) t)
+{
+  return cancellation_slot_binder<
+    typename decay<T>::type, CancellationSlot>(
+      s, BOOST_ASIO_MOVE_CAST(T)(t));
+}
+
+#if !defined(GENERATING_DOCUMENTATION)
+
+namespace detail {
+
+template <typename TargetAsyncResult,
+  typename CancellationSlot, typename = void>
+class cancellation_slot_binder_completion_handler_async_result
+{
+public:
+  template <typename T>
+  explicit cancellation_slot_binder_completion_handler_async_result(T&)
+  {
+  }
+};
+
+template <typename TargetAsyncResult, typename CancellationSlot>
+class cancellation_slot_binder_completion_handler_async_result<
+  TargetAsyncResult, CancellationSlot,
+  typename void_type<
+    typename TargetAsyncResult::completion_handler_type
+  >::type>
+{
+public:
+  typedef cancellation_slot_binder<
+    typename TargetAsyncResult::completion_handler_type, CancellationSlot>
+      completion_handler_type;
+
+  explicit cancellation_slot_binder_completion_handler_async_result(
+      typename TargetAsyncResult::completion_handler_type& handler)
+    : target_(handler)
+  {
+  }
+
+  typename TargetAsyncResult::return_type get()
+  {
+    return target_.get();
+  }
+
+private:
+  TargetAsyncResult target_;
+};
+
+template <typename TargetAsyncResult, typename = void>
+struct cancellation_slot_binder_async_result_return_type
+{
+};
+
+template <typename TargetAsyncResult>
+struct cancellation_slot_binder_async_result_return_type<
+  TargetAsyncResult,
+  typename void_type<
+    typename TargetAsyncResult::return_type
+  >::type>
+{
+  typedef typename TargetAsyncResult::return_type return_type;
+};
+
+} // namespace detail
+
+template <typename T, typename CancellationSlot, typename Signature>
+class async_result<cancellation_slot_binder<T, CancellationSlot>, Signature> :
+  public detail::cancellation_slot_binder_completion_handler_async_result<
+    async_result<T, Signature>, CancellationSlot>,
+  public detail::cancellation_slot_binder_async_result_return_type<
+    async_result<T, Signature> >
+{
+public:
+  explicit async_result(cancellation_slot_binder<T, CancellationSlot>& b)
+    : detail::cancellation_slot_binder_completion_handler_async_result<
+        async_result<T, Signature>, CancellationSlot>(b.get())
+  {
+  }
+
+  template <typename Initiation>
+  struct init_wrapper
+  {
+    template <typename Init>
+    init_wrapper(const CancellationSlot& slot, BOOST_ASIO_MOVE_ARG(Init) init)
+      : slot_(slot),
+        initiation_(BOOST_ASIO_MOVE_CAST(Init)(init))
+    {
+    }
+
+#if defined(BOOST_ASIO_HAS_VARIADIC_TEMPLATES)
+
+    template <typename Handler, typename... Args>
+    void operator()(
+        BOOST_ASIO_MOVE_ARG(Handler) handler,
+        BOOST_ASIO_MOVE_ARG(Args)... args)
+    {
+      BOOST_ASIO_MOVE_CAST(Initiation)(initiation_)(
+          cancellation_slot_binder<
+            typename decay<Handler>::type, CancellationSlot>(
+              slot_, BOOST_ASIO_MOVE_CAST(Handler)(handler)),
+          BOOST_ASIO_MOVE_CAST(Args)(args)...);
+    }
+
+    template <typename Handler, typename... Args>
+    void operator()(
+        BOOST_ASIO_MOVE_ARG(Handler) handler,
+        BOOST_ASIO_MOVE_ARG(Args)... args) const
+    {
+      initiation_(
+          cancellation_slot_binder<
+            typename decay<Handler>::type, CancellationSlot>(
+              slot_, BOOST_ASIO_MOVE_CAST(Handler)(handler)),
+          BOOST_ASIO_MOVE_CAST(Args)(args)...);
+    }
+
+#else // defined(BOOST_ASIO_HAS_VARIADIC_TEMPLATES)
+
+    template <typename Handler>
+    void operator()(
+        BOOST_ASIO_MOVE_ARG(Handler) handler)
+    {
+      BOOST_ASIO_MOVE_CAST(Initiation)(initiation_)(
+          cancellation_slot_binder<
+            typename decay<Handler>::type, CancellationSlot>(
+              slot_, BOOST_ASIO_MOVE_CAST(Handler)(handler)));
+    }
+
+    template <typename Handler>
+    void operator()(
+        BOOST_ASIO_MOVE_ARG(Handler) handler) const
+    {
+      initiation_(
+          cancellation_slot_binder<
+            typename decay<Handler>::type, CancellationSlot>(
+              slot_, BOOST_ASIO_MOVE_CAST(Handler)(handler)));
+    }
+
+#define BOOST_ASIO_PRIVATE_INIT_WRAPPER_DEF(n) \
+    template <typename Handler, BOOST_ASIO_VARIADIC_TPARAMS(n)> \
+    void operator()( \
+        BOOST_ASIO_MOVE_ARG(Handler) handler, \
+        BOOST_ASIO_VARIADIC_MOVE_PARAMS(n)) \
+    { \
+      BOOST_ASIO_MOVE_CAST(Initiation)(initiation_)( \
+          cancellation_slot_binder< \
+            typename decay<Handler>::type, CancellationSlot>( \
+              slot_, BOOST_ASIO_MOVE_CAST(Handler)(handler)), \
+          BOOST_ASIO_VARIADIC_MOVE_ARGS(n)); \
+    } \
+    \
+    template <typename Handler, BOOST_ASIO_VARIADIC_TPARAMS(n)> \
+    void operator()( \
+        BOOST_ASIO_MOVE_ARG(Handler) handler, \
+        BOOST_ASIO_VARIADIC_MOVE_PARAMS(n)) const \
+    { \
+      initiation_( \
+          cancellation_slot_binder< \
+            typename decay<Handler>::type, CancellationSlot>( \
+              slot_, BOOST_ASIO_MOVE_CAST(Handler)(handler)), \
+          BOOST_ASIO_VARIADIC_MOVE_ARGS(n)); \
+    } \
+    /**/
+    BOOST_ASIO_VARIADIC_GENERATE(BOOST_ASIO_PRIVATE_INIT_WRAPPER_DEF)
+#undef BOOST_ASIO_PRIVATE_INIT_WRAPPER_DEF
+
+#endif // defined(BOOST_ASIO_HAS_VARIADIC_TEMPLATES)
+
+    CancellationSlot slot_;
+    Initiation initiation_;
+  };
+
+#if defined(BOOST_ASIO_HAS_VARIADIC_TEMPLATES)
+
+  template <typename Initiation, typename RawCompletionToken, typename... Args>
+  static BOOST_ASIO_INITFN_DEDUCED_RESULT_TYPE(T, Signature,
+    (async_initiate<T, Signature>(
+        declval<init_wrapper<typename decay<Initiation>::type> >(),
+        declval<RawCompletionToken>().get(),
+        declval<BOOST_ASIO_MOVE_ARG(Args)>()...)))
+  initiate(
+      BOOST_ASIO_MOVE_ARG(Initiation) initiation,
+      BOOST_ASIO_MOVE_ARG(RawCompletionToken) token,
+      BOOST_ASIO_MOVE_ARG(Args)... args)
+  {
+    return async_initiate<T, Signature>(
+        init_wrapper<typename decay<Initiation>::type>(
+          token.get_cancellation_slot(),
+          BOOST_ASIO_MOVE_CAST(Initiation)(initiation)),
+        token.get(), BOOST_ASIO_MOVE_CAST(Args)(args)...);
+  }
+
+#else // defined(BOOST_ASIO_HAS_VARIADIC_TEMPLATES)
+
+  template <typename Initiation, typename RawCompletionToken>
+  static BOOST_ASIO_INITFN_DEDUCED_RESULT_TYPE(T, Signature,
+    (async_initiate<T, Signature>(
+        declval<init_wrapper<typename decay<Initiation>::type> >(),
+        declval<RawCompletionToken>().get())))
+  initiate(
+      BOOST_ASIO_MOVE_ARG(Initiation) initiation,
+      BOOST_ASIO_MOVE_ARG(RawCompletionToken) token)
+  {
+    return async_initiate<T, Signature>(
+        init_wrapper<typename decay<Initiation>::type>(
+          token.get_cancellation_slot(),
+          BOOST_ASIO_MOVE_CAST(Initiation)(initiation)),
+        token.get());
+  }
+
+#define BOOST_ASIO_PRIVATE_INITIATE_DEF(n) \
+  template <typename Initiation, typename RawCompletionToken, \
+      BOOST_ASIO_VARIADIC_TPARAMS(n)> \
+  static BOOST_ASIO_INITFN_DEDUCED_RESULT_TYPE(T, Signature, \
+    (async_initiate<T, Signature>( \
+        declval<init_wrapper<typename decay<Initiation>::type> >(), \
+        declval<RawCompletionToken>().get(), \
+        BOOST_ASIO_VARIADIC_MOVE_DECLVAL(n)))) \
+  initiate( \
+      BOOST_ASIO_MOVE_ARG(Initiation) initiation, \
+      BOOST_ASIO_MOVE_ARG(RawCompletionToken) token, \
+      BOOST_ASIO_VARIADIC_MOVE_PARAMS(n)) \
+  { \
+    return async_initiate<T, Signature>( \
+        init_wrapper<typename decay<Initiation>::type>( \
+          token.get_cancellation_slot(), \
+          BOOST_ASIO_MOVE_CAST(Initiation)(initiation)), \
+        token.get(), BOOST_ASIO_VARIADIC_MOVE_ARGS(n)); \
+  } \
+  /**/
+  BOOST_ASIO_VARIADIC_GENERATE(BOOST_ASIO_PRIVATE_INITIATE_DEF)
+#undef BOOST_ASIO_PRIVATE_INITIATE_DEF
+
+#endif // defined(BOOST_ASIO_HAS_VARIADIC_TEMPLATES)
+
+private:
+  async_result(const async_result&) BOOST_ASIO_DELETED;
+  async_result& operator=(const async_result&) BOOST_ASIO_DELETED;
+
+  async_result<T, Signature> target_;
+};
+
+template <template <typename, typename> class Associator,
+    typename T, typename CancellationSlot, typename DefaultCandidate>
+struct associator<Associator,
+    cancellation_slot_binder<T, CancellationSlot>,
+    DefaultCandidate>
+  : Associator<T, DefaultCandidate>
+{
+  static typename Associator<T, DefaultCandidate>::type
+  get(const cancellation_slot_binder<T, CancellationSlot>& b)
+    BOOST_ASIO_NOEXCEPT
+  {
+    return Associator<T, DefaultCandidate>::get(b.get());
+  }
+
+  static BOOST_ASIO_AUTO_RETURN_TYPE_PREFIX2(
+      typename Associator<T, DefaultCandidate>::type)
+  get(const cancellation_slot_binder<T, CancellationSlot>& b,
+      const DefaultCandidate& c) BOOST_ASIO_NOEXCEPT
+    BOOST_ASIO_AUTO_RETURN_TYPE_SUFFIX((
+      Associator<T, DefaultCandidate>::get(b.get(), c)))
+  {
+    return Associator<T, DefaultCandidate>::get(b.get(), c);
+  }
+};
+
+template <typename T, typename CancellationSlot, typename CancellationSlot1>
+struct associated_cancellation_slot<
+    cancellation_slot_binder<T, CancellationSlot>,
+    CancellationSlot1>
+{
+  typedef CancellationSlot type;
+
+  static BOOST_ASIO_AUTO_RETURN_TYPE_PREFIX(type) get(
+      const cancellation_slot_binder<T, CancellationSlot>& b,
+      const CancellationSlot1& = CancellationSlot1()) BOOST_ASIO_NOEXCEPT
+    BOOST_ASIO_AUTO_RETURN_TYPE_SUFFIX((b.get_cancellation_slot()))
+  {
+    return b.get_cancellation_slot();
+  }
+};
+
+#endif // !defined(GENERATING_DOCUMENTATION)
+
+} // namespace asio
+} // namespace boost
+
+#include <boost/asio/detail/pop_options.hpp>
+
+#endif // BOOST_ASIO_BIND_CANCELLATION_SLOT_HPP

linx64/include/boost/asio/bind_executor.hpp

@@ -2,7 +2,7 @@
 // bind_executor.hpp
 // ~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2019 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2023 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -19,8 +19,9 @@
 #include <boost/asio/detail/type_traits.hpp>
 #include <boost/asio/detail/variadic_templates.hpp>
 #include <boost/asio/associated_executor.hpp>
-#include <boost/asio/associated_allocator.hpp>
+#include <boost/asio/associator.hpp>
 #include <boost/asio/async_result.hpp>
+#include <boost/asio/execution/executor.hpp>
 #include <boost/asio/execution_context.hpp>
 #include <boost/asio/is_executor.hpp>
 #include <boost/asio/uses_executor.hpp>
@@ -31,12 +32,6 @@ namespace boost {
 namespace asio {
 namespace detail {
 
-template <typename T>
-struct executor_binder_check
-{
-  typedef void type;
-};
-
 // Helper to automatically define nested typedef result_type.
 
 template <typename T, typename = void>
@@ -48,7 +43,7 @@ protected:
 
 template <typename T>
 struct executor_binder_result_type<T,
-  typename executor_binder_check<typename T::result_type>::type>
+  typename void_type<typename T::result_type>::type>
 {
   typedef typename T::result_type result_type;
 protected:
@@ -110,7 +105,7 @@ struct executor_binder_argument_type {};
 
 template <typename T>
 struct executor_binder_argument_type<T,
-  typename executor_binder_check<typename T::argument_type>::type>
+  typename void_type<typename T::argument_type>::type>
 {
   typedef typename T::argument_type argument_type;
 };
@@ -135,7 +130,7 @@ struct executor_binder_argument_types {};
 
 template <typename T>
 struct executor_binder_argument_types<T,
-  typename executor_binder_check<typename T::first_argument_type>::type>
+  typename void_type<typename T::first_argument_type>::type>
 {
   typedef typename T::first_argument_type first_argument_type;
   typedef typename T::second_argument_type second_argument_type;
@@ -155,16 +150,14 @@ struct executor_binder_argument_type<R(&)(A1, A2)>
   typedef A2 second_argument_type;
 };
 
-// Helper to:
-// - Apply the empty base optimisation to the executor.
-// - Perform uses_executor construction of the target type, if required.
+// Helper to perform uses_executor construction of the target type, if
+// required.
 
 template <typename T, typename Executor, bool UsesExecutor>
 class executor_binder_base;
 
 template <typename T, typename Executor>
 class executor_binder_base<T, Executor, true>
-  : protected Executor
 {
 protected:
   template <typename E, typename U>
@@ -203,7 +196,7 @@ struct executor_binder_result_of0
 
 template <typename T>
 struct executor_binder_result_of0<T,
-  typename executor_binder_check<typename result_of<T()>::type>::type>
+  typename void_type<typename result_of<T()>::type>::type>
 {
   typedef typename result_of<T()>::type type;
 };
@@ -494,9 +487,11 @@ private:
 
 /// Associate an object of type @c T with an executor of type @c Executor.
 template <typename Executor, typename T>
-inline executor_binder<typename decay<T>::type, Executor>
+BOOST_ASIO_NODISCARD inline executor_binder<typename decay<T>::type, Executor>
 bind_executor(const Executor& ex, BOOST_ASIO_MOVE_ARG(T) t,
-    typename enable_if<is_executor<Executor>::value>::type* = 0)
+    typename constraint<
+      is_executor<Executor>::value || execution::is_executor<Executor>::value
+    >::type = 0)
 {
   return executor_binder<typename decay<T>::type, Executor>(
       executor_arg_t(), ex, BOOST_ASIO_MOVE_CAST(T)(t));
@@ -504,11 +499,11 @@ bind_executor(const Executor& ex, BOOST_ASIO_MOVE_ARG(T) t,
 
 /// Associate an object of type @c T with an execution context's executor.
 template <typename ExecutionContext, typename T>
-inline executor_binder<typename decay<T>::type,
+BOOST_ASIO_NODISCARD inline executor_binder<typename decay<T>::type,
   typename ExecutionContext::executor_type>
 bind_executor(ExecutionContext& ctx, BOOST_ASIO_MOVE_ARG(T) t,
-    typename enable_if<is_convertible<
-      ExecutionContext&, execution_context&>::value>::type* = 0)
+    typename constraint<is_convertible<
+      ExecutionContext&, execution_context&>::value>::type = 0)
 {
   return executor_binder<typename decay<T>::type,
     typename ExecutionContext::executor_type>(
@@ -521,42 +516,246 @@ template <typename T, typename Executor>
 struct uses_executor<executor_binder<T, Executor>, Executor>
   : true_type {};
 
-template <typename T, typename Executor, typename Signature>
-class async_result<executor_binder<T, Executor>, Signature>
+namespace detail {
+
+template <typename TargetAsyncResult, typename Executor, typename = void>
+class executor_binder_completion_handler_async_result
+{
+public:
+  template <typename T>
+  explicit executor_binder_completion_handler_async_result(T&)
+  {
+  }
+};
+
+template <typename TargetAsyncResult, typename Executor>
+class executor_binder_completion_handler_async_result<
+  TargetAsyncResult, Executor,
+  typename void_type<
+    typename TargetAsyncResult::completion_handler_type
+  >::type>
 {
 public:
   typedef executor_binder<
-    typename async_result<T, Signature>::completion_handler_type, Executor>
+    typename TargetAsyncResult::completion_handler_type, Executor>
       completion_handler_type;
 
-  typedef typename async_result<T, Signature>::return_type return_type;
-
-  explicit async_result(executor_binder<T, Executor>& b)
-    : target_(b.get())
+  explicit executor_binder_completion_handler_async_result(
+      typename TargetAsyncResult::completion_handler_type& handler)
+    : target_(handler)
   {
   }
 
-  return_type get()
+  typename TargetAsyncResult::return_type get()
   {
     return target_.get();
   }
 
 private:
-  async_result(const async_result&) BOOST_ASIO_DELETED;
-  async_result& operator=(const async_result&) BOOST_ASIO_DELETED;
-
-  async_result<T, Signature> target_;
+  TargetAsyncResult target_;
 };
 
-template <typename T, typename Executor, typename Allocator>
-struct associated_allocator<executor_binder<T, Executor>, Allocator>
+template <typename TargetAsyncResult, typename = void>
+struct executor_binder_async_result_return_type
 {
-  typedef typename associated_allocator<T, Allocator>::type type;
+};
 
-  static type get(const executor_binder<T, Executor>& b,
-      const Allocator& a = Allocator()) BOOST_ASIO_NOEXCEPT
+template <typename TargetAsyncResult>
+struct executor_binder_async_result_return_type<
+  TargetAsyncResult,
+  typename void_type<
+    typename TargetAsyncResult::return_type
+  >::type>
+{
+  typedef typename TargetAsyncResult::return_type return_type;
+};
+
+} // namespace detail
+
+template <typename T, typename Executor, typename Signature>
+class async_result<executor_binder<T, Executor>, Signature> :
+  public detail::executor_binder_completion_handler_async_result<
+    async_result<T, Signature>, Executor>,
+  public detail::executor_binder_async_result_return_type<
+    async_result<T, Signature> >
+{
+public:
+  explicit async_result(executor_binder<T, Executor>& b)
+    : detail::executor_binder_completion_handler_async_result<
+        async_result<T, Signature>, Executor>(b.get())
   {
-    return associated_allocator<T, Allocator>::get(b.get(), a);
+  }
+
+  template <typename Initiation>
+  struct init_wrapper
+  {
+    template <typename Init>
+    init_wrapper(const Executor& ex, BOOST_ASIO_MOVE_ARG(Init) init)
+      : ex_(ex),
+        initiation_(BOOST_ASIO_MOVE_CAST(Init)(init))
+    {
+    }
+
+#if defined(BOOST_ASIO_HAS_VARIADIC_TEMPLATES)
+
+    template <typename Handler, typename... Args>
+    void operator()(
+        BOOST_ASIO_MOVE_ARG(Handler) handler,
+        BOOST_ASIO_MOVE_ARG(Args)... args)
+    {
+      BOOST_ASIO_MOVE_CAST(Initiation)(initiation_)(
+          executor_binder<typename decay<Handler>::type, Executor>(
+            executor_arg_t(), ex_, BOOST_ASIO_MOVE_CAST(Handler)(handler)),
+          BOOST_ASIO_MOVE_CAST(Args)(args)...);
+    }
+
+    template <typename Handler, typename... Args>
+    void operator()(
+        BOOST_ASIO_MOVE_ARG(Handler) handler,
+        BOOST_ASIO_MOVE_ARG(Args)... args) const
+    {
+      initiation_(
+          executor_binder<typename decay<Handler>::type, Executor>(
+            executor_arg_t(), ex_, BOOST_ASIO_MOVE_CAST(Handler)(handler)),
+          BOOST_ASIO_MOVE_CAST(Args)(args)...);
+    }
+
+#else // defined(BOOST_ASIO_HAS_VARIADIC_TEMPLATES)
+
+    template <typename Handler>
+    void operator()(
+        BOOST_ASIO_MOVE_ARG(Handler) handler)
+    {
+      BOOST_ASIO_MOVE_CAST(Initiation)(initiation_)(
+          executor_binder<typename decay<Handler>::type, Executor>(
+            executor_arg_t(), ex_, BOOST_ASIO_MOVE_CAST(Handler)(handler)));
+    }
+
+    template <typename Handler>
+    void operator()(
+        BOOST_ASIO_MOVE_ARG(Handler) handler) const
+    {
+      initiation_(
+          executor_binder<typename decay<Handler>::type, Executor>(
+            executor_arg_t(), ex_, BOOST_ASIO_MOVE_CAST(Handler)(handler)));
+    }
+
+#define BOOST_ASIO_PRIVATE_INIT_WRAPPER_DEF(n) \
+    template <typename Handler, BOOST_ASIO_VARIADIC_TPARAMS(n)> \
+    void operator()( \
+        BOOST_ASIO_MOVE_ARG(Handler) handler, \
+        BOOST_ASIO_VARIADIC_MOVE_PARAMS(n)) \
+    { \
+      BOOST_ASIO_MOVE_CAST(Initiation)(initiation_)( \
+          executor_binder<typename decay<Handler>::type, Executor>( \
+            executor_arg_t(), ex_, BOOST_ASIO_MOVE_CAST(Handler)(handler)), \
+          BOOST_ASIO_VARIADIC_MOVE_ARGS(n)); \
+    } \
+    \
+    template <typename Handler, BOOST_ASIO_VARIADIC_TPARAMS(n)> \
+    void operator()( \
+        BOOST_ASIO_MOVE_ARG(Handler) handler, \
+        BOOST_ASIO_VARIADIC_MOVE_PARAMS(n)) const \
+    { \
+      initiation_( \
+          executor_binder<typename decay<Handler>::type, Executor>( \
+            executor_arg_t(), ex_, BOOST_ASIO_MOVE_CAST(Handler)(handler)), \
+          BOOST_ASIO_VARIADIC_MOVE_ARGS(n)); \
+    } \
+    /**/
+    BOOST_ASIO_VARIADIC_GENERATE(BOOST_ASIO_PRIVATE_INIT_WRAPPER_DEF)
+#undef BOOST_ASIO_PRIVATE_INIT_WRAPPER_DEF
+
+#endif // defined(BOOST_ASIO_HAS_VARIADIC_TEMPLATES)
+
+    Executor ex_;
+    Initiation initiation_;
+  };
+
+#if defined(BOOST_ASIO_HAS_VARIADIC_TEMPLATES)
+
+  template <typename Initiation, typename RawCompletionToken, typename... Args>
+  static BOOST_ASIO_INITFN_DEDUCED_RESULT_TYPE(T, Signature,
+    (async_initiate<T, Signature>(
+        declval<init_wrapper<typename decay<Initiation>::type> >(),
+        declval<RawCompletionToken>().get(),
+        declval<BOOST_ASIO_MOVE_ARG(Args)>()...)))
+  initiate(
+      BOOST_ASIO_MOVE_ARG(Initiation) initiation,
+      BOOST_ASIO_MOVE_ARG(RawCompletionToken) token,
+      BOOST_ASIO_MOVE_ARG(Args)... args)
+  {
+    return async_initiate<T, Signature>(
+        init_wrapper<typename decay<Initiation>::type>(
+          token.get_executor(), BOOST_ASIO_MOVE_CAST(Initiation)(initiation)),
+        token.get(), BOOST_ASIO_MOVE_CAST(Args)(args)...);
+  }
+
+#else // defined(BOOST_ASIO_HAS_VARIADIC_TEMPLATES)
+
+  template <typename Initiation, typename RawCompletionToken>
+  static BOOST_ASIO_INITFN_DEDUCED_RESULT_TYPE(T, Signature,
+    (async_initiate<T, Signature>(
+        declval<init_wrapper<typename decay<Initiation>::type> >(),
+        declval<RawCompletionToken>().get())))
+  initiate(
+      BOOST_ASIO_MOVE_ARG(Initiation) initiation,
+      BOOST_ASIO_MOVE_ARG(RawCompletionToken) token)
+  {
+    return async_initiate<T, Signature>(
+        init_wrapper<typename decay<Initiation>::type>(
+          token.get_executor(), BOOST_ASIO_MOVE_CAST(Initiation)(initiation)),
+        token.get());
+  }
+
+#define BOOST_ASIO_PRIVATE_INITIATE_DEF(n) \
+  template <typename Initiation, typename RawCompletionToken, \
+      BOOST_ASIO_VARIADIC_TPARAMS(n)> \
+  static BOOST_ASIO_INITFN_DEDUCED_RESULT_TYPE(T, Signature, \
+    (async_initiate<T, Signature>( \
+        declval<init_wrapper<typename decay<Initiation>::type> >(), \
+        declval<RawCompletionToken>().get(), \
+        BOOST_ASIO_VARIADIC_MOVE_DECLVAL(n)))) \
+  initiate( \
+      BOOST_ASIO_MOVE_ARG(Initiation) initiation, \
+      BOOST_ASIO_MOVE_ARG(RawCompletionToken) token, \
+      BOOST_ASIO_VARIADIC_MOVE_PARAMS(n)) \
+  { \
+    return async_initiate<T, Signature>( \
+        init_wrapper<typename decay<Initiation>::type>( \
+          token.get_executor(), BOOST_ASIO_MOVE_CAST(Initiation)(initiation)), \
+        token.get(), BOOST_ASIO_VARIADIC_MOVE_ARGS(n)); \
+  } \
+  /**/
+  BOOST_ASIO_VARIADIC_GENERATE(BOOST_ASIO_PRIVATE_INITIATE_DEF)
+#undef BOOST_ASIO_PRIVATE_INITIATE_DEF
+
+#endif // defined(BOOST_ASIO_HAS_VARIADIC_TEMPLATES)
+
+private:
+  async_result(const async_result&) BOOST_ASIO_DELETED;
+  async_result& operator=(const async_result&) BOOST_ASIO_DELETED;
+};
+
+template <template <typename, typename> class Associator,
+    typename T, typename Executor, typename DefaultCandidate>
+struct associator<Associator, executor_binder<T, Executor>, DefaultCandidate>
+  : Associator<T, DefaultCandidate>
+{
+  static typename Associator<T, DefaultCandidate>::type
+  get(const executor_binder<T, Executor>& b) BOOST_ASIO_NOEXCEPT
+  {
+    return Associator<T, DefaultCandidate>::get(b.get());
+  }
+
+  static BOOST_ASIO_AUTO_RETURN_TYPE_PREFIX2(
+      typename Associator<T, DefaultCandidate>::type)
+  get(const executor_binder<T, Executor>& b,
+      const DefaultCandidate& c) BOOST_ASIO_NOEXCEPT
+    BOOST_ASIO_AUTO_RETURN_TYPE_SUFFIX((
+      Associator<T, DefaultCandidate>::get(b.get(), c)))
+  {
+    return Associator<T, DefaultCandidate>::get(b.get(), c);
   }
 };
 
@@ -565,8 +764,10 @@ struct associated_executor<executor_binder<T, Executor>, Executor1>
 {
   typedef Executor type;
 
-  static type get(const executor_binder<T, Executor>& b,
+  static BOOST_ASIO_AUTO_RETURN_TYPE_PREFIX(type) get(
+      const executor_binder<T, Executor>& b,
       const Executor1& = Executor1()) BOOST_ASIO_NOEXCEPT
+    BOOST_ASIO_AUTO_RETURN_TYPE_SUFFIX((b.get_executor()))
   {
     return b.get_executor();
   }

linx64/include/boost/asio/bind_immediate_executor.hpp

@@ -0,0 +1,753 @@
+//
+// bind_immediate_executor.hpp
+// ~~~~~~~~~~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2023 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef BOOST_ASIO_BIND_IMMEDIATE_EXECUTOR_HPP
+#define BOOST_ASIO_BIND_IMMEDIATE_EXECUTOR_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include <boost/asio/detail/config.hpp>
+#include <boost/asio/detail/type_traits.hpp>
+#include <boost/asio/detail/variadic_templates.hpp>
+#include <boost/asio/associated_immediate_executor.hpp>
+#include <boost/asio/associator.hpp>
+#include <boost/asio/async_result.hpp>
+
+#include <boost/asio/detail/push_options.hpp>
+
+namespace boost {
+namespace asio {
+namespace detail {
+
+// Helper to automatically define nested typedef result_type.
+
+template <typename T, typename = void>
+struct immediate_executor_binder_result_type
+{
+protected:
+  typedef void result_type_or_void;
+};
+
+template <typename T>
+struct immediate_executor_binder_result_type<T,
+  typename void_type<typename T::result_type>::type>
+{
+  typedef typename T::result_type result_type;
+protected:
+  typedef result_type result_type_or_void;
+};
+
+template <typename R>
+struct immediate_executor_binder_result_type<R(*)()>
+{
+  typedef R result_type;
+protected:
+  typedef result_type result_type_or_void;
+};
+
+template <typename R>
+struct immediate_executor_binder_result_type<R(&)()>
+{
+  typedef R result_type;
+protected:
+  typedef result_type result_type_or_void;
+};
+
+template <typename R, typename A1>
+struct immediate_executor_binder_result_type<R(*)(A1)>
+{
+  typedef R result_type;
+protected:
+  typedef result_type result_type_or_void;
+};
+
+template <typename R, typename A1>
+struct immediate_executor_binder_result_type<R(&)(A1)>
+{
+  typedef R result_type;
+protected:
+  typedef result_type result_type_or_void;
+};
+
+template <typename R, typename A1, typename A2>
+struct immediate_executor_binder_result_type<R(*)(A1, A2)>
+{
+  typedef R result_type;
+protected:
+  typedef result_type result_type_or_void;
+};
+
+template <typename R, typename A1, typename A2>
+struct immediate_executor_binder_result_type<R(&)(A1, A2)>
+{
+  typedef R result_type;
+protected:
+  typedef result_type result_type_or_void;
+};
+
+// Helper to automatically define nested typedef argument_type.
+
+template <typename T, typename = void>
+struct immediate_executor_binder_argument_type {};
+
+template <typename T>
+struct immediate_executor_binder_argument_type<T,
+  typename void_type<typename T::argument_type>::type>
+{
+  typedef typename T::argument_type argument_type;
+};
+
+template <typename R, typename A1>
+struct immediate_executor_binder_argument_type<R(*)(A1)>
+{
+  typedef A1 argument_type;
+};
+
+template <typename R, typename A1>
+struct immediate_executor_binder_argument_type<R(&)(A1)>
+{
+  typedef A1 argument_type;
+};
+
+// Helper to automatically define nested typedefs first_argument_type and
+// second_argument_type.
+
+template <typename T, typename = void>
+struct immediate_executor_binder_argument_types {};
+
+template <typename T>
+struct immediate_executor_binder_argument_types<T,
+  typename void_type<typename T::first_argument_type>::type>
+{
+  typedef typename T::first_argument_type first_argument_type;
+  typedef typename T::second_argument_type second_argument_type;
+};
+
+template <typename R, typename A1, typename A2>
+struct immediate_executor_binder_argument_type<R(*)(A1, A2)>
+{
+  typedef A1 first_argument_type;
+  typedef A2 second_argument_type;
+};
+
+template <typename R, typename A1, typename A2>
+struct immediate_executor_binder_argument_type<R(&)(A1, A2)>
+{
+  typedef A1 first_argument_type;
+  typedef A2 second_argument_type;
+};
+
+// Helper to enable SFINAE on zero-argument operator() below.
+
+template <typename T, typename = void>
+struct immediate_executor_binder_result_of0
+{
+  typedef void type;
+};
+
+template <typename T>
+struct immediate_executor_binder_result_of0<T,
+  typename void_type<typename result_of<T()>::type>::type>
+{
+  typedef typename result_of<T()>::type type;
+};
+
+} // namespace detail
+
+/// A call wrapper type to bind a immediate executor of type @c Executor
+/// to an object of type @c T.
+template <typename T, typename Executor>
+class immediate_executor_binder
+#if !defined(GENERATING_DOCUMENTATION)
+  : public detail::immediate_executor_binder_result_type<T>,
+    public detail::immediate_executor_binder_argument_type<T>,
+    public detail::immediate_executor_binder_argument_types<T>
+#endif // !defined(GENERATING_DOCUMENTATION)
+{
+public:
+  /// The type of the target object.
+  typedef T target_type;
+
+  /// The type of the associated immediate executor.
+  typedef Executor immediate_executor_type;
+
+#if defined(GENERATING_DOCUMENTATION)
+  /// The return type if a function.
+  /**
+   * The type of @c result_type is based on the type @c T of the wrapper's
+   * target object:
+   *
+   * @li if @c T is a pointer to function type, @c result_type is a synonym for
+   * the return type of @c T;
+   *
+   * @li if @c T is a class type with a member type @c result_type, then @c
+   * result_type is a synonym for @c T::result_type;
+   *
+   * @li otherwise @c result_type is not defined.
+   */
+  typedef see_below result_type;
+
+  /// The type of the function's argument.
+  /**
+   * The type of @c argument_type is based on the type @c T of the wrapper's
+   * target object:
+   *
+   * @li if @c T is a pointer to a function type accepting a single argument,
+   * @c argument_type is a synonym for the return type of @c T;
+   *
+   * @li if @c T is a class type with a member type @c argument_type, then @c
+   * argument_type is a synonym for @c T::argument_type;
+   *
+   * @li otherwise @c argument_type is not defined.
+   */
+  typedef see_below argument_type;
+
+  /// The type of the function's first argument.
+  /**
+   * The type of @c first_argument_type is based on the type @c T of the
+   * wrapper's target object:
+   *
+   * @li if @c T is a pointer to a function type accepting two arguments, @c
+   * first_argument_type is a synonym for the return type of @c T;
+   *
+   * @li if @c T is a class type with a member type @c first_argument_type,
+   * then @c first_argument_type is a synonym for @c T::first_argument_type;
+   *
+   * @li otherwise @c first_argument_type is not defined.
+   */
+  typedef see_below first_argument_type;
+
+  /// The type of the function's second argument.
+  /**
+   * The type of @c second_argument_type is based on the type @c T of the
+   * wrapper's target object:
+   *
+   * @li if @c T is a pointer to a function type accepting two arguments, @c
+   * second_argument_type is a synonym for the return type of @c T;
+   *
+   * @li if @c T is a class type with a member type @c first_argument_type,
+   * then @c second_argument_type is a synonym for @c T::second_argument_type;
+   *
+   * @li otherwise @c second_argument_type is not defined.
+   */
+  typedef see_below second_argument_type;
+#endif // defined(GENERATING_DOCUMENTATION)
+
+  /// Construct a immediate executor wrapper for the specified object.
+  /**
+   * This constructor is only valid if the type @c T is constructible from type
+   * @c U.
+   */
+  template <typename U>
+  immediate_executor_binder(const immediate_executor_type& e,
+      BOOST_ASIO_MOVE_ARG(U) u)
+    : executor_(e),
+      target_(BOOST_ASIO_MOVE_CAST(U)(u))
+  {
+  }
+
+  /// Copy constructor.
+  immediate_executor_binder(const immediate_executor_binder& other)
+    : executor_(other.get_immediate_executor()),
+      target_(other.get())
+  {
+  }
+
+  /// Construct a copy, but specify a different immediate executor.
+  immediate_executor_binder(const immediate_executor_type& e,
+      const immediate_executor_binder& other)
+    : executor_(e),
+      target_(other.get())
+  {
+  }
+
+  /// Construct a copy of a different immediate executor wrapper type.
+  /**
+   * This constructor is only valid if the @c Executor type is
+   * constructible from type @c OtherExecutor, and the type @c T is
+   * constructible from type @c U.
+   */
+  template <typename U, typename OtherExecutor>
+  immediate_executor_binder(
+      const immediate_executor_binder<U, OtherExecutor>& other)
+    : executor_(other.get_immediate_executor()),
+      target_(other.get())
+  {
+  }
+
+  /// Construct a copy of a different immediate executor wrapper type, but
+  /// specify a different immediate executor.
+  /**
+   * This constructor is only valid if the type @c T is constructible from type
+   * @c U.
+   */
+  template <typename U, typename OtherExecutor>
+  immediate_executor_binder(const immediate_executor_type& e,
+      const immediate_executor_binder<U, OtherExecutor>& other)
+    : executor_(e),
+      target_(other.get())
+  {
+  }
+
+#if defined(BOOST_ASIO_HAS_MOVE) || defined(GENERATING_DOCUMENTATION)
+
+  /// Move constructor.
+  immediate_executor_binder(immediate_executor_binder&& other)
+    : executor_(BOOST_ASIO_MOVE_CAST(immediate_executor_type)(
+          other.get_immediate_executor())),
+      target_(BOOST_ASIO_MOVE_CAST(T)(other.get()))
+  {
+  }
+
+  /// Move construct the target object, but specify a different immediate
+  /// executor.
+  immediate_executor_binder(const immediate_executor_type& e,
+      immediate_executor_binder&& other)
+    : executor_(e),
+      target_(BOOST_ASIO_MOVE_CAST(T)(other.get()))
+  {
+  }
+
+  /// Move construct from a different immediate executor wrapper type.
+  template <typename U, typename OtherExecutor>
+  immediate_executor_binder(
+      immediate_executor_binder<U, OtherExecutor>&& other)
+    : executor_(BOOST_ASIO_MOVE_CAST(OtherExecutor)(
+          other.get_immediate_executor())),
+      target_(BOOST_ASIO_MOVE_CAST(U)(other.get()))
+  {
+  }
+
+  /// Move construct from a different immediate executor wrapper type, but
+  /// specify a different immediate executor.
+  template <typename U, typename OtherExecutor>
+  immediate_executor_binder(const immediate_executor_type& e,
+      immediate_executor_binder<U, OtherExecutor>&& other)
+    : executor_(e),
+      target_(BOOST_ASIO_MOVE_CAST(U)(other.get()))
+  {
+  }
+
+#endif // defined(BOOST_ASIO_HAS_MOVE) || defined(GENERATING_DOCUMENTATION)
+
+  /// Destructor.
+  ~immediate_executor_binder()
+  {
+  }
+
+  /// Obtain a reference to the target object.
+  target_type& get() BOOST_ASIO_NOEXCEPT
+  {
+    return target_;
+  }
+
+  /// Obtain a reference to the target object.
+  const target_type& get() const BOOST_ASIO_NOEXCEPT
+  {
+    return target_;
+  }
+
+  /// Obtain the associated immediate executor.
+  immediate_executor_type get_immediate_executor() const BOOST_ASIO_NOEXCEPT
+  {
+    return executor_;
+  }
+
+#if defined(GENERATING_DOCUMENTATION)
+
+  template <typename... Args> auto operator()(Args&& ...);
+  template <typename... Args> auto operator()(Args&& ...) const;
+
+#elif defined(BOOST_ASIO_HAS_VARIADIC_TEMPLATES)
+
+  /// Forwarding function call operator.
+  template <typename... Args>
+  typename result_of<T(Args...)>::type operator()(
+      BOOST_ASIO_MOVE_ARG(Args)... args)
+  {
+    return target_(BOOST_ASIO_MOVE_CAST(Args)(args)...);
+  }
+
+  /// Forwarding function call operator.
+  template <typename... Args>
+  typename result_of<T(Args...)>::type operator()(
+      BOOST_ASIO_MOVE_ARG(Args)... args) const
+  {
+    return target_(BOOST_ASIO_MOVE_CAST(Args)(args)...);
+  }
+
+#elif defined(BOOST_ASIO_HAS_STD_TYPE_TRAITS) && !defined(_MSC_VER)
+
+  typename detail::immediate_executor_binder_result_of0<T>::type operator()()
+  {
+    return target_();
+  }
+
+  typename detail::immediate_executor_binder_result_of0<T>::type
+  operator()() const
+  {
+    return target_();
+  }
+
+#define BOOST_ASIO_PRIVATE_BINDER_CALL_DEF(n) \
+  template <BOOST_ASIO_VARIADIC_TPARAMS(n)> \
+  typename result_of<T(BOOST_ASIO_VARIADIC_TARGS(n))>::type operator()( \
+      BOOST_ASIO_VARIADIC_MOVE_PARAMS(n)) \
+  { \
+    return target_(BOOST_ASIO_VARIADIC_MOVE_ARGS(n)); \
+  } \
+  \
+  template <BOOST_ASIO_VARIADIC_TPARAMS(n)> \
+  typename result_of<T(BOOST_ASIO_VARIADIC_TARGS(n))>::type operator()( \
+      BOOST_ASIO_VARIADIC_MOVE_PARAMS(n)) const \
+  { \
+    return target_(BOOST_ASIO_VARIADIC_MOVE_ARGS(n)); \
+  } \
+  /**/
+  BOOST_ASIO_VARIADIC_GENERATE(BOOST_ASIO_PRIVATE_BINDER_CALL_DEF)
+#undef BOOST_ASIO_PRIVATE_BINDER_CALL_DEF
+
+#else // defined(BOOST_ASIO_HAS_STD_TYPE_TRAITS) && !defined(_MSC_VER)
+
+  typedef typename detail::immediate_executor_binder_result_type<
+    T>::result_type_or_void result_type_or_void;
+
+  result_type_or_void operator()()
+  {
+    return target_();
+  }
+
+  result_type_or_void operator()() const
+  {
+    return target_();
+  }
+
+#define BOOST_ASIO_PRIVATE_BINDER_CALL_DEF(n) \
+  template <BOOST_ASIO_VARIADIC_TPARAMS(n)> \
+  result_type_or_void operator()( \
+      BOOST_ASIO_VARIADIC_MOVE_PARAMS(n)) \
+  { \
+    return target_(BOOST_ASIO_VARIADIC_MOVE_ARGS(n)); \
+  } \
+  \
+  template <BOOST_ASIO_VARIADIC_TPARAMS(n)> \
+  result_type_or_void operator()( \
+      BOOST_ASIO_VARIADIC_MOVE_PARAMS(n)) const \
+  { \
+    return target_(BOOST_ASIO_VARIADIC_MOVE_ARGS(n)); \
+  } \
+  /**/
+  BOOST_ASIO_VARIADIC_GENERATE(BOOST_ASIO_PRIVATE_BINDER_CALL_DEF)
+#undef BOOST_ASIO_PRIVATE_BINDER_CALL_DEF
+
+#endif // defined(BOOST_ASIO_HAS_STD_TYPE_TRAITS) && !defined(_MSC_VER)
+
+private:
+  Executor executor_;
+  T target_;
+};
+
+/// Associate an object of type @c T with a immediate executor of type
+/// @c Executor.
+template <typename Executor, typename T>
+BOOST_ASIO_NODISCARD inline
+immediate_executor_binder<typename decay<T>::type, Executor>
+bind_immediate_executor(const Executor& e, BOOST_ASIO_MOVE_ARG(T) t)
+{
+  return immediate_executor_binder<
+    typename decay<T>::type, Executor>(
+      e, BOOST_ASIO_MOVE_CAST(T)(t));
+}
+
+#if !defined(GENERATING_DOCUMENTATION)
+
+namespace detail {
+
+template <typename TargetAsyncResult, typename Executor, typename = void>
+class immediate_executor_binder_completion_handler_async_result
+{
+public:
+  template <typename T>
+  explicit immediate_executor_binder_completion_handler_async_result(T&)
+  {
+  }
+};
+
+template <typename TargetAsyncResult, typename Executor>
+class immediate_executor_binder_completion_handler_async_result<
+  TargetAsyncResult, Executor,
+  typename void_type<
+    typename TargetAsyncResult::completion_handler_type
+  >::type>
+{
+public:
+  typedef immediate_executor_binder<
+    typename TargetAsyncResult::completion_handler_type, Executor>
+      completion_handler_type;
+
+  explicit immediate_executor_binder_completion_handler_async_result(
+      typename TargetAsyncResult::completion_handler_type& handler)
+    : target_(handler)
+  {
+  }
+
+  typename TargetAsyncResult::return_type get()
+  {
+    return target_.get();
+  }
+
+private:
+  TargetAsyncResult target_;
+};
+
+template <typename TargetAsyncResult, typename = void>
+struct immediate_executor_binder_async_result_return_type
+{
+};
+
+template <typename TargetAsyncResult>
+struct immediate_executor_binder_async_result_return_type<
+  TargetAsyncResult,
+  typename void_type<
+    typename TargetAsyncResult::return_type
+  >::type>
+{
+  typedef typename TargetAsyncResult::return_type return_type;
+};
+
+} // namespace detail
+
+template <typename T, typename Executor, typename Signature>
+class async_result<immediate_executor_binder<T, Executor>, Signature> :
+  public detail::immediate_executor_binder_completion_handler_async_result<
+    async_result<T, Signature>, Executor>,
+  public detail::immediate_executor_binder_async_result_return_type<
+    async_result<T, Signature> >
+{
+public:
+  explicit async_result(immediate_executor_binder<T, Executor>& b)
+    : detail::immediate_executor_binder_completion_handler_async_result<
+        async_result<T, Signature>, Executor>(b.get())
+  {
+  }
+
+  template <typename Initiation>
+  struct init_wrapper
+  {
+    template <typename Init>
+    init_wrapper(const Executor& e, BOOST_ASIO_MOVE_ARG(Init) init)
+      : executor_(e),
+        initiation_(BOOST_ASIO_MOVE_CAST(Init)(init))
+    {
+    }
+
+#if defined(BOOST_ASIO_HAS_VARIADIC_TEMPLATES)
+
+    template <typename Handler, typename... Args>
+    void operator()(
+        BOOST_ASIO_MOVE_ARG(Handler) handler,
+        BOOST_ASIO_MOVE_ARG(Args)... args)
+    {
+      BOOST_ASIO_MOVE_CAST(Initiation)(initiation_)(
+          immediate_executor_binder<
+            typename decay<Handler>::type, Executor>(
+              executor_, BOOST_ASIO_MOVE_CAST(Handler)(handler)),
+          BOOST_ASIO_MOVE_CAST(Args)(args)...);
+    }
+
+    template <typename Handler, typename... Args>
+    void operator()(
+        BOOST_ASIO_MOVE_ARG(Handler) handler,
+        BOOST_ASIO_MOVE_ARG(Args)... args) const
+    {
+      initiation_(
+          immediate_executor_binder<
+            typename decay<Handler>::type, Executor>(
+              executor_, BOOST_ASIO_MOVE_CAST(Handler)(handler)),
+          BOOST_ASIO_MOVE_CAST(Args)(args)...);
+    }
+
+#else // defined(BOOST_ASIO_HAS_VARIADIC_TEMPLATES)
+
+    template <typename Handler>
+    void operator()(
+        BOOST_ASIO_MOVE_ARG(Handler) handler)
+    {
+      BOOST_ASIO_MOVE_CAST(Initiation)(initiation_)(
+          immediate_executor_binder<
+            typename decay<Handler>::type, Executor>(
+              executor_, BOOST_ASIO_MOVE_CAST(Handler)(handler)));
+    }
+
+    template <typename Handler>
+    void operator()(
+        BOOST_ASIO_MOVE_ARG(Handler) handler) const
+    {
+      initiation_(
+          immediate_executor_binder<
+            typename decay<Handler>::type, Executor>(
+              executor_, BOOST_ASIO_MOVE_CAST(Handler)(handler)));
+    }
+
+#define BOOST_ASIO_PRIVATE_INIT_WRAPPER_DEF(n) \
+    template <typename Handler, BOOST_ASIO_VARIADIC_TPARAMS(n)> \
+    void operator()( \
+        BOOST_ASIO_MOVE_ARG(Handler) handler, \
+        BOOST_ASIO_VARIADIC_MOVE_PARAMS(n)) \
+    { \
+      BOOST_ASIO_MOVE_CAST(Initiation)(initiation_)( \
+          immediate_executor_binder< \
+            typename decay<Handler>::type, Executor>( \
+              executor_, BOOST_ASIO_MOVE_CAST(Handler)(handler)), \
+          BOOST_ASIO_VARIADIC_MOVE_ARGS(n)); \
+    } \
+    \
+    template <typename Handler, BOOST_ASIO_VARIADIC_TPARAMS(n)> \
+    void operator()( \
+        BOOST_ASIO_MOVE_ARG(Handler) handler, \
+        BOOST_ASIO_VARIADIC_MOVE_PARAMS(n)) const \
+    { \
+      initiation_( \
+          immediate_executor_binder< \
+            typename decay<Handler>::type, Executor>( \
+              executor_, BOOST_ASIO_MOVE_CAST(Handler)(handler)), \
+          BOOST_ASIO_VARIADIC_MOVE_ARGS(n)); \
+    } \
+    /**/
+    BOOST_ASIO_VARIADIC_GENERATE(BOOST_ASIO_PRIVATE_INIT_WRAPPER_DEF)
+#undef BOOST_ASIO_PRIVATE_INIT_WRAPPER_DEF
+
+#endif // defined(BOOST_ASIO_HAS_VARIADIC_TEMPLATES)
+
+    Executor executor_;
+    Initiation initiation_;
+  };
+
+#if defined(BOOST_ASIO_HAS_VARIADIC_TEMPLATES)
+
+  template <typename Initiation, typename RawCompletionToken, typename... Args>
+  static BOOST_ASIO_INITFN_DEDUCED_RESULT_TYPE(T, Signature,
+    (async_initiate<T, Signature>(
+        declval<init_wrapper<typename decay<Initiation>::type> >(),
+        declval<RawCompletionToken>().get(),
+        declval<BOOST_ASIO_MOVE_ARG(Args)>()...)))
+  initiate(
+      BOOST_ASIO_MOVE_ARG(Initiation) initiation,
+      BOOST_ASIO_MOVE_ARG(RawCompletionToken) token,
+      BOOST_ASIO_MOVE_ARG(Args)... args)
+  {
+    return async_initiate<T, Signature>(
+        init_wrapper<typename decay<Initiation>::type>(
+          token.get_immediate_executor(),
+          BOOST_ASIO_MOVE_CAST(Initiation)(initiation)),
+        token.get(), BOOST_ASIO_MOVE_CAST(Args)(args)...);
+  }
+
+#else // defined(BOOST_ASIO_HAS_VARIADIC_TEMPLATES)
+
+  template <typename Initiation, typename RawCompletionToken>
+  static BOOST_ASIO_INITFN_DEDUCED_RESULT_TYPE(T, Signature,
+    (async_initiate<T, Signature>(
+        declval<init_wrapper<typename decay<Initiation>::type> >(),
+        declval<RawCompletionToken>().get())))
+  initiate(
+      BOOST_ASIO_MOVE_ARG(Initiation) initiation,
+      BOOST_ASIO_MOVE_ARG(RawCompletionToken) token)
+  {
+    return async_initiate<T, Signature>(
+        init_wrapper<typename decay<Initiation>::type>(
+          token.get_immediate_executor(),
+          BOOST_ASIO_MOVE_CAST(Initiation)(initiation)),
+        token.get());
+  }
+
+#define BOOST_ASIO_PRIVATE_INITIATE_DEF(n) \
+  template <typename Initiation, typename RawCompletionToken, \
+      BOOST_ASIO_VARIADIC_TPARAMS(n)> \
+  static BOOST_ASIO_INITFN_DEDUCED_RESULT_TYPE(T, Signature, \
+    (async_initiate<T, Signature>( \
+        declval<init_wrapper<typename decay<Initiation>::type> >(), \
+        declval<RawCompletionToken>().get(), \
+        BOOST_ASIO_VARIADIC_MOVE_DECLVAL(n)))) \
+  initiate( \
+      BOOST_ASIO_MOVE_ARG(Initiation) initiation, \
+      BOOST_ASIO_MOVE_ARG(RawCompletionToken) token, \
+      BOOST_ASIO_VARIADIC_MOVE_PARAMS(n)) \
+  { \
+    return async_initiate<T, Signature>( \
+        init_wrapper<typename decay<Initiation>::type>( \
+          token.get_immediate_executor(), \
+          BOOST_ASIO_MOVE_CAST(Initiation)(initiation)), \
+        token.get(), BOOST_ASIO_VARIADIC_MOVE_ARGS(n)); \
+  } \
+  /**/
+  BOOST_ASIO_VARIADIC_GENERATE(BOOST_ASIO_PRIVATE_INITIATE_DEF)
+#undef BOOST_ASIO_PRIVATE_INITIATE_DEF
+
+#endif // defined(BOOST_ASIO_HAS_VARIADIC_TEMPLATES)
+
+private:
+  async_result(const async_result&) BOOST_ASIO_DELETED;
+  async_result& operator=(const async_result&) BOOST_ASIO_DELETED;
+
+  async_result<T, Signature> target_;
+};
+
+template <template <typename, typename> class Associator,
+    typename T, typename Executor, typename DefaultCandidate>
+struct associator<Associator,
+    immediate_executor_binder<T, Executor>,
+    DefaultCandidate>
+  : Associator<T, DefaultCandidate>
+{
+  static typename Associator<T, DefaultCandidate>::type
+  get(const immediate_executor_binder<T, Executor>& b)
+    BOOST_ASIO_NOEXCEPT
+  {
+    return Associator<T, DefaultCandidate>::get(b.get());
+  }
+
+  static BOOST_ASIO_AUTO_RETURN_TYPE_PREFIX2(
+      typename Associator<T, DefaultCandidate>::type)
+  get(const immediate_executor_binder<T, Executor>& b,
+      const DefaultCandidate& c) BOOST_ASIO_NOEXCEPT
+    BOOST_ASIO_AUTO_RETURN_TYPE_SUFFIX((
+      Associator<T, DefaultCandidate>::get(b.get(), c)))
+  {
+    return Associator<T, DefaultCandidate>::get(b.get(), c);
+  }
+};
+
+template <typename T, typename Executor, typename Executor1>
+struct associated_immediate_executor<
+    immediate_executor_binder<T, Executor>,
+    Executor1>
+{
+  typedef Executor type;
+
+  static BOOST_ASIO_AUTO_RETURN_TYPE_PREFIX(type) get(
+      const immediate_executor_binder<T, Executor>& b,
+      const Executor1& = Executor1()) BOOST_ASIO_NOEXCEPT
+    BOOST_ASIO_AUTO_RETURN_TYPE_SUFFIX((b.get_immediate_executor()))
+  {
+    return b.get_immediate_executor();
+  }
+};
+
+#endif // !defined(GENERATING_DOCUMENTATION)
+
+} // namespace asio
+} // namespace boost
+
+#include <boost/asio/detail/pop_options.hpp>
+
+#endif // BOOST_ASIO_BIND_IMMEDIATE_EXECUTOR_HPP

linx64/include/boost/asio/buffer.hpp

@@ -2,7 +2,7 @@
 // buffer.hpp
 // ~~~~~~~~~~
 //
-// Copyright (c) 2003-2019 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2023 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -27,6 +27,7 @@
 #include <boost/asio/detail/string_view.hpp>
 #include <boost/asio/detail/throw_exception.hpp>
 #include <boost/asio/detail/type_traits.hpp>
+#include <boost/asio/is_contiguous_iterator.hpp>
 
 #if defined(BOOST_ASIO_MSVC) && (BOOST_ASIO_MSVC >= 1700)
 # if defined(_HAS_ITERATOR_DEBUGGING) && (_HAS_ITERATOR_DEBUGGING != 0)
@@ -50,11 +51,13 @@
 
 #if defined(BOOST_ASIO_HAS_BOOST_WORKAROUND)
 # include <boost/detail/workaround.hpp>
-# if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x582)) \
-    || BOOST_WORKAROUND(__SUNPRO_CC, BOOST_TESTED_AT(0x590))
+# if !defined(__clang__)
+#  if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x582))
+#   define BOOST_ASIO_ENABLE_ARRAY_BUFFER_WORKAROUND
+#  endif // BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x582))
+# elif BOOST_WORKAROUND(__SUNPRO_CC, BOOST_TESTED_AT(0x590))
 #  define BOOST_ASIO_ENABLE_ARRAY_BUFFER_WORKAROUND
-# endif // BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x582))
-        // || BOOST_WORKAROUND(__SUNPRO_CC, BOOST_TESTED_AT(0x590))
+# endif // BOOST_WORKAROUND(__SUNPRO_CC, BOOST_TESTED_AT(0x590))
 #endif // defined(BOOST_ASIO_HAS_BOOST_WORKAROUND)
 
 #if defined(BOOST_ASIO_ENABLE_ARRAY_BUFFER_WORKAROUND)
@@ -385,9 +388,9 @@ private:
 /// Get an iterator to the first element in a buffer sequence.
 template <typename MutableBuffer>
 inline const mutable_buffer* buffer_sequence_begin(const MutableBuffer& b,
-    typename enable_if<
+    typename constraint<
       is_convertible<const MutableBuffer*, const mutable_buffer*>::value
-    >::type* = 0) BOOST_ASIO_NOEXCEPT
+    >::type = 0) BOOST_ASIO_NOEXCEPT
 {
   return static_cast<const mutable_buffer*>(detail::addressof(b));
 }
@@ -395,9 +398,9 @@ inline const mutable_buffer* buffer_sequence_begin(const MutableBuffer& b,
 /// Get an iterator to the first element in a buffer sequence.
 template <typename ConstBuffer>
 inline const const_buffer* buffer_sequence_begin(const ConstBuffer& b,
-    typename enable_if<
+    typename constraint<
       is_convertible<const ConstBuffer*, const const_buffer*>::value
-    >::type* = 0) BOOST_ASIO_NOEXCEPT
+    >::type = 0) BOOST_ASIO_NOEXCEPT
 {
   return static_cast<const const_buffer*>(detail::addressof(b));
 }
@@ -407,10 +410,10 @@ inline const const_buffer* buffer_sequence_begin(const ConstBuffer& b,
 /// Get an iterator to the first element in a buffer sequence.
 template <typename C>
 inline auto buffer_sequence_begin(C& c,
-    typename enable_if<
+    typename constraint<
       !is_convertible<const C*, const mutable_buffer*>::value
         && !is_convertible<const C*, const const_buffer*>::value
-    >::type* = 0) BOOST_ASIO_NOEXCEPT -> decltype(c.begin())
+    >::type = 0) BOOST_ASIO_NOEXCEPT -> decltype(c.begin())
 {
   return c.begin();
 }
@@ -418,10 +421,10 @@ inline auto buffer_sequence_begin(C& c,
 /// Get an iterator to the first element in a buffer sequence.
 template <typename C>
 inline auto buffer_sequence_begin(const C& c,
-    typename enable_if<
+    typename constraint<
       !is_convertible<const C*, const mutable_buffer*>::value
         && !is_convertible<const C*, const const_buffer*>::value
-    >::type* = 0) BOOST_ASIO_NOEXCEPT -> decltype(c.begin())
+    >::type = 0) BOOST_ASIO_NOEXCEPT -> decltype(c.begin())
 {
   return c.begin();
 }
@@ -430,20 +433,20 @@ inline auto buffer_sequence_begin(const C& c,
 
 template <typename C>
 inline typename C::iterator buffer_sequence_begin(C& c,
-    typename enable_if<
+    typename constraint<
       !is_convertible<const C*, const mutable_buffer*>::value
         && !is_convertible<const C*, const const_buffer*>::value
-    >::type* = 0) BOOST_ASIO_NOEXCEPT
+    >::type = 0) BOOST_ASIO_NOEXCEPT
 {
   return c.begin();
 }
 
 template <typename C>
 inline typename C::const_iterator buffer_sequence_begin(const C& c,
-    typename enable_if<
+    typename constraint<
       !is_convertible<const C*, const mutable_buffer*>::value
         && !is_convertible<const C*, const const_buffer*>::value
-    >::type* = 0) BOOST_ASIO_NOEXCEPT
+    >::type = 0) BOOST_ASIO_NOEXCEPT
 {
   return c.begin();
 }
@@ -462,9 +465,9 @@ inline typename C::const_iterator buffer_sequence_begin(const C& c,
 /// Get an iterator to one past the end element in a buffer sequence.
 template <typename MutableBuffer>
 inline const mutable_buffer* buffer_sequence_end(const MutableBuffer& b,
-    typename enable_if<
+    typename constraint<
       is_convertible<const MutableBuffer*, const mutable_buffer*>::value
-    >::type* = 0) BOOST_ASIO_NOEXCEPT
+    >::type = 0) BOOST_ASIO_NOEXCEPT
 {
   return static_cast<const mutable_buffer*>(detail::addressof(b)) + 1;
 }
@@ -472,9 +475,9 @@ inline const mutable_buffer* buffer_sequence_end(const MutableBuffer& b,
 /// Get an iterator to one past the end element in a buffer sequence.
 template <typename ConstBuffer>
 inline const const_buffer* buffer_sequence_end(const ConstBuffer& b,
-    typename enable_if<
+    typename constraint<
       is_convertible<const ConstBuffer*, const const_buffer*>::value
-    >::type* = 0) BOOST_ASIO_NOEXCEPT
+    >::type = 0) BOOST_ASIO_NOEXCEPT
 {
   return static_cast<const const_buffer*>(detail::addressof(b)) + 1;
 }
@@ -484,10 +487,10 @@ inline const const_buffer* buffer_sequence_end(const ConstBuffer& b,
 /// Get an iterator to one past the end element in a buffer sequence.
 template <typename C>
 inline auto buffer_sequence_end(C& c,
-    typename enable_if<
+    typename constraint<
       !is_convertible<const C*, const mutable_buffer*>::value
         && !is_convertible<const C*, const const_buffer*>::value
-    >::type* = 0) BOOST_ASIO_NOEXCEPT -> decltype(c.end())
+    >::type = 0) BOOST_ASIO_NOEXCEPT -> decltype(c.end())
 {
   return c.end();
 }
@@ -495,10 +498,10 @@ inline auto buffer_sequence_end(C& c,
 /// Get an iterator to one past the end element in a buffer sequence.
 template <typename C>
 inline auto buffer_sequence_end(const C& c,
-    typename enable_if<
+    typename constraint<
       !is_convertible<const C*, const mutable_buffer*>::value
         && !is_convertible<const C*, const const_buffer*>::value
-    >::type* = 0) BOOST_ASIO_NOEXCEPT -> decltype(c.end())
+    >::type = 0) BOOST_ASIO_NOEXCEPT -> decltype(c.end())
 {
   return c.end();
 }
@@ -507,20 +510,20 @@ inline auto buffer_sequence_end(const C& c,
 
 template <typename C>
 inline typename C::iterator buffer_sequence_end(C& c,
-    typename enable_if<
+    typename constraint<
       !is_convertible<const C*, const mutable_buffer*>::value
         && !is_convertible<const C*, const const_buffer*>::value
-    >::type* = 0) BOOST_ASIO_NOEXCEPT
+    >::type = 0) BOOST_ASIO_NOEXCEPT
 {
   return c.end();
 }
 
 template <typename C>
 inline typename C::const_iterator buffer_sequence_end(const C& c,
-    typename enable_if<
+    typename constraint<
       !is_convertible<const C*, const mutable_buffer*>::value
         && !is_convertible<const C*, const const_buffer*>::value
-    >::type* = 0) BOOST_ASIO_NOEXCEPT
+    >::type = 0) BOOST_ASIO_NOEXCEPT
 {
   return c.end();
 }
@@ -890,6 +893,25 @@ private:
  * bufs2.push_back(boost::asio::buffer(d2));
  * bufs2.push_back(boost::asio::buffer(d3));
  * bytes_transferred = sock.send(bufs2); @endcode
+ *
+ * @par Buffer Literals
+ *
+ * The `_buf` literal suffix, defined in namespace
+ * <tt>boost::asio::buffer_literals</tt>, may be used to create @c const_buffer
+ * objects from string, binary integer, and hexadecimal integer literals.
+ * For example:
+ *
+ * @code
+ * using namespace boost::asio::buffer_literals;
+ *
+ * boost::asio::const_buffer b1 = "hello"_buf;
+ * boost::asio::const_buffer b2 = 0xdeadbeef_buf;
+ * boost::asio::const_buffer b3 = 0x0123456789abcdef0123456789abcdef_buf;
+ * boost::asio::const_buffer b4 = 0b1010101011001100_buf; @endcode
+ *
+ * Note that the memory associated with a buffer literal is valid for the
+ * lifetime of the program. This means that the buffer can be safely used with
+ * asynchronous operations.
  */
 /*@{*/
 
@@ -905,7 +927,7 @@ private:
 /**
  * @returns <tt>mutable_buffer(b)</tt>.
  */
-inline BOOST_ASIO_MUTABLE_BUFFER buffer(
+BOOST_ASIO_NODISCARD inline BOOST_ASIO_MUTABLE_BUFFER buffer(
     const mutable_buffer& b) BOOST_ASIO_NOEXCEPT
 {
   return BOOST_ASIO_MUTABLE_BUFFER(b);
@@ -918,7 +940,8 @@ inline BOOST_ASIO_MUTABLE_BUFFER buffer(
  *     b.data(),
  *     min(b.size(), max_size_in_bytes)); @endcode
  */
-inline BOOST_ASIO_MUTABLE_BUFFER buffer(const mutable_buffer& b,
+BOOST_ASIO_NODISCARD inline BOOST_ASIO_MUTABLE_BUFFER buffer(
+    const mutable_buffer& b,
     std::size_t max_size_in_bytes) BOOST_ASIO_NOEXCEPT
 {
   return BOOST_ASIO_MUTABLE_BUFFER(
@@ -935,7 +958,7 @@ inline BOOST_ASIO_MUTABLE_BUFFER buffer(const mutable_buffer& b,
 /**
  * @returns <tt>const_buffer(b)</tt>.
  */
-inline BOOST_ASIO_CONST_BUFFER buffer(
+BOOST_ASIO_NODISCARD inline BOOST_ASIO_CONST_BUFFER buffer(
     const const_buffer& b) BOOST_ASIO_NOEXCEPT
 {
   return BOOST_ASIO_CONST_BUFFER(b);
@@ -948,7 +971,8 @@ inline BOOST_ASIO_CONST_BUFFER buffer(
  *     b.data(),
  *     min(b.size(), max_size_in_bytes)); @endcode
  */
-inline BOOST_ASIO_CONST_BUFFER buffer(const const_buffer& b,
+BOOST_ASIO_NODISCARD inline BOOST_ASIO_CONST_BUFFER buffer(
+    const const_buffer& b,
     std::size_t max_size_in_bytes) BOOST_ASIO_NOEXCEPT
 {
   return BOOST_ASIO_CONST_BUFFER(b.data(),
@@ -964,8 +988,8 @@ inline BOOST_ASIO_CONST_BUFFER buffer(const const_buffer& b,
 /**
  * @returns <tt>mutable_buffer(data, size_in_bytes)</tt>.
  */
-inline BOOST_ASIO_MUTABLE_BUFFER buffer(void* data,
-    std::size_t size_in_bytes) BOOST_ASIO_NOEXCEPT
+BOOST_ASIO_NODISCARD inline BOOST_ASIO_MUTABLE_BUFFER buffer(
+    void* data, std::size_t size_in_bytes) BOOST_ASIO_NOEXCEPT
 {
   return BOOST_ASIO_MUTABLE_BUFFER(data, size_in_bytes);
 }
@@ -974,8 +998,8 @@ inline BOOST_ASIO_MUTABLE_BUFFER buffer(void* data,
 /**
  * @returns <tt>const_buffer(data, size_in_bytes)</tt>.
  */
-inline BOOST_ASIO_CONST_BUFFER buffer(const void* data,
-    std::size_t size_in_bytes) BOOST_ASIO_NOEXCEPT
+BOOST_ASIO_NODISCARD inline BOOST_ASIO_CONST_BUFFER buffer(
+    const void* data, std::size_t size_in_bytes) BOOST_ASIO_NOEXCEPT
 {
   return BOOST_ASIO_CONST_BUFFER(data, size_in_bytes);
 }
@@ -988,7 +1012,8 @@ inline BOOST_ASIO_CONST_BUFFER buffer(const void* data,
  *     N * sizeof(PodType)); @endcode
  */
 template <typename PodType, std::size_t N>
-inline BOOST_ASIO_MUTABLE_BUFFER buffer(PodType (&data)[N]) BOOST_ASIO_NOEXCEPT
+BOOST_ASIO_NODISCARD inline BOOST_ASIO_MUTABLE_BUFFER buffer(
+    PodType (&data)[N]) BOOST_ASIO_NOEXCEPT
 {
   return BOOST_ASIO_MUTABLE_BUFFER(data, N * sizeof(PodType));
 }
@@ -1001,7 +1026,8 @@ inline BOOST_ASIO_MUTABLE_BUFFER buffer(PodType (&data)[N]) BOOST_ASIO_NOEXCEPT
  *     min(N * sizeof(PodType), max_size_in_bytes)); @endcode
  */
 template <typename PodType, std::size_t N>
-inline BOOST_ASIO_MUTABLE_BUFFER buffer(PodType (&data)[N],
+BOOST_ASIO_NODISCARD inline BOOST_ASIO_MUTABLE_BUFFER buffer(
+    PodType (&data)[N],
     std::size_t max_size_in_bytes) BOOST_ASIO_NOEXCEPT
 {
   return BOOST_ASIO_MUTABLE_BUFFER(data,
@@ -1017,7 +1043,7 @@ inline BOOST_ASIO_MUTABLE_BUFFER buffer(PodType (&data)[N],
  *     N * sizeof(PodType)); @endcode
  */
 template <typename PodType, std::size_t N>
-inline BOOST_ASIO_CONST_BUFFER buffer(
+BOOST_ASIO_NODISCARD inline BOOST_ASIO_CONST_BUFFER buffer(
     const PodType (&data)[N]) BOOST_ASIO_NOEXCEPT
 {
   return BOOST_ASIO_CONST_BUFFER(data, N * sizeof(PodType));
@@ -1031,7 +1057,8 @@ inline BOOST_ASIO_CONST_BUFFER buffer(
  *     min(N * sizeof(PodType), max_size_in_bytes)); @endcode
  */
 template <typename PodType, std::size_t N>
-inline BOOST_ASIO_CONST_BUFFER buffer(const PodType (&data)[N],
+BOOST_ASIO_NODISCARD inline BOOST_ASIO_CONST_BUFFER buffer(
+    const PodType (&data)[N],
     std::size_t max_size_in_bytes) BOOST_ASIO_NOEXCEPT
 {
   return BOOST_ASIO_CONST_BUFFER(data,
@@ -1081,7 +1108,8 @@ struct buffer_types
 } // namespace detail
 
 template <typename PodType, std::size_t N>
-inline typename detail::buffer_types<PodType>::container_type
+BOOST_ASIO_NODISCARD inline
+typename detail::buffer_types<PodType>::container_type
 buffer(boost::array<PodType, N>& data) BOOST_ASIO_NOEXCEPT
 {
   typedef typename boost::asio::detail::buffer_types<PodType>::buffer_type
@@ -1093,7 +1121,8 @@ buffer(boost::array<PodType, N>& data) BOOST_ASIO_NOEXCEPT
 }
 
 template <typename PodType, std::size_t N>
-inline typename detail::buffer_types<PodType>::container_type
+BOOST_ASIO_NODISCARD inline
+typename detail::buffer_types<PodType>::container_type
 buffer(boost::array<PodType, N>& data,
     std::size_t max_size_in_bytes) BOOST_ASIO_NOEXCEPT
 {
@@ -1117,7 +1146,7 @@ buffer(boost::array<PodType, N>& data,
  *     data.size() * sizeof(PodType)); @endcode
  */
 template <typename PodType, std::size_t N>
-inline BOOST_ASIO_MUTABLE_BUFFER buffer(
+BOOST_ASIO_NODISCARD inline BOOST_ASIO_MUTABLE_BUFFER buffer(
     boost::array<PodType, N>& data) BOOST_ASIO_NOEXCEPT
 {
   return BOOST_ASIO_MUTABLE_BUFFER(
@@ -1132,7 +1161,8 @@ inline BOOST_ASIO_MUTABLE_BUFFER buffer(
  *     min(data.size() * sizeof(PodType), max_size_in_bytes)); @endcode
  */
 template <typename PodType, std::size_t N>
-inline BOOST_ASIO_MUTABLE_BUFFER buffer(boost::array<PodType, N>& data,
+BOOST_ASIO_NODISCARD inline BOOST_ASIO_MUTABLE_BUFFER buffer(
+    boost::array<PodType, N>& data,
     std::size_t max_size_in_bytes) BOOST_ASIO_NOEXCEPT
 {
   return BOOST_ASIO_MUTABLE_BUFFER(data.c_array(),
@@ -1148,7 +1178,7 @@ inline BOOST_ASIO_MUTABLE_BUFFER buffer(boost::array<PodType, N>& data,
  *     data.size() * sizeof(PodType)); @endcode
  */
 template <typename PodType, std::size_t N>
-inline BOOST_ASIO_CONST_BUFFER buffer(
+BOOST_ASIO_NODISCARD inline BOOST_ASIO_CONST_BUFFER buffer(
     boost::array<const PodType, N>& data) BOOST_ASIO_NOEXCEPT
 {
   return BOOST_ASIO_CONST_BUFFER(data.data(), data.size() * sizeof(PodType));
@@ -1162,7 +1192,8 @@ inline BOOST_ASIO_CONST_BUFFER buffer(
  *     min(data.size() * sizeof(PodType), max_size_in_bytes)); @endcode
  */
 template <typename PodType, std::size_t N>
-inline BOOST_ASIO_CONST_BUFFER buffer(boost::array<const PodType, N>& data,
+BOOST_ASIO_NODISCARD inline BOOST_ASIO_CONST_BUFFER buffer(
+    boost::array<const PodType, N>& data,
     std::size_t max_size_in_bytes) BOOST_ASIO_NOEXCEPT
 {
   return BOOST_ASIO_CONST_BUFFER(data.data(),
@@ -1180,7 +1211,7 @@ inline BOOST_ASIO_CONST_BUFFER buffer(boost::array<const PodType, N>& data,
  *     data.size() * sizeof(PodType)); @endcode
  */
 template <typename PodType, std::size_t N>
-inline BOOST_ASIO_CONST_BUFFER buffer(
+BOOST_ASIO_NODISCARD inline BOOST_ASIO_CONST_BUFFER buffer(
     const boost::array<PodType, N>& data) BOOST_ASIO_NOEXCEPT
 {
   return BOOST_ASIO_CONST_BUFFER(data.data(), data.size() * sizeof(PodType));
@@ -1194,7 +1225,8 @@ inline BOOST_ASIO_CONST_BUFFER buffer(
  *     min(data.size() * sizeof(PodType), max_size_in_bytes)); @endcode
  */
 template <typename PodType, std::size_t N>
-inline BOOST_ASIO_CONST_BUFFER buffer(const boost::array<PodType, N>& data,
+BOOST_ASIO_NODISCARD inline BOOST_ASIO_CONST_BUFFER buffer(
+    const boost::array<PodType, N>& data,
     std::size_t max_size_in_bytes) BOOST_ASIO_NOEXCEPT
 {
   return BOOST_ASIO_CONST_BUFFER(data.data(),
@@ -1212,7 +1244,7 @@ inline BOOST_ASIO_CONST_BUFFER buffer(const boost::array<PodType, N>& data,
  *     data.size() * sizeof(PodType)); @endcode
  */
 template <typename PodType, std::size_t N>
-inline BOOST_ASIO_MUTABLE_BUFFER buffer(
+BOOST_ASIO_NODISCARD inline BOOST_ASIO_MUTABLE_BUFFER buffer(
     std::array<PodType, N>& data) BOOST_ASIO_NOEXCEPT
 {
   return BOOST_ASIO_MUTABLE_BUFFER(data.data(), data.size() * sizeof(PodType));
@@ -1226,7 +1258,8 @@ inline BOOST_ASIO_MUTABLE_BUFFER buffer(
  *     min(data.size() * sizeof(PodType), max_size_in_bytes)); @endcode
  */
 template <typename PodType, std::size_t N>
-inline BOOST_ASIO_MUTABLE_BUFFER buffer(std::array<PodType, N>& data,
+BOOST_ASIO_NODISCARD inline BOOST_ASIO_MUTABLE_BUFFER buffer(
+    std::array<PodType, N>& data,
     std::size_t max_size_in_bytes) BOOST_ASIO_NOEXCEPT
 {
   return BOOST_ASIO_MUTABLE_BUFFER(data.data(),
@@ -1242,7 +1275,7 @@ inline BOOST_ASIO_MUTABLE_BUFFER buffer(std::array<PodType, N>& data,
  *     data.size() * sizeof(PodType)); @endcode
  */
 template <typename PodType, std::size_t N>
-inline BOOST_ASIO_CONST_BUFFER buffer(
+BOOST_ASIO_NODISCARD inline BOOST_ASIO_CONST_BUFFER buffer(
     std::array<const PodType, N>& data) BOOST_ASIO_NOEXCEPT
 {
   return BOOST_ASIO_CONST_BUFFER(data.data(), data.size() * sizeof(PodType));
@@ -1256,7 +1289,8 @@ inline BOOST_ASIO_CONST_BUFFER buffer(
  *     min(data.size() * sizeof(PodType), max_size_in_bytes)); @endcode
  */
 template <typename PodType, std::size_t N>
-inline BOOST_ASIO_CONST_BUFFER buffer(std::array<const PodType, N>& data,
+BOOST_ASIO_NODISCARD inline BOOST_ASIO_CONST_BUFFER buffer(
+    std::array<const PodType, N>& data,
     std::size_t max_size_in_bytes) BOOST_ASIO_NOEXCEPT
 {
   return BOOST_ASIO_CONST_BUFFER(data.data(),
@@ -1272,7 +1306,7 @@ inline BOOST_ASIO_CONST_BUFFER buffer(std::array<const PodType, N>& data,
  *     data.size() * sizeof(PodType)); @endcode
  */
 template <typename PodType, std::size_t N>
-inline BOOST_ASIO_CONST_BUFFER buffer(
+BOOST_ASIO_NODISCARD inline BOOST_ASIO_CONST_BUFFER buffer(
     const std::array<PodType, N>& data) BOOST_ASIO_NOEXCEPT
 {
   return BOOST_ASIO_CONST_BUFFER(data.data(), data.size() * sizeof(PodType));
@@ -1286,7 +1320,8 @@ inline BOOST_ASIO_CONST_BUFFER buffer(
  *     min(data.size() * sizeof(PodType), max_size_in_bytes)); @endcode
  */
 template <typename PodType, std::size_t N>
-inline BOOST_ASIO_CONST_BUFFER buffer(const std::array<PodType, N>& data,
+BOOST_ASIO_NODISCARD inline BOOST_ASIO_CONST_BUFFER buffer(
+    const std::array<PodType, N>& data,
     std::size_t max_size_in_bytes) BOOST_ASIO_NOEXCEPT
 {
   return BOOST_ASIO_CONST_BUFFER(data.data(),
@@ -1307,7 +1342,7 @@ inline BOOST_ASIO_CONST_BUFFER buffer(const std::array<PodType, N>& data,
  * invalidate iterators.
  */
 template <typename PodType, typename Allocator>
-inline BOOST_ASIO_MUTABLE_BUFFER buffer(
+BOOST_ASIO_NODISCARD inline BOOST_ASIO_MUTABLE_BUFFER buffer(
     std::vector<PodType, Allocator>& data) BOOST_ASIO_NOEXCEPT
 {
   return BOOST_ASIO_MUTABLE_BUFFER(
@@ -1331,7 +1366,8 @@ inline BOOST_ASIO_MUTABLE_BUFFER buffer(
  * invalidate iterators.
  */
 template <typename PodType, typename Allocator>
-inline BOOST_ASIO_MUTABLE_BUFFER buffer(std::vector<PodType, Allocator>& data,
+BOOST_ASIO_NODISCARD inline BOOST_ASIO_MUTABLE_BUFFER buffer(
+    std::vector<PodType, Allocator>& data,
     std::size_t max_size_in_bytes) BOOST_ASIO_NOEXCEPT
 {
   return BOOST_ASIO_MUTABLE_BUFFER(data.size() ? &data[0] : 0,
@@ -1356,7 +1392,7 @@ inline BOOST_ASIO_MUTABLE_BUFFER buffer(std::vector<PodType, Allocator>& data,
  * invalidate iterators.
  */
 template <typename PodType, typename Allocator>
-inline BOOST_ASIO_CONST_BUFFER buffer(
+BOOST_ASIO_NODISCARD inline BOOST_ASIO_CONST_BUFFER buffer(
     const std::vector<PodType, Allocator>& data) BOOST_ASIO_NOEXCEPT
 {
   return BOOST_ASIO_CONST_BUFFER(
@@ -1380,7 +1416,7 @@ inline BOOST_ASIO_CONST_BUFFER buffer(
  * invalidate iterators.
  */
 template <typename PodType, typename Allocator>
-inline BOOST_ASIO_CONST_BUFFER buffer(
+BOOST_ASIO_NODISCARD inline BOOST_ASIO_CONST_BUFFER buffer(
     const std::vector<PodType, Allocator>& data,
     std::size_t max_size_in_bytes) BOOST_ASIO_NOEXCEPT
 {
@@ -1404,7 +1440,7 @@ inline BOOST_ASIO_CONST_BUFFER buffer(
  * given string object.
  */
 template <typename Elem, typename Traits, typename Allocator>
-inline BOOST_ASIO_MUTABLE_BUFFER buffer(
+BOOST_ASIO_NODISCARD inline BOOST_ASIO_MUTABLE_BUFFER buffer(
     std::basic_string<Elem, Traits, Allocator>& data) BOOST_ASIO_NOEXCEPT
 {
   return BOOST_ASIO_MUTABLE_BUFFER(data.size() ? &data[0] : 0,
@@ -1428,7 +1464,7 @@ inline BOOST_ASIO_MUTABLE_BUFFER buffer(
  * given string object.
  */
 template <typename Elem, typename Traits, typename Allocator>
-inline BOOST_ASIO_MUTABLE_BUFFER buffer(
+BOOST_ASIO_NODISCARD inline BOOST_ASIO_MUTABLE_BUFFER buffer(
     std::basic_string<Elem, Traits, Allocator>& data,
     std::size_t max_size_in_bytes) BOOST_ASIO_NOEXCEPT
 {
@@ -1451,7 +1487,7 @@ inline BOOST_ASIO_MUTABLE_BUFFER buffer(
  * given string object.
  */
 template <typename Elem, typename Traits, typename Allocator>
-inline BOOST_ASIO_CONST_BUFFER buffer(
+BOOST_ASIO_NODISCARD inline BOOST_ASIO_CONST_BUFFER buffer(
     const std::basic_string<Elem, Traits, Allocator>& data) BOOST_ASIO_NOEXCEPT
 {
   return BOOST_ASIO_CONST_BUFFER(data.data(), data.size() * sizeof(Elem)
@@ -1474,7 +1510,7 @@ inline BOOST_ASIO_CONST_BUFFER buffer(
  * given string object.
  */
 template <typename Elem, typename Traits, typename Allocator>
-inline BOOST_ASIO_CONST_BUFFER buffer(
+BOOST_ASIO_NODISCARD inline BOOST_ASIO_CONST_BUFFER buffer(
     const std::basic_string<Elem, Traits, Allocator>& data,
     std::size_t max_size_in_bytes) BOOST_ASIO_NOEXCEPT
 {
@@ -1492,13 +1528,13 @@ inline BOOST_ASIO_CONST_BUFFER buffer(
 #if defined(BOOST_ASIO_HAS_STRING_VIEW) \
   || defined(GENERATING_DOCUMENTATION)
 
-/// Create a new modifiable buffer that represents the given string_view.
+/// Create a new non-modifiable buffer that represents the given string_view.
 /**
  * @returns <tt>mutable_buffer(data.size() ? &data[0] : 0,
  * data.size() * sizeof(Elem))</tt>.
  */
 template <typename Elem, typename Traits>
-inline BOOST_ASIO_CONST_BUFFER buffer(
+BOOST_ASIO_NODISCARD inline BOOST_ASIO_CONST_BUFFER buffer(
     basic_string_view<Elem, Traits> data) BOOST_ASIO_NOEXCEPT
 {
   return BOOST_ASIO_CONST_BUFFER(data.size() ? &data[0] : 0,
@@ -1519,7 +1555,7 @@ inline BOOST_ASIO_CONST_BUFFER buffer(
  *     min(data.size() * sizeof(Elem), max_size_in_bytes)); @endcode
  */
 template <typename Elem, typename Traits>
-inline BOOST_ASIO_CONST_BUFFER buffer(
+BOOST_ASIO_NODISCARD inline BOOST_ASIO_CONST_BUFFER buffer(
     basic_string_view<Elem, Traits> data,
     std::size_t max_size_in_bytes) BOOST_ASIO_NOEXCEPT
 {
@@ -1537,6 +1573,215 @@ inline BOOST_ASIO_CONST_BUFFER buffer(
 #endif // defined(BOOST_ASIO_HAS_STRING_VIEW)
        //  || defined(GENERATING_DOCUMENTATION)
 
+/// Create a new modifiable buffer from a contiguous container.
+/**
+ * @returns A mutable_buffer value equivalent to:
+ * @code mutable_buffer(
+ *     data.size() ? &data[0] : 0,
+ *     data.size() * sizeof(typename T::value_type)); @endcode
+ */
+template <typename T>
+BOOST_ASIO_NODISCARD inline BOOST_ASIO_MUTABLE_BUFFER buffer(
+    T& data,
+    typename constraint<
+      is_contiguous_iterator<typename T::iterator>::value,
+      defaulted_constraint
+    >::type = defaulted_constraint(),
+    typename constraint<
+      !is_convertible<T, const_buffer>::value,
+      defaulted_constraint
+    >::type = defaulted_constraint(),
+    typename constraint<
+      !is_convertible<T, mutable_buffer>::value,
+      defaulted_constraint
+    >::type = defaulted_constraint(),
+    typename constraint<
+      !is_const<
+        typename remove_reference<
+          typename std::iterator_traits<typename T::iterator>::reference
+        >::type
+      >::value,
+      defaulted_constraint
+    >::type = defaulted_constraint()) BOOST_ASIO_NOEXCEPT
+{
+  return BOOST_ASIO_MUTABLE_BUFFER(
+      data.size() ? detail::to_address(data.begin()) : 0,
+      data.size() * sizeof(typename T::value_type));
+}
+
+/// Create a new modifiable buffer from a contiguous container.
+/**
+ * @returns A mutable_buffer value equivalent to:
+ * @code mutable_buffer(
+ *     data.size() ? &data[0] : 0,
+ *     min(
+ *       data.size() * sizeof(typename T::value_type),
+ *       max_size_in_bytes)); @endcode
+ */
+template <typename T>
+BOOST_ASIO_NODISCARD inline BOOST_ASIO_MUTABLE_BUFFER buffer(
+    T& data, std::size_t max_size_in_bytes,
+    typename constraint<
+      is_contiguous_iterator<typename T::iterator>::value,
+      defaulted_constraint
+    >::type = defaulted_constraint(),
+    typename constraint<
+      !is_convertible<T, const_buffer>::value,
+      defaulted_constraint
+    >::type = defaulted_constraint(),
+    typename constraint<
+      !is_convertible<T, mutable_buffer>::value,
+      defaulted_constraint
+    >::type = defaulted_constraint(),
+    typename constraint<
+      !is_const<
+        typename remove_reference<
+          typename std::iterator_traits<typename T::iterator>::reference
+        >::type
+      >::value,
+      defaulted_constraint
+    >::type = defaulted_constraint()) BOOST_ASIO_NOEXCEPT
+{
+  return BOOST_ASIO_MUTABLE_BUFFER(
+      data.size() ? detail::to_address(data.begin()) : 0,
+      data.size() * sizeof(typename T::value_type) < max_size_in_bytes
+      ? data.size() * sizeof(typename T::value_type) : max_size_in_bytes);
+}
+
+/// Create a new non-modifiable buffer from a contiguous container.
+/**
+ * @returns A const_buffer value equivalent to:
+ * @code const_buffer(
+ *     data.size() ? &data[0] : 0,
+ *     data.size() * sizeof(typename T::value_type)); @endcode
+ */
+template <typename T>
+BOOST_ASIO_NODISCARD inline BOOST_ASIO_CONST_BUFFER buffer(
+    T& data,
+    typename constraint<
+      is_contiguous_iterator<typename T::iterator>::value,
+      defaulted_constraint
+    >::type = defaulted_constraint(),
+    typename constraint<
+      !is_convertible<T, const_buffer>::value,
+      defaulted_constraint
+    >::type = defaulted_constraint(),
+    typename constraint<
+      !is_convertible<T, mutable_buffer>::value,
+      defaulted_constraint
+    >::type = defaulted_constraint(),
+    typename constraint<
+      is_const<
+        typename remove_reference<
+          typename std::iterator_traits<typename T::iterator>::reference
+        >::type
+      >::value,
+      defaulted_constraint
+    >::type = defaulted_constraint()) BOOST_ASIO_NOEXCEPT
+{
+  return BOOST_ASIO_CONST_BUFFER(
+      data.size() ? detail::to_address(data.begin()) : 0,
+      data.size() * sizeof(typename T::value_type));
+}
+
+/// Create a new non-modifiable buffer from a contiguous container.
+/**
+ * @returns A const_buffer value equivalent to:
+ * @code const_buffer(
+ *     data.size() ? &data[0] : 0,
+ *     min(
+ *       data.size() * sizeof(typename T::value_type),
+ *       max_size_in_bytes)); @endcode
+ */
+template <typename T>
+BOOST_ASIO_NODISCARD inline BOOST_ASIO_CONST_BUFFER buffer(
+    T& data, std::size_t max_size_in_bytes,
+    typename constraint<
+      is_contiguous_iterator<typename T::iterator>::value,
+      defaulted_constraint
+    >::type = defaulted_constraint(),
+    typename constraint<
+      !is_convertible<T, const_buffer>::value,
+      defaulted_constraint
+    >::type = defaulted_constraint(),
+    typename constraint<
+      !is_convertible<T, mutable_buffer>::value,
+      defaulted_constraint
+    >::type = defaulted_constraint(),
+    typename constraint<
+      is_const<
+        typename remove_reference<
+          typename std::iterator_traits<typename T::iterator>::reference
+        >::type
+      >::value,
+      defaulted_constraint
+    >::type = defaulted_constraint()) BOOST_ASIO_NOEXCEPT
+{
+  return BOOST_ASIO_CONST_BUFFER(
+      data.size() ? detail::to_address(data.begin()) : 0,
+      data.size() * sizeof(typename T::value_type) < max_size_in_bytes
+      ? data.size() * sizeof(typename T::value_type) : max_size_in_bytes);
+}
+
+/// Create a new non-modifiable buffer from a contiguous container.
+/**
+ * @returns A const_buffer value equivalent to:
+ * @code const_buffer(
+ *     data.size() ? &data[0] : 0,
+ *     data.size() * sizeof(typename T::value_type)); @endcode
+ */
+template <typename T>
+BOOST_ASIO_NODISCARD inline BOOST_ASIO_CONST_BUFFER buffer(
+    const T& data,
+    typename constraint<
+      is_contiguous_iterator<typename T::const_iterator>::value,
+      defaulted_constraint
+    >::type = defaulted_constraint(),
+    typename constraint<
+      !is_convertible<T, const_buffer>::value,
+      defaulted_constraint
+    >::type = defaulted_constraint(),
+    typename constraint<
+      !is_convertible<T, mutable_buffer>::value,
+      defaulted_constraint
+    >::type = defaulted_constraint()) BOOST_ASIO_NOEXCEPT
+{
+  return BOOST_ASIO_CONST_BUFFER(
+      data.size() ? detail::to_address(data.begin()) : 0,
+      data.size() * sizeof(typename T::value_type));
+}
+
+/// Create a new non-modifiable buffer from a contiguous container.
+/**
+ * @returns A const_buffer value equivalent to:
+ * @code const_buffer(
+ *     data.size() ? &data[0] : 0,
+ *     min(
+ *       data.size() * sizeof(typename T::value_type),
+ *       max_size_in_bytes)); @endcode
+ */
+template <typename T>
+BOOST_ASIO_NODISCARD inline BOOST_ASIO_CONST_BUFFER buffer(
+    const T& data, std::size_t max_size_in_bytes,
+    typename constraint<
+      is_contiguous_iterator<typename T::const_iterator>::value,
+      defaulted_constraint
+    >::type = defaulted_constraint(),
+    typename constraint<
+      !is_convertible<T, const_buffer>::value,
+      defaulted_constraint
+    >::type = defaulted_constraint(),
+    typename constraint<
+      !is_convertible<T, mutable_buffer>::value,
+      defaulted_constraint
+    >::type = defaulted_constraint()) BOOST_ASIO_NOEXCEPT
+{
+  return BOOST_ASIO_CONST_BUFFER(
+      data.size() ? detail::to_address(data.begin()) : 0,
+      data.size() * sizeof(typename T::value_type) < max_size_in_bytes
+      ? data.size() * sizeof(typename T::value_type) : max_size_in_bytes);
+}
+
 /*@}*/
 
 /// Adapt a basic_string to the DynamicBuffer requirements.
@@ -2095,7 +2340,8 @@ private:
  * @returns <tt>dynamic_string_buffer<Elem, Traits, Allocator>(data)</tt>.
  */
 template <typename Elem, typename Traits, typename Allocator>
-inline dynamic_string_buffer<Elem, Traits, Allocator> dynamic_buffer(
+BOOST_ASIO_NODISCARD inline
+dynamic_string_buffer<Elem, Traits, Allocator> dynamic_buffer(
     std::basic_string<Elem, Traits, Allocator>& data) BOOST_ASIO_NOEXCEPT
 {
   return dynamic_string_buffer<Elem, Traits, Allocator>(data);
@@ -2107,7 +2353,8 @@ inline dynamic_string_buffer<Elem, Traits, Allocator> dynamic_buffer(
  * max_size)</tt>.
  */
 template <typename Elem, typename Traits, typename Allocator>
-inline dynamic_string_buffer<Elem, Traits, Allocator> dynamic_buffer(
+BOOST_ASIO_NODISCARD inline
+dynamic_string_buffer<Elem, Traits, Allocator> dynamic_buffer(
     std::basic_string<Elem, Traits, Allocator>& data,
     std::size_t max_size) BOOST_ASIO_NOEXCEPT
 {
@@ -2119,7 +2366,8 @@ inline dynamic_string_buffer<Elem, Traits, Allocator> dynamic_buffer(
  * @returns <tt>dynamic_vector_buffer<Elem, Allocator>(data)</tt>.
  */
 template <typename Elem, typename Allocator>
-inline dynamic_vector_buffer<Elem, Allocator> dynamic_buffer(
+BOOST_ASIO_NODISCARD inline
+dynamic_vector_buffer<Elem, Allocator> dynamic_buffer(
     std::vector<Elem, Allocator>& data) BOOST_ASIO_NOEXCEPT
 {
   return dynamic_vector_buffer<Elem, Allocator>(data);
@@ -2130,7 +2378,8 @@ inline dynamic_vector_buffer<Elem, Allocator> dynamic_buffer(
  * @returns <tt>dynamic_vector_buffer<Elem, Allocator>(data, max_size)</tt>.
  */
 template <typename Elem, typename Allocator>
-inline dynamic_vector_buffer<Elem, Allocator> dynamic_buffer(
+BOOST_ASIO_NODISCARD inline
+dynamic_vector_buffer<Elem, Allocator> dynamic_buffer(
     std::vector<Elem, Allocator>& data,
     std::size_t max_size) BOOST_ASIO_NOEXCEPT
 {
@@ -2476,7 +2725,7 @@ struct is_dynamic_buffer_v2
  * If @c BOOST_ASIO_NO_DYNAMIC_BUFFER_V1 is not defined, determines whether the
  * type satisfies the DynamicBuffer_v1 requirements. Otherwise, if @c
  * BOOST_ASIO_NO_DYNAMIC_BUFFER_V1 is defined, determines whether the type
- * satisfies the DynamicBuffer_v1 requirements.
+ * satisfies the DynamicBuffer_v2 requirements.
  */
 template <typename T>
 struct is_dynamic_buffer
@@ -2490,6 +2739,172 @@ struct is_dynamic_buffer
 {
 };
 
+#if (defined(BOOST_ASIO_HAS_USER_DEFINED_LITERALS) \
+    && defined(BOOST_ASIO_HAS_VARIADIC_TEMPLATES)) \
+  || defined(GENERATING_DOCUMENTATION)
+
+namespace buffer_literals {
+namespace detail {
+
+template <char... Chars>
+struct chars {};
+
+template <unsigned char... Bytes>
+struct bytes {};
+
+// Literal processor that converts binary literals to an array of bytes.
+
+template <typename Bytes, char... Chars>
+struct bin_literal;
+
+template <unsigned char... Bytes>
+struct bin_literal<bytes<Bytes...> >
+{
+  static const std::size_t size = sizeof...(Bytes);
+  static const unsigned char data[sizeof...(Bytes)];
+};
+
+template <unsigned char... Bytes>
+const unsigned char bin_literal<bytes<Bytes...> >::data[sizeof...(Bytes)]
+  = { Bytes... };
+
+template <unsigned char... Bytes, char Bit7, char Bit6, char Bit5,
+    char Bit4, char Bit3, char Bit2, char Bit1, char Bit0, char... Chars>
+struct bin_literal<bytes<Bytes...>, Bit7, Bit6,
+    Bit5, Bit4, Bit3, Bit2, Bit1, Bit0, Chars...> :
+  bin_literal<
+    bytes<Bytes...,
+      static_cast<unsigned char>(
+      (Bit7 == '1' ? 0x80 : 0) |
+        (Bit6 == '1' ? 0x40 : 0) |
+        (Bit5 == '1' ? 0x20 : 0) |
+        (Bit4 == '1' ? 0x10 : 0) |
+        (Bit3 == '1' ? 0x08 : 0) |
+        (Bit2 == '1' ? 0x04 : 0) |
+        (Bit1 == '1' ? 0x02 : 0) |
+        (Bit0 == '1' ? 0x01 : 0))
+    >, Chars...> {};
+
+template <unsigned char... Bytes, char... Chars>
+struct bin_literal<bytes<Bytes...>, Chars...>
+{
+  static_assert(sizeof...(Chars) == 0,
+      "number of digits in a binary buffer literal must be a multiple of 8");
+
+  static const std::size_t size = 0;
+  static const unsigned char data[1];
+};
+
+template <unsigned char... Bytes, char... Chars>
+const unsigned char bin_literal<bytes<Bytes...>, Chars...>::data[1] = {};
+
+// Literal processor that converts hexadecimal literals to an array of bytes.
+
+template <typename Bytes, char... Chars>
+struct hex_literal;
+
+template <unsigned char... Bytes>
+struct hex_literal<bytes<Bytes...> >
+{
+  static const std::size_t size = sizeof...(Bytes);
+  static const unsigned char data[sizeof...(Bytes)];
+};
+
+template <unsigned char... Bytes>
+const unsigned char hex_literal<bytes<Bytes...> >::data[sizeof...(Bytes)]
+  = { Bytes... };
+
+template <unsigned char... Bytes, char Hi, char Lo, char... Chars>
+struct hex_literal<bytes<Bytes...>, Hi, Lo, Chars...> :
+  hex_literal<
+    bytes<Bytes...,
+      static_cast<unsigned char>(
+        Lo >= 'A' && Lo <= 'F' ? Lo - 'A' + 10 :
+          (Lo >= 'a' && Lo <= 'f' ? Lo - 'a' + 10 : Lo - '0')) |
+      ((static_cast<unsigned char>(
+        Hi >= 'A' && Hi <= 'F' ? Hi - 'A' + 10 :
+          (Hi >= 'a' && Hi <= 'f' ? Hi - 'a' + 10 : Hi - '0'))) << 4)
+    >, Chars...> {};
+
+template <unsigned char... Bytes, char Char>
+struct hex_literal<bytes<Bytes...>, Char>
+{
+  static_assert(!Char,
+      "a hexadecimal buffer literal must have an even number of digits");
+
+  static const std::size_t size = 0;
+  static const unsigned char data[1];
+};
+
+template <unsigned char... Bytes, char Char>
+const unsigned char hex_literal<bytes<Bytes...>, Char>::data[1] = {};
+
+// Helper template that removes digit separators and then passes the cleaned
+// variadic pack of characters to the literal processor.
+
+template <template <typename, char...> class Literal,
+    typename Clean, char... Raw>
+struct remove_separators;
+
+template <template <typename, char...> class Literal,
+    char... Clean, char... Raw>
+struct remove_separators<Literal, chars<Clean...>, '\'', Raw...> :
+  remove_separators<Literal, chars<Clean...>, Raw...> {};
+
+template <template <typename, char...> class Literal,
+    char... Clean, char C, char... Raw>
+struct remove_separators<Literal, chars<Clean...>, C, Raw...> :
+  remove_separators<Literal, chars<Clean..., C>, Raw...> {};
+
+template <template <typename, char...> class Literal, char... Clean>
+struct remove_separators<Literal, chars<Clean...> > :
+  Literal<bytes<>, Clean...> {};
+
+// Helper template to determine the literal type based on the prefix.
+
+template <char... Chars>
+struct literal;
+
+template <char... Chars>
+struct literal<'0', 'b', Chars...> :
+  remove_separators<bin_literal, chars<>, Chars...>{};
+
+template <char... Chars>
+struct literal<'0', 'B', Chars...> :
+  remove_separators<bin_literal, chars<>, Chars...>{};
+
+template <char... Chars>
+struct literal<'0', 'x', Chars...> :
+  remove_separators<hex_literal, chars<>, Chars...>{};
+
+template <char... Chars>
+struct literal<'0', 'X', Chars...> :
+  remove_separators<hex_literal, chars<>, Chars...>{};
+
+} // namespace detail
+
+/// Literal operator for creating const_buffer objects from string literals.
+inline BOOST_ASIO_CONST_BUFFER operator"" _buf(const char* data, std::size_t n)
+{
+  return BOOST_ASIO_CONST_BUFFER(data, n);
+}
+
+/// Literal operator for creating const_buffer objects from unbounded binary or
+/// hexadecimal integer literals.
+template <char... Chars>
+inline BOOST_ASIO_CONST_BUFFER operator"" _buf()
+{
+  return BOOST_ASIO_CONST_BUFFER(
+      +detail::literal<Chars...>::data,
+      detail::literal<Chars...>::size);
+}
+
+} // namespace buffer_literals
+
+#endif // (defined(BOOST_ASIO_HAS_USER_DEFINED_LITERALS)
+       //     && defined(BOOST_ASIO_HAS_VARIADIC_TEMPLATES))
+       //   || defined(GENERATING_DOCUMENTATION)
+
 } // namespace asio
 } // namespace boost
 

linx64/include/boost/asio/buffer_registration.hpp

@@ -0,0 +1,330 @@
+//
+// buffer_registration.hpp
+// ~~~~~~~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2023 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef BOOST_ASIO_BUFFER_REGISTRATION_HPP
+#define BOOST_ASIO_BUFFER_REGISTRATION_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include <boost/asio/detail/config.hpp>
+#include <iterator>
+#include <vector>
+#include <boost/asio/detail/memory.hpp>
+#include <boost/asio/execution/context.hpp>
+#include <boost/asio/execution/executor.hpp>
+#include <boost/asio/execution_context.hpp>
+#include <boost/asio/is_executor.hpp>
+#include <boost/asio/query.hpp>
+#include <boost/asio/registered_buffer.hpp>
+
+#if defined(BOOST_ASIO_HAS_IO_URING)
+# include <boost/asio/detail/scheduler.hpp>
+# include <boost/asio/detail/io_uring_service.hpp>
+#endif // defined(BOOST_ASIO_HAS_IO_URING)
+
+#if defined(BOOST_ASIO_HAS_MOVE)
+# include <utility>
+#endif // defined(BOOST_ASIO_HAS_MOVE)
+
+#include <boost/asio/detail/push_options.hpp>
+
+namespace boost {
+namespace asio {
+namespace detail {
+
+class buffer_registration_base
+{
+protected:
+  static mutable_registered_buffer make_buffer(const mutable_buffer& b,
+      const void* scope, int index) BOOST_ASIO_NOEXCEPT
+  {
+    return mutable_registered_buffer(b, registered_buffer_id(scope, index));
+  }
+};
+
+} // namespace detail
+
+/// Automatically registers and unregistered buffers with an execution context.
+/**
+ * For portability, applications should assume that only one registration is
+ * permitted per execution context.
+ */
+template <typename MutableBufferSequence,
+    typename Allocator = std::allocator<void> >
+class buffer_registration
+  : detail::buffer_registration_base
+{
+public:
+  /// The allocator type used for allocating storage for the buffers container.
+  typedef Allocator allocator_type;
+
+#if defined(GENERATING_DOCUMENTATION)
+  /// The type of an iterator over the registered buffers.
+  typedef unspecified iterator;
+
+  /// The type of a const iterator over the registered buffers.
+  typedef unspecified const_iterator;
+#else // defined(GENERATING_DOCUMENTATION)
+  typedef std::vector<mutable_registered_buffer>::const_iterator iterator;
+  typedef std::vector<mutable_registered_buffer>::const_iterator const_iterator;
+#endif // defined(GENERATING_DOCUMENTATION)
+
+  /// Register buffers with an executor's execution context.
+  template <typename Executor>
+  buffer_registration(const Executor& ex,
+      const MutableBufferSequence& buffer_sequence,
+      const allocator_type& alloc = allocator_type(),
+      typename constraint<
+        is_executor<Executor>::value || execution::is_executor<Executor>::value
+      >::type = 0)
+    : buffer_sequence_(buffer_sequence),
+      buffers_(
+          BOOST_ASIO_REBIND_ALLOC(allocator_type,
+            mutable_registered_buffer)(alloc))
+  {
+    init_buffers(buffer_registration::get_context(ex),
+        boost::asio::buffer_sequence_begin(buffer_sequence_),
+        boost::asio::buffer_sequence_end(buffer_sequence_));
+  }
+
+  /// Register buffers with an execution context.
+  template <typename ExecutionContext>
+  buffer_registration(ExecutionContext& ctx,
+      const MutableBufferSequence& buffer_sequence,
+      const allocator_type& alloc = allocator_type(),
+      typename constraint<
+        is_convertible<ExecutionContext&, execution_context&>::value
+      >::type = 0)
+    : buffer_sequence_(buffer_sequence),
+      buffers_(
+          BOOST_ASIO_REBIND_ALLOC(allocator_type,
+            mutable_registered_buffer)(alloc))
+  {
+    init_buffers(ctx,
+        boost::asio::buffer_sequence_begin(buffer_sequence_),
+        boost::asio::buffer_sequence_end(buffer_sequence_));
+  }
+
+#if defined(BOOST_ASIO_HAS_MOVE) || defined(GENERATING_DOCUMENTATION)
+  /// Move constructor.
+  buffer_registration(buffer_registration&& other) BOOST_ASIO_NOEXCEPT
+    : buffer_sequence_(std::move(other.buffer_sequence_)),
+      buffers_(std::move(other.buffers_))
+  {
+#if defined(BOOST_ASIO_HAS_IO_URING)
+    service_ = other.service_;
+    other.service_ = 0;
+#endif // defined(BOOST_ASIO_HAS_IO_URING)
+  }
+#endif // defined(BOOST_ASIO_HAS_MOVE) || defined(GENERATING_DOCUMENTATION)
+
+  /// Unregisters the buffers.
+  ~buffer_registration()
+  {
+#if defined(BOOST_ASIO_HAS_IO_URING)
+    if (service_)
+      service_->unregister_buffers();
+#endif // defined(BOOST_ASIO_HAS_IO_URING)
+  }
+  
+#if defined(BOOST_ASIO_HAS_MOVE) || defined(GENERATING_DOCUMENTATION)
+  /// Move assignment.
+  buffer_registration& operator=(
+      buffer_registration&& other) BOOST_ASIO_NOEXCEPT
+  {
+    if (this != &other)
+    {
+      buffer_sequence_ = std::move(other.buffer_sequence_);
+      buffers_ = std::move(other.buffers_);
+#if defined(BOOST_ASIO_HAS_IO_URING)
+      if (service_)
+        service_->unregister_buffers();
+      service_ = other.service_;
+      other.service_ = 0;
+#endif // defined(BOOST_ASIO_HAS_IO_URING)
+    }
+    return *this;
+  }
+#endif // defined(BOOST_ASIO_HAS_MOVE) || defined(GENERATING_DOCUMENTATION)
+
+  /// Get the number of registered buffers.
+  std::size_t size() const BOOST_ASIO_NOEXCEPT
+  {
+    return buffers_.size();
+  }
+
+  /// Get the begin iterator for the sequence of registered buffers.
+  const_iterator begin() const BOOST_ASIO_NOEXCEPT
+  {
+    return buffers_.begin();
+  }
+
+  /// Get the begin iterator for the sequence of registered buffers.
+  const_iterator cbegin() const BOOST_ASIO_NOEXCEPT
+  {
+    return buffers_.cbegin();
+  }
+
+  /// Get the end iterator for the sequence of registered buffers.
+  const_iterator end() const BOOST_ASIO_NOEXCEPT
+  {
+    return buffers_.end();
+  }
+
+  /// Get the end iterator for the sequence of registered buffers.
+  const_iterator cend() const BOOST_ASIO_NOEXCEPT
+  {
+    return buffers_.cend();
+  }
+
+  /// Get the buffer at the specified index.
+  const mutable_registered_buffer& operator[](std::size_t i) BOOST_ASIO_NOEXCEPT
+  {
+    return buffers_[i];
+  }
+
+  /// Get the buffer at the specified index.
+  const mutable_registered_buffer& at(std::size_t i) BOOST_ASIO_NOEXCEPT
+  {
+    return buffers_.at(i);
+  }
+
+private:
+  // Disallow copying and assignment.
+  buffer_registration(const buffer_registration&) BOOST_ASIO_DELETED;
+  buffer_registration& operator=(const buffer_registration&) BOOST_ASIO_DELETED;
+
+  // Helper function to get an executor's context.
+  template <typename T>
+  static execution_context& get_context(const T& t,
+      typename enable_if<execution::is_executor<T>::value>::type* = 0)
+  {
+    return boost::asio::query(t, execution::context);
+  }
+
+  // Helper function to get an executor's context.
+  template <typename T>
+  static execution_context& get_context(const T& t,
+      typename enable_if<!execution::is_executor<T>::value>::type* = 0)
+  {
+    return t.context();
+  }
+
+  // Helper function to initialise the container of buffers.
+  template <typename Iterator>
+  void init_buffers(execution_context& ctx, Iterator begin, Iterator end)
+  {
+    std::size_t n = std::distance(begin, end);
+    buffers_.resize(n);
+
+#if defined(BOOST_ASIO_HAS_IO_URING)
+    service_ = &use_service<detail::io_uring_service>(ctx);
+    std::vector<iovec,
+      BOOST_ASIO_REBIND_ALLOC(allocator_type, iovec)> iovecs(n,
+          BOOST_ASIO_REBIND_ALLOC(allocator_type, iovec)(
+            buffers_.get_allocator()));
+#endif // defined(BOOST_ASIO_HAS_IO_URING)
+
+    Iterator iter = begin;
+    for (int index = 0; iter != end; ++index, ++iter)
+    {
+      mutable_buffer b(*iter);
+      std::size_t i = static_cast<std::size_t>(index);
+      buffers_[i] = this->make_buffer(b, &ctx, index);
+
+#if defined(BOOST_ASIO_HAS_IO_URING)
+      iovecs[i].iov_base = buffers_[i].data();
+      iovecs[i].iov_len = buffers_[i].size();
+#endif // defined(BOOST_ASIO_HAS_IO_URING)
+    }
+
+#if defined(BOOST_ASIO_HAS_IO_URING)
+    if (n > 0)
+    {
+      service_->register_buffers(&iovecs[0],
+          static_cast<unsigned>(iovecs.size()));
+    }
+#endif // defined(BOOST_ASIO_HAS_IO_URING)
+  }
+
+  MutableBufferSequence buffer_sequence_;
+  std::vector<mutable_registered_buffer,
+    BOOST_ASIO_REBIND_ALLOC(allocator_type,
+      mutable_registered_buffer)> buffers_;
+#if defined(BOOST_ASIO_HAS_IO_URING)
+  detail::io_uring_service* service_;
+#endif // defined(BOOST_ASIO_HAS_IO_URING)
+};
+
+#if defined(BOOST_ASIO_HAS_MOVE) || defined(GENERATING_DOCUMENTATION)
+/// Register buffers with an execution context.
+template <typename Executor, typename MutableBufferSequence>
+BOOST_ASIO_NODISCARD inline
+buffer_registration<MutableBufferSequence>
+register_buffers(const Executor& ex,
+    const MutableBufferSequence& buffer_sequence,
+    typename constraint<
+      is_executor<Executor>::value || execution::is_executor<Executor>::value
+    >::type = 0)
+{
+  return buffer_registration<MutableBufferSequence>(ex, buffer_sequence);
+}
+
+/// Register buffers with an execution context.
+template <typename Executor, typename MutableBufferSequence, typename Allocator>
+BOOST_ASIO_NODISCARD inline
+buffer_registration<MutableBufferSequence, Allocator>
+register_buffers(const Executor& ex,
+    const MutableBufferSequence& buffer_sequence, const Allocator& alloc,
+    typename constraint<
+      is_executor<Executor>::value || execution::is_executor<Executor>::value
+    >::type = 0)
+{
+  return buffer_registration<MutableBufferSequence, Allocator>(
+      ex, buffer_sequence, alloc);
+}
+
+/// Register buffers with an execution context.
+template <typename ExecutionContext, typename MutableBufferSequence>
+BOOST_ASIO_NODISCARD inline
+buffer_registration<MutableBufferSequence>
+register_buffers(ExecutionContext& ctx,
+    const MutableBufferSequence& buffer_sequence,
+    typename constraint<
+      is_convertible<ExecutionContext&, execution_context&>::value
+    >::type = 0)
+{
+  return buffer_registration<MutableBufferSequence>(ctx, buffer_sequence);
+}
+
+/// Register buffers with an execution context.
+template <typename ExecutionContext,
+    typename MutableBufferSequence, typename Allocator>
+BOOST_ASIO_NODISCARD inline
+buffer_registration<MutableBufferSequence, Allocator>
+register_buffers(ExecutionContext& ctx,
+    const MutableBufferSequence& buffer_sequence, const Allocator& alloc,
+    typename constraint<
+      is_convertible<ExecutionContext&, execution_context&>::value
+    >::type = 0)
+{
+  return buffer_registration<MutableBufferSequence, Allocator>(
+      ctx, buffer_sequence, alloc);
+}
+#endif // defined(BOOST_ASIO_HAS_MOVE) || defined(GENERATING_DOCUMENTATION)
+
+} // namespace asio
+} // namespace boost
+
+#include <boost/asio/detail/pop_options.hpp>
+
+#endif // BOOST_ASIO_BUFFER_REGISTRATION_HPP

linx64/include/boost/asio/buffered_read_stream.hpp

@@ -2,7 +2,7 @@
 // buffered_read_stream.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2019 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2023 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -31,6 +31,12 @@
 
 namespace boost {
 namespace asio {
+namespace detail {
+
+template <typename> class initiate_async_buffered_fill;
+template <typename> class initiate_async_buffered_read_some;
+
+} // namespace detail
 
 /// Adds buffering to the read-related operations of a stream.
 /**
@@ -67,16 +73,17 @@ public:
 
   /// Construct, passing the specified argument to initialise the next layer.
   template <typename Arg>
-  explicit buffered_read_stream(Arg& a)
-    : next_layer_(a),
+  explicit buffered_read_stream(BOOST_ASIO_MOVE_OR_LVALUE_ARG(Arg) a)
+    : next_layer_(BOOST_ASIO_MOVE_OR_LVALUE(Arg)(a)),
       storage_(default_buffer_size)
   {
   }
 
   /// Construct, passing the specified argument to initialise the next layer.
   template <typename Arg>
-  buffered_read_stream(Arg& a, std::size_t buffer_size)
-    : next_layer_(a),
+  buffered_read_stream(BOOST_ASIO_MOVE_OR_LVALUE_ARG(Arg) a,
+      std::size_t buffer_size)
+    : next_layer_(BOOST_ASIO_MOVE_OR_LVALUE(Arg)(a)),
       storage_(buffer_size)
   {
   }
@@ -137,11 +144,23 @@ public:
 
   /// Start an asynchronous write. The data being written must be valid for the
   /// lifetime of the asynchronous operation.
-  template <typename ConstBufferSequence, typename WriteHandler>
-  BOOST_ASIO_INITFN_RESULT_TYPE(WriteHandler,
+  /**
+   * @par Completion Signature
+   * @code void(boost::system::error_code, std::size_t) @endcode
+   */
+  template <typename ConstBufferSequence,
+      BOOST_ASIO_COMPLETION_TOKEN_FOR(void (boost::system::error_code,
+        std::size_t)) WriteHandler
+          BOOST_ASIO_DEFAULT_COMPLETION_TOKEN_TYPE(executor_type)>
+  BOOST_ASIO_INITFN_AUTO_RESULT_TYPE_PREFIX(WriteHandler,
       void (boost::system::error_code, std::size_t))
   async_write_some(const ConstBufferSequence& buffers,
-      BOOST_ASIO_MOVE_ARG(WriteHandler) handler)
+      BOOST_ASIO_MOVE_ARG(WriteHandler) handler
+        BOOST_ASIO_DEFAULT_COMPLETION_TOKEN(executor_type))
+    BOOST_ASIO_INITFN_AUTO_RESULT_TYPE_SUFFIX((
+      declval<typename conditional<true, Stream&, WriteHandler>::type>()
+        .async_write_some(buffers,
+          BOOST_ASIO_MOVE_CAST(WriteHandler)(handler))))
   {
     return next_layer_.async_write_some(buffers,
         BOOST_ASIO_MOVE_CAST(WriteHandler)(handler));
@@ -156,10 +175,24 @@ public:
   std::size_t fill(boost::system::error_code& ec);
 
   /// Start an asynchronous fill.
-  template <typename ReadHandler>
-  BOOST_ASIO_INITFN_RESULT_TYPE(ReadHandler,
+  /**
+   * @par Completion Signature
+   * @code void(boost::system::error_code, std::size_t) @endcode
+   */
+  template <
+      BOOST_ASIO_COMPLETION_TOKEN_FOR(void (boost::system::error_code,
+        std::size_t)) ReadHandler
+          BOOST_ASIO_DEFAULT_COMPLETION_TOKEN_TYPE(executor_type)>
+  BOOST_ASIO_INITFN_AUTO_RESULT_TYPE_PREFIX(ReadHandler,
       void (boost::system::error_code, std::size_t))
-  async_fill(BOOST_ASIO_MOVE_ARG(ReadHandler) handler);
+  async_fill(
+      BOOST_ASIO_MOVE_ARG(ReadHandler) handler
+        BOOST_ASIO_DEFAULT_COMPLETION_TOKEN(executor_type))
+    BOOST_ASIO_INITFN_AUTO_RESULT_TYPE_SUFFIX((
+      async_initiate<ReadHandler,
+        void (boost::system::error_code, std::size_t)>(
+          declval<detail::initiate_async_buffered_fill<Stream> >(),
+          handler, declval<detail::buffered_stream_storage*>())));
 
   /// Read some data from the stream. Returns the number of bytes read. Throws
   /// an exception on failure.
@@ -174,11 +207,24 @@ public:
 
   /// Start an asynchronous read. The buffer into which the data will be read
   /// must be valid for the lifetime of the asynchronous operation.
-  template <typename MutableBufferSequence, typename ReadHandler>
-  BOOST_ASIO_INITFN_RESULT_TYPE(ReadHandler,
+  /**
+   * @par Completion Signature
+   * @code void(boost::system::error_code, std::size_t) @endcode
+   */
+  template <typename MutableBufferSequence,
+      BOOST_ASIO_COMPLETION_TOKEN_FOR(void (boost::system::error_code,
+        std::size_t)) ReadHandler
+          BOOST_ASIO_DEFAULT_COMPLETION_TOKEN_TYPE(executor_type)>
+  BOOST_ASIO_INITFN_AUTO_RESULT_TYPE_PREFIX(ReadHandler,
       void (boost::system::error_code, std::size_t))
   async_read_some(const MutableBufferSequence& buffers,
-      BOOST_ASIO_MOVE_ARG(ReadHandler) handler);
+      BOOST_ASIO_MOVE_ARG(ReadHandler) handler
+        BOOST_ASIO_DEFAULT_COMPLETION_TOKEN(executor_type))
+    BOOST_ASIO_INITFN_AUTO_RESULT_TYPE_SUFFIX((
+      async_initiate<ReadHandler,
+        void (boost::system::error_code, std::size_t)>(
+          declval<detail::initiate_async_buffered_read_some<Stream> >(),
+          handler, declval<detail::buffered_stream_storage*>(), buffers)));
 
   /// Peek at the incoming data on the stream. Returns the number of bytes read.
   /// Throws an exception on failure.

linx64/include/boost/asio/buffered_read_stream_fwd.hpp

@@ -2,7 +2,7 @@
 // buffered_read_stream_fwd.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2019 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2023 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

linx64/include/boost/asio/buffered_stream.hpp

@@ -2,7 +2,7 @@
 // buffered_stream.hpp
 // ~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2019 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2023 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -57,17 +57,17 @@ public:
 
   /// Construct, passing the specified argument to initialise the next layer.
   template <typename Arg>
-  explicit buffered_stream(Arg& a)
-    : inner_stream_impl_(a),
+  explicit buffered_stream(BOOST_ASIO_MOVE_OR_LVALUE_ARG(Arg) a)
+    : inner_stream_impl_(BOOST_ASIO_MOVE_OR_LVALUE(Arg)(a)),
       stream_impl_(inner_stream_impl_)
   {
   }
 
   /// Construct, passing the specified argument to initialise the next layer.
   template <typename Arg>
-  explicit buffered_stream(Arg& a, std::size_t read_buffer_size,
-      std::size_t write_buffer_size)
-    : inner_stream_impl_(a, write_buffer_size),
+  explicit buffered_stream(BOOST_ASIO_MOVE_OR_LVALUE_ARG(Arg) a,
+      std::size_t read_buffer_size, std::size_t write_buffer_size)
+    : inner_stream_impl_(BOOST_ASIO_MOVE_OR_LVALUE(Arg)(a), write_buffer_size),
       stream_impl_(inner_stream_impl_, read_buffer_size)
   {
   }
@@ -126,10 +126,22 @@ public:
   }
 
   /// Start an asynchronous flush.
-  template <typename WriteHandler>
-  BOOST_ASIO_INITFN_RESULT_TYPE(WriteHandler,
+  /**
+   * @par Completion Signature
+   * @code void(boost::system::error_code, std::size_t) @endcode
+   */
+  template <
+      BOOST_ASIO_COMPLETION_TOKEN_FOR(void (boost::system::error_code,
+        std::size_t)) WriteHandler
+          BOOST_ASIO_DEFAULT_COMPLETION_TOKEN_TYPE(executor_type)>
+  BOOST_ASIO_INITFN_AUTO_RESULT_TYPE_PREFIX(WriteHandler,
       void (boost::system::error_code, std::size_t))
-  async_flush(BOOST_ASIO_MOVE_ARG(WriteHandler) handler)
+  async_flush(
+      BOOST_ASIO_MOVE_ARG(WriteHandler) handler
+        BOOST_ASIO_DEFAULT_COMPLETION_TOKEN(executor_type))
+    BOOST_ASIO_INITFN_AUTO_RESULT_TYPE_SUFFIX((
+      declval<buffered_write_stream<Stream>&>().async_flush(
+          BOOST_ASIO_MOVE_CAST(WriteHandler)(handler))))
   {
     return stream_impl_.next_layer().async_flush(
         BOOST_ASIO_MOVE_CAST(WriteHandler)(handler));
@@ -154,11 +166,22 @@ public:
 
   /// Start an asynchronous write. The data being written must be valid for the
   /// lifetime of the asynchronous operation.
-  template <typename ConstBufferSequence, typename WriteHandler>
-  BOOST_ASIO_INITFN_RESULT_TYPE(WriteHandler,
+  /**
+   * @par Completion Signature
+   * @code void(boost::system::error_code, std::size_t) @endcode
+   */
+  template <typename ConstBufferSequence,
+      BOOST_ASIO_COMPLETION_TOKEN_FOR(void (boost::system::error_code,
+        std::size_t)) WriteHandler
+          BOOST_ASIO_DEFAULT_COMPLETION_TOKEN_TYPE(executor_type)>
+  BOOST_ASIO_INITFN_AUTO_RESULT_TYPE_PREFIX(WriteHandler,
       void (boost::system::error_code, std::size_t))
   async_write_some(const ConstBufferSequence& buffers,
-      BOOST_ASIO_MOVE_ARG(WriteHandler) handler)
+      BOOST_ASIO_MOVE_ARG(WriteHandler) handler
+        BOOST_ASIO_DEFAULT_COMPLETION_TOKEN(executor_type))
+    BOOST_ASIO_INITFN_AUTO_RESULT_TYPE_SUFFIX((
+      declval<Stream&>().async_write_some(buffers,
+          BOOST_ASIO_MOVE_CAST(WriteHandler)(handler))))
   {
     return stream_impl_.async_write_some(buffers,
         BOOST_ASIO_MOVE_CAST(WriteHandler)(handler));
@@ -179,10 +202,23 @@ public:
   }
 
   /// Start an asynchronous fill.
-  template <typename ReadHandler>
-  BOOST_ASIO_INITFN_RESULT_TYPE(ReadHandler,
+  /**
+   * @par Completion Signature
+   * @code void(boost::system::error_code, std::size_t) @endcode
+   */
+  template <
+      BOOST_ASIO_COMPLETION_TOKEN_FOR(void (boost::system::error_code,
+        std::size_t)) ReadHandler
+          BOOST_ASIO_DEFAULT_COMPLETION_TOKEN_TYPE(executor_type)>
+  BOOST_ASIO_INITFN_AUTO_RESULT_TYPE_PREFIX(ReadHandler,
       void (boost::system::error_code, std::size_t))
-  async_fill(BOOST_ASIO_MOVE_ARG(ReadHandler) handler)
+  async_fill(
+      BOOST_ASIO_MOVE_ARG(ReadHandler) handler
+        BOOST_ASIO_DEFAULT_COMPLETION_TOKEN(executor_type))
+    BOOST_ASIO_INITFN_AUTO_RESULT_TYPE_SUFFIX((
+      declval<buffered_read_stream<
+        buffered_write_stream<Stream> >&>().async_fill(
+          BOOST_ASIO_MOVE_CAST(ReadHandler)(handler))))
   {
     return stream_impl_.async_fill(BOOST_ASIO_MOVE_CAST(ReadHandler)(handler));
   }
@@ -206,11 +242,22 @@ public:
 
   /// Start an asynchronous read. The buffer into which the data will be read
   /// must be valid for the lifetime of the asynchronous operation.
-  template <typename MutableBufferSequence, typename ReadHandler>
-  BOOST_ASIO_INITFN_RESULT_TYPE(ReadHandler,
+  /**
+   * @par Completion Signature
+   * @code void(boost::system::error_code, std::size_t) @endcode
+   */
+  template <typename MutableBufferSequence,
+      BOOST_ASIO_COMPLETION_TOKEN_FOR(void (boost::system::error_code,
+        std::size_t)) ReadHandler
+          BOOST_ASIO_DEFAULT_COMPLETION_TOKEN_TYPE(executor_type)>
+  BOOST_ASIO_INITFN_AUTO_RESULT_TYPE_PREFIX(ReadHandler,
       void (boost::system::error_code, std::size_t))
   async_read_some(const MutableBufferSequence& buffers,
-      BOOST_ASIO_MOVE_ARG(ReadHandler) handler)
+      BOOST_ASIO_MOVE_ARG(ReadHandler) handler
+        BOOST_ASIO_DEFAULT_COMPLETION_TOKEN(executor_type))
+    BOOST_ASIO_INITFN_AUTO_RESULT_TYPE_SUFFIX((
+      declval<Stream&>().async_read_some(buffers,
+          BOOST_ASIO_MOVE_CAST(ReadHandler)(handler))))
   {
     return stream_impl_.async_read_some(buffers,
         BOOST_ASIO_MOVE_CAST(ReadHandler)(handler));

linx64/include/boost/asio/buffered_stream_fwd.hpp

@@ -2,7 +2,7 @@
 // buffered_stream_fwd.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2019 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2023 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

linx64/include/boost/asio/buffered_write_stream.hpp

@@ -2,7 +2,7 @@
 // buffered_write_stream.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2019 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2023 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -31,6 +31,12 @@
 
 namespace boost {
 namespace asio {
+namespace detail {
+
+template <typename> class initiate_async_buffered_flush;
+template <typename> class initiate_async_buffered_write_some;
+
+} // namespace detail
 
 /// Adds buffering to the write-related operations of a stream.
 /**
@@ -67,16 +73,17 @@ public:
 
   /// Construct, passing the specified argument to initialise the next layer.
   template <typename Arg>
-  explicit buffered_write_stream(Arg& a)
-    : next_layer_(a),
+  explicit buffered_write_stream(BOOST_ASIO_MOVE_OR_LVALUE_ARG(Arg) a)
+    : next_layer_(BOOST_ASIO_MOVE_OR_LVALUE(Arg)(a)),
       storage_(default_buffer_size)
   {
   }
 
   /// Construct, passing the specified argument to initialise the next layer.
   template <typename Arg>
-  buffered_write_stream(Arg& a, std::size_t buffer_size)
-    : next_layer_(a),
+  buffered_write_stream(BOOST_ASIO_MOVE_OR_LVALUE_ARG(Arg) a,
+      std::size_t buffer_size)
+    : next_layer_(BOOST_ASIO_MOVE_OR_LVALUE(Arg)(a)),
       storage_(buffer_size)
   {
   }
@@ -129,10 +136,24 @@ public:
   std::size_t flush(boost::system::error_code& ec);
 
   /// Start an asynchronous flush.
-  template <typename WriteHandler>
-  BOOST_ASIO_INITFN_RESULT_TYPE(WriteHandler,
+  /**
+   * @par Completion Signature
+   * @code void(boost::system::error_code, std::size_t) @endcode
+   */
+  template <
+      BOOST_ASIO_COMPLETION_TOKEN_FOR(void (boost::system::error_code,
+        std::size_t)) WriteHandler
+          BOOST_ASIO_DEFAULT_COMPLETION_TOKEN_TYPE(executor_type)>
+  BOOST_ASIO_INITFN_AUTO_RESULT_TYPE_PREFIX(WriteHandler,
       void (boost::system::error_code, std::size_t))
-  async_flush(BOOST_ASIO_MOVE_ARG(WriteHandler) handler);
+  async_flush(
+      BOOST_ASIO_MOVE_ARG(WriteHandler) handler
+        BOOST_ASIO_DEFAULT_COMPLETION_TOKEN(executor_type))
+    BOOST_ASIO_INITFN_AUTO_RESULT_TYPE_SUFFIX((
+      async_initiate<WriteHandler,
+        void (boost::system::error_code, std::size_t)>(
+          declval<detail::initiate_async_buffered_flush<Stream> >(),
+          handler, declval<detail::buffered_stream_storage*>())));
 
   /// Write the given data to the stream. Returns the number of bytes written.
   /// Throws an exception on failure.
@@ -147,11 +168,24 @@ public:
 
   /// Start an asynchronous write. The data being written must be valid for the
   /// lifetime of the asynchronous operation.
-  template <typename ConstBufferSequence, typename WriteHandler>
-  BOOST_ASIO_INITFN_RESULT_TYPE(WriteHandler,
+  /**
+   * @par Completion Signature
+   * @code void(boost::system::error_code, std::size_t) @endcode
+   */
+  template <typename ConstBufferSequence,
+      BOOST_ASIO_COMPLETION_TOKEN_FOR(void (boost::system::error_code,
+        std::size_t)) WriteHandler
+          BOOST_ASIO_DEFAULT_COMPLETION_TOKEN_TYPE(executor_type)>
+  BOOST_ASIO_INITFN_AUTO_RESULT_TYPE_PREFIX(WriteHandler,
       void (boost::system::error_code, std::size_t))
   async_write_some(const ConstBufferSequence& buffers,
-      BOOST_ASIO_MOVE_ARG(WriteHandler) handler);
+      BOOST_ASIO_MOVE_ARG(WriteHandler) handler
+        BOOST_ASIO_DEFAULT_COMPLETION_TOKEN(executor_type))
+    BOOST_ASIO_INITFN_AUTO_RESULT_TYPE_SUFFIX((
+      async_initiate<WriteHandler,
+        void (boost::system::error_code, std::size_t)>(
+          declval<detail::initiate_async_buffered_write_some<Stream> >(),
+          handler, declval<detail::buffered_stream_storage*>(), buffers)));
 
   /// Read some data from the stream. Returns the number of bytes read. Throws
   /// an exception on failure.
@@ -172,11 +206,23 @@ public:
 
   /// Start an asynchronous read. The buffer into which the data will be read
   /// must be valid for the lifetime of the asynchronous operation.
-  template <typename MutableBufferSequence, typename ReadHandler>
-  BOOST_ASIO_INITFN_RESULT_TYPE(ReadHandler,
+  /**
+   * @par Completion Signature
+   * @code void(boost::system::error_code, std::size_t) @endcode
+   */
+  template <typename MutableBufferSequence,
+      BOOST_ASIO_COMPLETION_TOKEN_FOR(void (boost::system::error_code,
+        std::size_t)) ReadHandler
+          BOOST_ASIO_DEFAULT_COMPLETION_TOKEN_TYPE(executor_type)>
+  BOOST_ASIO_INITFN_AUTO_RESULT_TYPE_PREFIX(ReadHandler,
       void (boost::system::error_code, std::size_t))
   async_read_some(const MutableBufferSequence& buffers,
-      BOOST_ASIO_MOVE_ARG(ReadHandler) handler)
+      BOOST_ASIO_MOVE_ARG(ReadHandler) handler
+        BOOST_ASIO_DEFAULT_COMPLETION_TOKEN(executor_type))
+    BOOST_ASIO_INITFN_AUTO_RESULT_TYPE_SUFFIX((
+      declval<typename conditional<true, Stream&, ReadHandler>::type>()
+        .async_read_some(buffers,
+          BOOST_ASIO_MOVE_CAST(ReadHandler)(handler))))
   {
     return next_layer_.async_read_some(buffers,
         BOOST_ASIO_MOVE_CAST(ReadHandler)(handler));

linx64/include/boost/asio/buffered_write_stream_fwd.hpp

@@ -2,7 +2,7 @@
 // buffered_write_stream_fwd.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2019 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2023 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

linx64/include/boost/asio/buffers_iterator.hpp

@@ -2,7 +2,7 @@
 // buffers_iterator.hpp
 // ~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2019 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2023 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

linx64/include/boost/asio/cancellation_signal.hpp

@@ -0,0 +1,307 @@
+//
+// cancellation_signal.hpp
+// ~~~~~~~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2023 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef BOOST_ASIO_CANCELLATION_SIGNAL_HPP
+#define BOOST_ASIO_CANCELLATION_SIGNAL_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include <boost/asio/detail/config.hpp>
+#include <cassert>
+#include <new>
+#include <utility>
+#include <boost/asio/cancellation_type.hpp>
+#include <boost/asio/detail/cstddef.hpp>
+#include <boost/asio/detail/type_traits.hpp>
+#include <boost/asio/detail/variadic_templates.hpp>
+
+#include <boost/asio/detail/push_options.hpp>
+
+namespace boost {
+namespace asio {
+namespace detail {
+
+class cancellation_handler_base
+{
+public:
+  virtual void call(cancellation_type_t) = 0;
+  virtual std::pair<void*, std::size_t> destroy() BOOST_ASIO_NOEXCEPT = 0;
+
+protected:
+  ~cancellation_handler_base() {}
+};
+
+template <typename Handler>
+class cancellation_handler
+  : public cancellation_handler_base
+{
+public:
+#if defined(BOOST_ASIO_HAS_VARIADIC_TEMPLATES)
+  template <typename... Args>
+  cancellation_handler(std::size_t size, BOOST_ASIO_MOVE_ARG(Args)... args)
+    : handler_(BOOST_ASIO_MOVE_CAST(Args)(args)...),
+      size_(size)
+  {
+  }
+#else // defined(BOOST_ASIO_HAS_VARIADIC_TEMPLATES)
+  cancellation_handler(std::size_t size)
+    : handler_(),
+      size_(size)
+  {
+  }
+
+#define BOOST_ASIO_PRIVATE_HANDLER_CTOR_DEF(n) \
+  template <BOOST_ASIO_VARIADIC_TPARAMS(n)> \
+  cancellation_handler(std::size_t size, BOOST_ASIO_VARIADIC_MOVE_PARAMS(n)) \
+    : handler_(BOOST_ASIO_VARIADIC_MOVE_ARGS(n)), \
+      size_(size) \
+  { \
+  } \
+  /**/
+  BOOST_ASIO_VARIADIC_GENERATE(BOOST_ASIO_PRIVATE_HANDLER_CTOR_DEF)
+#undef BOOST_ASIO_PRIVATE_HANDLER_CTOR_DEF
+#endif // defined(BOOST_ASIO_HAS_VARIADIC_TEMPLATES)
+
+  void call(cancellation_type_t type)
+  {
+    handler_(type);
+  }
+
+  std::pair<void*, std::size_t> destroy() BOOST_ASIO_NOEXCEPT
+  {
+    std::pair<void*, std::size_t> mem(this, size_);
+    this->cancellation_handler::~cancellation_handler();
+    return mem;
+  }
+
+  Handler& handler() BOOST_ASIO_NOEXCEPT
+  {
+    return handler_;
+  }
+
+private:
+  ~cancellation_handler()
+  {
+  }
+
+  Handler handler_;
+  std::size_t size_;
+};
+
+} // namespace detail
+
+class cancellation_slot;
+
+/// A cancellation signal with a single slot.
+class cancellation_signal
+{
+public:
+  BOOST_ASIO_CONSTEXPR cancellation_signal()
+    : handler_(0)
+  {
+  }
+
+  BOOST_ASIO_DECL ~cancellation_signal();
+
+  /// Emits the signal and causes invocation of the slot's handler, if any.
+  void emit(cancellation_type_t type)
+  {
+    if (handler_)
+      handler_->call(type);
+  }
+
+  /// Returns the single slot associated with the signal.
+  /**
+   * The signal object must remain valid for as long the slot may be used.
+   * Destruction of the signal invalidates the slot.
+   */
+  cancellation_slot slot() BOOST_ASIO_NOEXCEPT;
+
+private:
+  cancellation_signal(const cancellation_signal&) BOOST_ASIO_DELETED;
+  cancellation_signal& operator=(const cancellation_signal&) BOOST_ASIO_DELETED;
+
+  detail::cancellation_handler_base* handler_;
+};
+
+/// A slot associated with a cancellation signal.
+class cancellation_slot
+{
+public:
+  /// Creates a slot that is not connected to any cancellation signal.
+  BOOST_ASIO_CONSTEXPR cancellation_slot()
+    : handler_(0)
+  {
+  }
+
+#if defined(BOOST_ASIO_HAS_VARIADIC_TEMPLATES) \
+  || defined(GENERATING_DOCUMENTATION)
+  /// Installs a handler into the slot, constructing the new object directly.
+  /**
+   * Destroys any existing handler in the slot, then installs the new handler,
+   * constructing it with the supplied @c args.
+   *
+   * The handler is a function object to be called when the signal is emitted.
+   * The signature of the handler must be
+   * @code void handler(boost::asio::cancellation_type_t); @endcode
+   *
+   * @param args Arguments to be passed to the @c CancellationHandler object's
+   * constructor.
+   *
+   * @returns A reference to the newly installed handler.
+   *
+   * @note Handlers installed into the slot via @c emplace are not required to
+   * be copy constructible or move constructible.
+   */
+  template <typename CancellationHandler, typename... Args>
+  CancellationHandler& emplace(BOOST_ASIO_MOVE_ARG(Args)... args)
+  {
+    typedef detail::cancellation_handler<CancellationHandler>
+      cancellation_handler_type;
+    auto_delete_helper del = { prepare_memory(
+        sizeof(cancellation_handler_type),
+        BOOST_ASIO_ALIGNOF(CancellationHandler)) };
+    cancellation_handler_type* handler_obj =
+      new (del.mem.first) cancellation_handler_type(
+        del.mem.second, BOOST_ASIO_MOVE_CAST(Args)(args)...);
+    del.mem.first = 0;
+    *handler_ = handler_obj;
+    return handler_obj->handler();
+  }
+#else // defined(BOOST_ASIO_HAS_VARIADIC_TEMPLATES)
+      //   || defined(GENERATING_DOCUMENTATION)
+  template <typename CancellationHandler>
+  CancellationHandler& emplace()
+  {
+    typedef detail::cancellation_handler<CancellationHandler>
+      cancellation_handler_type;
+    auto_delete_helper del = { prepare_memory(
+        sizeof(cancellation_handler_type),
+        BOOST_ASIO_ALIGNOF(CancellationHandler)) };
+    cancellation_handler_type* handler_obj =
+      new (del.mem.first) cancellation_handler_type(del.mem.second);
+    del.mem.first = 0;
+    *handler_ = handler_obj;
+    return handler_obj->handler();
+  }
+
+#define BOOST_ASIO_PRIVATE_HANDLER_EMPLACE_DEF(n) \
+  template <typename CancellationHandler, BOOST_ASIO_VARIADIC_TPARAMS(n)> \
+  CancellationHandler& emplace(BOOST_ASIO_VARIADIC_MOVE_PARAMS(n)) \
+  { \
+    typedef detail::cancellation_handler<CancellationHandler> \
+      cancellation_handler_type; \
+    auto_delete_helper del = { prepare_memory( \
+        sizeof(cancellation_handler_type), \
+        BOOST_ASIO_ALIGNOF(CancellationHandler)) }; \
+    cancellation_handler_type* handler_obj = \
+      new (del.mem.first) cancellation_handler_type( \
+        del.mem.second, BOOST_ASIO_VARIADIC_MOVE_ARGS(n)); \
+    del.mem.first = 0; \
+    *handler_ = handler_obj; \
+    return handler_obj->handler(); \
+  } \
+  /**/
+  BOOST_ASIO_VARIADIC_GENERATE(BOOST_ASIO_PRIVATE_HANDLER_EMPLACE_DEF)
+#undef BOOST_ASIO_PRIVATE_HANDLER_EMPLACE_DEF
+#endif // defined(BOOST_ASIO_HAS_VARIADIC_TEMPLATES)
+
+  /// Installs a handler into the slot.
+  /**
+   * Destroys any existing handler in the slot, then installs the new handler,
+   * constructing it as a decay-copy of the supplied handler.
+   *
+   * The handler is a function object to be called when the signal is emitted.
+   * The signature of the handler must be
+   * @code void handler(boost::asio::cancellation_type_t); @endcode
+   *
+   * @param handler The handler to be installed.
+   *
+   * @returns A reference to the newly installed handler.
+   */
+  template <typename CancellationHandler>
+  typename decay<CancellationHandler>::type& assign(
+      BOOST_ASIO_MOVE_ARG(CancellationHandler) handler)
+  {
+    return this->emplace<typename decay<CancellationHandler>::type>(
+        BOOST_ASIO_MOVE_CAST(CancellationHandler)(handler));
+  }
+
+  /// Clears the slot.
+  /**
+   * Destroys any existing handler in the slot.
+   */
+  BOOST_ASIO_DECL void clear();
+
+  /// Returns whether the slot is connected to a signal.
+  BOOST_ASIO_CONSTEXPR bool is_connected() const BOOST_ASIO_NOEXCEPT
+  {
+    return handler_ != 0;
+  }
+
+  /// Returns whether the slot is connected and has an installed handler.
+  BOOST_ASIO_CONSTEXPR bool has_handler() const BOOST_ASIO_NOEXCEPT
+  {
+    return handler_ != 0 && *handler_ != 0;
+  }
+
+  /// Compare two slots for equality.
+  friend BOOST_ASIO_CONSTEXPR bool operator==(const cancellation_slot& lhs,
+      const cancellation_slot& rhs) BOOST_ASIO_NOEXCEPT
+  {
+    return lhs.handler_ == rhs.handler_;
+  }
+
+  /// Compare two slots for inequality.
+  friend BOOST_ASIO_CONSTEXPR bool operator!=(const cancellation_slot& lhs,
+      const cancellation_slot& rhs) BOOST_ASIO_NOEXCEPT
+  {
+    return lhs.handler_ != rhs.handler_;
+  }
+
+private:
+  friend class cancellation_signal;
+
+  BOOST_ASIO_CONSTEXPR cancellation_slot(int,
+      detail::cancellation_handler_base** handler)
+    : handler_(handler)
+  {
+  }
+
+  BOOST_ASIO_DECL std::pair<void*, std::size_t> prepare_memory(
+      std::size_t size, std::size_t align);
+
+  struct auto_delete_helper
+  {
+    std::pair<void*, std::size_t> mem;
+
+    BOOST_ASIO_DECL ~auto_delete_helper();
+  };
+
+  detail::cancellation_handler_base** handler_;
+};
+
+inline cancellation_slot cancellation_signal::slot() BOOST_ASIO_NOEXCEPT
+{
+  return cancellation_slot(0, &handler_);
+}
+
+} // namespace asio
+} // namespace boost
+
+#include <boost/asio/detail/pop_options.hpp>
+
+#if defined(BOOST_ASIO_HEADER_ONLY)
+# include <boost/asio/impl/cancellation_signal.ipp>
+#endif // defined(BOOST_ASIO_HEADER_ONLY)
+
+#endif // BOOST_ASIO_CANCELLATION_SIGNAL_HPP

linx64/include/boost/asio/cancellation_state.hpp

@@ -0,0 +1,237 @@
+//
+// cancellation_state.hpp
+// ~~~~~~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2023 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef BOOST_ASIO_CANCELLATION_STATE_HPP
+#define BOOST_ASIO_CANCELLATION_STATE_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include <boost/asio/detail/config.hpp>
+#include <cassert>
+#include <new>
+#include <utility>
+#include <boost/asio/cancellation_signal.hpp>
+#include <boost/asio/detail/cstddef.hpp>
+
+#include <boost/asio/detail/push_options.hpp>
+
+namespace boost {
+namespace asio {
+
+/// A simple cancellation signal propagation filter.
+template <cancellation_type_t Mask>
+struct cancellation_filter
+{
+  /// Returns <tt>type & Mask</tt>.
+  cancellation_type_t operator()(
+      cancellation_type_t type) const BOOST_ASIO_NOEXCEPT
+  {
+    return type & Mask;
+  }
+};
+
+/// A cancellation filter that disables cancellation.
+typedef cancellation_filter<cancellation_type::none>
+  disable_cancellation;
+
+/// A cancellation filter that enables terminal cancellation only.
+typedef cancellation_filter<cancellation_type::terminal>
+  enable_terminal_cancellation;
+
+#if defined(GENERATING_DOCUMENTATION)
+
+/// A cancellation filter that enables terminal and partial cancellation.
+typedef cancellation_filter<
+    cancellation_type::terminal | cancellation_type::partial>
+  enable_partial_cancellation;
+
+/// A cancellation filter that enables terminal, partial and total cancellation.
+typedef cancellation_filter<cancellation_type::terminal
+    | cancellation_type::partial | cancellation_type::total>
+  enable_total_cancellation;
+
+#else // defined(GENERATING_DOCUMENTATION)
+
+typedef cancellation_filter<
+    static_cast<cancellation_type_t>(
+      static_cast<unsigned int>(cancellation_type::terminal)
+        | static_cast<unsigned int>(cancellation_type::partial))>
+  enable_partial_cancellation;
+
+typedef cancellation_filter<
+    static_cast<cancellation_type_t>(
+      static_cast<unsigned int>(cancellation_type::terminal)
+        | static_cast<unsigned int>(cancellation_type::partial)
+        | static_cast<unsigned int>(cancellation_type::total))>
+  enable_total_cancellation;
+
+#endif // defined(GENERATING_DOCUMENTATION)
+
+/// A cancellation state is used for chaining signals and slots in compositions.
+class cancellation_state
+{
+public:
+  /// Construct a disconnected cancellation state.
+  BOOST_ASIO_CONSTEXPR cancellation_state() BOOST_ASIO_NOEXCEPT
+    : impl_(0)
+  {
+  }
+
+  /// Construct and attach to a parent slot to create a new child slot.
+  /**
+   * Initialises the cancellation state so that it allows terminal cancellation
+   * only. Equivalent to <tt>cancellation_state(slot,
+   * enable_terminal_cancellation())</tt>.
+   *
+   * @param slot The parent cancellation slot to which the state will be
+   * attached.
+   */
+  template <typename CancellationSlot>
+  BOOST_ASIO_CONSTEXPR explicit cancellation_state(CancellationSlot slot)
+    : impl_(slot.is_connected() ? &slot.template emplace<impl<> >() : 0)
+  {
+  }
+
+  /// Construct and attach to a parent slot to create a new child slot.
+  /**
+   * @param slot The parent cancellation slot to which the state will be
+   * attached.
+   *
+   * @param filter A function object that is used to transform incoming
+   * cancellation signals as they are received from the parent slot. This
+   * function object must have the signature:
+   * @code boost::asio::cancellation_type_t filter(
+   *     boost::asio::cancellation_type_t); @endcode
+   *
+   * The library provides the following pre-defined cancellation filters:
+   *
+   * @li boost::asio::disable_cancellation
+   * @li boost::asio::enable_terminal_cancellation
+   * @li boost::asio::enable_partial_cancellation
+   * @li boost::asio::enable_total_cancellation
+   */
+  template <typename CancellationSlot, typename Filter>
+  BOOST_ASIO_CONSTEXPR cancellation_state(CancellationSlot slot, Filter filter)
+    : impl_(slot.is_connected()
+        ? &slot.template emplace<impl<Filter, Filter> >(filter, filter)
+        : 0)
+  {
+  }
+
+  /// Construct and attach to a parent slot to create a new child slot.
+  /**
+   * @param slot The parent cancellation slot to which the state will be
+   * attached.
+   *
+   * @param in_filter A function object that is used to transform incoming
+   * cancellation signals as they are received from the parent slot. This
+   * function object must have the signature:
+   * @code boost::asio::cancellation_type_t in_filter(
+   *     boost::asio::cancellation_type_t); @endcode
+   *
+   * @param out_filter A function object that is used to transform outcoming
+   * cancellation signals as they are relayed to the child slot. This function
+   * object must have the signature:
+   * @code boost::asio::cancellation_type_t out_filter(
+   *     boost::asio::cancellation_type_t); @endcode
+   *
+   * The library provides the following pre-defined cancellation filters:
+   *
+   * @li boost::asio::disable_cancellation
+   * @li boost::asio::enable_terminal_cancellation
+   * @li boost::asio::enable_partial_cancellation
+   * @li boost::asio::enable_total_cancellation
+   */
+  template <typename CancellationSlot, typename InFilter, typename OutFilter>
+  BOOST_ASIO_CONSTEXPR cancellation_state(CancellationSlot slot,
+      InFilter in_filter, OutFilter out_filter)
+    : impl_(slot.is_connected()
+        ? &slot.template emplace<impl<InFilter, OutFilter> >(
+            BOOST_ASIO_MOVE_CAST(InFilter)(in_filter),
+            BOOST_ASIO_MOVE_CAST(OutFilter)(out_filter))
+        : 0)
+  {
+  }
+
+  /// Returns the single child slot associated with the state.
+  /**
+   * This sub-slot is used with the operations that are being composed.
+   */
+  BOOST_ASIO_CONSTEXPR cancellation_slot slot() const BOOST_ASIO_NOEXCEPT
+  {
+    return impl_ ? impl_->signal_.slot() : cancellation_slot();
+  }
+
+  /// Returns the cancellation types that have been triggered.
+  cancellation_type_t cancelled() const BOOST_ASIO_NOEXCEPT
+  {
+    return impl_ ? impl_->cancelled_ : cancellation_type_t();
+  }
+
+  /// Clears the specified cancellation types, if they have been triggered.
+  void clear(cancellation_type_t mask = cancellation_type::all)
+    BOOST_ASIO_NOEXCEPT
+  {
+    if (impl_)
+      impl_->cancelled_ &= ~mask;
+  }
+
+private:
+  struct impl_base
+  {
+    impl_base()
+      : cancelled_()
+    {
+    }
+
+    cancellation_signal signal_;
+    cancellation_type_t cancelled_;
+  };
+
+  template <
+      typename InFilter = enable_terminal_cancellation,
+      typename OutFilter = InFilter>
+  struct impl : impl_base
+  {
+    impl()
+      : in_filter_(),
+        out_filter_()
+    {
+    }
+
+    impl(InFilter in_filter, OutFilter out_filter)
+      : in_filter_(BOOST_ASIO_MOVE_CAST(InFilter)(in_filter)),
+        out_filter_(BOOST_ASIO_MOVE_CAST(OutFilter)(out_filter))
+    {
+    }
+
+    void operator()(cancellation_type_t in)
+    {
+      this->cancelled_ = in_filter_(in);
+      cancellation_type_t out = out_filter_(this->cancelled_);
+      if (out != cancellation_type::none)
+        this->signal_.emit(out);
+    }
+
+    InFilter in_filter_;
+    OutFilter out_filter_;
+  };
+
+  impl_base* impl_;
+};
+
+} // namespace asio
+} // namespace boost
+
+#include <boost/asio/detail/pop_options.hpp>
+
+#endif // BOOST_ASIO_CANCELLATION_STATE_HPP

linx64/include/boost/asio/cancellation_type.hpp

@@ -0,0 +1,176 @@
+//
+// cancellation_type.hpp
+// ~~~~~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2023 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef BOOST_ASIO_CANCELLATION_TYPE_HPP
+#define BOOST_ASIO_CANCELLATION_TYPE_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include <boost/asio/detail/config.hpp>
+
+#include <boost/asio/detail/push_options.hpp>
+
+namespace boost {
+namespace asio {
+
+# if defined(GENERATING_DOCUMENTATION)
+
+/// Enumeration representing the different types of cancellation that may
+/// be requested from or implemented by an asynchronous operation.
+enum cancellation_type
+{
+  /// Bitmask representing no types of cancellation.
+  none = 0,
+
+  /// Requests cancellation where, following a successful cancellation, the only
+  /// safe operations on the I/O object are closure or destruction.
+  terminal = 1,
+
+  /// Requests cancellation where a successful cancellation may result in
+  /// partial side effects or no side effects. Following cancellation, the I/O
+  /// object is in a well-known state, and may be used for further operations.
+  partial = 2,
+
+  /// Requests cancellation where a successful cancellation results in no
+  /// apparent side effects. Following cancellation, the I/O object is in the
+  /// same observable state as it was prior to the operation.
+  total = 4,
+
+  /// Bitmask representing all types of cancellation.
+  all = 0xFFFFFFFF
+};
+
+/// Portability typedef.
+typedef cancellation_type cancellation_type_t;
+
+#elif defined(BOOST_ASIO_HAS_ENUM_CLASS)
+
+enum class cancellation_type : unsigned int
+{
+  none = 0,
+  terminal = 1,
+  partial = 2,
+  total = 4,
+  all = 0xFFFFFFFF
+};
+
+typedef cancellation_type cancellation_type_t;
+
+#else // defined(BOOST_ASIO_HAS_ENUM_CLASS)
+
+namespace cancellation_type {
+
+enum cancellation_type_t
+{
+  none = 0,
+  terminal = 1,
+  partial = 2,
+  total = 4,
+  all = 0xFFFFFFFF
+};
+
+} // namespace cancellation_type
+
+typedef cancellation_type::cancellation_type_t cancellation_type_t;
+
+#endif // defined(BOOST_ASIO_HAS_ENUM_CLASS)
+
+/// Negation operator.
+/**
+ * @relates cancellation_type
+ */
+inline BOOST_ASIO_CONSTEXPR bool operator!(cancellation_type_t x)
+{
+  return static_cast<unsigned int>(x) == 0;
+}
+
+/// Bitwise and operator.
+/**
+ * @relates cancellation_type
+ */
+inline BOOST_ASIO_CONSTEXPR cancellation_type_t operator&(
+    cancellation_type_t x, cancellation_type_t y)
+{
+  return static_cast<cancellation_type_t>(
+      static_cast<unsigned int>(x) & static_cast<unsigned int>(y));
+}
+
+/// Bitwise or operator.
+/**
+ * @relates cancellation_type
+ */
+inline BOOST_ASIO_CONSTEXPR cancellation_type_t operator|(
+    cancellation_type_t x, cancellation_type_t y)
+{
+  return static_cast<cancellation_type_t>(
+      static_cast<unsigned int>(x) | static_cast<unsigned int>(y));
+}
+
+/// Bitwise xor operator.
+/**
+ * @relates cancellation_type
+ */
+inline BOOST_ASIO_CONSTEXPR cancellation_type_t operator^(
+    cancellation_type_t x, cancellation_type_t y)
+{
+  return static_cast<cancellation_type_t>(
+      static_cast<unsigned int>(x) ^ static_cast<unsigned int>(y));
+}
+
+/// Bitwise negation operator.
+/**
+ * @relates cancellation_type
+ */
+inline BOOST_ASIO_CONSTEXPR cancellation_type_t operator~(cancellation_type_t x)
+{
+  return static_cast<cancellation_type_t>(~static_cast<unsigned int>(x));
+}
+
+/// Bitwise and-assignment operator.
+/**
+ * @relates cancellation_type
+ */
+inline cancellation_type_t& operator&=(
+    cancellation_type_t& x, cancellation_type_t y)
+{
+  x = x & y;
+  return x;
+}
+
+/// Bitwise or-assignment operator.
+/**
+ * @relates cancellation_type
+ */
+inline cancellation_type_t& operator|=(
+    cancellation_type_t& x, cancellation_type_t y)
+{
+  x = x | y;
+  return x;
+}
+
+/// Bitwise xor-assignment operator.
+/**
+ * @relates cancellation_type
+ */
+inline cancellation_type_t& operator^=(
+    cancellation_type_t& x, cancellation_type_t y)
+{
+  x = x ^ y;
+  return x;
+}
+
+} // namespace asio
+} // namespace boost
+
+#include <boost/asio/detail/pop_options.hpp>
+
+#endif // BOOST_ASIO_CANCELLATION_TYPE_HPP

linx64/include/boost/asio/co_spawn.hpp

@@ -2,7 +2,7 @@
 // co_spawn.hpp
 // ~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2019 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2023 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -20,6 +20,7 @@
 #if defined(BOOST_ASIO_HAS_CO_AWAIT) || defined(GENERATING_DOCUMENTATION)
 
 #include <boost/asio/awaitable.hpp>
+#include <boost/asio/execution/executor.hpp>
 #include <boost/asio/execution_context.hpp>
 #include <boost/asio/is_executor.hpp>
 
@@ -46,37 +47,471 @@ struct awaitable_signature<awaitable<void, Executor>>
 
 } // namespace detail
 
-/// Spawn a new thread of execution.
+/// Spawn a new coroutined-based thread of execution.
 /**
- * The entry point function object @c f must have the signature:
+ * @param ex The executor that will be used to schedule the new thread of
+ * execution.
  *
- * @code awaitable<void, E> f(); @endcode
+ * @param a The boost::asio::awaitable object that is the result of calling the
+ * coroutine's entry point function.
  *
- * where @c E is convertible from @c Executor.
+ * @param token The @ref completion_token that will handle the notification that
+ * the thread of execution has completed. The function signature of the
+ * completion handler must be:
+ * @code void handler(std::exception_ptr, T); @endcode
+ *
+ * @par Completion Signature
+ * @code void(std::exception_ptr, T) @endcode
+ *
+ * @par Example
+ * @code
+ * boost::asio::awaitable<std::size_t> echo(tcp::socket socket)
+ * {
+ *   std::size_t bytes_transferred = 0;
+ *
+ *   try
+ *   {
+ *     char data[1024];
+ *     for (;;)
+ *     {
+ *       std::size_t n = co_await socket.async_read_some(
+ *           boost::asio::buffer(data), boost::asio::use_awaitable);
+ *
+ *       co_await boost::asio::async_write(socket,
+ *           boost::asio::buffer(data, n), boost::asio::use_awaitable);
+ *
+ *       bytes_transferred += n;
+ *     }
+ *   }
+ *   catch (const std::exception&)
+ *   {
+ *   }
+ *
+ *   co_return bytes_transferred;
+ * }
+ *
+ * // ...
+ *
+ * boost::asio::co_spawn(my_executor,
+ *   echo(std::move(my_tcp_socket)),
+ *   [](std::exception_ptr e, std::size_t n)
+ *   {
+ *     std::cout << "transferred " << n << "\n";
+ *   });
+ * @endcode
+ *
+ * @par Per-Operation Cancellation
+ * The new thread of execution is created with a cancellation state that
+ * supports @c cancellation_type::terminal values only. To change the
+ * cancellation state, call boost::asio::this_coro::reset_cancellation_state.
  */
-template <typename Executor, typename F, typename CompletionToken>
-BOOST_ASIO_INITFN_RESULT_TYPE(CompletionToken,
-    typename detail::awaitable_signature<typename result_of<F()>::type>::type)
-co_spawn(const Executor& ex, F&& f, CompletionToken&& token,
-    typename enable_if<
-      is_executor<Executor>::value
-    >::type* = 0);
+template <typename Executor, typename T, typename AwaitableExecutor,
+    BOOST_ASIO_COMPLETION_TOKEN_FOR(
+      void(std::exception_ptr, T)) CompletionToken
+        BOOST_ASIO_DEFAULT_COMPLETION_TOKEN_TYPE(Executor)>
+inline BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(
+    CompletionToken, void(std::exception_ptr, T))
+co_spawn(const Executor& ex, awaitable<T, AwaitableExecutor> a,
+    CompletionToken&& token
+      BOOST_ASIO_DEFAULT_COMPLETION_TOKEN(Executor),
+    typename constraint<
+      (is_executor<Executor>::value || execution::is_executor<Executor>::value)
+        && is_convertible<Executor, AwaitableExecutor>::value
+    >::type = 0);
 
-/// Spawn a new thread of execution.
+/// Spawn a new coroutined-based thread of execution.
 /**
- * The entry point function object @c f must have the signature:
+ * @param ex The executor that will be used to schedule the new thread of
+ * execution.
  *
- * @code awaitable<void, E> f(); @endcode
+ * @param a The boost::asio::awaitable object that is the result of calling the
+ * coroutine's entry point function.
  *
- * where @c E is convertible from @c ExecutionContext::executor_type.
+ * @param token The @ref completion_token that will handle the notification that
+ * the thread of execution has completed. The function signature of the
+ * completion handler must be:
+ * @code void handler(std::exception_ptr); @endcode
+ *
+ * @par Completion Signature
+ * @code void(std::exception_ptr) @endcode
+ *
+ * @par Example
+ * @code
+ * boost::asio::awaitable<void> echo(tcp::socket socket)
+ * {
+ *   try
+ *   {
+ *     char data[1024];
+ *     for (;;)
+ *     {
+ *       std::size_t n = co_await socket.async_read_some(
+ *           boost::asio::buffer(data), boost::asio::use_awaitable);
+ *
+ *       co_await boost::asio::async_write(socket,
+ *           boost::asio::buffer(data, n), boost::asio::use_awaitable);
+ *     }
+ *   }
+ *   catch (const std::exception& e)
+ *   {
+ *     std::cerr << "Exception: " << e.what() << "\n";
+ *   }
+ * }
+ *
+ * // ...
+ *
+ * boost::asio::co_spawn(my_executor,
+ *   echo(std::move(my_tcp_socket)),
+ *   boost::asio::detached);
+ * @endcode
+ *
+ * @par Per-Operation Cancellation
+ * The new thread of execution is created with a cancellation state that
+ * supports @c cancellation_type::terminal values only. To change the
+ * cancellation state, call boost::asio::this_coro::reset_cancellation_state.
  */
-template <typename ExecutionContext, typename F, typename CompletionToken>
-BOOST_ASIO_INITFN_RESULT_TYPE(CompletionToken,
-    typename detail::awaitable_signature<typename result_of<F()>::type>::type)
-co_spawn(ExecutionContext& ctx, F&& f, CompletionToken&& token,
-    typename enable_if<
+template <typename Executor, typename AwaitableExecutor,
+    BOOST_ASIO_COMPLETION_TOKEN_FOR(
+      void(std::exception_ptr)) CompletionToken
+        BOOST_ASIO_DEFAULT_COMPLETION_TOKEN_TYPE(Executor)>
+inline BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(
+    CompletionToken, void(std::exception_ptr))
+co_spawn(const Executor& ex, awaitable<void, AwaitableExecutor> a,
+    CompletionToken&& token
+      BOOST_ASIO_DEFAULT_COMPLETION_TOKEN(Executor),
+    typename constraint<
+      (is_executor<Executor>::value || execution::is_executor<Executor>::value)
+        && is_convertible<Executor, AwaitableExecutor>::value
+    >::type = 0);
+
+/// Spawn a new coroutined-based thread of execution.
+/**
+ * @param ctx An execution context that will provide the executor to be used to
+ * schedule the new thread of execution.
+ *
+ * @param a The boost::asio::awaitable object that is the result of calling the
+ * coroutine's entry point function.
+ *
+ * @param token The @ref completion_token that will handle the notification that
+ * the thread of execution has completed. The function signature of the
+ * completion handler must be:
+ * @code void handler(std::exception_ptr); @endcode
+ *
+ * @par Completion Signature
+ * @code void(std::exception_ptr, T) @endcode
+ *
+ * @par Example
+ * @code
+ * boost::asio::awaitable<std::size_t> echo(tcp::socket socket)
+ * {
+ *   std::size_t bytes_transferred = 0;
+ *
+ *   try
+ *   {
+ *     char data[1024];
+ *     for (;;)
+ *     {
+ *       std::size_t n = co_await socket.async_read_some(
+ *           boost::asio::buffer(data), boost::asio::use_awaitable);
+ *
+ *       co_await boost::asio::async_write(socket,
+ *           boost::asio::buffer(data, n), boost::asio::use_awaitable);
+ *
+ *       bytes_transferred += n;
+ *     }
+ *   }
+ *   catch (const std::exception&)
+ *   {
+ *   }
+ *
+ *   co_return bytes_transferred;
+ * }
+ *
+ * // ...
+ *
+ * boost::asio::co_spawn(my_io_context,
+ *   echo(std::move(my_tcp_socket)),
+ *   [](std::exception_ptr e, std::size_t n)
+ *   {
+ *     std::cout << "transferred " << n << "\n";
+ *   });
+ * @endcode
+ *
+ * @par Per-Operation Cancellation
+ * The new thread of execution is created with a cancellation state that
+ * supports @c cancellation_type::terminal values only. To change the
+ * cancellation state, call boost::asio::this_coro::reset_cancellation_state.
+ */
+template <typename ExecutionContext, typename T, typename AwaitableExecutor,
+    BOOST_ASIO_COMPLETION_TOKEN_FOR(
+      void(std::exception_ptr, T)) CompletionToken
+        BOOST_ASIO_DEFAULT_COMPLETION_TOKEN_TYPE(
+          typename ExecutionContext::executor_type)>
+inline BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(
+    CompletionToken, void(std::exception_ptr, T))
+co_spawn(ExecutionContext& ctx, awaitable<T, AwaitableExecutor> a,
+    CompletionToken&& token
+      BOOST_ASIO_DEFAULT_COMPLETION_TOKEN(
+        typename ExecutionContext::executor_type),
+    typename constraint<
       is_convertible<ExecutionContext&, execution_context&>::value
-    >::type* = 0);
+        && is_convertible<typename ExecutionContext::executor_type,
+          AwaitableExecutor>::value
+    >::type = 0);
+
+/// Spawn a new coroutined-based thread of execution.
+/**
+ * @param ctx An execution context that will provide the executor to be used to
+ * schedule the new thread of execution.
+ *
+ * @param a The boost::asio::awaitable object that is the result of calling the
+ * coroutine's entry point function.
+ *
+ * @param token The @ref completion_token that will handle the notification that
+ * the thread of execution has completed. The function signature of the
+ * completion handler must be:
+ * @code void handler(std::exception_ptr); @endcode
+ *
+ * @par Completion Signature
+ * @code void(std::exception_ptr) @endcode
+ *
+ * @par Example
+ * @code
+ * boost::asio::awaitable<void> echo(tcp::socket socket)
+ * {
+ *   try
+ *   {
+ *     char data[1024];
+ *     for (;;)
+ *     {
+ *       std::size_t n = co_await socket.async_read_some(
+ *           boost::asio::buffer(data), boost::asio::use_awaitable);
+ *
+ *       co_await boost::asio::async_write(socket,
+ *           boost::asio::buffer(data, n), boost::asio::use_awaitable);
+ *     }
+ *   }
+ *   catch (const std::exception& e)
+ *   {
+ *     std::cerr << "Exception: " << e.what() << "\n";
+ *   }
+ * }
+ *
+ * // ...
+ *
+ * boost::asio::co_spawn(my_io_context,
+ *   echo(std::move(my_tcp_socket)),
+ *   boost::asio::detached);
+ * @endcode
+ *
+ * @par Per-Operation Cancellation
+ * The new thread of execution is created with a cancellation state that
+ * supports @c cancellation_type::terminal values only. To change the
+ * cancellation state, call boost::asio::this_coro::reset_cancellation_state.
+ */
+template <typename ExecutionContext, typename AwaitableExecutor,
+    BOOST_ASIO_COMPLETION_TOKEN_FOR(
+      void(std::exception_ptr)) CompletionToken
+        BOOST_ASIO_DEFAULT_COMPLETION_TOKEN_TYPE(
+          typename ExecutionContext::executor_type)>
+inline BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(
+    CompletionToken, void(std::exception_ptr))
+co_spawn(ExecutionContext& ctx, awaitable<void, AwaitableExecutor> a,
+    CompletionToken&& token
+      BOOST_ASIO_DEFAULT_COMPLETION_TOKEN(
+        typename ExecutionContext::executor_type),
+    typename constraint<
+      is_convertible<ExecutionContext&, execution_context&>::value
+        && is_convertible<typename ExecutionContext::executor_type,
+          AwaitableExecutor>::value
+    >::type = 0);
+
+/// Spawn a new coroutined-based thread of execution.
+/**
+ * @param ex The executor that will be used to schedule the new thread of
+ * execution.
+ *
+ * @param f A nullary function object with a return type of the form
+ * @c boost::asio::awaitable<R,E> that will be used as the coroutine's entry
+ * point.
+ *
+ * @param token The @ref completion_token that will handle the notification
+ * that the thread of execution has completed. If @c R is @c void, the function
+ * signature of the completion handler must be:
+ *
+ * @code void handler(std::exception_ptr); @endcode
+ * Otherwise, the function signature of the completion handler must be:
+ * @code void handler(std::exception_ptr, R); @endcode
+ *
+ * @par Completion Signature
+ * @code void(std::exception_ptr, R) @endcode
+ * where @c R is the first template argument to the @c awaitable returned by the
+ * supplied function object @c F:
+ * @code boost::asio::awaitable<R, AwaitableExecutor> F() @endcode
+ *
+ * @par Example
+ * @code
+ * boost::asio::awaitable<std::size_t> echo(tcp::socket socket)
+ * {
+ *   std::size_t bytes_transferred = 0;
+ *
+ *   try
+ *   {
+ *     char data[1024];
+ *     for (;;)
+ *     {
+ *       std::size_t n = co_await socket.async_read_some(
+ *           boost::asio::buffer(data), boost::asio::use_awaitable);
+ *
+ *       co_await boost::asio::async_write(socket,
+ *           boost::asio::buffer(data, n), boost::asio::use_awaitable);
+ *
+ *       bytes_transferred += n;
+ *     }
+ *   }
+ *   catch (const std::exception&)
+ *   {
+ *   }
+ *
+ *   co_return bytes_transferred;
+ * }
+ *
+ * // ...
+ *
+ * boost::asio::co_spawn(my_executor,
+ *   [socket = std::move(my_tcp_socket)]() mutable
+ *     -> boost::asio::awaitable<void>
+ *   {
+ *     try
+ *     {
+ *       char data[1024];
+ *       for (;;)
+ *       {
+ *         std::size_t n = co_await socket.async_read_some(
+ *             boost::asio::buffer(data), boost::asio::use_awaitable);
+ *
+ *         co_await boost::asio::async_write(socket,
+ *             boost::asio::buffer(data, n), boost::asio::use_awaitable);
+ *       }
+ *     }
+ *     catch (const std::exception& e)
+ *     {
+ *       std::cerr << "Exception: " << e.what() << "\n";
+ *     }
+ *   }, boost::asio::detached);
+ * @endcode
+ *
+ * @par Per-Operation Cancellation
+ * The new thread of execution is created with a cancellation state that
+ * supports @c cancellation_type::terminal values only. To change the
+ * cancellation state, call boost::asio::this_coro::reset_cancellation_state.
+ */
+template <typename Executor, typename F,
+    BOOST_ASIO_COMPLETION_TOKEN_FOR(typename detail::awaitable_signature<
+      typename result_of<F()>::type>::type) CompletionToken
+        BOOST_ASIO_DEFAULT_COMPLETION_TOKEN_TYPE(Executor)>
+BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(CompletionToken,
+    typename detail::awaitable_signature<typename result_of<F()>::type>::type)
+co_spawn(const Executor& ex, F&& f,
+    CompletionToken&& token
+      BOOST_ASIO_DEFAULT_COMPLETION_TOKEN(Executor),
+    typename constraint<
+      is_executor<Executor>::value || execution::is_executor<Executor>::value
+    >::type = 0);
+
+/// Spawn a new coroutined-based thread of execution.
+/**
+ * @param ctx An execution context that will provide the executor to be used to
+ * schedule the new thread of execution.
+ *
+ * @param f A nullary function object with a return type of the form
+ * @c boost::asio::awaitable<R,E> that will be used as the coroutine's entry
+ * point.
+ *
+ * @param token The @ref completion_token that will handle the notification
+ * that the thread of execution has completed. If @c R is @c void, the function
+ * signature of the completion handler must be:
+ *
+ * @code void handler(std::exception_ptr); @endcode
+ * Otherwise, the function signature of the completion handler must be:
+ * @code void handler(std::exception_ptr, R); @endcode
+ *
+ * @par Completion Signature
+ * @code void(std::exception_ptr, R) @endcode
+ * where @c R is the first template argument to the @c awaitable returned by the
+ * supplied function object @c F:
+ * @code boost::asio::awaitable<R, AwaitableExecutor> F() @endcode
+ *
+ * @par Example
+ * @code
+ * boost::asio::awaitable<std::size_t> echo(tcp::socket socket)
+ * {
+ *   std::size_t bytes_transferred = 0;
+ *
+ *   try
+ *   {
+ *     char data[1024];
+ *     for (;;)
+ *     {
+ *       std::size_t n = co_await socket.async_read_some(
+ *           boost::asio::buffer(data), boost::asio::use_awaitable);
+ *
+ *       co_await boost::asio::async_write(socket,
+ *           boost::asio::buffer(data, n), boost::asio::use_awaitable);
+ *
+ *       bytes_transferred += n;
+ *     }
+ *   }
+ *   catch (const std::exception&)
+ *   {
+ *   }
+ *
+ *   co_return bytes_transferred;
+ * }
+ *
+ * // ...
+ *
+ * boost::asio::co_spawn(my_io_context,
+ *   [socket = std::move(my_tcp_socket)]() mutable
+ *     -> boost::asio::awaitable<void>
+ *   {
+ *     try
+ *     {
+ *       char data[1024];
+ *       for (;;)
+ *       {
+ *         std::size_t n = co_await socket.async_read_some(
+ *             boost::asio::buffer(data), boost::asio::use_awaitable);
+ *
+ *         co_await boost::asio::async_write(socket,
+ *             boost::asio::buffer(data, n), boost::asio::use_awaitable);
+ *       }
+ *     }
+ *     catch (const std::exception& e)
+ *     {
+ *       std::cerr << "Exception: " << e.what() << "\n";
+ *     }
+ *   }, boost::asio::detached);
+ * @endcode
+ *
+ * @par Per-Operation Cancellation
+ * The new thread of execution is created with a cancellation state that
+ * supports @c cancellation_type::terminal values only. To change the
+ * cancellation state, call boost::asio::this_coro::reset_cancellation_state.
+ */
+template <typename ExecutionContext, typename F,
+    BOOST_ASIO_COMPLETION_TOKEN_FOR(typename detail::awaitable_signature<
+      typename result_of<F()>::type>::type) CompletionToken
+        BOOST_ASIO_DEFAULT_COMPLETION_TOKEN_TYPE(
+          typename ExecutionContext::executor_type)>
+BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(CompletionToken,
+    typename detail::awaitable_signature<typename result_of<F()>::type>::type)
+co_spawn(ExecutionContext& ctx, F&& f,
+    CompletionToken&& token
+      BOOST_ASIO_DEFAULT_COMPLETION_TOKEN(
+        typename ExecutionContext::executor_type),
+    typename constraint<
+      is_convertible<ExecutionContext&, execution_context&>::value
+    >::type = 0);
 
 } // namespace asio
 } // namespace boost

linx64/include/boost/asio/completion_condition.hpp

@@ -2,7 +2,7 @@
 // completion_condition.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2019 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2023 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

linx64/include/boost/asio/compose.hpp

@@ -2,7 +2,7 @@
 // compose.hpp
 // ~~~~~~~~~~~
 //
-// Copyright (c) 2003-2019 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2023 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -16,12 +16,308 @@
 #endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
 
 #include <boost/asio/detail/config.hpp>
+#include <boost/asio/associated_executor.hpp>
 #include <boost/asio/async_result.hpp>
+#include <boost/asio/detail/base_from_cancellation_state.hpp>
+#include <boost/asio/detail/composed_work.hpp>
+#include <boost/asio/detail/handler_alloc_helpers.hpp>
+#include <boost/asio/detail/handler_cont_helpers.hpp>
+#include <boost/asio/detail/handler_invoke_helpers.hpp>
+#include <boost/asio/detail/type_traits.hpp>
+#include <boost/asio/detail/variadic_templates.hpp>
 
 #include <boost/asio/detail/push_options.hpp>
 
 namespace boost {
 namespace asio {
+namespace detail {
+
+#if defined(BOOST_ASIO_HAS_VARIADIC_TEMPLATES)
+template <typename Impl, typename Work, typename Handler, typename Signature>
+class composed_op;
+
+template <typename Impl, typename Work, typename Handler,
+    typename R, typename... Args>
+class composed_op<Impl, Work, Handler, R(Args...)>
+#else // defined(BOOST_ASIO_HAS_VARIADIC_TEMPLATES)
+template <typename Impl, typename Work, typename Handler, typename Signature>
+class composed_op
+#endif // defined(BOOST_ASIO_HAS_VARIADIC_TEMPLATES)
+  : public base_from_cancellation_state<Handler>
+{
+public:
+  template <typename I, typename W, typename H>
+  composed_op(BOOST_ASIO_MOVE_ARG(I) impl,
+      BOOST_ASIO_MOVE_ARG(W) work,
+      BOOST_ASIO_MOVE_ARG(H) handler)
+    : base_from_cancellation_state<Handler>(
+        handler, enable_terminal_cancellation()),
+      impl_(BOOST_ASIO_MOVE_CAST(I)(impl)),
+      work_(BOOST_ASIO_MOVE_CAST(W)(work)),
+      handler_(BOOST_ASIO_MOVE_CAST(H)(handler)),
+      invocations_(0)
+  {
+  }
+
+#if defined(BOOST_ASIO_HAS_MOVE)
+  composed_op(composed_op&& other)
+    : base_from_cancellation_state<Handler>(
+        BOOST_ASIO_MOVE_CAST(base_from_cancellation_state<
+          Handler>)(other)),
+      impl_(BOOST_ASIO_MOVE_CAST(Impl)(other.impl_)),
+      work_(BOOST_ASIO_MOVE_CAST(Work)(other.work_)),
+      handler_(BOOST_ASIO_MOVE_CAST(Handler)(other.handler_)),
+      invocations_(other.invocations_)
+  {
+  }
+#endif // defined(BOOST_ASIO_HAS_MOVE)
+
+  typedef typename composed_work_guard<
+    typename Work::head_type>::executor_type io_executor_type;
+
+  io_executor_type get_io_executor() const BOOST_ASIO_NOEXCEPT
+  {
+    return work_.head_.get_executor();
+  }
+
+  typedef typename associated_executor<Handler, io_executor_type>::type
+    executor_type;
+
+  executor_type get_executor() const BOOST_ASIO_NOEXCEPT
+  {
+    return (get_associated_executor)(handler_, work_.head_.get_executor());
+  }
+
+  typedef typename associated_allocator<Handler,
+    std::allocator<void> >::type allocator_type;
+
+  allocator_type get_allocator() const BOOST_ASIO_NOEXCEPT
+  {
+    return (get_associated_allocator)(handler_, std::allocator<void>());
+  }
+
+#if defined(BOOST_ASIO_HAS_VARIADIC_TEMPLATES)
+
+  template<typename... T>
+  void operator()(BOOST_ASIO_MOVE_ARG(T)... t)
+  {
+    if (invocations_ < ~0u)
+      ++invocations_;
+    this->get_cancellation_state().slot().clear();
+    impl_(*this, BOOST_ASIO_MOVE_CAST(T)(t)...);
+  }
+
+  void complete(Args... args)
+  {
+    this->work_.reset();
+    BOOST_ASIO_MOVE_OR_LVALUE(Handler)(this->handler_)(
+        BOOST_ASIO_MOVE_CAST(Args)(args)...);
+  }
+
+#else // defined(BOOST_ASIO_HAS_VARIADIC_TEMPLATES)
+
+  void operator()()
+  {
+    if (invocations_ < ~0u)
+      ++invocations_;
+    this->get_cancellation_state().slot().clear();
+    impl_(*this);
+  }
+
+  void complete()
+  {
+    this->work_.reset();
+    BOOST_ASIO_MOVE_OR_LVALUE(Handler)(this->handler_)();
+  }
+
+#define BOOST_ASIO_PRIVATE_COMPOSED_OP_DEF(n) \
+  template<BOOST_ASIO_VARIADIC_TPARAMS(n)> \
+  void operator()(BOOST_ASIO_VARIADIC_MOVE_PARAMS(n)) \
+  { \
+    if (invocations_ < ~0u) \
+      ++invocations_; \
+    this->get_cancellation_state().slot().clear(); \
+    impl_(*this, BOOST_ASIO_VARIADIC_MOVE_ARGS(n)); \
+  } \
+  \
+  template<BOOST_ASIO_VARIADIC_TPARAMS(n)> \
+  void complete(BOOST_ASIO_VARIADIC_MOVE_PARAMS(n)) \
+  { \
+    this->work_.reset(); \
+    BOOST_ASIO_MOVE_OR_LVALUE(Handler)(this->handler_)( \
+        BOOST_ASIO_VARIADIC_MOVE_ARGS(n)); \
+  } \
+  /**/
+  BOOST_ASIO_VARIADIC_GENERATE(BOOST_ASIO_PRIVATE_COMPOSED_OP_DEF)
+#undef BOOST_ASIO_PRIVATE_COMPOSED_OP_DEF
+
+#endif // defined(BOOST_ASIO_HAS_VARIADIC_TEMPLATES)
+
+  void reset_cancellation_state()
+  {
+    base_from_cancellation_state<Handler>::reset_cancellation_state(handler_);
+  }
+
+  template <typename Filter>
+  void reset_cancellation_state(BOOST_ASIO_MOVE_ARG(Filter) filter)
+  {
+    base_from_cancellation_state<Handler>::reset_cancellation_state(handler_,
+        BOOST_ASIO_MOVE_CAST(Filter)(filter));
+  }
+
+  template <typename InFilter, typename OutFilter>
+  void reset_cancellation_state(BOOST_ASIO_MOVE_ARG(InFilter) in_filter,
+      BOOST_ASIO_MOVE_ARG(OutFilter) out_filter)
+  {
+    base_from_cancellation_state<Handler>::reset_cancellation_state(handler_,
+        BOOST_ASIO_MOVE_CAST(InFilter)(in_filter),
+        BOOST_ASIO_MOVE_CAST(OutFilter)(out_filter));
+  }
+
+  cancellation_type_t cancelled() const BOOST_ASIO_NOEXCEPT
+  {
+    return base_from_cancellation_state<Handler>::cancelled();
+  }
+
+//private:
+  Impl impl_;
+  Work work_;
+  Handler handler_;
+  unsigned invocations_;
+};
+
+template <typename Impl, typename Work, typename Handler, typename Signature>
+inline asio_handler_allocate_is_deprecated
+asio_handler_allocate(std::size_t size,
+    composed_op<Impl, Work, Handler, Signature>* this_handler)
+{
+#if defined(BOOST_ASIO_NO_DEPRECATED)
+  boost_asio_handler_alloc_helpers::allocate(size, this_handler->handler_);
+  return asio_handler_allocate_is_no_longer_used();
+#else // defined(BOOST_ASIO_NO_DEPRECATED)
+  return boost_asio_handler_alloc_helpers::allocate(
+      size, this_handler->handler_);
+#endif // defined(BOOST_ASIO_NO_DEPRECATED)
+}
+
+template <typename Impl, typename Work, typename Handler, typename Signature>
+inline asio_handler_deallocate_is_deprecated
+asio_handler_deallocate(void* pointer, std::size_t size,
+    composed_op<Impl, Work, Handler, Signature>* this_handler)
+{
+  boost_asio_handler_alloc_helpers::deallocate(
+      pointer, size, this_handler->handler_);
+#if defined(BOOST_ASIO_NO_DEPRECATED)
+  return asio_handler_deallocate_is_no_longer_used();
+#endif // defined(BOOST_ASIO_NO_DEPRECATED)
+}
+
+template <typename Impl, typename Work, typename Handler, typename Signature>
+inline bool asio_handler_is_continuation(
+    composed_op<Impl, Work, Handler, Signature>* this_handler)
+{
+  return this_handler->invocations_ > 1 ? true
+    : boost_asio_handler_cont_helpers::is_continuation(
+        this_handler->handler_);
+}
+
+template <typename Function, typename Impl,
+    typename Work, typename Handler, typename Signature>
+inline asio_handler_invoke_is_deprecated
+asio_handler_invoke(Function& function,
+    composed_op<Impl, Work, Handler, Signature>* this_handler)
+{
+  boost_asio_handler_invoke_helpers::invoke(
+      function, this_handler->handler_);
+#if defined(BOOST_ASIO_NO_DEPRECATED)
+  return asio_handler_invoke_is_no_longer_used();
+#endif // defined(BOOST_ASIO_NO_DEPRECATED)
+}
+
+template <typename Function, typename Impl,
+    typename Work, typename Handler, typename Signature>
+inline asio_handler_invoke_is_deprecated
+asio_handler_invoke(const Function& function,
+    composed_op<Impl, Work, Handler, Signature>* this_handler)
+{
+  boost_asio_handler_invoke_helpers::invoke(
+      function, this_handler->handler_);
+#if defined(BOOST_ASIO_NO_DEPRECATED)
+  return asio_handler_invoke_is_no_longer_used();
+#endif // defined(BOOST_ASIO_NO_DEPRECATED)
+}
+
+template <typename Signature, typename Executors>
+class initiate_composed_op
+{
+public:
+  typedef typename composed_io_executors<Executors>::head_type executor_type;
+
+  template <typename T>
+  explicit initiate_composed_op(int, BOOST_ASIO_MOVE_ARG(T) executors)
+    : executors_(BOOST_ASIO_MOVE_CAST(T)(executors))
+  {
+  }
+
+  executor_type get_executor() const BOOST_ASIO_NOEXCEPT
+  {
+    return executors_.head_;
+  }
+
+  template <typename Handler, typename Impl>
+  void operator()(BOOST_ASIO_MOVE_ARG(Handler) handler,
+      BOOST_ASIO_MOVE_ARG(Impl) impl) const
+  {
+    composed_op<typename decay<Impl>::type, composed_work<Executors>,
+      typename decay<Handler>::type, Signature>(
+        BOOST_ASIO_MOVE_CAST(Impl)(impl),
+        composed_work<Executors>(executors_),
+        BOOST_ASIO_MOVE_CAST(Handler)(handler))();
+  }
+
+private:
+  composed_io_executors<Executors> executors_;
+};
+
+template <typename Signature, typename Executors>
+inline initiate_composed_op<Signature, Executors> make_initiate_composed_op(
+    BOOST_ASIO_MOVE_ARG(composed_io_executors<Executors>) executors)
+{
+  return initiate_composed_op<Signature, Executors>(0,
+      BOOST_ASIO_MOVE_CAST(composed_io_executors<Executors>)(executors));
+}
+
+} // namespace detail
+
+#if !defined(GENERATING_DOCUMENTATION)
+
+template <template <typename, typename> class Associator,
+    typename Impl, typename Work, typename Handler,
+    typename Signature, typename DefaultCandidate>
+struct associator<Associator,
+    detail::composed_op<Impl, Work, Handler, Signature>,
+    DefaultCandidate>
+  : Associator<Handler, DefaultCandidate>
+{
+  static typename Associator<Handler, DefaultCandidate>::type
+  get(const detail::composed_op<Impl, Work, Handler, Signature>& h)
+    BOOST_ASIO_NOEXCEPT
+  {
+    return Associator<Handler, DefaultCandidate>::get(h.handler_);
+  }
+
+  static BOOST_ASIO_AUTO_RETURN_TYPE_PREFIX2(
+      typename Associator<Handler, DefaultCandidate>::type)
+  get(const detail::composed_op<Impl, Work, Handler, Signature>& h,
+      const DefaultCandidate& c) BOOST_ASIO_NOEXCEPT
+    BOOST_ASIO_AUTO_RETURN_TYPE_SUFFIX((
+      Associator<Handler, DefaultCandidate>::get(h.handler_, c)))
+  {
+    return Associator<Handler, DefaultCandidate>::get(h.handler_, c);
+  }
+};
+
+#endif // !defined(GENERATING_DOCUMENTATION)
 
 #if defined(BOOST_ASIO_HAS_VARIADIC_TEMPLATES) \
   || defined(GENERATING_DOCUMENTATION)
@@ -38,12 +334,19 @@ namespace asio {
  * handler. The remaining arguments are any arguments that originate from the
  * completion handlers of any asynchronous operations performed by the
  * implementation.
-
+ *
  * @param token The completion token.
  *
  * @param io_objects_or_executors Zero or more I/O objects or I/O executors for
  * which outstanding work must be maintained.
  *
+ * @par Per-Operation Cancellation
+ * By default, terminal per-operation cancellation is enabled for
+ * composed operations that are implemented using @c async_compose. To
+ * disable cancellation for the composed operation, or to alter its
+ * supported cancellation types, call the @c self object's @c
+ * reset_cancellation_state function.
+ *
  * @par Example:
  *
  * @code struct async_echo_implementation
@@ -88,9 +391,11 @@ namespace asio {
  * auto async_echo(tcp::socket& socket,
  *     boost::asio::mutable_buffer buffer,
  *     CompletionToken&& token) ->
- *   typename boost::asio::async_result<
- *     typename std::decay<CompletionToken>::type,
- *       void(boost::system::error_code, std::size_t)>::return_type
+ *   decltype(
+ *     boost::asio::async_compose<CompletionToken,
+ *       void(boost::system::error_code, std::size_t)>(
+ *         std::declval<async_echo_implementation>(),
+ *         token, socket))
  * {
  *   return boost::asio::async_compose<CompletionToken,
  *     void(boost::system::error_code, std::size_t)>(
@@ -101,30 +406,129 @@ namespace asio {
  */
 template <typename CompletionToken, typename Signature,
     typename Implementation, typename... IoObjectsOrExecutors>
-BOOST_ASIO_INITFN_RESULT_TYPE(CompletionToken, Signature)
+BOOST_ASIO_INITFN_AUTO_RESULT_TYPE_PREFIX(CompletionToken, Signature)
 async_compose(BOOST_ASIO_MOVE_ARG(Implementation) implementation,
     BOOST_ASIO_NONDEDUCED_MOVE_ARG(CompletionToken) token,
-    BOOST_ASIO_MOVE_ARG(IoObjectsOrExecutors)... io_objects_or_executors);
+    BOOST_ASIO_MOVE_ARG(IoObjectsOrExecutors)... io_objects_or_executors)
+  BOOST_ASIO_INITFN_AUTO_RESULT_TYPE_SUFFIX((
+    async_initiate<CompletionToken, Signature>(
+        detail::make_initiate_composed_op<Signature>(
+          detail::make_composed_io_executors(
+            detail::get_composed_io_executor(
+              BOOST_ASIO_MOVE_CAST(IoObjectsOrExecutors)(
+                io_objects_or_executors))...)),
+        token, BOOST_ASIO_MOVE_CAST(Implementation)(implementation))))
+{
+  return async_initiate<CompletionToken, Signature>(
+      detail::make_initiate_composed_op<Signature>(
+        detail::make_composed_io_executors(
+          detail::get_composed_io_executor(
+            BOOST_ASIO_MOVE_CAST(IoObjectsOrExecutors)(
+              io_objects_or_executors))...)),
+      token, BOOST_ASIO_MOVE_CAST(Implementation)(implementation));
+}
 
 #else // defined(BOOST_ASIO_HAS_VARIADIC_TEMPLATES)
       //   || defined(GENERATING_DOCUMENTATION)
 
 template <typename CompletionToken, typename Signature, typename Implementation>
-BOOST_ASIO_INITFN_RESULT_TYPE(CompletionToken, Signature)
+BOOST_ASIO_INITFN_AUTO_RESULT_TYPE_PREFIX(CompletionToken, Signature)
 async_compose(BOOST_ASIO_MOVE_ARG(Implementation) implementation,
-    BOOST_ASIO_NONDEDUCED_MOVE_ARG(CompletionToken) token);
+    BOOST_ASIO_NONDEDUCED_MOVE_ARG(CompletionToken) token)
+  BOOST_ASIO_INITFN_AUTO_RESULT_TYPE_SUFFIX((
+    async_initiate<CompletionToken, Signature>(
+        detail::make_initiate_composed_op<Signature>(
+          detail::make_composed_io_executors()),
+        token, BOOST_ASIO_MOVE_CAST(Implementation)(implementation))))
+{
+  return async_initiate<CompletionToken, Signature>(
+      detail::make_initiate_composed_op<Signature>(
+        detail::make_composed_io_executors()),
+      token, BOOST_ASIO_MOVE_CAST(Implementation)(implementation));
+}
+
+# define BOOST_ASIO_PRIVATE_GET_COMPOSED_IO_EXECUTOR(n) \
+  BOOST_ASIO_PRIVATE_GET_COMPOSED_IO_EXECUTOR_##n
+
+# define BOOST_ASIO_PRIVATE_GET_COMPOSED_IO_EXECUTOR_1 \
+  detail::get_composed_io_executor(BOOST_ASIO_MOVE_CAST(T1)(x1))
+# define BOOST_ASIO_PRIVATE_GET_COMPOSED_IO_EXECUTOR_2 \
+  detail::get_composed_io_executor(BOOST_ASIO_MOVE_CAST(T1)(x1)), \
+  detail::get_composed_io_executor(BOOST_ASIO_MOVE_CAST(T2)(x2))
+# define BOOST_ASIO_PRIVATE_GET_COMPOSED_IO_EXECUTOR_3 \
+  detail::get_composed_io_executor(BOOST_ASIO_MOVE_CAST(T1)(x1)), \
+  detail::get_composed_io_executor(BOOST_ASIO_MOVE_CAST(T2)(x2)), \
+  detail::get_composed_io_executor(BOOST_ASIO_MOVE_CAST(T3)(x3))
+# define BOOST_ASIO_PRIVATE_GET_COMPOSED_IO_EXECUTOR_4 \
+  detail::get_composed_io_executor(BOOST_ASIO_MOVE_CAST(T1)(x1)), \
+  detail::get_composed_io_executor(BOOST_ASIO_MOVE_CAST(T2)(x2)), \
+  detail::get_composed_io_executor(BOOST_ASIO_MOVE_CAST(T3)(x3)), \
+  detail::get_composed_io_executor(BOOST_ASIO_MOVE_CAST(T4)(x4))
+# define BOOST_ASIO_PRIVATE_GET_COMPOSED_IO_EXECUTOR_5 \
+  detail::get_composed_io_executor(BOOST_ASIO_MOVE_CAST(T1)(x1)), \
+  detail::get_composed_io_executor(BOOST_ASIO_MOVE_CAST(T2)(x2)), \
+  detail::get_composed_io_executor(BOOST_ASIO_MOVE_CAST(T3)(x3)), \
+  detail::get_composed_io_executor(BOOST_ASIO_MOVE_CAST(T4)(x4)), \
+  detail::get_composed_io_executor(BOOST_ASIO_MOVE_CAST(T5)(x5))
+# define BOOST_ASIO_PRIVATE_GET_COMPOSED_IO_EXECUTOR_6 \
+  detail::get_composed_io_executor(BOOST_ASIO_MOVE_CAST(T1)(x1)), \
+  detail::get_composed_io_executor(BOOST_ASIO_MOVE_CAST(T2)(x2)), \
+  detail::get_composed_io_executor(BOOST_ASIO_MOVE_CAST(T3)(x3)), \
+  detail::get_composed_io_executor(BOOST_ASIO_MOVE_CAST(T4)(x4)), \
+  detail::get_composed_io_executor(BOOST_ASIO_MOVE_CAST(T5)(x5)), \
+  detail::get_composed_io_executor(BOOST_ASIO_MOVE_CAST(T6)(x6))
+# define BOOST_ASIO_PRIVATE_GET_COMPOSED_IO_EXECUTOR_7 \
+  detail::get_composed_io_executor(BOOST_ASIO_MOVE_CAST(T1)(x1)), \
+  detail::get_composed_io_executor(BOOST_ASIO_MOVE_CAST(T2)(x2)), \
+  detail::get_composed_io_executor(BOOST_ASIO_MOVE_CAST(T3)(x3)), \
+  detail::get_composed_io_executor(BOOST_ASIO_MOVE_CAST(T4)(x4)), \
+  detail::get_composed_io_executor(BOOST_ASIO_MOVE_CAST(T5)(x5)), \
+  detail::get_composed_io_executor(BOOST_ASIO_MOVE_CAST(T6)(x6)), \
+  detail::get_composed_io_executor(BOOST_ASIO_MOVE_CAST(T7)(x7))
+# define BOOST_ASIO_PRIVATE_GET_COMPOSED_IO_EXECUTOR_8 \
+  detail::get_composed_io_executor(BOOST_ASIO_MOVE_CAST(T1)(x1)), \
+  detail::get_composed_io_executor(BOOST_ASIO_MOVE_CAST(T2)(x2)), \
+  detail::get_composed_io_executor(BOOST_ASIO_MOVE_CAST(T3)(x3)), \
+  detail::get_composed_io_executor(BOOST_ASIO_MOVE_CAST(T4)(x4)), \
+  detail::get_composed_io_executor(BOOST_ASIO_MOVE_CAST(T5)(x5)), \
+  detail::get_composed_io_executor(BOOST_ASIO_MOVE_CAST(T6)(x6)), \
+  detail::get_composed_io_executor(BOOST_ASIO_MOVE_CAST(T7)(x7)), \
+  detail::get_composed_io_executor(BOOST_ASIO_MOVE_CAST(T8)(x8))
 
 #define BOOST_ASIO_PRIVATE_ASYNC_COMPOSE_DEF(n) \
   template <typename CompletionToken, typename Signature, \
       typename Implementation, BOOST_ASIO_VARIADIC_TPARAMS(n)> \
-  BOOST_ASIO_INITFN_RESULT_TYPE(CompletionToken, Signature) \
+  BOOST_ASIO_INITFN_AUTO_RESULT_TYPE_PREFIX(CompletionToken, Signature) \
   async_compose(BOOST_ASIO_MOVE_ARG(Implementation) implementation, \
       BOOST_ASIO_NONDEDUCED_MOVE_ARG(CompletionToken) token, \
-      BOOST_ASIO_VARIADIC_MOVE_PARAMS(n));
+      BOOST_ASIO_VARIADIC_MOVE_PARAMS(n)) \
+    BOOST_ASIO_INITFN_AUTO_RESULT_TYPE_SUFFIX(( \
+      async_initiate<CompletionToken, Signature>( \
+          detail::make_initiate_composed_op<Signature>( \
+            detail::make_composed_io_executors( \
+              BOOST_ASIO_PRIVATE_GET_COMPOSED_IO_EXECUTOR(n))), \
+          token, BOOST_ASIO_MOVE_CAST(Implementation)(implementation)))) \
+  { \
+    return async_initiate<CompletionToken, Signature>( \
+        detail::make_initiate_composed_op<Signature>( \
+          detail::make_composed_io_executors( \
+            BOOST_ASIO_PRIVATE_GET_COMPOSED_IO_EXECUTOR(n))), \
+        token, BOOST_ASIO_MOVE_CAST(Implementation)(implementation)); \
+  } \
   /**/
   BOOST_ASIO_VARIADIC_GENERATE(BOOST_ASIO_PRIVATE_ASYNC_COMPOSE_DEF)
 #undef BOOST_ASIO_PRIVATE_ASYNC_COMPOSE_DEF
 
+#undef BOOST_ASIO_PRIVATE_GET_COMPOSED_IO_EXECUTOR
+#undef BOOST_ASIO_PRIVATE_GET_COMPOSED_IO_EXECUTOR_1
+#undef BOOST_ASIO_PRIVATE_GET_COMPOSED_IO_EXECUTOR_2
+#undef BOOST_ASIO_PRIVATE_GET_COMPOSED_IO_EXECUTOR_3
+#undef BOOST_ASIO_PRIVATE_GET_COMPOSED_IO_EXECUTOR_4
+#undef BOOST_ASIO_PRIVATE_GET_COMPOSED_IO_EXECUTOR_5
+#undef BOOST_ASIO_PRIVATE_GET_COMPOSED_IO_EXECUTOR_6
+#undef BOOST_ASIO_PRIVATE_GET_COMPOSED_IO_EXECUTOR_7
+#undef BOOST_ASIO_PRIVATE_GET_COMPOSED_IO_EXECUTOR_8
+
 #endif // defined(BOOST_ASIO_HAS_VARIADIC_TEMPLATES)
        //   || defined(GENERATING_DOCUMENTATION)
 
@@ -133,6 +537,4 @@ async_compose(BOOST_ASIO_MOVE_ARG(Implementation) implementation,
 
 #include <boost/asio/detail/pop_options.hpp>
 
-#include <boost/asio/impl/compose.hpp>
-
 #endif // BOOST_ASIO_COMPOSE_HPP

linx64/include/boost/asio/connect.hpp

@@ -2,7 +2,7 @@
 // connect.hpp
 // ~~~~~~~~~~~
 //
-// Copyright (c) 2003-2019 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2023 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -28,6 +28,10 @@ namespace asio {
 
 namespace detail
 {
+  struct default_connect_condition;
+  template <typename, typename> class initiate_async_range_connect;
+  template <typename, typename> class initiate_async_iterator_connect;
+
   char (&has_iterator_helper(...))[2];
 
   template <typename T>
@@ -91,8 +95,8 @@ struct is_endpoint_sequence
 template <typename Protocol, typename Executor, typename EndpointSequence>
 typename Protocol::endpoint connect(basic_socket<Protocol, Executor>& s,
     const EndpointSequence& endpoints,
-    typename enable_if<is_endpoint_sequence<
-        EndpointSequence>::value>::type* = 0);
+    typename constraint<is_endpoint_sequence<
+        EndpointSequence>::value>::type = 0);
 
 /// Establishes a socket connection by trying each endpoint in a sequence.
 /**
@@ -127,8 +131,8 @@ typename Protocol::endpoint connect(basic_socket<Protocol, Executor>& s,
 template <typename Protocol, typename Executor, typename EndpointSequence>
 typename Protocol::endpoint connect(basic_socket<Protocol, Executor>& s,
     const EndpointSequence& endpoints, boost::system::error_code& ec,
-    typename enable_if<is_endpoint_sequence<
-        EndpointSequence>::value>::type* = 0);
+    typename constraint<is_endpoint_sequence<
+        EndpointSequence>::value>::type = 0);
 
 #if !defined(BOOST_ASIO_NO_DEPRECATED)
 /// (Deprecated: Use range overload.) Establishes a socket connection by trying
@@ -157,7 +161,7 @@ typename Protocol::endpoint connect(basic_socket<Protocol, Executor>& s,
  */
 template <typename Protocol, typename Executor, typename Iterator>
 Iterator connect(basic_socket<Protocol, Executor>& s, Iterator begin,
-    typename enable_if<!is_endpoint_sequence<Iterator>::value>::type* = 0);
+    typename constraint<!is_endpoint_sequence<Iterator>::value>::type = 0);
 
 /// (Deprecated: Use range overload.) Establishes a socket connection by trying
 /// each endpoint in a sequence.
@@ -186,7 +190,7 @@ Iterator connect(basic_socket<Protocol, Executor>& s, Iterator begin,
 template <typename Protocol, typename Executor, typename Iterator>
 Iterator connect(basic_socket<Protocol, Executor>& s,
     Iterator begin, boost::system::error_code& ec,
-    typename enable_if<!is_endpoint_sequence<Iterator>::value>::type* = 0);
+    typename constraint<!is_endpoint_sequence<Iterator>::value>::type = 0);
 #endif // !defined(BOOST_ASIO_NO_DEPRECATED)
 
 /// Establishes a socket connection by trying each endpoint in a sequence.
@@ -312,8 +316,8 @@ template <typename Protocol, typename Executor,
     typename EndpointSequence, typename ConnectCondition>
 typename Protocol::endpoint connect(basic_socket<Protocol, Executor>& s,
     const EndpointSequence& endpoints, ConnectCondition connect_condition,
-    typename enable_if<is_endpoint_sequence<
-        EndpointSequence>::value>::type* = 0);
+    typename constraint<is_endpoint_sequence<
+        EndpointSequence>::value>::type = 0);
 
 /// Establishes a socket connection by trying each endpoint in a sequence.
 /**
@@ -380,8 +384,8 @@ template <typename Protocol, typename Executor,
 typename Protocol::endpoint connect(basic_socket<Protocol, Executor>& s,
     const EndpointSequence& endpoints, ConnectCondition connect_condition,
     boost::system::error_code& ec,
-    typename enable_if<is_endpoint_sequence<
-        EndpointSequence>::value>::type* = 0);
+    typename constraint<is_endpoint_sequence<
+        EndpointSequence>::value>::type = 0);
 
 #if !defined(BOOST_ASIO_NO_DEPRECATED)
 /// (Deprecated: Use range overload.) Establishes a socket connection by trying
@@ -423,7 +427,7 @@ template <typename Protocol, typename Executor,
     typename Iterator, typename ConnectCondition>
 Iterator connect(basic_socket<Protocol, Executor>& s,
     Iterator begin, ConnectCondition connect_condition,
-    typename enable_if<!is_endpoint_sequence<Iterator>::value>::type* = 0);
+    typename constraint<!is_endpoint_sequence<Iterator>::value>::type = 0);
 
 /// (Deprecated: Use range overload.) Establishes a socket connection by trying
 /// each endpoint in a sequence.
@@ -464,7 +468,7 @@ template <typename Protocol, typename Executor,
     typename Iterator, typename ConnectCondition>
 Iterator connect(basic_socket<Protocol, Executor>& s, Iterator begin,
     ConnectCondition connect_condition, boost::system::error_code& ec,
-    typename enable_if<!is_endpoint_sequence<Iterator>::value>::type* = 0);
+    typename constraint<!is_endpoint_sequence<Iterator>::value>::type = 0);
 #endif // !defined(BOOST_ASIO_NO_DEPRECATED)
 
 /// Establishes a socket connection by trying each endpoint in a sequence.
@@ -611,16 +615,19 @@ Iterator connect(basic_socket<Protocol, Executor>& s,
  * This function attempts to connect a socket to one of a sequence of
  * endpoints. It does this by repeated calls to the socket's @c async_connect
  * member function, once for each endpoint in the sequence, until a connection
- * is successfully established.
+ * is successfully established. It is an initiating function for an @ref
+ * asynchronous_operation, and always returns immediately.
  *
  * @param s The socket to be connected. If the socket is already open, it will
  * be closed.
  *
  * @param endpoints A sequence of endpoints.
  *
- * @param handler The handler to be called when the connect operation
- * completes. Copies will be made of the handler as required. The function
- * signature of the handler must be:
+ * @param token The @ref completion_token that will be used to produce a
+ * completion handler, which will be called when the connect completes.
+ * Potential completion tokens include @ref use_future, @ref use_awaitable,
+ * @ref yield_context, or a function object with the correct completion
+ * signature. The function signature of the completion handler must be:
  * @code void handler(
  *   // Result of operation. if the sequence is empty, set to
  *   // boost::asio::error::not_found. Otherwise, contains the
@@ -632,10 +639,13 @@ Iterator connect(basic_socket<Protocol, Executor>& s,
  *   const typename Protocol::endpoint& endpoint
  * ); @endcode
  * Regardless of whether the asynchronous operation completes immediately or
- * not, the handler will not be invoked from within this function. On
- * immediate completion, invocation of the handler will be performed in a
+ * not, the completion handler will not be invoked from within this function.
+ * On immediate completion, invocation of the handler will be performed in a
  * manner equivalent to using boost::asio::post().
  *
+ * @par Completion Signature
+ * @code void(boost::system::error_code, typename Protocol::endpoint) @endcode
+ *
  * @par Example
  * @code tcp::resolver r(my_context);
  * tcp::resolver::query q("host", "service");
@@ -665,16 +675,34 @@ Iterator connect(basic_socket<Protocol, Executor>& s,
  * {
  *   // ...
  * } @endcode
+ *
+ * @par Per-Operation Cancellation
+ * This asynchronous operation supports cancellation for the following
+ * boost::asio::cancellation_type values:
+ *
+ * @li @c cancellation_type::terminal
+ *
+ * @li @c cancellation_type::partial
+ *
+ * if they are also supported by the socket's @c async_connect operation.
  */
-template <typename Protocol, typename Executor,
-    typename EndpointSequence, typename RangeConnectHandler>
-BOOST_ASIO_INITFN_RESULT_TYPE(RangeConnectHandler,
+template <typename Protocol, typename Executor, typename EndpointSequence,
+    BOOST_ASIO_COMPLETION_TOKEN_FOR(void (boost::system::error_code,
+      typename Protocol::endpoint)) RangeConnectToken
+        BOOST_ASIO_DEFAULT_COMPLETION_TOKEN_TYPE(Executor)>
+BOOST_ASIO_INITFN_AUTO_RESULT_TYPE_PREFIX(RangeConnectToken,
     void (boost::system::error_code, typename Protocol::endpoint))
 async_connect(basic_socket<Protocol, Executor>& s,
     const EndpointSequence& endpoints,
-    BOOST_ASIO_MOVE_ARG(RangeConnectHandler) handler,
-    typename enable_if<is_endpoint_sequence<
-        EndpointSequence>::value>::type* = 0);
+    BOOST_ASIO_MOVE_ARG(RangeConnectToken) token
+      BOOST_ASIO_DEFAULT_COMPLETION_TOKEN(Executor),
+    typename constraint<is_endpoint_sequence<
+        EndpointSequence>::value>::type = 0)
+  BOOST_ASIO_INITFN_AUTO_RESULT_TYPE_SUFFIX((
+    async_initiate<RangeConnectToken,
+      void (boost::system::error_code, typename Protocol::endpoint)>(
+        declval<detail::initiate_async_range_connect<Protocol, Executor> >(),
+        token, endpoints, declval<detail::default_connect_condition>())));
 
 #if !defined(BOOST_ASIO_NO_DEPRECATED)
 /// (Deprecated: Use range overload.) Asynchronously establishes a socket
@@ -683,16 +711,19 @@ async_connect(basic_socket<Protocol, Executor>& s,
  * This function attempts to connect a socket to one of a sequence of
  * endpoints. It does this by repeated calls to the socket's @c async_connect
  * member function, once for each endpoint in the sequence, until a connection
- * is successfully established.
+ * is successfully established. It is an initiating function for an @ref
+ * asynchronous_operation, and always returns immediately.
  *
  * @param s The socket to be connected. If the socket is already open, it will
  * be closed.
  *
  * @param begin An iterator pointing to the start of a sequence of endpoints.
  *
- * @param handler The handler to be called when the connect operation
- * completes. Copies will be made of the handler as required. The function
- * signature of the handler must be:
+ * @param token The @ref completion_token that will be used to produce a
+ * completion handler, which will be called when the connect completes.
+ * Potential completion tokens include @ref use_future, @ref use_awaitable,
+ * @ref yield_context, or a function object with the correct completion
+ * signature. The function signature of the completion handler must be:
  * @code void handler(
  *   // Result of operation. if the sequence is empty, set to
  *   // boost::asio::error::not_found. Otherwise, contains the
@@ -704,21 +735,43 @@ async_connect(basic_socket<Protocol, Executor>& s,
  *   Iterator iterator
  * ); @endcode
  * Regardless of whether the asynchronous operation completes immediately or
- * not, the handler will not be invoked from within this function. On
- * immediate completion, invocation of the handler will be performed in a
+ * not, the completion handler will not be invoked from within this function.
+ * On immediate completion, invocation of the handler will be performed in a
  * manner equivalent to using boost::asio::post().
  *
+ * @par Completion Signature
+ * @code void(boost::system::error_code, Iterator) @endcode
+ *
  * @note This overload assumes that a default constructed object of type @c
  * Iterator represents the end of the sequence. This is a valid assumption for
  * iterator types such as @c boost::asio::ip::tcp::resolver::iterator.
+ *
+ * @par Per-Operation Cancellation
+ * This asynchronous operation supports cancellation for the following
+ * boost::asio::cancellation_type values:
+ *
+ * @li @c cancellation_type::terminal
+ *
+ * @li @c cancellation_type::partial
+ *
+ * if they are also supported by the socket's @c async_connect operation.
  */
-template <typename Protocol, typename Executor,
-    typename Iterator, typename IteratorConnectHandler>
-BOOST_ASIO_INITFN_RESULT_TYPE(IteratorConnectHandler,
+template <typename Protocol, typename Executor, typename Iterator,
+    BOOST_ASIO_COMPLETION_TOKEN_FOR(void (boost::system::error_code,
+      Iterator)) IteratorConnectToken
+        BOOST_ASIO_DEFAULT_COMPLETION_TOKEN_TYPE(Executor)>
+BOOST_ASIO_INITFN_AUTO_RESULT_TYPE_PREFIX(IteratorConnectToken,
     void (boost::system::error_code, Iterator))
 async_connect(basic_socket<Protocol, Executor>& s, Iterator begin,
-    BOOST_ASIO_MOVE_ARG(IteratorConnectHandler) handler,
-    typename enable_if<!is_endpoint_sequence<Iterator>::value>::type* = 0);
+    BOOST_ASIO_MOVE_ARG(IteratorConnectToken) token
+      BOOST_ASIO_DEFAULT_COMPLETION_TOKEN(Executor),
+    typename constraint<!is_endpoint_sequence<Iterator>::value>::type = 0)
+  BOOST_ASIO_INITFN_AUTO_RESULT_TYPE_SUFFIX((
+    async_initiate<IteratorConnectToken,
+      void (boost::system::error_code, Iterator)>(
+        declval<detail::initiate_async_iterator_connect<Protocol, Executor> >(),
+        token, begin, Iterator(),
+        declval<detail::default_connect_condition>())));
 #endif // !defined(BOOST_ASIO_NO_DEPRECATED)
 
 /// Asynchronously establishes a socket connection by trying each endpoint in a
@@ -727,7 +780,8 @@ async_connect(basic_socket<Protocol, Executor>& s, Iterator begin,
  * This function attempts to connect a socket to one of a sequence of
  * endpoints. It does this by repeated calls to the socket's @c async_connect
  * member function, once for each endpoint in the sequence, until a connection
- * is successfully established.
+ * is successfully established. It is an initiating function for an @ref
+ * asynchronous_operation, and always returns immediately.
  *
  * @param s The socket to be connected. If the socket is already open, it will
  * be closed.
@@ -736,9 +790,11 @@ async_connect(basic_socket<Protocol, Executor>& s, Iterator begin,
  *
  * @param end An iterator pointing to the end of a sequence of endpoints.
  *
- * @param handler The handler to be called when the connect operation
- * completes. Copies will be made of the handler as required. The function
- * signature of the handler must be:
+ * @param token The @ref completion_token that will be used to produce a
+ * completion handler, which will be called when the connect completes.
+ * Potential completion tokens include @ref use_future, @ref use_awaitable,
+ * @ref yield_context, or a function object with the correct completion
+ * signature. The function signature of the completion handler must be:
  * @code void handler(
  *   // Result of operation. if the sequence is empty, set to
  *   // boost::asio::error::not_found. Otherwise, contains the
@@ -750,10 +806,13 @@ async_connect(basic_socket<Protocol, Executor>& s, Iterator begin,
  *   Iterator iterator
  * ); @endcode
  * Regardless of whether the asynchronous operation completes immediately or
- * not, the handler will not be invoked from within this function. On
- * immediate completion, invocation of the handler will be performed in a
+ * not, the completion handler will not be invoked from within this function.
+ * On immediate completion, invocation of the handler will be performed in a
  * manner equivalent to using boost::asio::post().
  *
+ * @par Completion Signature
+ * @code void(boost::system::error_code, Iterator) @endcode
+ *
  * @par Example
  * @code std::vector<tcp::endpoint> endpoints = ...;
  * tcp::socket s(my_context);
@@ -769,13 +828,31 @@ async_connect(basic_socket<Protocol, Executor>& s, Iterator begin,
  * {
  *   // ...
  * } @endcode
+ *
+ * @par Per-Operation Cancellation
+ * This asynchronous operation supports cancellation for the following
+ * boost::asio::cancellation_type values:
+ *
+ * @li @c cancellation_type::terminal
+ *
+ * @li @c cancellation_type::partial
+ *
+ * if they are also supported by the socket's @c async_connect operation.
  */
-template <typename Protocol, typename Executor,
-    typename Iterator, typename IteratorConnectHandler>
-BOOST_ASIO_INITFN_RESULT_TYPE(IteratorConnectHandler,
+template <typename Protocol, typename Executor, typename Iterator,
+    BOOST_ASIO_COMPLETION_TOKEN_FOR(void (boost::system::error_code,
+      Iterator)) IteratorConnectToken
+        BOOST_ASIO_DEFAULT_COMPLETION_TOKEN_TYPE(Executor)>
+BOOST_ASIO_INITFN_AUTO_RESULT_TYPE_PREFIX(IteratorConnectToken,
     void (boost::system::error_code, Iterator))
 async_connect(basic_socket<Protocol, Executor>& s, Iterator begin, Iterator end,
-    BOOST_ASIO_MOVE_ARG(IteratorConnectHandler) handler);
+    BOOST_ASIO_MOVE_ARG(IteratorConnectToken) token
+      BOOST_ASIO_DEFAULT_COMPLETION_TOKEN(Executor))
+  BOOST_ASIO_INITFN_AUTO_RESULT_TYPE_SUFFIX((
+    async_initiate<IteratorConnectToken,
+      void (boost::system::error_code, Iterator)>(
+        declval<detail::initiate_async_iterator_connect<Protocol, Executor> >(),
+        token, begin, end, declval<detail::default_connect_condition>())));
 
 /// Asynchronously establishes a socket connection by trying each endpoint in a
 /// sequence.
@@ -783,7 +860,8 @@ async_connect(basic_socket<Protocol, Executor>& s, Iterator begin, Iterator end,
  * This function attempts to connect a socket to one of a sequence of
  * endpoints. It does this by repeated calls to the socket's @c async_connect
  * member function, once for each endpoint in the sequence, until a connection
- * is successfully established.
+ * is successfully established. It is an initiating function for an @ref
+ * asynchronous_operation, and always returns immediately.
  *
  * @param s The socket to be connected. If the socket is already open, it will
  * be closed.
@@ -801,9 +879,11 @@ async_connect(basic_socket<Protocol, Executor>& s, Iterator begin, Iterator end,
  * The function object should return true if the next endpoint should be tried,
  * and false if it should be skipped.
  *
- * @param handler The handler to be called when the connect operation
- * completes. Copies will be made of the handler as required. The function
- * signature of the handler must be:
+ * @param token The @ref completion_token that will be used to produce a
+ * completion handler, which will be called when the connect completes.
+ * Potential completion tokens include @ref use_future, @ref use_awaitable,
+ * @ref yield_context, or a function object with the correct completion
+ * signature. The function signature of the completion handler must be:
  * @code void handler(
  *   // Result of operation. if the sequence is empty, set to
  *   // boost::asio::error::not_found. Otherwise, contains the
@@ -815,10 +895,13 @@ async_connect(basic_socket<Protocol, Executor>& s, Iterator begin, Iterator end,
  *   Iterator iterator
  * ); @endcode
  * Regardless of whether the asynchronous operation completes immediately or
- * not, the handler will not be invoked from within this function. On
- * immediate completion, invocation of the handler will be performed in a
+ * not, the completion handler will not be invoked from within this function.
+ * On immediate completion, invocation of the handler will be performed in a
  * manner equivalent to using boost::asio::post().
  *
+ * @par Completion Signature
+ * @code void(boost::system::error_code, typename Protocol::endpoint) @endcode
+ *
  * @par Example
  * The following connect condition function object can be used to output
  * information about the individual connection attempts:
@@ -871,16 +954,35 @@ async_connect(basic_socket<Protocol, Executor>& s, Iterator begin, Iterator end,
  *     std::cout << "Connected to: " << endpoint << std::endl;
  *   }
  * } @endcode
+ *
+ * @par Per-Operation Cancellation
+ * This asynchronous operation supports cancellation for the following
+ * boost::asio::cancellation_type values:
+ *
+ * @li @c cancellation_type::terminal
+ *
+ * @li @c cancellation_type::partial
+ *
+ * if they are also supported by the socket's @c async_connect operation.
  */
-template <typename Protocol, typename Executor, typename EndpointSequence,
-    typename ConnectCondition, typename RangeConnectHandler>
-BOOST_ASIO_INITFN_RESULT_TYPE(RangeConnectHandler,
+template <typename Protocol, typename Executor,
+    typename EndpointSequence, typename ConnectCondition,
+    BOOST_ASIO_COMPLETION_TOKEN_FOR(void (boost::system::error_code,
+      typename Protocol::endpoint)) RangeConnectToken
+        BOOST_ASIO_DEFAULT_COMPLETION_TOKEN_TYPE(Executor)>
+BOOST_ASIO_INITFN_AUTO_RESULT_TYPE_PREFIX(RangeConnectToken,
     void (boost::system::error_code, typename Protocol::endpoint))
 async_connect(basic_socket<Protocol, Executor>& s,
     const EndpointSequence& endpoints, ConnectCondition connect_condition,
-    BOOST_ASIO_MOVE_ARG(RangeConnectHandler) handler,
-    typename enable_if<is_endpoint_sequence<
-        EndpointSequence>::value>::type* = 0);
+    BOOST_ASIO_MOVE_ARG(RangeConnectToken) token
+      BOOST_ASIO_DEFAULT_COMPLETION_TOKEN(Executor),
+    typename constraint<is_endpoint_sequence<
+        EndpointSequence>::value>::type = 0)
+  BOOST_ASIO_INITFN_AUTO_RESULT_TYPE_SUFFIX((
+    async_initiate<RangeConnectToken,
+      void (boost::system::error_code, typename Protocol::endpoint)>(
+        declval<detail::initiate_async_range_connect<Protocol, Executor> >(),
+        token, endpoints, connect_condition)));
 
 #if !defined(BOOST_ASIO_NO_DEPRECATED)
 /// (Deprecated: Use range overload.) Asynchronously establishes a socket
@@ -889,7 +991,8 @@ async_connect(basic_socket<Protocol, Executor>& s,
  * This function attempts to connect a socket to one of a sequence of
  * endpoints. It does this by repeated calls to the socket's @c async_connect
  * member function, once for each endpoint in the sequence, until a connection
- * is successfully established.
+ * is successfully established. It is an initiating function for an @ref
+ * asynchronous_operation, and always returns immediately.
  *
  * @param s The socket to be connected. If the socket is already open, it will
  * be closed.
@@ -907,9 +1010,11 @@ async_connect(basic_socket<Protocol, Executor>& s,
  * The function object should return true if the next endpoint should be tried,
  * and false if it should be skipped.
  *
- * @param handler The handler to be called when the connect operation
- * completes. Copies will be made of the handler as required. The function
- * signature of the handler must be:
+ * @param token The @ref completion_token that will be used to produce a
+ * completion handler, which will be called when the connect completes.
+ * Potential completion tokens include @ref use_future, @ref use_awaitable,
+ * @ref yield_context, or a function object with the correct completion
+ * signature. The function signature of the completion handler must be:
  * @code void handler(
  *   // Result of operation. if the sequence is empty, set to
  *   // boost::asio::error::not_found. Otherwise, contains the
@@ -921,22 +1026,44 @@ async_connect(basic_socket<Protocol, Executor>& s,
  *   Iterator iterator
  * ); @endcode
  * Regardless of whether the asynchronous operation completes immediately or
- * not, the handler will not be invoked from within this function. On
- * immediate completion, invocation of the handler will be performed in a
+ * not, the completion handler will not be invoked from within this function.
+ * On immediate completion, invocation of the handler will be performed in a
  * manner equivalent to using boost::asio::post().
  *
+ * @par Completion Signature
+ * @code void(boost::system::error_code, Iterator) @endcode
+ *
  * @note This overload assumes that a default constructed object of type @c
  * Iterator represents the end of the sequence. This is a valid assumption for
  * iterator types such as @c boost::asio::ip::tcp::resolver::iterator.
+ *
+ * @par Per-Operation Cancellation
+ * This asynchronous operation supports cancellation for the following
+ * boost::asio::cancellation_type values:
+ *
+ * @li @c cancellation_type::terminal
+ *
+ * @li @c cancellation_type::partial
+ *
+ * if they are also supported by the socket's @c async_connect operation.
  */
-template <typename Protocol, typename Executor, typename Iterator,
-    typename ConnectCondition, typename IteratorConnectHandler>
-BOOST_ASIO_INITFN_RESULT_TYPE(IteratorConnectHandler,
+template <typename Protocol, typename Executor,
+    typename Iterator, typename ConnectCondition,
+    BOOST_ASIO_COMPLETION_TOKEN_FOR(void (boost::system::error_code,
+      Iterator)) IteratorConnectToken
+        BOOST_ASIO_DEFAULT_COMPLETION_TOKEN_TYPE(Executor)>
+BOOST_ASIO_INITFN_AUTO_RESULT_TYPE_PREFIX(IteratorConnectToken,
     void (boost::system::error_code, Iterator))
 async_connect(basic_socket<Protocol, Executor>& s, Iterator begin,
     ConnectCondition connect_condition,
-    BOOST_ASIO_MOVE_ARG(IteratorConnectHandler) handler,
-    typename enable_if<!is_endpoint_sequence<Iterator>::value>::type* = 0);
+    BOOST_ASIO_MOVE_ARG(IteratorConnectToken) token
+      BOOST_ASIO_DEFAULT_COMPLETION_TOKEN(Executor),
+    typename constraint<!is_endpoint_sequence<Iterator>::value>::type = 0)
+  BOOST_ASIO_INITFN_AUTO_RESULT_TYPE_SUFFIX((
+    async_initiate<IteratorConnectToken,
+      void (boost::system::error_code, Iterator)>(
+        declval<detail::initiate_async_iterator_connect<Protocol, Executor> >(),
+        token, begin, Iterator(), connect_condition)));
 #endif // !defined(BOOST_ASIO_NO_DEPRECATED)
 
 /// Asynchronously establishes a socket connection by trying each endpoint in a
@@ -945,7 +1072,8 @@ async_connect(basic_socket<Protocol, Executor>& s, Iterator begin,
  * This function attempts to connect a socket to one of a sequence of
  * endpoints. It does this by repeated calls to the socket's @c async_connect
  * member function, once for each endpoint in the sequence, until a connection
- * is successfully established.
+ * is successfully established. It is an initiating function for an @ref
+ * asynchronous_operation, and always returns immediately.
  *
  * @param s The socket to be connected. If the socket is already open, it will
  * be closed.
@@ -965,9 +1093,11 @@ async_connect(basic_socket<Protocol, Executor>& s, Iterator begin,
  * The function object should return true if the next endpoint should be tried,
  * and false if it should be skipped.
  *
- * @param handler The handler to be called when the connect operation
- * completes. Copies will be made of the handler as required. The function
- * signature of the handler must be:
+ * @param token The @ref completion_token that will be used to produce a
+ * completion handler, which will be called when the connect completes.
+ * Potential completion tokens include @ref use_future, @ref use_awaitable,
+ * @ref yield_context, or a function object with the correct completion
+ * signature. The function signature of the completion handler must be:
  * @code void handler(
  *   // Result of operation. if the sequence is empty, set to
  *   // boost::asio::error::not_found. Otherwise, contains the
@@ -979,10 +1109,13 @@ async_connect(basic_socket<Protocol, Executor>& s, Iterator begin,
  *   Iterator iterator
  * ); @endcode
  * Regardless of whether the asynchronous operation completes immediately or
- * not, the handler will not be invoked from within this function. On
- * immediate completion, invocation of the handler will be performed in a
+ * not, the completion handler will not be invoked from within this function.
+ * On immediate completion, invocation of the handler will be performed in a
  * manner equivalent to using boost::asio::post().
  *
+ * @par Completion Signature
+ * @code void(boost::system::error_code, Iterator) @endcode
+ *
  * @par Example
  * The following connect condition function object can be used to output
  * information about the individual connection attempts:
@@ -1036,14 +1169,33 @@ async_connect(basic_socket<Protocol, Executor>& s, Iterator begin,
  *     std::cout << "Connected to: " << i->endpoint() << std::endl;
  *   }
  * } @endcode
+ *
+ * @par Per-Operation Cancellation
+ * This asynchronous operation supports cancellation for the following
+ * boost::asio::cancellation_type values:
+ *
+ * @li @c cancellation_type::terminal
+ *
+ * @li @c cancellation_type::partial
+ *
+ * if they are also supported by the socket's @c async_connect operation.
  */
-template <typename Protocol, typename Executor, typename Iterator,
-    typename ConnectCondition, typename IteratorConnectHandler>
-BOOST_ASIO_INITFN_RESULT_TYPE(IteratorConnectHandler,
+template <typename Protocol, typename Executor,
+    typename Iterator, typename ConnectCondition,
+    BOOST_ASIO_COMPLETION_TOKEN_FOR(void (boost::system::error_code,
+      Iterator)) IteratorConnectToken
+        BOOST_ASIO_DEFAULT_COMPLETION_TOKEN_TYPE(Executor)>
+BOOST_ASIO_INITFN_AUTO_RESULT_TYPE_PREFIX(IteratorConnectToken,
     void (boost::system::error_code, Iterator))
 async_connect(basic_socket<Protocol, Executor>& s, Iterator begin,
     Iterator end, ConnectCondition connect_condition,
-    BOOST_ASIO_MOVE_ARG(IteratorConnectHandler) handler);
+    BOOST_ASIO_MOVE_ARG(IteratorConnectToken) token
+      BOOST_ASIO_DEFAULT_COMPLETION_TOKEN(Executor))
+  BOOST_ASIO_INITFN_AUTO_RESULT_TYPE_SUFFIX((
+    async_initiate<IteratorConnectToken,
+      void (boost::system::error_code, Iterator)>(
+        declval<detail::initiate_async_iterator_connect<Protocol, Executor> >(),
+        token, begin, end, connect_condition)));
 
 /*@}*/
 

linx64/include/boost/asio/connect_pipe.hpp

@@ -0,0 +1,85 @@
+//
+// connect_pipe.hpp
+// ~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2023 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef BOOST_ASIO_CONNECT_PIPE_HPP
+#define BOOST_ASIO_CONNECT_PIPE_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include <boost/asio/detail/config.hpp>
+
+#if defined(BOOST_ASIO_HAS_PIPE) \
+  || defined(GENERATING_DOCUMENTATION)
+
+#include <boost/asio/basic_readable_pipe.hpp>
+#include <boost/asio/basic_writable_pipe.hpp>
+#include <boost/asio/error.hpp>
+
+#include <boost/asio/detail/push_options.hpp>
+
+namespace boost {
+namespace asio {
+namespace detail {
+
+#if defined(BOOST_ASIO_HAS_IOCP)
+typedef HANDLE native_pipe_handle;
+#else // defined(BOOST_ASIO_HAS_IOCP)
+typedef int native_pipe_handle;
+#endif // defined(BOOST_ASIO_HAS_IOCP)
+
+BOOST_ASIO_DECL void create_pipe(native_pipe_handle p[2],
+    boost::system::error_code& ec);
+
+BOOST_ASIO_DECL void close_pipe(native_pipe_handle p);
+
+} // namespace detail
+
+/// Connect two pipe ends using an anonymous pipe.
+/**
+ * @param read_end The read end of the pipe.
+ *
+ * @param write_end The write end of the pipe.
+ *
+ * @throws boost::system::system_error Thrown on failure.
+ */
+template <typename Executor1, typename Executor2>
+void connect_pipe(basic_readable_pipe<Executor1>& read_end,
+    basic_writable_pipe<Executor2>& write_end);
+
+/// Connect two pipe ends using an anonymous pipe.
+/**
+ * @param read_end The read end of the pipe.
+ *
+ * @param write_end The write end of the pipe.
+ *
+ * @throws boost::system::system_error Thrown on failure.
+ *
+ * @param ec Set to indicate what error occurred, if any.
+ */
+template <typename Executor1, typename Executor2>
+BOOST_ASIO_SYNC_OP_VOID connect_pipe(basic_readable_pipe<Executor1>& read_end,
+    basic_writable_pipe<Executor2>& write_end, boost::system::error_code& ec);
+
+} // namespace asio
+} // namespace boost
+
+#include <boost/asio/detail/pop_options.hpp>
+
+#include <boost/asio/impl/connect_pipe.hpp>
+#if defined(BOOST_ASIO_HEADER_ONLY)
+# include <boost/asio/impl/connect_pipe.ipp>
+#endif // defined(BOOST_ASIO_HEADER_ONLY)
+
+#endif // defined(BOOST_ASIO_HAS_PIPE)
+       //   || defined(GENERATING_DOCUMENTATION)
+
+#endif // BOOST_ASIO_CONNECT_PIPE_HPP

linx64/include/boost/asio/consign.hpp

@@ -0,0 +1,90 @@
+//
+// consign.hpp
+// ~~~~~~~~~~
+//
+// Copyright (c) 2003-2023 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef BOOST_ASIO_CONSIGN_HPP
+#define BOOST_ASIO_CONSIGN_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include <boost/asio/detail/config.hpp>
+
+#if (defined(BOOST_ASIO_HAS_STD_TUPLE) \
+    && defined(BOOST_ASIO_HAS_VARIADIC_TEMPLATES)) \
+  || defined(GENERATING_DOCUMENTATION)
+
+#include <tuple>
+#include <boost/asio/detail/type_traits.hpp>
+
+#include <boost/asio/detail/push_options.hpp>
+
+namespace boost {
+namespace asio {
+
+/// Completion token type used to specify that the completion handler should
+/// carry additional values along with it.
+/**
+ * This completion token adapter is typically used to keep at least one copy of
+ * an object, such as a smart pointer, alive until the completion handler is
+ * called.
+ */
+template <typename CompletionToken, typename... Values>
+class consign_t
+{
+public:
+  /// Constructor.
+  template <typename T, typename... V>
+  BOOST_ASIO_CONSTEXPR explicit consign_t(
+      BOOST_ASIO_MOVE_ARG(T) completion_token,
+      BOOST_ASIO_MOVE_ARG(V)... values)
+    : token_(BOOST_ASIO_MOVE_CAST(T)(completion_token)),
+      values_(BOOST_ASIO_MOVE_CAST(V)(values)...)
+  {
+  }
+
+#if defined(GENERATING_DOCUMENTATION)
+private:
+#endif // defined(GENERATING_DOCUMENTATION)
+  CompletionToken token_;
+  std::tuple<Values...> values_;
+};
+
+/// Completion token adapter used to specify that the completion handler should
+/// carry additional values along with it.
+/**
+ * This completion token adapter is typically used to keep at least one copy of
+ * an object, such as a smart pointer, alive until the completion handler is
+ * called.
+ */
+template <typename CompletionToken, typename... Values>
+BOOST_ASIO_NODISCARD inline BOOST_ASIO_CONSTEXPR consign_t<
+  typename decay<CompletionToken>::type, typename decay<Values>::type...>
+consign(BOOST_ASIO_MOVE_ARG(CompletionToken) completion_token,
+    BOOST_ASIO_MOVE_ARG(Values)... values)
+{
+  return consign_t<
+    typename decay<CompletionToken>::type, typename decay<Values>::type...>(
+      BOOST_ASIO_MOVE_CAST(CompletionToken)(completion_token),
+      BOOST_ASIO_MOVE_CAST(Values)(values)...);
+}
+
+} // namespace asio
+} // namespace boost
+
+#include <boost/asio/detail/pop_options.hpp>
+
+#include <boost/asio/impl/consign.hpp>
+
+#endif // (defined(BOOST_ASIO_HAS_STD_TUPLE)
+       //     && defined(BOOST_ASIO_HAS_VARIADIC_TEMPLATES))
+       //   || defined(GENERATING_DOCUMENTATION)
+
+#endif // BOOST_ASIO_CONSIGN_HPP

linx64/include/boost/asio/coroutine.hpp

@@ -2,7 +2,7 @@
 // coroutine.hpp
 // ~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2019 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2023 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

linx64/include/boost/asio/deadline_timer.hpp

@@ -2,7 +2,7 @@
 // deadline_timer.hpp
 // ~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2019 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2023 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

linx64/include/boost/asio/defer.hpp

@@ -2,7 +2,7 @@
 // defer.hpp
 // ~~~~~~~~~
 //
-// Copyright (c) 2003-2019 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2023 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -17,9 +17,13 @@
 
 #include <boost/asio/detail/config.hpp>
 #include <boost/asio/async_result.hpp>
+#include <boost/asio/detail/initiate_defer.hpp>
 #include <boost/asio/detail/type_traits.hpp>
 #include <boost/asio/execution_context.hpp>
+#include <boost/asio/execution/blocking.hpp>
+#include <boost/asio/execution/executor.hpp>
 #include <boost/asio/is_executor.hpp>
+#include <boost/asio/require.hpp>
 
 #include <boost/asio/detail/push_options.hpp>
 
@@ -37,27 +41,54 @@ namespace asio {
  * may allow the executor to optimise queueing for cases when the function
  * object represents a continuation of the current call context.
  *
- * This function has the following effects:
+ * @param token The @ref completion_token that will be used to produce a
+ * completion handler. The function signature of the completion handler must be:
+ * @code void handler(); @endcode
  *
- * @li Constructs a function object handler of type @c Handler, initialized
- * with <tt>handler(forward<CompletionToken>(token))</tt>.
+ * @returns This function returns <tt>async_initiate<NullaryToken,
+ * void()>(Init{}, token)</tt>, where @c Init is a function object type defined
+ * as:
  *
- * @li Constructs an object @c result of type <tt>async_result<Handler></tt>,
- * initializing the object as <tt>result(handler)</tt>.
+ * @code class Init
+ * {
+ * public:
+ *   template <typename CompletionHandler>
+ *     void operator()(CompletionHandler&& completion_handler) const;
+ * }; @endcode
  *
- * @li Obtains the handler's associated executor object @c ex by performing
- * <tt>get_associated_executor(handler)</tt>.
+ * The function call operator of @c Init:
+ *
+ * @li Obtains the handler's associated executor object @c ex of type @c Ex by
+ * performing @code auto ex = get_associated_executor(handler); @endcode
  *
  * @li Obtains the handler's associated allocator object @c alloc by performing
- * <tt>get_associated_allocator(handler)</tt>.
+ * @code auto alloc = get_associated_allocator(handler); @endcode
  *
- * @li Performs <tt>ex.defer(std::move(handler), alloc)</tt>.
+ * @li If <tt>execution::is_executor<Ex>::value</tt> is true, performs
+ * @code prefer(
+ *     require(ex, execution::blocking.never),
+ *     execution::relationship.continuation,
+ *     execution::allocator(alloc)
+ *   ).execute(std::forward<CompletionHandler>(completion_handler)); @endcode
  *
- * @li Returns <tt>result.get()</tt>.
+ * @li If <tt>execution::is_executor<Ex>::value</tt> is false, performs
+ * @code ex.defer(
+ *     std::forward<CompletionHandler>(completion_handler),
+ *     alloc); @endcode
+ *
+ * @par Completion Signature
+ * @code void() @endcode
  */
-template <typename CompletionToken>
-BOOST_ASIO_INITFN_RESULT_TYPE(CompletionToken, void()) defer(
-    BOOST_ASIO_MOVE_ARG(CompletionToken) token);
+template <BOOST_ASIO_COMPLETION_TOKEN_FOR(void()) NullaryToken>
+BOOST_ASIO_INITFN_AUTO_RESULT_TYPE_PREFIX(NullaryToken, void()) defer(
+    BOOST_ASIO_MOVE_ARG(NullaryToken) token)
+  BOOST_ASIO_INITFN_AUTO_RESULT_TYPE_SUFFIX((
+    async_initiate<NullaryToken, void()>(
+        declval<detail::initiate_defer>(), token)))
+{
+  return async_initiate<NullaryToken, void()>(
+      detail::initiate_defer(), token);
+}
 
 /// Submits a completion token or function object for execution.
 /**
@@ -70,50 +101,124 @@ BOOST_ASIO_INITFN_RESULT_TYPE(CompletionToken, void()) defer(
  * may allow the executor to optimise queueing for cases when the function
  * object represents a continuation of the current call context.
  *
- * This function has the following effects:
+ * @param ex The target executor.
  *
- * @li Constructs a function object handler of type @c Handler, initialized
- * with <tt>handler(forward<CompletionToken>(token))</tt>.
+ * @param token The @ref completion_token that will be used to produce a
+ * completion handler. The function signature of the completion handler must be:
+ * @code void handler(); @endcode
  *
- * @li Constructs an object @c result of type <tt>async_result<Handler></tt>,
- * initializing the object as <tt>result(handler)</tt>.
+ * @returns This function returns <tt>async_initiate<NullaryToken,
+ * void()>(Init{ex}, token)</tt>, where @c Init is a function object type
+ * defined as:
  *
- * @li Obtains the handler's associated executor object @c ex1 by performing
- * <tt>get_associated_executor(handler)</tt>.
+ * @code class Init
+ * {
+ * public:
+ *   using executor_type = Executor;
+ *   explicit Init(const Executor& ex) : ex_(ex) {}
+ *   executor_type get_executor() const noexcept { return ex_; }
+ *   template <typename CompletionHandler>
+ *     void operator()(CompletionHandler&& completion_handler) const;
+ * private:
+ *   Executor ex_; // exposition only
+ * }; @endcode
  *
- * @li Creates a work object @c w by performing <tt>make_work(ex1)</tt>.
+ * The function call operator of @c Init:
+ *
+ * @li Obtains the handler's associated executor object @c ex1 of type @c Ex1 by
+ * performing @code auto ex1 = get_associated_executor(handler, ex); @endcode
  *
  * @li Obtains the handler's associated allocator object @c alloc by performing
- * <tt>get_associated_allocator(handler)</tt>.
+ * @code auto alloc = get_associated_allocator(handler); @endcode
  *
- * @li Constructs a function object @c f with a function call operator that
- * performs <tt>ex1.dispatch(std::move(handler), alloc)</tt> followed by
- * <tt>w.reset()</tt>.
+ * @li If <tt>execution::is_executor<Ex1>::value</tt> is true, constructs a
+ * function object @c f with a member @c executor_ that is initialised with
+ * <tt>prefer(ex1, execution::outstanding_work.tracked)</tt>, a member @c
+ * handler_ that is a decay-copy of @c completion_handler, and a function call
+ * operator that performs:
+ * @code auto a = get_associated_allocator(handler_);
+ * prefer(executor_, execution::allocator(a)).execute(std::move(handler_));
+ * @endcode
  *
- * @li Performs <tt>Executor(ex).defer(std::move(f), alloc)</tt>.
+ * @li If <tt>execution::is_executor<Ex1>::value</tt> is false, constructs a
+ * function object @c f with a member @c work_ that is initialised with
+ * <tt>make_work_guard(ex1)</tt>, a member @c handler_ that is a decay-copy of
+ * @c completion_handler, and a function call operator that performs:
+ * @code auto a = get_associated_allocator(handler_);
+ * work_.get_executor().dispatch(std::move(handler_), a);
+ * work_.reset(); @endcode
  *
- * @li Returns <tt>result.get()</tt>.
+ * @li If <tt>execution::is_executor<Ex>::value</tt> is true, performs
+ * @code prefer(
+ *     require(ex, execution::blocking.never),
+ *     execution::relationship.continuation,
+ *     execution::allocator(alloc)
+ *   ).execute(std::move(f)); @endcode
+ *
+ * @li If <tt>execution::is_executor<Ex>::value</tt> is false, performs
+ * @code ex.defer(std::move(f), alloc); @endcode
+ *
+ * @par Completion Signature
+ * @code void() @endcode
  */
-template <typename Executor, typename CompletionToken>
-BOOST_ASIO_INITFN_RESULT_TYPE(CompletionToken, void()) defer(
-    const Executor& ex, BOOST_ASIO_MOVE_ARG(CompletionToken) token,
-    typename enable_if<is_executor<Executor>::value>::type* = 0);
+template <typename Executor,
+    BOOST_ASIO_COMPLETION_TOKEN_FOR(void()) NullaryToken
+      BOOST_ASIO_DEFAULT_COMPLETION_TOKEN_TYPE(Executor)>
+BOOST_ASIO_INITFN_AUTO_RESULT_TYPE_PREFIX(NullaryToken, void()) defer(
+    const Executor& ex,
+    BOOST_ASIO_MOVE_ARG(NullaryToken) token
+      BOOST_ASIO_DEFAULT_COMPLETION_TOKEN(Executor),
+    typename constraint<
+      (execution::is_executor<Executor>::value
+          && can_require<Executor, execution::blocking_t::never_t>::value)
+        || is_executor<Executor>::value
+    >::type = 0)
+  BOOST_ASIO_INITFN_AUTO_RESULT_TYPE_SUFFIX((
+    async_initiate<NullaryToken, void()>(
+        declval<detail::initiate_defer_with_executor<Executor> >(), token)))
+{
+  return async_initiate<NullaryToken, void()>(
+      detail::initiate_defer_with_executor<Executor>(ex), token);
+}
 
 /// Submits a completion token or function object for execution.
 /**
- * @returns <tt>defer(ctx.get_executor(), forward<CompletionToken>(token))</tt>.
+ * @param ctx An execution context, from which the target executor is obtained.
+ *
+ * @param token The @ref completion_token that will be used to produce a
+ * completion handler. The function signature of the completion handler must be:
+ * @code void handler(); @endcode
+ *
+ * @returns <tt>defer(ctx.get_executor(), forward<NullaryToken>(token))</tt>.
+ *
+ * @par Completion Signature
+ * @code void() @endcode
  */
-template <typename ExecutionContext, typename CompletionToken>
-BOOST_ASIO_INITFN_RESULT_TYPE(CompletionToken, void()) defer(
-    ExecutionContext& ctx, BOOST_ASIO_MOVE_ARG(CompletionToken) token,
-    typename enable_if<is_convertible<
-      ExecutionContext&, execution_context&>::value>::type* = 0);
+template <typename ExecutionContext,
+    BOOST_ASIO_COMPLETION_TOKEN_FOR(void()) NullaryToken
+      BOOST_ASIO_DEFAULT_COMPLETION_TOKEN_TYPE(
+        typename ExecutionContext::executor_type)>
+BOOST_ASIO_INITFN_AUTO_RESULT_TYPE_PREFIX(NullaryToken, void()) defer(
+    ExecutionContext& ctx,
+    BOOST_ASIO_MOVE_ARG(NullaryToken) token
+      BOOST_ASIO_DEFAULT_COMPLETION_TOKEN(
+        typename ExecutionContext::executor_type),
+    typename constraint<is_convertible<
+      ExecutionContext&, execution_context&>::value>::type = 0)
+  BOOST_ASIO_INITFN_AUTO_RESULT_TYPE_SUFFIX((
+    async_initiate<NullaryToken, void()>(
+        declval<detail::initiate_defer_with_executor<
+          typename ExecutionContext::executor_type> >(), token)))
+{
+  return async_initiate<NullaryToken, void()>(
+      detail::initiate_defer_with_executor<
+        typename ExecutionContext::executor_type>(
+          ctx.get_executor()), token);
+}
 
 } // namespace asio
 } // namespace boost
 
 #include <boost/asio/detail/pop_options.hpp>
 
-#include <boost/asio/impl/defer.hpp>
-
 #endif // BOOST_ASIO_DEFER_HPP

linx64/include/boost/asio/deferred.hpp

@@ -0,0 +1,804 @@
+//
+// deferred.hpp
+// ~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2023 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef BOOST_ASIO_DEFERRED_HPP
+#define BOOST_ASIO_DEFERRED_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include <boost/asio/detail/config.hpp>
+
+#if (defined(BOOST_ASIO_HAS_STD_TUPLE) \
+    && defined(BOOST_ASIO_HAS_DECLTYPE) \
+    && defined(BOOST_ASIO_HAS_VARIADIC_TEMPLATES)) \
+  || defined(GENERATING_DOCUMENTATION)
+
+#include <tuple>
+#include <boost/asio/associator.hpp>
+#include <boost/asio/async_result.hpp>
+#include <boost/asio/detail/type_traits.hpp>
+#include <boost/asio/detail/utility.hpp>
+
+#include <boost/asio/detail/push_options.hpp>
+
+namespace boost {
+namespace asio {
+
+/// Trait for detecting objects that are usable as deferred operations.
+template <typename T>
+struct is_deferred : false_type
+{
+};
+
+/// Helper type to wrap multiple completion signatures.
+template <typename... Signatures>
+struct deferred_signatures
+{
+};
+
+namespace detail {
+
+// Helper trait for getting the completion signatures of the tail in a sequence
+// when invoked with the specified arguments.
+
+template <typename Tail, typename... Signatures>
+struct deferred_sequence_signatures;
+
+template <typename Tail, typename R, typename... Args, typename... Signatures>
+struct deferred_sequence_signatures<Tail, R(Args...), Signatures...>
+  : completion_signature_of<decltype(declval<Tail>()(declval<Args>()...))>
+{
+  static_assert(
+      !is_same<decltype(declval<Tail>()(declval<Args>()...)), void>::value,
+      "deferred functions must produce a deferred return type");
+};
+
+// Completion handler for the head component of a deferred sequence.
+template <typename Handler, typename Tail>
+class deferred_sequence_handler
+{
+public:
+  template <typename H, typename T>
+  explicit deferred_sequence_handler(
+      BOOST_ASIO_MOVE_ARG(H) handler, BOOST_ASIO_MOVE_ARG(T) tail)
+    : handler_(BOOST_ASIO_MOVE_CAST(H)(handler)),
+      tail_(BOOST_ASIO_MOVE_CAST(T)(tail))
+  {
+  }
+
+  template <typename... Args>
+  void operator()(BOOST_ASIO_MOVE_ARG(Args)... args)
+  {
+    BOOST_ASIO_MOVE_OR_LVALUE(Tail)(tail_)(
+        BOOST_ASIO_MOVE_CAST(Args)(args)...)(
+          BOOST_ASIO_MOVE_OR_LVALUE(Handler)(handler_));
+  }
+
+//private:
+  Handler handler_;
+  Tail tail_;
+};
+
+template <typename Head, typename Tail, typename... Signatures>
+class deferred_sequence_base
+{
+private:
+  struct initiate
+  {
+    template <typename Handler>
+    void operator()(BOOST_ASIO_MOVE_ARG(Handler) handler,
+        Head head, BOOST_ASIO_MOVE_ARG(Tail) tail)
+    {
+      BOOST_ASIO_MOVE_OR_LVALUE(Head)(head)(
+          deferred_sequence_handler<
+            typename decay<Handler>::type,
+            typename decay<Tail>::type>(
+              BOOST_ASIO_MOVE_CAST(Handler)(handler),
+              BOOST_ASIO_MOVE_CAST(Tail)(tail)));
+    }
+  };
+
+  Head head_;
+  Tail tail_;
+
+public:
+  template <typename H, typename T>
+  BOOST_ASIO_CONSTEXPR explicit deferred_sequence_base(
+      BOOST_ASIO_MOVE_ARG(H) head, BOOST_ASIO_MOVE_ARG(T) tail)
+    : head_(BOOST_ASIO_MOVE_CAST(H)(head)),
+      tail_(BOOST_ASIO_MOVE_CAST(T)(tail))
+  {
+  }
+
+  template <BOOST_ASIO_COMPLETION_TOKEN_FOR(Signatures...) CompletionToken>
+  auto operator()(
+      BOOST_ASIO_MOVE_ARG(CompletionToken) token) BOOST_ASIO_RVALUE_REF_QUAL
+    -> decltype(
+        boost::asio::async_initiate<CompletionToken, Signatures...>(
+          declval<initiate>(), token,
+          BOOST_ASIO_MOVE_OR_LVALUE(Head)(this->head_),
+          BOOST_ASIO_MOVE_OR_LVALUE(Tail)(this->tail_)))
+  {
+    return boost::asio::async_initiate<CompletionToken, Signatures...>(
+        initiate(), token,
+        BOOST_ASIO_MOVE_OR_LVALUE(Head)(head_),
+        BOOST_ASIO_MOVE_OR_LVALUE(Tail)(tail_));
+  }
+
+#if defined(BOOST_ASIO_HAS_REF_QUALIFIED_FUNCTIONS)
+  template <BOOST_ASIO_COMPLETION_TOKEN_FOR(Signatures...) CompletionToken>
+  auto operator()(
+      BOOST_ASIO_MOVE_ARG(CompletionToken) token) const &
+    -> decltype(
+        boost::asio::async_initiate<CompletionToken, Signatures...>(
+          initiate(), token, this->head_, this->tail_))
+  {
+    return boost::asio::async_initiate<CompletionToken, Signatures...>(
+        initiate(), token, head_, tail_);
+  }
+#endif // defined(BOOST_ASIO_HAS_REF_QUALIFIED_FUNCTIONS)
+};
+
+// Two-step application of variadic Signatures to determine correct base type.
+
+template <typename Head, typename Tail>
+struct deferred_sequence_types
+{
+  template <typename... Signatures>
+  struct op1
+  {
+    typedef deferred_sequence_base<Head, Tail, Signatures...> type;
+  };
+
+  template <typename... Signatures>
+  struct op2
+  {
+    typedef typename deferred_sequence_signatures<Tail, Signatures...>::template
+      apply<op1>::type::type type;
+  };
+
+  typedef typename completion_signature_of<Head>::template
+    apply<op2>::type::type base;
+};
+
+} // namespace detail
+
+/// Used to represent an empty deferred action.
+struct deferred_noop
+{
+  /// No effect.
+  template <typename... Args>
+  void operator()(BOOST_ASIO_MOVE_ARG(Args)...) BOOST_ASIO_RVALUE_REF_QUAL
+  {
+  }
+
+#if defined(BOOST_ASIO_HAS_REF_QUALIFIED_FUNCTIONS)
+  /// No effect.
+  template <typename... Args>
+  void operator()(BOOST_ASIO_MOVE_ARG(Args)...) const &
+  {
+  }
+#endif // defined(BOOST_ASIO_HAS_REF_QUALIFIED_FUNCTIONS)
+};
+
+#if !defined(GENERATING_DOCUMENTATION)
+template <>
+struct is_deferred<deferred_noop> : true_type
+{
+};
+#endif // !defined(GENERATING_DOCUMENTATION)
+
+/// Tag type to disambiguate deferred constructors.
+struct deferred_init_tag {};
+
+/// Wraps a function object so that it may be used as an element in a deferred
+/// composition.
+template <typename Function>
+class deferred_function
+{
+public:
+  /// Constructor. 
+  template <typename F>
+  BOOST_ASIO_CONSTEXPR explicit deferred_function(
+      deferred_init_tag, BOOST_ASIO_MOVE_ARG(F) function)
+    : function_(BOOST_ASIO_MOVE_CAST(F)(function))
+  {
+  }
+
+//private:
+  Function function_;
+
+public:
+  template <typename... Args>
+  auto operator()(
+      BOOST_ASIO_MOVE_ARG(Args)... args) BOOST_ASIO_RVALUE_REF_QUAL
+    -> decltype(
+        BOOST_ASIO_MOVE_CAST(Function)(this->function_)(
+          BOOST_ASIO_MOVE_CAST(Args)(args)...))
+  {
+    return BOOST_ASIO_MOVE_CAST(Function)(function_)(
+        BOOST_ASIO_MOVE_CAST(Args)(args)...);
+  }
+
+#if defined(BOOST_ASIO_HAS_REF_QUALIFIED_FUNCTIONS)
+  template <typename... Args>
+  auto operator()(
+      BOOST_ASIO_MOVE_ARG(Args)... args) const &
+    -> decltype(Function(function_)(BOOST_ASIO_MOVE_CAST(Args)(args)...))
+  {
+    return Function(function_)(BOOST_ASIO_MOVE_CAST(Args)(args)...);
+  }
+#endif // defined(BOOST_ASIO_HAS_REF_QUALIFIED_FUNCTIONS)
+};
+
+#if !defined(GENERATING_DOCUMENTATION)
+template <typename Function>
+struct is_deferred<deferred_function<Function> > : true_type
+{
+};
+#endif // !defined(GENERATING_DOCUMENTATION)
+
+/// Encapsulates deferred values.
+template <typename... Values>
+class BOOST_ASIO_NODISCARD deferred_values
+{
+private:
+  std::tuple<Values...> values_;
+
+  struct initiate
+  {
+    template <typename Handler, typename... V>
+    void operator()(Handler handler, BOOST_ASIO_MOVE_ARG(V)... values)
+    {
+      BOOST_ASIO_MOVE_OR_LVALUE(Handler)(handler)(
+          BOOST_ASIO_MOVE_CAST(V)(values)...);
+    }
+  };
+
+  template <typename CompletionToken, std::size_t... I>
+  auto invoke_helper(
+      BOOST_ASIO_MOVE_ARG(CompletionToken) token,
+      detail::index_sequence<I...>)
+    -> decltype(
+        boost::asio::async_initiate<CompletionToken, void(Values...)>(
+          initiate(), token,
+          std::get<I>(
+            BOOST_ASIO_MOVE_CAST(std::tuple<Values...>)(this->values_))...))
+  {
+    return boost::asio::async_initiate<CompletionToken, void(Values...)>(
+        initiate(), token,
+        std::get<I>(BOOST_ASIO_MOVE_CAST(std::tuple<Values...>)(values_))...);
+  }
+
+#if defined(BOOST_ASIO_HAS_REF_QUALIFIED_FUNCTIONS)
+  template <typename CompletionToken, std::size_t... I>
+  auto const_invoke_helper(
+      BOOST_ASIO_MOVE_ARG(CompletionToken) token,
+      detail::index_sequence<I...>)
+    -> decltype(
+        boost::asio::async_initiate<CompletionToken, void(Values...)>(
+          initiate(), token, std::get<I>(values_)...))
+  {
+    return boost::asio::async_initiate<CompletionToken, void(Values...)>(
+        initiate(), token, std::get<I>(values_)...);
+  }
+#endif // defined(BOOST_ASIO_HAS_REF_QUALIFIED_FUNCTIONS)
+
+public:
+  /// Construct a deferred asynchronous operation from the arguments to an
+  /// initiation function object.
+  template <typename... V>
+  BOOST_ASIO_CONSTEXPR explicit deferred_values(
+      deferred_init_tag, BOOST_ASIO_MOVE_ARG(V)... values)
+    : values_(BOOST_ASIO_MOVE_CAST(V)(values)...)
+  {
+  }
+
+  /// Initiate the deferred operation using the supplied completion token.
+  template <BOOST_ASIO_COMPLETION_TOKEN_FOR(void(Values...)) CompletionToken>
+  auto operator()(
+      BOOST_ASIO_MOVE_ARG(CompletionToken) token) BOOST_ASIO_RVALUE_REF_QUAL
+    -> decltype(
+        this->invoke_helper(
+          BOOST_ASIO_MOVE_CAST(CompletionToken)(token),
+          detail::index_sequence_for<Values...>()))
+  {
+    return this->invoke_helper(
+        BOOST_ASIO_MOVE_CAST(CompletionToken)(token),
+        detail::index_sequence_for<Values...>());
+  }
+
+#if defined(BOOST_ASIO_HAS_REF_QUALIFIED_FUNCTIONS)
+  template <BOOST_ASIO_COMPLETION_TOKEN_FOR(void(Values...)) CompletionToken>
+  auto operator()(
+      BOOST_ASIO_MOVE_ARG(CompletionToken) token) const &
+    -> decltype(
+        this->const_invoke_helper(
+          BOOST_ASIO_MOVE_CAST(CompletionToken)(token),
+          detail::index_sequence_for<Values...>()))
+  {
+    return this->const_invoke_helper(
+        BOOST_ASIO_MOVE_CAST(CompletionToken)(token),
+        detail::index_sequence_for<Values...>());
+  }
+#endif // defined(BOOST_ASIO_HAS_REF_QUALIFIED_FUNCTIONS)
+};
+
+#if !defined(GENERATING_DOCUMENTATION)
+template <typename... Values>
+struct is_deferred<deferred_values<Values...> > : true_type
+{
+};
+#endif // !defined(GENERATING_DOCUMENTATION)
+
+/// Encapsulates a deferred asynchronous operation.
+template <typename Signature, typename Initiation, typename... InitArgs>
+class BOOST_ASIO_NODISCARD deferred_async_operation
+{
+private:
+  typedef typename decay<Initiation>::type initiation_t;
+  initiation_t initiation_;
+  typedef std::tuple<typename decay<InitArgs>::type...> init_args_t;
+  init_args_t init_args_;
+
+  template <typename CompletionToken, std::size_t... I>
+  auto invoke_helper(
+      BOOST_ASIO_MOVE_ARG(CompletionToken) token,
+      detail::index_sequence<I...>)
+    -> decltype(
+        boost::asio::async_initiate<CompletionToken, Signature>(
+          BOOST_ASIO_MOVE_CAST(initiation_t)(initiation_), token,
+          std::get<I>(BOOST_ASIO_MOVE_CAST(init_args_t)(init_args_))...))
+  {
+    return boost::asio::async_initiate<CompletionToken, Signature>(
+        BOOST_ASIO_MOVE_CAST(initiation_t)(initiation_), token,
+        std::get<I>(BOOST_ASIO_MOVE_CAST(init_args_t)(init_args_))...);
+  }
+
+#if defined(BOOST_ASIO_HAS_REF_QUALIFIED_FUNCTIONS)
+  template <typename CompletionToken, std::size_t... I>
+  auto const_invoke_helper(
+      BOOST_ASIO_MOVE_ARG(CompletionToken) token,
+      detail::index_sequence<I...>) const &
+    -> decltype(
+        boost::asio::async_initiate<CompletionToken, Signature>(
+          initiation_t(initiation_), token, std::get<I>(init_args_)...))
+    {
+    return boost::asio::async_initiate<CompletionToken, Signature>(
+        initiation_t(initiation_), token, std::get<I>(init_args_)...);
+  }
+#endif // defined(BOOST_ASIO_HAS_REF_QUALIFIED_FUNCTIONS)
+
+public:
+  /// Construct a deferred asynchronous operation from the arguments to an
+  /// initiation function object.
+  template <typename I, typename... A>
+  BOOST_ASIO_CONSTEXPR explicit deferred_async_operation(
+      deferred_init_tag, BOOST_ASIO_MOVE_ARG(I) initiation,
+      BOOST_ASIO_MOVE_ARG(A)... init_args)
+    : initiation_(BOOST_ASIO_MOVE_CAST(I)(initiation)),
+      init_args_(BOOST_ASIO_MOVE_CAST(A)(init_args)...)
+  {
+  }
+
+  /// Initiate the asynchronous operation using the supplied completion token.
+  template <BOOST_ASIO_COMPLETION_TOKEN_FOR(Signature) CompletionToken>
+  auto operator()(
+      BOOST_ASIO_MOVE_ARG(CompletionToken) token) BOOST_ASIO_RVALUE_REF_QUAL
+    -> decltype(
+        this->invoke_helper(
+          BOOST_ASIO_MOVE_CAST(CompletionToken)(token),
+          detail::index_sequence_for<InitArgs...>()))
+  {
+    return this->invoke_helper(
+        BOOST_ASIO_MOVE_CAST(CompletionToken)(token),
+        detail::index_sequence_for<InitArgs...>());
+  }
+
+#if defined(BOOST_ASIO_HAS_REF_QUALIFIED_FUNCTIONS)
+  template <BOOST_ASIO_COMPLETION_TOKEN_FOR(Signature) CompletionToken>
+  auto operator()(
+      BOOST_ASIO_MOVE_ARG(CompletionToken) token) const &
+    -> decltype(
+        this->const_invoke_helper(
+          BOOST_ASIO_MOVE_CAST(CompletionToken)(token),
+          detail::index_sequence_for<InitArgs...>()))
+  {
+    return this->const_invoke_helper(
+        BOOST_ASIO_MOVE_CAST(CompletionToken)(token),
+        detail::index_sequence_for<InitArgs...>());
+  }
+#endif // defined(BOOST_ASIO_HAS_REF_QUALIFIED_FUNCTIONS)
+};
+
+/// Encapsulates a deferred asynchronous operation thas has multiple completion
+/// signatures.
+template <typename... Signatures, typename Initiation, typename... InitArgs>
+class BOOST_ASIO_NODISCARD deferred_async_operation<
+    deferred_signatures<Signatures...>, Initiation, InitArgs...>
+{
+private:
+  typedef typename decay<Initiation>::type initiation_t;
+  initiation_t initiation_;
+  typedef std::tuple<typename decay<InitArgs>::type...> init_args_t;
+  init_args_t init_args_;
+
+  template <typename CompletionToken, std::size_t... I>
+  auto invoke_helper(
+      BOOST_ASIO_MOVE_ARG(CompletionToken) token,
+      detail::index_sequence<I...>)
+    -> decltype(
+        boost::asio::async_initiate<CompletionToken, Signatures...>(
+          BOOST_ASIO_MOVE_CAST(initiation_t)(initiation_), token,
+          std::get<I>(BOOST_ASIO_MOVE_CAST(init_args_t)(init_args_))...))
+  {
+    return boost::asio::async_initiate<CompletionToken, Signatures...>(
+        BOOST_ASIO_MOVE_CAST(initiation_t)(initiation_), token,
+        std::get<I>(BOOST_ASIO_MOVE_CAST(init_args_t)(init_args_))...);
+  }
+
+#if defined(BOOST_ASIO_HAS_REF_QUALIFIED_FUNCTIONS)
+  template <typename CompletionToken, std::size_t... I>
+  auto const_invoke_helper(
+      BOOST_ASIO_MOVE_ARG(CompletionToken) token,
+      detail::index_sequence<I...>) const &
+    -> decltype(
+        boost::asio::async_initiate<CompletionToken, Signatures...>(
+          initiation_t(initiation_), token, std::get<I>(init_args_)...))
+    {
+    return boost::asio::async_initiate<CompletionToken, Signatures...>(
+        initiation_t(initiation_), token, std::get<I>(init_args_)...);
+  }
+#endif // defined(BOOST_ASIO_HAS_REF_QUALIFIED_FUNCTIONS)
+
+public:
+  /// Construct a deferred asynchronous operation from the arguments to an
+  /// initiation function object.
+  template <typename I, typename... A>
+  BOOST_ASIO_CONSTEXPR explicit deferred_async_operation(
+      deferred_init_tag, BOOST_ASIO_MOVE_ARG(I) initiation,
+      BOOST_ASIO_MOVE_ARG(A)... init_args)
+    : initiation_(BOOST_ASIO_MOVE_CAST(I)(initiation)),
+      init_args_(BOOST_ASIO_MOVE_CAST(A)(init_args)...)
+  {
+  }
+
+  /// Initiate the asynchronous operation using the supplied completion token.
+  template <BOOST_ASIO_COMPLETION_TOKEN_FOR(Signatures...) CompletionToken>
+  auto operator()(
+      BOOST_ASIO_MOVE_ARG(CompletionToken) token) BOOST_ASIO_RVALUE_REF_QUAL
+    -> decltype(
+        this->invoke_helper(
+          BOOST_ASIO_MOVE_CAST(CompletionToken)(token),
+          detail::index_sequence_for<InitArgs...>()))
+  {
+    return this->invoke_helper(
+        BOOST_ASIO_MOVE_CAST(CompletionToken)(token),
+        detail::index_sequence_for<InitArgs...>());
+  }
+
+#if defined(BOOST_ASIO_HAS_REF_QUALIFIED_FUNCTIONS)
+  template <BOOST_ASIO_COMPLETION_TOKEN_FOR(Signatures...) CompletionToken>
+  auto operator()(
+      BOOST_ASIO_MOVE_ARG(CompletionToken) token) const &
+    -> decltype(
+        this->const_invoke_helper(
+          BOOST_ASIO_MOVE_CAST(CompletionToken)(token),
+          detail::index_sequence_for<InitArgs...>()))
+  {
+    return this->const_invoke_helper(
+        BOOST_ASIO_MOVE_CAST(CompletionToken)(token),
+        detail::index_sequence_for<InitArgs...>());
+  }
+#endif // defined(BOOST_ASIO_HAS_REF_QUALIFIED_FUNCTIONS)
+};
+
+#if !defined(GENERATING_DOCUMENTATION)
+template <typename Signature, typename Initiation, typename... InitArgs>
+struct is_deferred<
+    deferred_async_operation<Signature, Initiation, InitArgs...> > : true_type
+{
+};
+#endif // !defined(GENERATING_DOCUMENTATION)
+
+/// Defines a link between two consecutive operations in a sequence.
+template <typename Head, typename Tail>
+class BOOST_ASIO_NODISCARD deferred_sequence :
+  public detail::deferred_sequence_types<Head, Tail>::base
+{
+public:
+  template <typename H, typename T>
+  BOOST_ASIO_CONSTEXPR explicit deferred_sequence(deferred_init_tag,
+      BOOST_ASIO_MOVE_ARG(H) head, BOOST_ASIO_MOVE_ARG(T) tail)
+    : detail::deferred_sequence_types<Head, Tail>::base(
+        BOOST_ASIO_MOVE_CAST(H)(head), BOOST_ASIO_MOVE_CAST(T)(tail))
+  {
+  }
+
+#if defined(GENERATING_DOCUMENTATION)
+  template <typename CompletionToken>
+  auto operator()(BOOST_ASIO_MOVE_ARG(CompletionToken) token)
+    BOOST_ASIO_RVALUE_REF_QUAL;
+
+  template <typename CompletionToken>
+  auto operator()(BOOST_ASIO_MOVE_ARG(CompletionToken) token) const &;
+#endif // defined(BOOST_ASIO_HAS_REF_QUALIFIED_FUNCTIONS)
+};
+
+#if !defined(GENERATING_DOCUMENTATION)
+template <typename Head, typename Tail>
+struct is_deferred<deferred_sequence<Head, Tail> > : true_type
+{
+};
+#endif // !defined(GENERATING_DOCUMENTATION)
+
+/// Used to represent a deferred conditional branch.
+template <typename OnTrue = deferred_noop,
+    typename OnFalse = deferred_noop>
+class BOOST_ASIO_NODISCARD deferred_conditional
+{
+private:
+  template <typename T, typename F> friend class deferred_conditional;
+
+  // Helper constructor.
+  template <typename T, typename F>
+  explicit deferred_conditional(bool b, BOOST_ASIO_MOVE_ARG(T) on_true,
+      BOOST_ASIO_MOVE_ARG(F) on_false)
+    : on_true_(BOOST_ASIO_MOVE_CAST(T)(on_true)),
+      on_false_(BOOST_ASIO_MOVE_CAST(F)(on_false)),
+      bool_(b)
+  {
+  }
+
+  OnTrue on_true_;
+  OnFalse on_false_;
+  bool bool_;
+
+public:
+  /// Construct a deferred conditional with the value to determine which branch
+  /// will be executed.
+  BOOST_ASIO_CONSTEXPR explicit deferred_conditional(bool b)
+    : on_true_(),
+      on_false_(),
+      bool_(b)
+  {
+  }
+
+  /// Invoke the conditional branch bsaed on the stored alue.
+  template <typename... Args>
+  auto operator()(BOOST_ASIO_MOVE_ARG(Args)... args) BOOST_ASIO_RVALUE_REF_QUAL
+    -> decltype(
+        BOOST_ASIO_MOVE_OR_LVALUE(OnTrue)(on_true_)(
+          BOOST_ASIO_MOVE_CAST(Args)(args)...))
+  {
+    if (bool_)
+    {
+      return BOOST_ASIO_MOVE_OR_LVALUE(OnTrue)(on_true_)(
+          BOOST_ASIO_MOVE_CAST(Args)(args)...);
+    }
+    else
+    {
+      return BOOST_ASIO_MOVE_OR_LVALUE(OnFalse)(on_false_)(
+          BOOST_ASIO_MOVE_CAST(Args)(args)...);
+    }
+  }
+
+#if defined(BOOST_ASIO_HAS_REF_QUALIFIED_FUNCTIONS)
+  template <typename... Args>
+  auto operator()(BOOST_ASIO_MOVE_ARG(Args)... args) const &
+    -> decltype(on_true_(BOOST_ASIO_MOVE_CAST(Args)(args)...))
+  {
+    if (bool_)
+    {
+      return on_true_(BOOST_ASIO_MOVE_CAST(Args)(args)...);
+    }
+    else
+    {
+      return on_false_(BOOST_ASIO_MOVE_CAST(Args)(args)...);
+    }
+  }
+#endif // defined(BOOST_ASIO_HAS_REF_QUALIFIED_FUNCTIONS)
+
+  /// Set the true branch of the conditional.
+  template <typename T>
+  deferred_conditional<T, OnFalse> then(T on_true,
+      typename constraint<
+        is_deferred<T>::value
+      >::type* = 0,
+      typename constraint<
+        is_same<
+          typename conditional<true, OnTrue, T>::type,
+          deferred_noop
+        >::value
+      >::type* = 0) BOOST_ASIO_RVALUE_REF_QUAL
+  {
+    return deferred_conditional<T, OnFalse>(
+        bool_, BOOST_ASIO_MOVE_CAST(T)(on_true),
+        BOOST_ASIO_MOVE_CAST(OnFalse)(on_false_));
+  }
+
+  /// Set the false branch of the conditional.
+  template <typename T>
+  deferred_conditional<OnTrue, T> otherwise(T on_false,
+      typename constraint<
+        is_deferred<T>::value
+      >::type* = 0,
+      typename constraint<
+        !is_same<
+          typename conditional<true, OnTrue, T>::type,
+          deferred_noop
+        >::value
+      >::type* = 0,
+      typename constraint<
+        is_same<
+          typename conditional<true, OnFalse, T>::type,
+          deferred_noop
+        >::value
+      >::type* = 0) BOOST_ASIO_RVALUE_REF_QUAL
+  {
+    return deferred_conditional<OnTrue, T>(
+        bool_, BOOST_ASIO_MOVE_CAST(OnTrue)(on_true_),
+        BOOST_ASIO_MOVE_CAST(T)(on_false));
+  }
+};
+
+#if !defined(GENERATING_DOCUMENTATION)
+template <typename OnTrue, typename OnFalse>
+struct is_deferred<deferred_conditional<OnTrue, OnFalse> > : true_type
+{
+};
+#endif // !defined(GENERATING_DOCUMENTATION)
+
+/// Class used to specify that an asynchronous operation should return a
+/// function object to lazily launch the operation.
+/**
+ * The deferred_t class is used to indicate that an asynchronous operation
+ * should return a function object which is itself an initiation function. A
+ * deferred_t object may be passed as a completion token to an asynchronous
+ * operation, typically using the special value @c boost::asio::deferred. For
+ * example:
+ *
+ * @code auto my_deferred_op
+ *   = my_socket.async_read_some(my_buffer,
+ *       boost::asio::deferred); @endcode
+ *
+ * The initiating function (async_read_some in the above example) returns a
+ * function object that will lazily initiate the operation.
+ */
+class deferred_t
+{
+public:
+  /// Default constructor.
+  BOOST_ASIO_CONSTEXPR deferred_t()
+  {
+  }
+
+  /// Adapts an executor to add the @c deferred_t completion token as the
+  /// default.
+  template <typename InnerExecutor>
+  struct executor_with_default : InnerExecutor
+  {
+    /// Specify @c deferred_t as the default completion token type.
+    typedef deferred_t default_completion_token_type;
+
+    /// Construct the adapted executor from the inner executor type.
+    template <typename InnerExecutor1>
+    executor_with_default(const InnerExecutor1& ex,
+        typename constraint<
+          conditional<
+            !is_same<InnerExecutor1, executor_with_default>::value,
+            is_convertible<InnerExecutor1, InnerExecutor>,
+            false_type
+          >::type::value
+        >::type = 0) BOOST_ASIO_NOEXCEPT
+      : InnerExecutor(ex)
+    {
+    }
+  };
+
+  /// Type alias to adapt an I/O object to use @c deferred_t as its
+  /// default completion token type.
+#if defined(BOOST_ASIO_HAS_ALIAS_TEMPLATES) \
+  || defined(GENERATING_DOCUMENTATION)
+  template <typename T>
+  using as_default_on_t = typename T::template rebind_executor<
+      executor_with_default<typename T::executor_type> >::other;
+#endif // defined(BOOST_ASIO_HAS_ALIAS_TEMPLATES)
+       //   || defined(GENERATING_DOCUMENTATION)
+
+  /// Function helper to adapt an I/O object to use @c deferred_t as its
+  /// default completion token type.
+  template <typename T>
+  static typename decay<T>::type::template rebind_executor<
+      executor_with_default<typename decay<T>::type::executor_type>
+    >::other
+  as_default_on(BOOST_ASIO_MOVE_ARG(T) object)
+  {
+    return typename decay<T>::type::template rebind_executor<
+        executor_with_default<typename decay<T>::type::executor_type>
+      >::other(BOOST_ASIO_MOVE_CAST(T)(object));
+  }
+
+  /// Creates a new deferred from a function.
+  template <typename Function>
+  typename constraint<
+    !is_deferred<typename decay<Function>::type>::value,
+    deferred_function<typename decay<Function>::type>
+  >::type operator()(BOOST_ASIO_MOVE_ARG(Function) function) const
+  {
+    return deferred_function<typename decay<Function>::type>(
+        deferred_init_tag{}, BOOST_ASIO_MOVE_CAST(Function)(function));
+  }
+
+  /// Passes through anything that is already deferred.
+  template <typename T>
+  typename constraint<
+    is_deferred<typename decay<T>::type>::value,
+    typename decay<T>::type
+  >::type operator()(BOOST_ASIO_MOVE_ARG(T) t) const
+  {
+    return BOOST_ASIO_MOVE_CAST(T)(t);
+  }
+
+  /// Returns a deferred operation that returns the provided values.
+  template <typename... Args>
+  static BOOST_ASIO_CONSTEXPR deferred_values<typename decay<Args>::type...>
+  values(BOOST_ASIO_MOVE_ARG(Args)... args)
+  {
+    return deferred_values<typename decay<Args>::type...>(
+        deferred_init_tag{}, BOOST_ASIO_MOVE_CAST(Args)(args)...);
+  }
+
+  /// Creates a conditional object for branching deferred operations.
+  static BOOST_ASIO_CONSTEXPR deferred_conditional<> when(bool b)
+  {
+    return deferred_conditional<>(b);
+  }
+};
+
+/// Pipe operator used to chain deferred operations.
+template <typename Head, typename Tail>
+inline auto operator|(Head head, BOOST_ASIO_MOVE_ARG(Tail) tail)
+  -> typename constraint<
+      is_deferred<Head>::value,
+      decltype(BOOST_ASIO_MOVE_OR_LVALUE(Head)(head)(
+            BOOST_ASIO_MOVE_CAST(Tail)(tail)))
+    >::type
+{
+  return BOOST_ASIO_MOVE_OR_LVALUE(Head)(head)(
+      BOOST_ASIO_MOVE_CAST(Tail)(tail));
+}
+
+/// A @ref completion_token object used to specify that an asynchronous
+/// operation should return a function object to lazily launch the operation.
+/**
+ * See the documentation for boost::asio::deferred_t for a usage example.
+ */
+#if defined(BOOST_ASIO_HAS_CONSTEXPR) || defined(GENERATING_DOCUMENTATION)
+constexpr deferred_t deferred;
+#elif defined(BOOST_ASIO_MSVC)
+__declspec(selectany) deferred_t deferred;
+#endif
+
+} // namespace asio
+} // namespace boost
+
+#include <boost/asio/detail/pop_options.hpp>
+
+#include <boost/asio/impl/deferred.hpp>
+
+#endif // (defined(BOOST_ASIO_HAS_STD_TUPLE)
+       //     && defined(BOOST_ASIO_HAS_DECLTYPE))
+       //     && defined(BOOST_ASIO_HAS_VARIADIC_TEMPLATES))
+       //   || defined(GENERATING_DOCUMENTATION)
+
+#endif // BOOST_ASIO_DEFERRED_HPP

linx64/include/boost/asio/detached.hpp

@@ -2,7 +2,7 @@
 // detached.hpp
 // ~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2019 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2023 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -17,21 +17,22 @@
 
 #include <boost/asio/detail/config.hpp>
 #include <memory>
+#include <boost/asio/detail/type_traits.hpp>
 
 #include <boost/asio/detail/push_options.hpp>
 
 namespace boost {
 namespace asio {
 
-/// Class used to specify that an asynchronous operation is detached.
+/// A @ref completion_token type used to specify that an asynchronous operation
+/// is detached.
 /**
-
  * The detached_t class is used to indicate that an asynchronous operation is
  * detached. That is, there is no completion handler waiting for the
  * operation's result. A detached_t object may be passed as a handler to an
  * asynchronous operation, typically using the special value
  * @c boost::asio::detached. For example:
-
+ *
  * @code my_socket.async_send(my_buffer, boost::asio::detached);
  * @endcode
  */
@@ -42,9 +43,59 @@ public:
   BOOST_ASIO_CONSTEXPR detached_t()
   {
   }
+
+  /// Adapts an executor to add the @c detached_t completion token as the
+  /// default.
+  template <typename InnerExecutor>
+  struct executor_with_default : InnerExecutor
+  {
+    /// Specify @c detached_t as the default completion token type.
+    typedef detached_t default_completion_token_type;
+
+    /// Construct the adapted executor from the inner executor type.
+    executor_with_default(const InnerExecutor& ex) BOOST_ASIO_NOEXCEPT
+      : InnerExecutor(ex)
+    {
+    }
+
+    /// Convert the specified executor to the inner executor type, then use
+    /// that to construct the adapted executor.
+    template <typename OtherExecutor>
+    executor_with_default(const OtherExecutor& ex,
+        typename constraint<
+          is_convertible<OtherExecutor, InnerExecutor>::value
+        >::type = 0) BOOST_ASIO_NOEXCEPT
+      : InnerExecutor(ex)
+    {
+    }
+  };
+
+  /// Type alias to adapt an I/O object to use @c detached_t as its
+  /// default completion token type.
+#if defined(BOOST_ASIO_HAS_ALIAS_TEMPLATES) \
+  || defined(GENERATING_DOCUMENTATION)
+  template <typename T>
+  using as_default_on_t = typename T::template rebind_executor<
+      executor_with_default<typename T::executor_type> >::other;
+#endif // defined(BOOST_ASIO_HAS_ALIAS_TEMPLATES)
+       //   || defined(GENERATING_DOCUMENTATION)
+
+  /// Function helper to adapt an I/O object to use @c detached_t as its
+  /// default completion token type.
+  template <typename T>
+  static typename decay<T>::type::template rebind_executor<
+      executor_with_default<typename decay<T>::type::executor_type>
+    >::other
+  as_default_on(BOOST_ASIO_MOVE_ARG(T) object)
+  {
+    return typename decay<T>::type::template rebind_executor<
+        executor_with_default<typename decay<T>::type::executor_type>
+      >::other(BOOST_ASIO_MOVE_CAST(T)(object));
+  }
 };
 
-/// A special value, similar to std::nothrow.
+/// A @ref completion_token object used to specify that an asynchronous
+/// operation is detached.
 /**
  * See the documentation for boost::asio::detached_t for a usage example.
  */

linx64/include/boost/asio/detail/array.hpp

@@ -2,7 +2,7 @@
 // detail/array.hpp
 // ~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2019 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2023 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

linx64/include/boost/asio/detail/array_fwd.hpp

@@ -2,7 +2,7 @@
 // detail/array_fwd.hpp
 // ~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2019 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2023 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

linx64/include/boost/asio/detail/assert.hpp

@@ -2,7 +2,7 @@
 // detail/assert.hpp
 // ~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2019 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2023 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

linx64/include/boost/asio/detail/atomic_count.hpp

@@ -2,7 +2,7 @@
 // detail/atomic_count.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2019 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2023 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -32,12 +32,34 @@ namespace detail {
 #if !defined(BOOST_ASIO_HAS_THREADS)
 typedef long atomic_count;
 inline void increment(atomic_count& a, long b) { a += b; }
+inline void decrement(atomic_count& a, long b) { a -= b; }
+inline void ref_count_up(atomic_count& a) { ++a; }
+inline bool ref_count_down(atomic_count& a) { return --a == 0; }
 #elif defined(BOOST_ASIO_HAS_STD_ATOMIC)
 typedef std::atomic<long> atomic_count;
 inline void increment(atomic_count& a, long b) { a += b; }
+inline void decrement(atomic_count& a, long b) { a -= b; }
+
+inline void ref_count_up(atomic_count& a)
+{
+  a.fetch_add(1, std::memory_order_relaxed);
+}
+
+inline bool ref_count_down(atomic_count& a)
+{
+  if (a.fetch_sub(1, std::memory_order_release) == 1)
+  {
+    std::atomic_thread_fence(std::memory_order_acquire);
+    return true;
+  }
+  return false;
+}
 #else // defined(BOOST_ASIO_HAS_STD_ATOMIC)
 typedef boost::detail::atomic_count atomic_count;
 inline void increment(atomic_count& a, long b) { while (b > 0) ++a, --b; }
+inline void decrement(atomic_count& a, long b) { while (b > 0) --a, --b; }
+inline void ref_count_up(atomic_count& a) { ++a; }
+inline bool ref_count_down(atomic_count& a) { return --a == 0; }
 #endif // defined(BOOST_ASIO_HAS_STD_ATOMIC)
 
 } // namespace detail

linx64/include/boost/asio/detail/base_from_cancellation_state.hpp

@@ -0,0 +1,165 @@
+//
+// detail/base_from_cancellation_state.hpp
+// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2023 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef BOOST_ASIO_DETAIL_BASE_FROM_CANCELLATION_STATE_HPP
+#define BOOST_ASIO_DETAIL_BASE_FROM_CANCELLATION_STATE_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include <boost/asio/detail/config.hpp>
+#include <boost/asio/associated_cancellation_slot.hpp>
+#include <boost/asio/cancellation_state.hpp>
+#include <boost/asio/detail/type_traits.hpp>
+
+#include <boost/asio/detail/push_options.hpp>
+
+namespace boost {
+namespace asio {
+namespace detail {
+
+template <typename Handler, typename = void>
+class base_from_cancellation_state
+{
+public:
+  typedef cancellation_slot cancellation_slot_type;
+
+  cancellation_slot_type get_cancellation_slot() const BOOST_ASIO_NOEXCEPT
+  {
+    return cancellation_state_.slot();
+  }
+
+  cancellation_state get_cancellation_state() const BOOST_ASIO_NOEXCEPT
+  {
+    return cancellation_state_;
+  }
+
+protected:
+  explicit base_from_cancellation_state(const Handler& handler)
+    : cancellation_state_(
+        boost::asio::get_associated_cancellation_slot(handler))
+  {
+  }
+
+  template <typename Filter>
+  base_from_cancellation_state(const Handler& handler, Filter filter)
+    : cancellation_state_(
+        boost::asio::get_associated_cancellation_slot(handler), filter, filter)
+  {
+  }
+
+  template <typename InFilter, typename OutFilter>
+  base_from_cancellation_state(const Handler& handler,
+      BOOST_ASIO_MOVE_ARG(InFilter) in_filter,
+      BOOST_ASIO_MOVE_ARG(OutFilter) out_filter)
+    : cancellation_state_(
+        boost::asio::get_associated_cancellation_slot(handler),
+        BOOST_ASIO_MOVE_CAST(InFilter)(in_filter),
+        BOOST_ASIO_MOVE_CAST(OutFilter)(out_filter))
+  {
+  }
+
+  void reset_cancellation_state(const Handler& handler)
+  {
+    cancellation_state_ = cancellation_state(
+        boost::asio::get_associated_cancellation_slot(handler));
+  }
+
+  template <typename Filter>
+  void reset_cancellation_state(const Handler& handler, Filter filter)
+  {
+    cancellation_state_ = cancellation_state(
+        boost::asio::get_associated_cancellation_slot(handler), filter, filter);
+  }
+
+  template <typename InFilter, typename OutFilter>
+  void reset_cancellation_state(const Handler& handler,
+      BOOST_ASIO_MOVE_ARG(InFilter) in_filter,
+      BOOST_ASIO_MOVE_ARG(OutFilter) out_filter)
+  {
+    cancellation_state_ = cancellation_state(
+        boost::asio::get_associated_cancellation_slot(handler),
+        BOOST_ASIO_MOVE_CAST(InFilter)(in_filter),
+        BOOST_ASIO_MOVE_CAST(OutFilter)(out_filter));
+  }
+
+  cancellation_type_t cancelled() const BOOST_ASIO_NOEXCEPT
+  {
+    return cancellation_state_.cancelled();
+  }
+
+private:
+  cancellation_state cancellation_state_;
+};
+
+template <typename Handler>
+class base_from_cancellation_state<Handler,
+    typename enable_if<
+      is_same<
+        typename associated_cancellation_slot<
+          Handler, cancellation_slot
+        >::asio_associated_cancellation_slot_is_unspecialised,
+        void
+      >::value
+    >::type>
+{
+public:
+  cancellation_state get_cancellation_state() const BOOST_ASIO_NOEXCEPT
+  {
+    return cancellation_state();
+  }
+
+protected:
+  explicit base_from_cancellation_state(const Handler&)
+  {
+  }
+
+  template <typename Filter>
+  base_from_cancellation_state(const Handler&, Filter)
+  {
+  }
+
+  template <typename InFilter, typename OutFilter>
+  base_from_cancellation_state(const Handler&,
+      BOOST_ASIO_MOVE_ARG(InFilter),
+      BOOST_ASIO_MOVE_ARG(OutFilter))
+  {
+  }
+
+  void reset_cancellation_state(const Handler&)
+  {
+  }
+
+  template <typename Filter>
+  void reset_cancellation_state(const Handler&, Filter)
+  {
+  }
+
+  template <typename InFilter, typename OutFilter>
+  void reset_cancellation_state(const Handler&,
+      BOOST_ASIO_MOVE_ARG(InFilter),
+      BOOST_ASIO_MOVE_ARG(OutFilter))
+  {
+  }
+
+  BOOST_ASIO_CONSTEXPR cancellation_type_t cancelled() const BOOST_ASIO_NOEXCEPT
+  {
+    return cancellation_type::none;
+  }
+};
+
+} // namespace detail
+} // namespace asio
+} // namespace boost
+
+#include <boost/asio/detail/pop_options.hpp>
+
+#endif // BOOST_ASIO_DETAIL_BASE_FROM_CANCELLATION_STATE_HPP

linx64/include/boost/asio/detail/base_from_completion_cond.hpp

@@ -2,7 +2,7 @@
 // detail/base_from_completion_cond.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2019 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2023 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

linx64/include/boost/asio/detail/bind_handler.hpp

@@ -2,7 +2,7 @@
 // detail/bind_handler.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2019 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2023 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -16,8 +16,7 @@
 #endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
 
 #include <boost/asio/detail/config.hpp>
-#include <boost/asio/associated_allocator.hpp>
-#include <boost/asio/associated_executor.hpp>
+#include <boost/asio/associator.hpp>
 #include <boost/asio/detail/handler_alloc_helpers.hpp>
 #include <boost/asio/detail/handler_cont_helpers.hpp>
 #include <boost/asio/detail/handler_invoke_helpers.hpp>
@@ -29,6 +28,113 @@ namespace boost {
 namespace asio {
 namespace detail {
 
+template <typename Handler>
+class binder0
+{
+public:
+  template <typename T>
+  binder0(int, BOOST_ASIO_MOVE_ARG(T) handler)
+    : handler_(BOOST_ASIO_MOVE_CAST(T)(handler))
+  {
+  }
+
+  binder0(Handler& handler)
+    : handler_(BOOST_ASIO_MOVE_CAST(Handler)(handler))
+  {
+  }
+
+#if defined(BOOST_ASIO_HAS_MOVE)
+  binder0(const binder0& other)
+    : handler_(other.handler_)
+  {
+  }
+
+  binder0(binder0&& other)
+    : handler_(BOOST_ASIO_MOVE_CAST(Handler)(other.handler_))
+  {
+  }
+#endif // defined(BOOST_ASIO_HAS_MOVE)
+
+  void operator()()
+  {
+    BOOST_ASIO_MOVE_OR_LVALUE(Handler)(handler_)();
+  }
+
+  void operator()() const
+  {
+    handler_();
+  }
+
+//private:
+  Handler handler_;
+};
+
+template <typename Handler>
+inline asio_handler_allocate_is_deprecated
+asio_handler_allocate(std::size_t size,
+    binder0<Handler>* this_handler)
+{
+#if defined(BOOST_ASIO_NO_DEPRECATED)
+  boost_asio_handler_alloc_helpers::allocate(size, this_handler->handler_);
+  return asio_handler_allocate_is_no_longer_used();
+#else // defined(BOOST_ASIO_NO_DEPRECATED)
+  return boost_asio_handler_alloc_helpers::allocate(
+      size, this_handler->handler_);
+#endif // defined(BOOST_ASIO_NO_DEPRECATED)
+}
+
+template <typename Handler>
+inline asio_handler_deallocate_is_deprecated
+asio_handler_deallocate(void* pointer, std::size_t size,
+    binder0<Handler>* this_handler)
+{
+  boost_asio_handler_alloc_helpers::deallocate(
+      pointer, size, this_handler->handler_);
+#if defined(BOOST_ASIO_NO_DEPRECATED)
+  return asio_handler_deallocate_is_no_longer_used();
+#endif // defined(BOOST_ASIO_NO_DEPRECATED)
+}
+
+template <typename Handler>
+inline bool asio_handler_is_continuation(
+    binder0<Handler>* this_handler)
+{
+  return boost_asio_handler_cont_helpers::is_continuation(
+      this_handler->handler_);
+}
+
+template <typename Function, typename Handler>
+inline asio_handler_invoke_is_deprecated
+asio_handler_invoke(Function& function,
+    binder0<Handler>* this_handler)
+{
+  boost_asio_handler_invoke_helpers::invoke(
+      function, this_handler->handler_);
+#if defined(BOOST_ASIO_NO_DEPRECATED)
+  return asio_handler_invoke_is_no_longer_used();
+#endif // defined(BOOST_ASIO_NO_DEPRECATED)
+}
+
+template <typename Function, typename Handler>
+inline asio_handler_invoke_is_deprecated
+asio_handler_invoke(const Function& function,
+    binder0<Handler>* this_handler)
+{
+  boost_asio_handler_invoke_helpers::invoke(
+      function, this_handler->handler_);
+#if defined(BOOST_ASIO_NO_DEPRECATED)
+  return asio_handler_invoke_is_no_longer_used();
+#endif // defined(BOOST_ASIO_NO_DEPRECATED)
+}
+
+template <typename Handler>
+inline binder0<typename decay<Handler>::type> bind_handler(
+    BOOST_ASIO_MOVE_ARG(Handler) handler)
+{
+  return binder0<typename decay<Handler>::type>(
+      0, BOOST_ASIO_MOVE_CAST(Handler)(handler));
+}
+
 template <typename Handler, typename Arg1>
 class binder1
 {
@@ -62,7 +168,8 @@ public:
 
   void operator()()
   {
-    handler_(static_cast<const Arg1&>(arg1_));
+    BOOST_ASIO_MOVE_OR_LVALUE(Handler)(handler_)(
+        static_cast<const Arg1&>(arg1_));
   }
 
   void operator()() const
@@ -76,19 +183,29 @@ public:
 };
 
 template <typename Handler, typename Arg1>
-inline void* asio_handler_allocate(std::size_t size,
+inline asio_handler_allocate_is_deprecated
+asio_handler_allocate(std::size_t size,
     binder1<Handler, Arg1>* this_handler)
 {
+#if defined(BOOST_ASIO_NO_DEPRECATED)
+  boost_asio_handler_alloc_helpers::allocate(size, this_handler->handler_);
+  return asio_handler_allocate_is_no_longer_used();
+#else // defined(BOOST_ASIO_NO_DEPRECATED)
   return boost_asio_handler_alloc_helpers::allocate(
       size, this_handler->handler_);
+#endif // defined(BOOST_ASIO_NO_DEPRECATED)
 }
 
 template <typename Handler, typename Arg1>
-inline void asio_handler_deallocate(void* pointer, std::size_t size,
+inline asio_handler_deallocate_is_deprecated
+asio_handler_deallocate(void* pointer, std::size_t size,
     binder1<Handler, Arg1>* this_handler)
 {
   boost_asio_handler_alloc_helpers::deallocate(
       pointer, size, this_handler->handler_);
+#if defined(BOOST_ASIO_NO_DEPRECATED)
+  return asio_handler_deallocate_is_no_longer_used();
+#endif // defined(BOOST_ASIO_NO_DEPRECATED)
 }
 
 template <typename Handler, typename Arg1>
@@ -100,19 +217,27 @@ inline bool asio_handler_is_continuation(
 }
 
 template <typename Function, typename Handler, typename Arg1>
-inline void asio_handler_invoke(Function& function,
+inline asio_handler_invoke_is_deprecated
+asio_handler_invoke(Function& function,
     binder1<Handler, Arg1>* this_handler)
 {
   boost_asio_handler_invoke_helpers::invoke(
       function, this_handler->handler_);
+#if defined(BOOST_ASIO_NO_DEPRECATED)
+  return asio_handler_invoke_is_no_longer_used();
+#endif // defined(BOOST_ASIO_NO_DEPRECATED)
 }
 
 template <typename Function, typename Handler, typename Arg1>
-inline void asio_handler_invoke(const Function& function,
+inline asio_handler_invoke_is_deprecated
+asio_handler_invoke(const Function& function,
     binder1<Handler, Arg1>* this_handler)
 {
   boost_asio_handler_invoke_helpers::invoke(
       function, this_handler->handler_);
+#if defined(BOOST_ASIO_NO_DEPRECATED)
+  return asio_handler_invoke_is_no_longer_used();
+#endif // defined(BOOST_ASIO_NO_DEPRECATED)
 }
 
 template <typename Handler, typename Arg1>
@@ -161,7 +286,8 @@ public:
 
   void operator()()
   {
-    handler_(static_cast<const Arg1&>(arg1_),
+    BOOST_ASIO_MOVE_OR_LVALUE(Handler)(handler_)(
+        static_cast<const Arg1&>(arg1_),
         static_cast<const Arg2&>(arg2_));
   }
 
@@ -177,19 +303,29 @@ public:
 };
 
 template <typename Handler, typename Arg1, typename Arg2>
-inline void* asio_handler_allocate(std::size_t size,
+inline asio_handler_allocate_is_deprecated
+asio_handler_allocate(std::size_t size,
     binder2<Handler, Arg1, Arg2>* this_handler)
 {
+#if defined(BOOST_ASIO_NO_DEPRECATED)
+  boost_asio_handler_alloc_helpers::allocate(size, this_handler->handler_);
+  return asio_handler_allocate_is_no_longer_used();
+#else // defined(BOOST_ASIO_NO_DEPRECATED)
   return boost_asio_handler_alloc_helpers::allocate(
       size, this_handler->handler_);
+#endif // defined(BOOST_ASIO_NO_DEPRECATED)
 }
 
 template <typename Handler, typename Arg1, typename Arg2>
-inline void asio_handler_deallocate(void* pointer, std::size_t size,
+inline asio_handler_deallocate_is_deprecated
+asio_handler_deallocate(void* pointer, std::size_t size,
     binder2<Handler, Arg1, Arg2>* this_handler)
 {
   boost_asio_handler_alloc_helpers::deallocate(
       pointer, size, this_handler->handler_);
+#if defined(BOOST_ASIO_NO_DEPRECATED)
+  return asio_handler_deallocate_is_no_longer_used();
+#endif // defined(BOOST_ASIO_NO_DEPRECATED)
 }
 
 template <typename Handler, typename Arg1, typename Arg2>
@@ -201,19 +337,27 @@ inline bool asio_handler_is_continuation(
 }
 
 template <typename Function, typename Handler, typename Arg1, typename Arg2>
-inline void asio_handler_invoke(Function& function,
+inline asio_handler_invoke_is_deprecated
+asio_handler_invoke(Function& function,
     binder2<Handler, Arg1, Arg2>* this_handler)
 {
   boost_asio_handler_invoke_helpers::invoke(
       function, this_handler->handler_);
+#if defined(BOOST_ASIO_NO_DEPRECATED)
+  return asio_handler_invoke_is_no_longer_used();
+#endif // defined(BOOST_ASIO_NO_DEPRECATED)
 }
 
 template <typename Function, typename Handler, typename Arg1, typename Arg2>
-inline void asio_handler_invoke(const Function& function,
+inline asio_handler_invoke_is_deprecated
+asio_handler_invoke(const Function& function,
     binder2<Handler, Arg1, Arg2>* this_handler)
 {
   boost_asio_handler_invoke_helpers::invoke(
       function, this_handler->handler_);
+#if defined(BOOST_ASIO_NO_DEPRECATED)
+  return asio_handler_invoke_is_no_longer_used();
+#endif // defined(BOOST_ASIO_NO_DEPRECATED)
 }
 
 template <typename Handler, typename Arg1, typename Arg2>
@@ -267,8 +411,10 @@ public:
 
   void operator()()
   {
-    handler_(static_cast<const Arg1&>(arg1_),
-        static_cast<const Arg2&>(arg2_), static_cast<const Arg3&>(arg3_));
+    BOOST_ASIO_MOVE_OR_LVALUE(Handler)(handler_)(
+        static_cast<const Arg1&>(arg1_),
+        static_cast<const Arg2&>(arg2_),
+        static_cast<const Arg3&>(arg3_));
   }
 
   void operator()() const
@@ -284,19 +430,29 @@ public:
 };
 
 template <typename Handler, typename Arg1, typename Arg2, typename Arg3>
-inline void* asio_handler_allocate(std::size_t size,
+inline asio_handler_allocate_is_deprecated
+asio_handler_allocate(std::size_t size,
     binder3<Handler, Arg1, Arg2, Arg3>* this_handler)
 {
+#if defined(BOOST_ASIO_NO_DEPRECATED)
+  boost_asio_handler_alloc_helpers::allocate(size, this_handler->handler_);
+  return asio_handler_allocate_is_no_longer_used();
+#else // defined(BOOST_ASIO_NO_DEPRECATED)
   return boost_asio_handler_alloc_helpers::allocate(
       size, this_handler->handler_);
+#endif // defined(BOOST_ASIO_NO_DEPRECATED)
 }
 
 template <typename Handler, typename Arg1, typename Arg2, typename Arg3>
-inline void asio_handler_deallocate(void* pointer, std::size_t size,
+inline asio_handler_deallocate_is_deprecated
+asio_handler_deallocate(void* pointer, std::size_t size,
     binder3<Handler, Arg1, Arg2, Arg3>* this_handler)
 {
   boost_asio_handler_alloc_helpers::deallocate(
       pointer, size, this_handler->handler_);
+#if defined(BOOST_ASIO_NO_DEPRECATED)
+  return asio_handler_deallocate_is_no_longer_used();
+#endif // defined(BOOST_ASIO_NO_DEPRECATED)
 }
 
 template <typename Handler, typename Arg1, typename Arg2, typename Arg3>
@@ -309,20 +465,28 @@ inline bool asio_handler_is_continuation(
 
 template <typename Function, typename Handler,
     typename Arg1, typename Arg2, typename Arg3>
-inline void asio_handler_invoke(Function& function,
+inline asio_handler_invoke_is_deprecated
+asio_handler_invoke(Function& function,
     binder3<Handler, Arg1, Arg2, Arg3>* this_handler)
 {
   boost_asio_handler_invoke_helpers::invoke(
       function, this_handler->handler_);
+#if defined(BOOST_ASIO_NO_DEPRECATED)
+  return asio_handler_invoke_is_no_longer_used();
+#endif // defined(BOOST_ASIO_NO_DEPRECATED)
 }
 
 template <typename Function, typename Handler,
     typename Arg1, typename Arg2, typename Arg3>
-inline void asio_handler_invoke(const Function& function,
+inline asio_handler_invoke_is_deprecated
+asio_handler_invoke(const Function& function,
     binder3<Handler, Arg1, Arg2, Arg3>* this_handler)
 {
   boost_asio_handler_invoke_helpers::invoke(
       function, this_handler->handler_);
+#if defined(BOOST_ASIO_NO_DEPRECATED)
+  return asio_handler_invoke_is_no_longer_used();
+#endif // defined(BOOST_ASIO_NO_DEPRECATED)
 }
 
 template <typename Handler, typename Arg1, typename Arg2, typename Arg3>
@@ -382,8 +546,10 @@ public:
 
   void operator()()
   {
-    handler_(static_cast<const Arg1&>(arg1_),
-        static_cast<const Arg2&>(arg2_), static_cast<const Arg3&>(arg3_),
+    BOOST_ASIO_MOVE_OR_LVALUE(Handler)(handler_)(
+        static_cast<const Arg1&>(arg1_),
+        static_cast<const Arg2&>(arg2_),
+        static_cast<const Arg3&>(arg3_),
         static_cast<const Arg4&>(arg4_));
   }
 
@@ -402,20 +568,30 @@ public:
 
 template <typename Handler, typename Arg1,
     typename Arg2, typename Arg3, typename Arg4>
-inline void* asio_handler_allocate(std::size_t size,
+inline asio_handler_allocate_is_deprecated
+asio_handler_allocate(std::size_t size,
     binder4<Handler, Arg1, Arg2, Arg3, Arg4>* this_handler)
 {
+#if defined(BOOST_ASIO_NO_DEPRECATED)
+  boost_asio_handler_alloc_helpers::allocate(size, this_handler->handler_);
+  return asio_handler_allocate_is_no_longer_used();
+#else // defined(BOOST_ASIO_NO_DEPRECATED)
   return boost_asio_handler_alloc_helpers::allocate(
       size, this_handler->handler_);
+#endif // defined(BOOST_ASIO_NO_DEPRECATED)
 }
 
 template <typename Handler, typename Arg1,
     typename Arg2, typename Arg3, typename Arg4>
-inline void asio_handler_deallocate(void* pointer, std::size_t size,
+inline asio_handler_deallocate_is_deprecated
+asio_handler_deallocate(void* pointer, std::size_t size,
     binder4<Handler, Arg1, Arg2, Arg3, Arg4>* this_handler)
 {
   boost_asio_handler_alloc_helpers::deallocate(
       pointer, size, this_handler->handler_);
+#if defined(BOOST_ASIO_NO_DEPRECATED)
+  return asio_handler_deallocate_is_no_longer_used();
+#endif // defined(BOOST_ASIO_NO_DEPRECATED)
 }
 
 template <typename Handler, typename Arg1,
@@ -429,20 +605,28 @@ inline bool asio_handler_is_continuation(
 
 template <typename Function, typename Handler, typename Arg1,
     typename Arg2, typename Arg3, typename Arg4>
-inline void asio_handler_invoke(Function& function,
+inline asio_handler_invoke_is_deprecated
+asio_handler_invoke(Function& function,
     binder4<Handler, Arg1, Arg2, Arg3, Arg4>* this_handler)
 {
   boost_asio_handler_invoke_helpers::invoke(
       function, this_handler->handler_);
+#if defined(BOOST_ASIO_NO_DEPRECATED)
+  return asio_handler_invoke_is_no_longer_used();
+#endif // defined(BOOST_ASIO_NO_DEPRECATED)
 }
 
 template <typename Function, typename Handler, typename Arg1,
     typename Arg2, typename Arg3, typename Arg4>
-inline void asio_handler_invoke(const Function& function,
+inline asio_handler_invoke_is_deprecated
+asio_handler_invoke(const Function& function,
     binder4<Handler, Arg1, Arg2, Arg3, Arg4>* this_handler)
 {
   boost_asio_handler_invoke_helpers::invoke(
       function, this_handler->handler_);
+#if defined(BOOST_ASIO_NO_DEPRECATED)
+  return asio_handler_invoke_is_no_longer_used();
+#endif // defined(BOOST_ASIO_NO_DEPRECATED)
 }
 
 template <typename Handler, typename Arg1,
@@ -507,9 +691,12 @@ public:
 
   void operator()()
   {
-    handler_(static_cast<const Arg1&>(arg1_),
-        static_cast<const Arg2&>(arg2_), static_cast<const Arg3&>(arg3_),
-        static_cast<const Arg4&>(arg4_), static_cast<const Arg5&>(arg5_));
+    BOOST_ASIO_MOVE_OR_LVALUE(Handler)(handler_)(
+        static_cast<const Arg1&>(arg1_),
+        static_cast<const Arg2&>(arg2_),
+        static_cast<const Arg3&>(arg3_),
+        static_cast<const Arg4&>(arg4_),
+        static_cast<const Arg5&>(arg5_));
   }
 
   void operator()() const
@@ -528,20 +715,30 @@ public:
 
 template <typename Handler, typename Arg1, typename Arg2,
     typename Arg3, typename Arg4, typename Arg5>
-inline void* asio_handler_allocate(std::size_t size,
+inline asio_handler_allocate_is_deprecated
+asio_handler_allocate(std::size_t size,
     binder5<Handler, Arg1, Arg2, Arg3, Arg4, Arg5>* this_handler)
 {
+#if defined(BOOST_ASIO_NO_DEPRECATED)
+  boost_asio_handler_alloc_helpers::allocate(size, this_handler->handler_);
+  return asio_handler_allocate_is_no_longer_used();
+#else // defined(BOOST_ASIO_NO_DEPRECATED)
   return boost_asio_handler_alloc_helpers::allocate(
       size, this_handler->handler_);
+#endif // defined(BOOST_ASIO_NO_DEPRECATED)
 }
 
 template <typename Handler, typename Arg1, typename Arg2,
     typename Arg3, typename Arg4, typename Arg5>
-inline void asio_handler_deallocate(void* pointer, std::size_t size,
+inline asio_handler_deallocate_is_deprecated
+asio_handler_deallocate(void* pointer, std::size_t size,
     binder5<Handler, Arg1, Arg2, Arg3, Arg4, Arg5>* this_handler)
 {
   boost_asio_handler_alloc_helpers::deallocate(
       pointer, size, this_handler->handler_);
+#if defined(BOOST_ASIO_NO_DEPRECATED)
+  return asio_handler_deallocate_is_no_longer_used();
+#endif // defined(BOOST_ASIO_NO_DEPRECATED)
 }
 
 template <typename Handler, typename Arg1, typename Arg2,
@@ -555,20 +752,28 @@ inline bool asio_handler_is_continuation(
 
 template <typename Function, typename Handler, typename Arg1,
     typename Arg2, typename Arg3, typename Arg4, typename Arg5>
-inline void asio_handler_invoke(Function& function,
+inline asio_handler_invoke_is_deprecated
+asio_handler_invoke(Function& function,
     binder5<Handler, Arg1, Arg2, Arg3, Arg4, Arg5>* this_handler)
 {
   boost_asio_handler_invoke_helpers::invoke(
       function, this_handler->handler_);
+#if defined(BOOST_ASIO_NO_DEPRECATED)
+  return asio_handler_invoke_is_no_longer_used();
+#endif // defined(BOOST_ASIO_NO_DEPRECATED)
 }
 
 template <typename Function, typename Handler, typename Arg1,
     typename Arg2, typename Arg3, typename Arg4, typename Arg5>
-inline void asio_handler_invoke(const Function& function,
+inline asio_handler_invoke_is_deprecated
+asio_handler_invoke(const Function& function,
     binder5<Handler, Arg1, Arg2, Arg3, Arg4, Arg5>* this_handler)
 {
   boost_asio_handler_invoke_helpers::invoke(
       function, this_handler->handler_);
+#if defined(BOOST_ASIO_NO_DEPRECATED)
+  return asio_handler_invoke_is_no_longer_used();
+#endif // defined(BOOST_ASIO_NO_DEPRECATED)
 }
 
 template <typename Handler, typename Arg1, typename Arg2,
@@ -602,7 +807,8 @@ public:
 
   void operator()()
   {
-    handler_(BOOST_ASIO_MOVE_CAST(Arg1)(arg1_));
+    BOOST_ASIO_MOVE_OR_LVALUE(Handler)(handler_)(
+        BOOST_ASIO_MOVE_CAST(Arg1)(arg1_));
   }
 
 //private:
@@ -611,19 +817,29 @@ public:
 };
 
 template <typename Handler, typename Arg1>
-inline void* asio_handler_allocate(std::size_t size,
+inline asio_handler_allocate_is_deprecated
+asio_handler_allocate(std::size_t size,
     move_binder1<Handler, Arg1>* this_handler)
 {
+#if defined(BOOST_ASIO_NO_DEPRECATED)
+  boost_asio_handler_alloc_helpers::allocate(size, this_handler->handler_);
+  return asio_handler_allocate_is_no_longer_used();
+#else // defined(BOOST_ASIO_NO_DEPRECATED)
   return boost_asio_handler_alloc_helpers::allocate(
       size, this_handler->handler_);
+#endif // defined(BOOST_ASIO_NO_DEPRECATED)
 }
 
 template <typename Handler, typename Arg1>
-inline void asio_handler_deallocate(void* pointer, std::size_t size,
+inline asio_handler_deallocate_is_deprecated
+asio_handler_deallocate(void* pointer, std::size_t size,
     move_binder1<Handler, Arg1>* this_handler)
 {
   boost_asio_handler_alloc_helpers::deallocate(
       pointer, size, this_handler->handler_);
+#if defined(BOOST_ASIO_NO_DEPRECATED)
+  return asio_handler_deallocate_is_no_longer_used();
+#endif // defined(BOOST_ASIO_NO_DEPRECATED)
 }
 
 template <typename Handler, typename Arg1>
@@ -635,11 +851,15 @@ inline bool asio_handler_is_continuation(
 }
 
 template <typename Function, typename Handler, typename Arg1>
-inline void asio_handler_invoke(BOOST_ASIO_MOVE_ARG(Function) function,
+inline asio_handler_invoke_is_deprecated
+asio_handler_invoke(BOOST_ASIO_MOVE_ARG(Function) function,
     move_binder1<Handler, Arg1>* this_handler)
 {
   boost_asio_handler_invoke_helpers::invoke(
       BOOST_ASIO_MOVE_CAST(Function)(function), this_handler->handler_);
+#if defined(BOOST_ASIO_NO_DEPRECATED)
+  return asio_handler_invoke_is_no_longer_used();
+#endif // defined(BOOST_ASIO_NO_DEPRECATED)
 }
 
 template <typename Handler, typename Arg1, typename Arg2>
@@ -663,7 +883,8 @@ public:
 
   void operator()()
   {
-    handler_(static_cast<const Arg1&>(arg1_),
+    BOOST_ASIO_MOVE_OR_LVALUE(Handler)(handler_)(
+        static_cast<const Arg1&>(arg1_),
         BOOST_ASIO_MOVE_CAST(Arg2)(arg2_));
   }
 
@@ -674,19 +895,29 @@ public:
 };
 
 template <typename Handler, typename Arg1, typename Arg2>
-inline void* asio_handler_allocate(std::size_t size,
+inline asio_handler_allocate_is_deprecated
+asio_handler_allocate(std::size_t size,
     move_binder2<Handler, Arg1, Arg2>* this_handler)
 {
+#if defined(BOOST_ASIO_NO_DEPRECATED)
+  boost_asio_handler_alloc_helpers::allocate(size, this_handler->handler_);
+  return asio_handler_allocate_is_no_longer_used();
+#else // defined(BOOST_ASIO_NO_DEPRECATED)
   return boost_asio_handler_alloc_helpers::allocate(
       size, this_handler->handler_);
+#endif // defined(BOOST_ASIO_NO_DEPRECATED)
 }
 
 template <typename Handler, typename Arg1, typename Arg2>
-inline void asio_handler_deallocate(void* pointer, std::size_t size,
+inline asio_handler_deallocate_is_deprecated
+asio_handler_deallocate(void* pointer, std::size_t size,
     move_binder2<Handler, Arg1, Arg2>* this_handler)
 {
   boost_asio_handler_alloc_helpers::deallocate(
       pointer, size, this_handler->handler_);
+#if defined(BOOST_ASIO_NO_DEPRECATED)
+  return asio_handler_deallocate_is_no_longer_used();
+#endif // defined(BOOST_ASIO_NO_DEPRECATED)
 }
 
 template <typename Handler, typename Arg1, typename Arg2>
@@ -698,113 +929,211 @@ inline bool asio_handler_is_continuation(
 }
 
 template <typename Function, typename Handler, typename Arg1, typename Arg2>
-inline void asio_handler_invoke(BOOST_ASIO_MOVE_ARG(Function) function,
+inline asio_handler_invoke_is_deprecated
+asio_handler_invoke(BOOST_ASIO_MOVE_ARG(Function) function,
     move_binder2<Handler, Arg1, Arg2>* this_handler)
 {
   boost_asio_handler_invoke_helpers::invoke(
       BOOST_ASIO_MOVE_CAST(Function)(function), this_handler->handler_);
+#if defined(BOOST_ASIO_NO_DEPRECATED)
+  return asio_handler_invoke_is_no_longer_used();
+#endif // defined(BOOST_ASIO_NO_DEPRECATED)
 }
 
 #endif // defined(BOOST_ASIO_HAS_MOVE)
 
 } // namespace detail
 
-template <typename Handler, typename Arg1, typename Allocator>
-struct associated_allocator<detail::binder1<Handler, Arg1>, Allocator>
+template <template <typename, typename> class Associator,
+    typename Handler, typename DefaultCandidate>
+struct associator<Associator,
+    detail::binder0<Handler>, DefaultCandidate>
+  : Associator<Handler, DefaultCandidate>
 {
-  typedef typename associated_allocator<Handler, Allocator>::type type;
-
-  static type get(const detail::binder1<Handler, Arg1>& h,
-      const Allocator& a = Allocator()) BOOST_ASIO_NOEXCEPT
+  static typename Associator<Handler, DefaultCandidate>::type
+  get(const detail::binder0<Handler>& h) BOOST_ASIO_NOEXCEPT
   {
-    return associated_allocator<Handler, Allocator>::get(h.handler_, a);
+    return Associator<Handler, DefaultCandidate>::get(h.handler_);
+  }
+
+  static BOOST_ASIO_AUTO_RETURN_TYPE_PREFIX2(
+      typename Associator<Handler, DefaultCandidate>::type)
+  get(const detail::binder0<Handler>& h,
+      const DefaultCandidate& c) BOOST_ASIO_NOEXCEPT
+    BOOST_ASIO_AUTO_RETURN_TYPE_SUFFIX((
+      Associator<Handler, DefaultCandidate>::get(h.handler_, c)))
+  {
+    return Associator<Handler, DefaultCandidate>::get(h.handler_, c);
   }
 };
 
-template <typename Handler, typename Arg1, typename Arg2, typename Allocator>
-struct associated_allocator<detail::binder2<Handler, Arg1, Arg2>, Allocator>
+template <template <typename, typename> class Associator,
+    typename Handler, typename Arg1, typename DefaultCandidate>
+struct associator<Associator,
+    detail::binder1<Handler, Arg1>, DefaultCandidate>
+  : Associator<Handler, DefaultCandidate>
 {
-  typedef typename associated_allocator<Handler, Allocator>::type type;
-
-  static type get(const detail::binder2<Handler, Arg1, Arg2>& h,
-      const Allocator& a = Allocator()) BOOST_ASIO_NOEXCEPT
+  static typename Associator<Handler, DefaultCandidate>::type
+  get(const detail::binder1<Handler, Arg1>& h) BOOST_ASIO_NOEXCEPT
   {
-    return associated_allocator<Handler, Allocator>::get(h.handler_, a);
+    return Associator<Handler, DefaultCandidate>::get(h.handler_);
+  }
+
+  static BOOST_ASIO_AUTO_RETURN_TYPE_PREFIX2(
+      typename Associator<Handler, DefaultCandidate>::type)
+  get(const detail::binder1<Handler, Arg1>& h,
+      const DefaultCandidate& c) BOOST_ASIO_NOEXCEPT
+    BOOST_ASIO_AUTO_RETURN_TYPE_SUFFIX((
+      Associator<Handler, DefaultCandidate>::get(h.handler_, c)))
+  {
+    return Associator<Handler, DefaultCandidate>::get(h.handler_, c);
   }
 };
 
-template <typename Handler, typename Arg1, typename Executor>
-struct associated_executor<detail::binder1<Handler, Arg1>, Executor>
+template <template <typename, typename> class Associator,
+    typename Handler, typename Arg1, typename Arg2,
+    typename DefaultCandidate>
+struct associator<Associator,
+    detail::binder2<Handler, Arg1, Arg2>, DefaultCandidate>
+  : Associator<Handler, DefaultCandidate>
 {
-  typedef typename associated_executor<Handler, Executor>::type type;
-
-  static type get(const detail::binder1<Handler, Arg1>& h,
-      const Executor& ex = Executor()) BOOST_ASIO_NOEXCEPT
+  static typename Associator<Handler, DefaultCandidate>::type
+  get(const detail::binder2<Handler, Arg1, Arg2>& h) BOOST_ASIO_NOEXCEPT
   {
-    return associated_executor<Handler, Executor>::get(h.handler_, ex);
+    return Associator<Handler, DefaultCandidate>::get(h.handler_);
+  }
+
+  static BOOST_ASIO_AUTO_RETURN_TYPE_PREFIX2(
+      typename Associator<Handler, DefaultCandidate>::type)
+  get(const detail::binder2<Handler, Arg1, Arg2>& h,
+      const DefaultCandidate& c) BOOST_ASIO_NOEXCEPT
+    BOOST_ASIO_AUTO_RETURN_TYPE_SUFFIX((
+      Associator<Handler, DefaultCandidate>::get(h.handler_, c)))
+  {
+    return Associator<Handler, DefaultCandidate>::get(h.handler_, c);
   }
 };
 
-template <typename Handler, typename Arg1, typename Arg2, typename Executor>
-struct associated_executor<detail::binder2<Handler, Arg1, Arg2>, Executor>
+template <template <typename, typename> class Associator,
+    typename Handler, typename Arg1, typename Arg2, typename Arg3,
+    typename DefaultCandidate>
+struct associator<Associator,
+    detail::binder3<Handler, Arg1, Arg2, Arg3>, DefaultCandidate>
+  : Associator<Handler, DefaultCandidate>
 {
-  typedef typename associated_executor<Handler, Executor>::type type;
-
-  static type get(const detail::binder2<Handler, Arg1, Arg2>& h,
-      const Executor& ex = Executor()) BOOST_ASIO_NOEXCEPT
+  static typename Associator<Handler, DefaultCandidate>::type
+  get(const detail::binder3<Handler, Arg1, Arg2, Arg3>& h) BOOST_ASIO_NOEXCEPT
   {
-    return associated_executor<Handler, Executor>::get(h.handler_, ex);
+    return Associator<Handler, DefaultCandidate>::get(h.handler_);
+  }
+
+  static BOOST_ASIO_AUTO_RETURN_TYPE_PREFIX2(
+      typename Associator<Handler, DefaultCandidate>::type)
+  get(const detail::binder3<Handler, Arg1, Arg2, Arg3>& h,
+      const DefaultCandidate& c) BOOST_ASIO_NOEXCEPT
+    BOOST_ASIO_AUTO_RETURN_TYPE_SUFFIX((
+      Associator<Handler, DefaultCandidate>::get(h.handler_, c)))
+  {
+    return Associator<Handler, DefaultCandidate>::get(h.handler_, c);
+  }
+};
+
+template <template <typename, typename> class Associator,
+    typename Handler, typename Arg1, typename Arg2, typename Arg3,
+    typename Arg4, typename DefaultCandidate>
+struct associator<Associator,
+    detail::binder4<Handler, Arg1, Arg2, Arg3, Arg4>, DefaultCandidate>
+  : Associator<Handler, DefaultCandidate>
+{
+  static typename Associator<Handler, DefaultCandidate>::type
+  get(const detail::binder4<Handler, Arg1, Arg2, Arg3, Arg4>& h)
+    BOOST_ASIO_NOEXCEPT
+  {
+    return Associator<Handler, DefaultCandidate>::get(h.handler_);
+  }
+
+  static BOOST_ASIO_AUTO_RETURN_TYPE_PREFIX2(
+      typename Associator<Handler, DefaultCandidate>::type)
+  get(const detail::binder4<Handler, Arg1, Arg2, Arg3, Arg4>& h,
+      const DefaultCandidate& c) BOOST_ASIO_NOEXCEPT
+    BOOST_ASIO_AUTO_RETURN_TYPE_SUFFIX((
+      Associator<Handler, DefaultCandidate>::get(h.handler_, c)))
+  {
+    return Associator<Handler, DefaultCandidate>::get(h.handler_, c);
+  }
+};
+
+template <template <typename, typename> class Associator,
+    typename Handler, typename Arg1, typename Arg2, typename Arg3,
+    typename Arg4, typename Arg5, typename DefaultCandidate>
+struct associator<Associator,
+    detail::binder5<Handler, Arg1, Arg2, Arg3, Arg4, Arg5>, DefaultCandidate>
+  : Associator<Handler, DefaultCandidate>
+{
+  static typename Associator<Handler, DefaultCandidate>::type
+  get(const detail::binder5<Handler, Arg1, Arg2, Arg3, Arg4, Arg5>& h)
+    BOOST_ASIO_NOEXCEPT
+  {
+    return Associator<Handler, DefaultCandidate>::get(h.handler_);
+  }
+
+  static BOOST_ASIO_AUTO_RETURN_TYPE_PREFIX2(
+      typename Associator<Handler, DefaultCandidate>::type)
+  get(const detail::binder5<Handler, Arg1, Arg2, Arg3, Arg4, Arg5>& h,
+      const DefaultCandidate& c) BOOST_ASIO_NOEXCEPT
+    BOOST_ASIO_AUTO_RETURN_TYPE_SUFFIX((
+      Associator<Handler, DefaultCandidate>::get(h.handler_, c)))
+  {
+    return Associator<Handler, DefaultCandidate>::get(h.handler_, c);
   }
 };
 
 #if defined(BOOST_ASIO_HAS_MOVE)
 
-template <typename Handler, typename Arg1, typename Allocator>
-struct associated_allocator<detail::move_binder1<Handler, Arg1>, Allocator>
+template <template <typename, typename> class Associator,
+    typename Handler, typename Arg1, typename DefaultCandidate>
+struct associator<Associator,
+    detail::move_binder1<Handler, Arg1>, DefaultCandidate>
+  : Associator<Handler, DefaultCandidate>
 {
-  typedef typename associated_allocator<Handler, Allocator>::type type;
-
-  static type get(const detail::move_binder1<Handler, Arg1>& h,
-      const Allocator& a = Allocator()) BOOST_ASIO_NOEXCEPT
+  static typename Associator<Handler, DefaultCandidate>::type
+  get(const detail::move_binder1<Handler, Arg1>& h) BOOST_ASIO_NOEXCEPT
   {
-    return associated_allocator<Handler, Allocator>::get(h.handler_, a);
+    return Associator<Handler, DefaultCandidate>::get(h.handler_);
+  }
+
+  static BOOST_ASIO_AUTO_RETURN_TYPE_PREFIX2(
+      typename Associator<Handler, DefaultCandidate>::type)
+  get(const detail::move_binder1<Handler, Arg1>& h,
+      const DefaultCandidate& c) BOOST_ASIO_NOEXCEPT
+    BOOST_ASIO_AUTO_RETURN_TYPE_SUFFIX((
+      Associator<Handler, DefaultCandidate>::get(h.handler_, c)))
+  {
+    return Associator<Handler, DefaultCandidate>::get(h.handler_, c);
   }
 };
 
-template <typename Handler, typename Arg1, typename Arg2, typename Allocator>
-struct associated_allocator<
-    detail::move_binder2<Handler, Arg1, Arg2>, Allocator>
+template <template <typename, typename> class Associator,
+    typename Handler, typename Arg1, typename Arg2,
+    typename DefaultCandidate>
+struct associator<Associator,
+    detail::move_binder2<Handler, Arg1, Arg2>, DefaultCandidate>
+  : Associator<Handler, DefaultCandidate>
 {
-  typedef typename associated_allocator<Handler, Allocator>::type type;
-
-  static type get(const detail::move_binder2<Handler, Arg1, Arg2>& h,
-      const Allocator& a = Allocator()) BOOST_ASIO_NOEXCEPT
+  static typename Associator<Handler, DefaultCandidate>::type
+  get(const detail::move_binder2<Handler, Arg1, Arg2>& h) BOOST_ASIO_NOEXCEPT
   {
-    return associated_allocator<Handler, Allocator>::get(h.handler_, a);
+    return Associator<Handler, DefaultCandidate>::get(h.handler_);
   }
-};
 
-template <typename Handler, typename Arg1, typename Executor>
-struct associated_executor<detail::move_binder1<Handler, Arg1>, Executor>
-{
-  typedef typename associated_executor<Handler, Executor>::type type;
-
-  static type get(const detail::move_binder1<Handler, Arg1>& h,
-      const Executor& ex = Executor()) BOOST_ASIO_NOEXCEPT
+  static BOOST_ASIO_AUTO_RETURN_TYPE_PREFIX2(
+      typename Associator<Handler, DefaultCandidate>::type)
+  get(const detail::move_binder2<Handler, Arg1, Arg2>& h,
+      const DefaultCandidate& c) BOOST_ASIO_NOEXCEPT
+    BOOST_ASIO_AUTO_RETURN_TYPE_SUFFIX((
+      Associator<Handler, DefaultCandidate>::get(h.handler_, c)))
   {
-    return associated_executor<Handler, Executor>::get(h.handler_, ex);
-  }
-};
-
-template <typename Handler, typename Arg1, typename Arg2, typename Executor>
-struct associated_executor<detail::move_binder2<Handler, Arg1, Arg2>, Executor>
-{
-  typedef typename associated_executor<Handler, Executor>::type type;
-
-  static type get(const detail::move_binder2<Handler, Arg1, Arg2>& h,
-      const Executor& ex = Executor()) BOOST_ASIO_NOEXCEPT
-  {
-    return associated_executor<Handler, Executor>::get(h.handler_, ex);
+    return Associator<Handler, DefaultCandidate>::get(h.handler_, c);
   }
 };
 

linx64/include/boost/asio/detail/blocking_executor_op.hpp

@@ -0,0 +1,110 @@
+//
+// detail/blocking_executor_op.hpp
+// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2023 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef BOOST_ASIO_DETAIL_BLOCKING_EXECUTOR_OP_HPP
+#define BOOST_ASIO_DETAIL_BLOCKING_EXECUTOR_OP_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include <boost/asio/detail/config.hpp>
+#include <boost/asio/detail/event.hpp>
+#include <boost/asio/detail/fenced_block.hpp>
+#include <boost/asio/detail/handler_invoke_helpers.hpp>
+#include <boost/asio/detail/mutex.hpp>
+#include <boost/asio/detail/scheduler_operation.hpp>
+
+#include <boost/asio/detail/push_options.hpp>
+
+namespace boost {
+namespace asio {
+namespace detail {
+
+template <typename Operation = scheduler_operation>
+class blocking_executor_op_base : public Operation
+{
+public:
+  blocking_executor_op_base(typename Operation::func_type complete_func)
+    : Operation(complete_func),
+      is_complete_(false)
+  {
+  }
+
+  void wait()
+  {
+    boost::asio::detail::mutex::scoped_lock lock(mutex_);
+    while (!is_complete_)
+      event_.wait(lock);
+  }
+
+protected:
+  struct do_complete_cleanup
+  {
+    ~do_complete_cleanup()
+    {
+      boost::asio::detail::mutex::scoped_lock lock(op_->mutex_);
+      op_->is_complete_ = true;
+      op_->event_.unlock_and_signal_one_for_destruction(lock);
+    }
+
+    blocking_executor_op_base* op_;
+  };
+
+private:
+  boost::asio::detail::mutex mutex_;
+  boost::asio::detail::event event_;
+  bool is_complete_;
+};
+
+template <typename Handler, typename Operation = scheduler_operation>
+class blocking_executor_op : public blocking_executor_op_base<Operation>
+{
+public:
+  blocking_executor_op(Handler& h)
+    : blocking_executor_op_base<Operation>(&blocking_executor_op::do_complete),
+      handler_(h)
+  {
+  }
+
+  static void do_complete(void* owner, Operation* base,
+      const boost::system::error_code& /*ec*/,
+      std::size_t /*bytes_transferred*/)
+  {
+    BOOST_ASIO_ASSUME(base != 0);
+    blocking_executor_op* o(static_cast<blocking_executor_op*>(base));
+
+    typename blocking_executor_op_base<Operation>::do_complete_cleanup
+      on_exit = { o };
+    (void)on_exit;
+
+    BOOST_ASIO_HANDLER_COMPLETION((*o));
+
+    // Make the upcall if required.
+    if (owner)
+    {
+      fenced_block b(fenced_block::half);
+      BOOST_ASIO_HANDLER_INVOCATION_BEGIN(());
+      boost_asio_handler_invoke_helpers::invoke(o->handler_, o->handler_);
+      BOOST_ASIO_HANDLER_INVOCATION_END;
+    }
+  }
+
+private:
+  Handler& handler_;
+};
+
+} // namespace detail
+} // namespace asio
+} // namespace boost
+
+#include <boost/asio/detail/pop_options.hpp>
+
+#endif // BOOST_ASIO_DETAIL_BLOCKING_EXECUTOR_OP_HPP

linx64/include/boost/asio/detail/buffer_resize_guard.hpp

@@ -2,7 +2,7 @@
 // detail/buffer_resize_guard.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2019 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2023 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

linx64/include/boost/asio/detail/buffer_sequence_adapter.hpp

@@ -2,7 +2,7 @@
 // detail/buffer_sequence_adapter.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2019 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2023 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -19,6 +19,7 @@
 #include <boost/asio/buffer.hpp>
 #include <boost/asio/detail/array_fwd.hpp>
 #include <boost/asio/detail/socket_types.hpp>
+#include <boost/asio/registered_buffer.hpp>
 
 #include <boost/asio/detail/push_options.hpp>
 
@@ -105,6 +106,9 @@ class buffer_sequence_adapter
   : buffer_sequence_adapter_base
 {
 public:
+  enum { is_single_buffer = false };
+  enum { is_registered_buffer = false };
+
   explicit buffer_sequence_adapter(const Buffers& buffer_sequence)
     : count_(0), total_buffer_size_(0)
   {
@@ -128,6 +132,11 @@ public:
     return total_buffer_size_;
   }
 
+  registered_buffer_id registered_id() const
+  {
+    return registered_buffer_id();
+  }
+
   bool all_empty() const
   {
     return total_buffer_size_ == 0;
@@ -154,6 +163,16 @@ public:
         boost::asio::buffer_sequence_end(buffer_sequence));
   }
 
+  enum { linearisation_storage_size = 8192 };
+
+  static Buffer linearise(const Buffers& buffer_sequence,
+      const boost::asio::mutable_buffer& storage)
+  {
+    return buffer_sequence_adapter::linearise(
+        boost::asio::buffer_sequence_begin(buffer_sequence),
+        boost::asio::buffer_sequence_end(buffer_sequence), storage);
+  }
+
 private:
   template <typename Iterator>
   void init(Iterator begin, Iterator end)
@@ -202,6 +221,30 @@ private:
     return Buffer();
   }
 
+  template <typename Iterator>
+  static Buffer linearise(Iterator begin, Iterator end,
+      const boost::asio::mutable_buffer& storage)
+  {
+    boost::asio::mutable_buffer unused_storage = storage;
+    Iterator iter = begin;
+    while (iter != end && unused_storage.size() != 0)
+    {
+      Buffer buffer(*iter);
+      ++iter;
+      if (buffer.size() == 0)
+        continue;
+      if (unused_storage.size() == storage.size())
+      {
+        if (iter == end)
+          return buffer;
+        if (buffer.size() >= unused_storage.size())
+          return buffer;
+      }
+      unused_storage += boost::asio::buffer_copy(unused_storage, buffer);
+    }
+    return Buffer(storage.data(), storage.size() - unused_storage.size());
+  }
+
   native_buffer_type buffers_[max_buffers];
   std::size_t count_;
   std::size_t total_buffer_size_;
@@ -212,6 +255,9 @@ class buffer_sequence_adapter<Buffer, boost::asio::mutable_buffer>
   : buffer_sequence_adapter_base
 {
 public:
+  enum { is_single_buffer = true };
+  enum { is_registered_buffer = false };
+
   explicit buffer_sequence_adapter(
       const boost::asio::mutable_buffer& buffer_sequence)
   {
@@ -234,6 +280,11 @@ public:
     return total_buffer_size_;
   }
 
+  registered_buffer_id registered_id() const
+  {
+    return registered_buffer_id();
+  }
+
   bool all_empty() const
   {
     return total_buffer_size_ == 0;
@@ -254,6 +305,14 @@ public:
     return Buffer(buffer_sequence);
   }
 
+  enum { linearisation_storage_size = 1 };
+
+  static Buffer linearise(const boost::asio::mutable_buffer& buffer_sequence,
+      const Buffer&)
+  {
+    return Buffer(buffer_sequence);
+  }
+
 private:
   native_buffer_type buffer_;
   std::size_t total_buffer_size_;
@@ -264,6 +323,9 @@ class buffer_sequence_adapter<Buffer, boost::asio::const_buffer>
   : buffer_sequence_adapter_base
 {
 public:
+  enum { is_single_buffer = true };
+  enum { is_registered_buffer = false };
+
   explicit buffer_sequence_adapter(
       const boost::asio::const_buffer& buffer_sequence)
   {
@@ -286,6 +348,11 @@ public:
     return total_buffer_size_;
   }
 
+  registered_buffer_id registered_id() const
+  {
+    return registered_buffer_id();
+  }
+
   bool all_empty() const
   {
     return total_buffer_size_ == 0;
@@ -306,6 +373,14 @@ public:
     return Buffer(buffer_sequence);
   }
 
+  enum { linearisation_storage_size = 1 };
+
+  static Buffer linearise(const boost::asio::const_buffer& buffer_sequence,
+      const Buffer&)
+  {
+    return Buffer(buffer_sequence);
+  }
+
 private:
   native_buffer_type buffer_;
   std::size_t total_buffer_size_;
@@ -318,6 +393,9 @@ class buffer_sequence_adapter<Buffer, boost::asio::mutable_buffers_1>
   : buffer_sequence_adapter_base
 {
 public:
+  enum { is_single_buffer = true };
+  enum { is_registered_buffer = false };
+
   explicit buffer_sequence_adapter(
       const boost::asio::mutable_buffers_1& buffer_sequence)
   {
@@ -340,6 +418,11 @@ public:
     return total_buffer_size_;
   }
 
+  registered_buffer_id registered_id() const
+  {
+    return registered_buffer_id();
+  }
+
   bool all_empty() const
   {
     return total_buffer_size_ == 0;
@@ -360,6 +443,14 @@ public:
     return Buffer(buffer_sequence);
   }
 
+  enum { linearisation_storage_size = 1 };
+
+  static Buffer linearise(const boost::asio::mutable_buffers_1& buffer_sequence,
+      const Buffer&)
+  {
+    return Buffer(buffer_sequence);
+  }
+
 private:
   native_buffer_type buffer_;
   std::size_t total_buffer_size_;
@@ -370,6 +461,9 @@ class buffer_sequence_adapter<Buffer, boost::asio::const_buffers_1>
   : buffer_sequence_adapter_base
 {
 public:
+  enum { is_single_buffer = true };
+  enum { is_registered_buffer = false };
+
   explicit buffer_sequence_adapter(
       const boost::asio::const_buffers_1& buffer_sequence)
   {
@@ -392,6 +486,11 @@ public:
     return total_buffer_size_;
   }
 
+  registered_buffer_id registered_id() const
+  {
+    return registered_buffer_id();
+  }
+
   bool all_empty() const
   {
     return total_buffer_size_ == 0;
@@ -412,6 +511,14 @@ public:
     return Buffer(buffer_sequence);
   }
 
+  enum { linearisation_storage_size = 1 };
+
+  static Buffer linearise(const boost::asio::const_buffers_1& buffer_sequence,
+      const Buffer&)
+  {
+    return Buffer(buffer_sequence);
+  }
+
 private:
   native_buffer_type buffer_;
   std::size_t total_buffer_size_;
@@ -419,11 +526,162 @@ private:
 
 #endif // !defined(BOOST_ASIO_NO_DEPRECATED)
 
+template <typename Buffer>
+class buffer_sequence_adapter<Buffer, boost::asio::mutable_registered_buffer>
+  : buffer_sequence_adapter_base
+{
+public:
+  enum { is_single_buffer = true };
+  enum { is_registered_buffer = true };
+
+  explicit buffer_sequence_adapter(
+      const boost::asio::mutable_registered_buffer& buffer_sequence)
+  {
+    init_native_buffer(buffer_, buffer_sequence.buffer());
+    total_buffer_size_ = buffer_sequence.size();
+    registered_id_ = buffer_sequence.id();
+  }
+
+  native_buffer_type* buffers()
+  {
+    return &buffer_;
+  }
+
+  std::size_t count() const
+  {
+    return 1;
+  }
+
+  std::size_t total_size() const
+  {
+    return total_buffer_size_;
+  }
+
+  registered_buffer_id registered_id() const
+  {
+    return registered_id_;
+  }
+
+  bool all_empty() const
+  {
+    return total_buffer_size_ == 0;
+  }
+
+  static bool all_empty(
+      const boost::asio::mutable_registered_buffer& buffer_sequence)
+  {
+    return buffer_sequence.size() == 0;
+  }
+
+  static void validate(
+      const boost::asio::mutable_registered_buffer& buffer_sequence)
+  {
+    buffer_sequence.data();
+  }
+
+  static Buffer first(
+      const boost::asio::mutable_registered_buffer& buffer_sequence)
+  {
+    return Buffer(buffer_sequence.buffer());
+  }
+
+  enum { linearisation_storage_size = 1 };
+
+  static Buffer linearise(
+      const boost::asio::mutable_registered_buffer& buffer_sequence,
+      const Buffer&)
+  {
+    return Buffer(buffer_sequence.buffer());
+  }
+
+private:
+  native_buffer_type buffer_;
+  std::size_t total_buffer_size_;
+  registered_buffer_id registered_id_;
+};
+
+template <typename Buffer>
+class buffer_sequence_adapter<Buffer, boost::asio::const_registered_buffer>
+  : buffer_sequence_adapter_base
+{
+public:
+  enum { is_single_buffer = true };
+  enum { is_registered_buffer = true };
+
+  explicit buffer_sequence_adapter(
+      const boost::asio::const_registered_buffer& buffer_sequence)
+  {
+    init_native_buffer(buffer_, buffer_sequence.buffer());
+    total_buffer_size_ = buffer_sequence.size();
+    registered_id_ = buffer_sequence.id();
+  }
+
+  native_buffer_type* buffers()
+  {
+    return &buffer_;
+  }
+
+  std::size_t count() const
+  {
+    return 1;
+  }
+
+  std::size_t total_size() const
+  {
+    return total_buffer_size_;
+  }
+
+  registered_buffer_id registered_id() const
+  {
+    return registered_id_;
+  }
+
+  bool all_empty() const
+  {
+    return total_buffer_size_ == 0;
+  }
+
+  static bool all_empty(
+      const boost::asio::const_registered_buffer& buffer_sequence)
+  {
+    return buffer_sequence.size() == 0;
+  }
+
+  static void validate(
+      const boost::asio::const_registered_buffer& buffer_sequence)
+  {
+    buffer_sequence.data();
+  }
+
+  static Buffer first(
+      const boost::asio::const_registered_buffer& buffer_sequence)
+  {
+    return Buffer(buffer_sequence.buffer());
+  }
+
+  enum { linearisation_storage_size = 1 };
+
+  static Buffer linearise(
+      const boost::asio::const_registered_buffer& buffer_sequence,
+      const Buffer&)
+  {
+    return Buffer(buffer_sequence.buffer());
+  }
+
+private:
+  native_buffer_type buffer_;
+  std::size_t total_buffer_size_;
+  registered_buffer_id registered_id_;
+};
+
 template <typename Buffer, typename Elem>
 class buffer_sequence_adapter<Buffer, boost::array<Elem, 2> >
   : buffer_sequence_adapter_base
 {
 public:
+  enum { is_single_buffer = false };
+  enum { is_registered_buffer = false };
+
   explicit buffer_sequence_adapter(
       const boost::array<Elem, 2>& buffer_sequence)
   {
@@ -447,6 +705,11 @@ public:
     return total_buffer_size_;
   }
 
+  registered_buffer_id registered_id() const
+  {
+    return registered_buffer_id();
+  }
+
   bool all_empty() const
   {
     return total_buffer_size_ == 0;
@@ -469,6 +732,19 @@ public:
         ? buffer_sequence[0] : buffer_sequence[1]);
   }
 
+  enum { linearisation_storage_size = 8192 };
+
+  static Buffer linearise(const boost::array<Elem, 2>& buffer_sequence,
+      const boost::asio::mutable_buffer& storage)
+  {
+    if (buffer_sequence[0].size() == 0)
+      return Buffer(buffer_sequence[1]);
+    if (buffer_sequence[1].size() == 0)
+      return Buffer(buffer_sequence[0]);
+    return Buffer(storage.data(),
+        boost::asio::buffer_copy(storage, buffer_sequence));
+  }
+
 private:
   native_buffer_type buffers_[2];
   std::size_t total_buffer_size_;
@@ -481,6 +757,9 @@ class buffer_sequence_adapter<Buffer, std::array<Elem, 2> >
   : buffer_sequence_adapter_base
 {
 public:
+  enum { is_single_buffer = false };
+  enum { is_registered_buffer = false };
+
   explicit buffer_sequence_adapter(
       const std::array<Elem, 2>& buffer_sequence)
   {
@@ -504,6 +783,11 @@ public:
     return total_buffer_size_;
   }
 
+  registered_buffer_id registered_id() const
+  {
+    return registered_buffer_id();
+  }
+
   bool all_empty() const
   {
     return total_buffer_size_ == 0;
@@ -526,6 +810,19 @@ public:
         ? buffer_sequence[0] : buffer_sequence[1]);
   }
 
+  enum { linearisation_storage_size = 8192 };
+
+  static Buffer linearise(const std::array<Elem, 2>& buffer_sequence,
+      const boost::asio::mutable_buffer& storage)
+  {
+    if (buffer_sequence[0].size() == 0)
+      return Buffer(buffer_sequence[1]);
+    if (buffer_sequence[1].size() == 0)
+      return Buffer(buffer_sequence[0]);
+    return Buffer(storage.data(),
+        boost::asio::buffer_copy(storage, buffer_sequence));
+  }
+
 private:
   native_buffer_type buffers_[2];
   std::size_t total_buffer_size_;

linx64/include/boost/asio/detail/buffered_stream_storage.hpp

@@ -2,7 +2,7 @@
 // detail/buffered_stream_storage.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2019 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2023 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

linx64/include/boost/asio/detail/bulk_executor_op.hpp

@@ -0,0 +1,91 @@
+//
+// detail/bulk_executor_op.hpp
+// ~~~~~~~~~~~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2023 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef BOOST_ASIO_DETAIL_BULK_EXECUTOR_OP_HPP
+#define BOOST_ASIO_DETAIL_BULK_EXECUTOR_OP_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include <boost/asio/detail/config.hpp>
+#include <boost/asio/detail/bind_handler.hpp>
+#include <boost/asio/detail/fenced_block.hpp>
+#include <boost/asio/detail/handler_alloc_helpers.hpp>
+#include <boost/asio/detail/handler_invoke_helpers.hpp>
+#include <boost/asio/detail/scheduler_operation.hpp>
+
+#include <boost/asio/detail/push_options.hpp>
+
+namespace boost {
+namespace asio {
+namespace detail {
+
+template <typename Handler, typename Alloc,
+    typename Operation = scheduler_operation>
+class bulk_executor_op : public Operation
+{
+public:
+  BOOST_ASIO_DEFINE_HANDLER_ALLOCATOR_PTR(bulk_executor_op);
+
+  template <typename H>
+  bulk_executor_op(BOOST_ASIO_MOVE_ARG(H) h,
+      const Alloc& allocator, std::size_t i)
+    : Operation(&bulk_executor_op::do_complete),
+      handler_(BOOST_ASIO_MOVE_CAST(H)(h)),
+      allocator_(allocator),
+      index_(i)
+  {
+  }
+
+  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.
+    BOOST_ASIO_ASSUME(base != 0);
+    bulk_executor_op* o(static_cast<bulk_executor_op*>(base));
+    Alloc allocator(o->allocator_);
+    ptr p = { detail::addressof(allocator), 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::binder1<Handler, std::size_t> handler(o->handler_, o->index_);
+    p.reset();
+
+    // Make the upcall if required.
+    if (owner)
+    {
+      fenced_block b(fenced_block::half);
+      BOOST_ASIO_HANDLER_INVOCATION_BEGIN(());
+      boost_asio_handler_invoke_helpers::invoke(handler, handler.handler_);
+      BOOST_ASIO_HANDLER_INVOCATION_END;
+    }
+  }
+
+private:
+  Handler handler_;
+  Alloc allocator_;
+  std::size_t index_;
+};
+
+} // namespace detail
+} // namespace asio
+} // namespace boost
+
+#include <boost/asio/detail/pop_options.hpp>
+
+#endif // BOOST_ASIO_DETAIL_BULK_EXECUTOR_OP_HPP

linx64/include/boost/asio/detail/call_stack.hpp

@@ -2,7 +2,7 @@
 // detail/call_stack.hpp
 // ~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2019 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2023 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

linx64/include/boost/asio/detail/chrono.hpp

@@ -2,7 +2,7 @@
 // detail/chrono.hpp
 // ~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2019 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2023 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

linx64/include/boost/asio/detail/chrono_time_traits.hpp

@@ -2,7 +2,7 @@
 // detail/chrono_time_traits.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2019 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2023 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

linx64/include/boost/asio/detail/completion_handler.hpp

@@ -2,7 +2,7 @@
 // detail/completion_handler.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2019 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2023 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -28,17 +28,17 @@ namespace boost {
 namespace asio {
 namespace detail {
 
-template <typename Handler>
+template <typename Handler, typename IoExecutor>
 class completion_handler : public operation
 {
 public:
   BOOST_ASIO_DEFINE_HANDLER_PTR(completion_handler);
 
-  completion_handler(Handler& h)
+  completion_handler(Handler& h, const IoExecutor& io_ex)
     : operation(&completion_handler::do_complete),
-      handler_(BOOST_ASIO_MOVE_CAST(Handler)(h))
+      handler_(BOOST_ASIO_MOVE_CAST(Handler)(h)),
+      work_(handler_, io_ex)
   {
-    handler_work<Handler>::start(handler_);
   }
 
   static void do_complete(void* owner, operation* base,
@@ -48,10 +48,14 @@ public:
     // Take ownership of the handler object.
     completion_handler* h(static_cast<completion_handler*>(base));
     ptr p = { boost::asio::detail::addressof(h->handler_), h, h };
-    handler_work<Handler> w(h->handler_);
 
     BOOST_ASIO_HANDLER_COMPLETION((*h));
 
+    // Take ownership of the operation's outstanding work.
+    handler_work<Handler, IoExecutor> w(
+        BOOST_ASIO_MOVE_CAST2(handler_work<Handler, IoExecutor>)(
+          h->work_));
+
     // 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
@@ -74,6 +78,7 @@ public:
 
 private:
   Handler handler_;
+  handler_work<Handler, IoExecutor> work_;
 };
 
 } // namespace detail

linx64/include/boost/asio/detail/composed_work.hpp

@@ -0,0 +1,330 @@
+//
+// detail/composed_work.hpp
+// ~~~~~~~~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2023 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef BOOST_ASIO_DETAIL_COMPOSED_WORK_HPP
+#define BOOST_ASIO_DETAIL_COMPOSED_WORK_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include <boost/asio/detail/config.hpp>
+#include <boost/asio/detail/type_traits.hpp>
+#include <boost/asio/detail/variadic_templates.hpp>
+#include <boost/asio/execution/executor.hpp>
+#include <boost/asio/execution/outstanding_work.hpp>
+#include <boost/asio/executor_work_guard.hpp>
+#include <boost/asio/is_executor.hpp>
+#include <boost/asio/system_executor.hpp>
+
+#include <boost/asio/detail/push_options.hpp>
+
+namespace boost {
+namespace asio {
+namespace detail {
+
+template <typename Executor, typename = void>
+class composed_work_guard
+{
+public:
+  typedef typename decay<
+      typename prefer_result<Executor,
+        execution::outstanding_work_t::tracked_t
+      >::type
+    >::type executor_type;
+
+  composed_work_guard(const Executor& ex)
+    : executor_(boost::asio::prefer(ex, execution::outstanding_work.tracked))
+  {
+  }
+
+  void reset()
+  {
+  }
+
+  executor_type get_executor() const BOOST_ASIO_NOEXCEPT
+  {
+    return executor_;
+  }
+
+private:
+  executor_type executor_;
+};
+
+template <>
+struct composed_work_guard<system_executor>
+{
+public:
+  typedef system_executor executor_type;
+
+  composed_work_guard(const system_executor&)
+  {
+  }
+
+  void reset()
+  {
+  }
+
+  executor_type get_executor() const BOOST_ASIO_NOEXCEPT
+  {
+    return system_executor();
+  }
+};
+
+#if !defined(BOOST_ASIO_NO_TS_EXECUTORS)
+
+template <typename Executor>
+struct composed_work_guard<Executor,
+    typename enable_if<
+      !execution::is_executor<Executor>::value
+    >::type> : executor_work_guard<Executor>
+{
+  composed_work_guard(const Executor& ex)
+    : executor_work_guard<Executor>(ex)
+  {
+  }
+};
+
+#endif // !defined(BOOST_ASIO_NO_TS_EXECUTORS)
+
+template <typename>
+struct composed_io_executors;
+
+template <>
+struct composed_io_executors<void()>
+{
+  composed_io_executors() BOOST_ASIO_NOEXCEPT
+    : head_(system_executor())
+  {
+  }
+
+  typedef system_executor head_type;
+  system_executor head_;
+};
+
+inline composed_io_executors<void()> make_composed_io_executors()
+{
+  return composed_io_executors<void()>();
+}
+
+template <typename Head>
+struct composed_io_executors<void(Head)>
+{
+  explicit composed_io_executors(const Head& ex) BOOST_ASIO_NOEXCEPT
+    : head_(ex)
+  {
+  }
+
+  typedef Head head_type;
+  Head head_;
+};
+
+template <typename Head>
+inline composed_io_executors<void(Head)>
+make_composed_io_executors(const Head& head)
+{
+  return composed_io_executors<void(Head)>(head);
+}
+
+#if defined(BOOST_ASIO_HAS_VARIADIC_TEMPLATES)
+
+template <typename Head, typename... Tail>
+struct composed_io_executors<void(Head, Tail...)>
+{
+  explicit composed_io_executors(const Head& head,
+      const Tail&... tail) BOOST_ASIO_NOEXCEPT
+    : head_(head),
+      tail_(tail...)
+  {
+  }
+
+  void reset()
+  {
+    head_.reset();
+    tail_.reset();
+  }
+
+  typedef Head head_type;
+  Head head_;
+  composed_io_executors<void(Tail...)> tail_;
+};
+
+template <typename Head, typename... Tail>
+inline composed_io_executors<void(Head, Tail...)>
+make_composed_io_executors(const Head& head, const Tail&... tail)
+{
+  return composed_io_executors<void(Head, Tail...)>(head, tail...);
+}
+
+#else // defined(BOOST_ASIO_HAS_VARIADIC_TEMPLATES)
+
+#define BOOST_ASIO_PRIVATE_COMPOSED_IO_EXECUTORS_DEF(n) \
+template <typename Head, BOOST_ASIO_VARIADIC_TPARAMS(n)> \
+struct composed_io_executors<void(Head, BOOST_ASIO_VARIADIC_TARGS(n))> \
+{ \
+  explicit composed_io_executors(const Head& head, \
+      BOOST_ASIO_VARIADIC_CONSTREF_PARAMS(n)) BOOST_ASIO_NOEXCEPT \
+    : head_(head), \
+      tail_(BOOST_ASIO_VARIADIC_BYVAL_ARGS(n)) \
+  { \
+  } \
+\
+  void reset() \
+  { \
+    head_.reset(); \
+    tail_.reset(); \
+  } \
+\
+  typedef Head head_type; \
+  Head head_; \
+  composed_io_executors<void(BOOST_ASIO_VARIADIC_TARGS(n))> tail_; \
+}; \
+\
+template <typename Head, BOOST_ASIO_VARIADIC_TPARAMS(n)> \
+inline composed_io_executors<void(Head, BOOST_ASIO_VARIADIC_TARGS(n))> \
+make_composed_io_executors(const Head& head, \
+    BOOST_ASIO_VARIADIC_CONSTREF_PARAMS(n)) \
+{ \
+  return composed_io_executors< \
+    void(Head, BOOST_ASIO_VARIADIC_TARGS(n))>( \
+      head, BOOST_ASIO_VARIADIC_BYVAL_ARGS(n)); \
+} \
+/**/
+BOOST_ASIO_VARIADIC_GENERATE(BOOST_ASIO_PRIVATE_COMPOSED_IO_EXECUTORS_DEF)
+#undef BOOST_ASIO_PRIVATE_COMPOSED_IO_EXECUTORS_DEF
+
+#endif // defined(BOOST_ASIO_HAS_VARIADIC_TEMPLATES)
+
+template <typename>
+struct composed_work;
+
+template <>
+struct composed_work<void()>
+{
+  typedef composed_io_executors<void()> executors_type;
+
+  composed_work(const executors_type&) BOOST_ASIO_NOEXCEPT
+    : head_(system_executor())
+  {
+  }
+
+  void reset()
+  {
+    head_.reset();
+  }
+
+  typedef system_executor head_type;
+  composed_work_guard<system_executor> head_;
+};
+
+template <typename Head>
+struct composed_work<void(Head)>
+{
+  typedef composed_io_executors<void(Head)> executors_type;
+
+  explicit composed_work(const executors_type& ex) BOOST_ASIO_NOEXCEPT
+    : head_(ex.head_)
+  {
+  }
+
+  void reset()
+  {
+    head_.reset();
+  }
+
+  typedef Head head_type;
+  composed_work_guard<Head> head_;
+};
+
+#if defined(BOOST_ASIO_HAS_VARIADIC_TEMPLATES)
+
+template <typename Head, typename... Tail>
+struct composed_work<void(Head, Tail...)>
+{
+  typedef composed_io_executors<void(Head, Tail...)> executors_type;
+
+  explicit composed_work(const executors_type& ex) BOOST_ASIO_NOEXCEPT
+    : head_(ex.head_),
+      tail_(ex.tail_)
+  {
+  }
+
+  void reset()
+  {
+    head_.reset();
+    tail_.reset();
+  }
+
+  typedef Head head_type;
+  composed_work_guard<Head> head_;
+  composed_work<void(Tail...)> tail_;
+};
+
+#else // defined(BOOST_ASIO_HAS_VARIADIC_TEMPLATES)
+
+#define BOOST_ASIO_PRIVATE_COMPOSED_WORK_DEF(n) \
+template <typename Head, BOOST_ASIO_VARIADIC_TPARAMS(n)> \
+struct composed_work<void(Head, BOOST_ASIO_VARIADIC_TARGS(n))> \
+{ \
+  typedef composed_io_executors<void(Head, \
+    BOOST_ASIO_VARIADIC_TARGS(n))> executors_type; \
+\
+  explicit composed_work(const executors_type& ex) BOOST_ASIO_NOEXCEPT \
+    : head_(ex.head_), \
+      tail_(ex.tail_) \
+  { \
+  } \
+\
+  void reset() \
+  { \
+    head_.reset(); \
+    tail_.reset(); \
+  } \
+\
+  typedef Head head_type; \
+  composed_work_guard<Head> head_; \
+  composed_work<void(BOOST_ASIO_VARIADIC_TARGS(n))> tail_; \
+}; \
+/**/
+BOOST_ASIO_VARIADIC_GENERATE(BOOST_ASIO_PRIVATE_COMPOSED_WORK_DEF)
+#undef BOOST_ASIO_PRIVATE_COMPOSED_WORK_DEF
+
+#endif // defined(BOOST_ASIO_HAS_VARIADIC_TEMPLATES)
+
+template <typename IoObject>
+inline typename IoObject::executor_type
+get_composed_io_executor(IoObject& io_object,
+    typename enable_if<
+      !is_executor<IoObject>::value
+    >::type* = 0,
+    typename enable_if<
+      !execution::is_executor<IoObject>::value
+    >::type* = 0)
+{
+  return io_object.get_executor();
+}
+
+template <typename Executor>
+inline const Executor& get_composed_io_executor(const Executor& ex,
+    typename enable_if<
+      is_executor<Executor>::value
+        || execution::is_executor<Executor>::value
+    >::type* = 0)
+{
+  return ex;
+}
+
+} // namespace detail
+} // namespace asio
+} // namespace boost
+
+#include <boost/asio/detail/pop_options.hpp>
+
+#endif // BOOST_ASIO_DETAIL_COMPOSED_WORK_HPP

linx64/include/boost/asio/detail/concurrency_hint.hpp

@@ -2,7 +2,7 @@
 // detail/concurrency_hint.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2019 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2023 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

linx64/include/boost/asio/detail/conditionally_enabled_event.hpp

@@ -2,7 +2,7 @@
 // detail/conditionally_enabled_event.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2019 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2023 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -65,6 +65,14 @@ public:
       event_.unlock_and_signal_one(lock);
   }
 
+  // Unlock the mutex and signal one waiter who may destroy us.
+  void unlock_and_signal_one_for_destruction(
+      conditionally_enabled_mutex::scoped_lock& lock)
+  {
+    if (lock.mutex_.enabled_)
+      event_.unlock_and_signal_one(lock);
+  }
+
   // If there's a waiter, unlock the mutex and signal it.
   bool maybe_unlock_and_signal_one(
       conditionally_enabled_mutex::scoped_lock& lock)

linx64/include/boost/asio/detail/conditionally_enabled_mutex.hpp

@@ -2,7 +2,7 @@
 // detail/conditionally_enabled_mutex.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2019 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2023 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

linx64/include/boost/asio/detail/consuming_buffers.hpp

@@ -2,7 +2,7 @@
 // detail/consuming_buffers.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2019 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2023 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -20,6 +20,7 @@
 #include <boost/asio/buffer.hpp>
 #include <boost/asio/detail/buffer_sequence_adapter.hpp>
 #include <boost/asio/detail/limits.hpp>
+#include <boost/asio/registered_buffer.hpp>
 
 #include <boost/asio/detail/push_options.hpp>
 
@@ -270,6 +271,42 @@ public:
 
 #endif // !defined(BOOST_ASIO_NO_DEPRECATED)
 
+template <>
+class consuming_buffers<mutable_buffer,
+    mutable_registered_buffer, const mutable_buffer*>
+  : public consuming_single_buffer<mutable_registered_buffer>
+{
+public:
+  explicit consuming_buffers(const mutable_registered_buffer& buffer)
+    : consuming_single_buffer<mutable_registered_buffer>(buffer)
+  {
+  }
+};
+
+template <>
+class consuming_buffers<const_buffer,
+    mutable_registered_buffer, const mutable_buffer*>
+  : public consuming_single_buffer<mutable_registered_buffer>
+{
+public:
+  explicit consuming_buffers(const mutable_registered_buffer& buffer)
+    : consuming_single_buffer<mutable_registered_buffer>(buffer)
+  {
+  }
+};
+
+template <>
+class consuming_buffers<const_buffer,
+    const_registered_buffer, const const_buffer*>
+  : public consuming_single_buffer<const_registered_buffer>
+{
+public:
+  explicit consuming_buffers(const const_registered_buffer& buffer)
+    : consuming_single_buffer<const_registered_buffer>(buffer)
+  {
+  }
+};
+
 template <typename Buffer, typename Elem>
 class consuming_buffers<Buffer, boost::array<Elem, 2>,
     typename boost::array<Elem, 2>::const_iterator>

linx64/include/boost/asio/detail/cstddef.hpp

@@ -2,7 +2,7 @@
 // detail/cstddef.hpp
 // ~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2019 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2023 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

linx64/include/boost/asio/detail/cstdint.hpp

@@ -2,7 +2,7 @@
 // detail/cstdint.hpp
 // ~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2019 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2023 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -39,6 +39,7 @@ using std::int64_t;
 using std::int_least64_t;
 using std::uint64_t;
 using std::uint_least64_t;
+using std::uintptr_t;
 using std::uintmax_t;
 #else // defined(BOOST_ASIO_HAS_CSTDINT)
 using boost::int16_t;
@@ -53,6 +54,7 @@ using boost::int64_t;
 using boost::int_least64_t;
 using boost::uint64_t;
 using boost::uint_least64_t;
+using boost::uintptr_t;
 using boost::uintmax_t;
 #endif // defined(BOOST_ASIO_HAS_CSTDINT)
 

linx64/include/boost/asio/detail/date_time_fwd.hpp

@@ -2,7 +2,7 @@
 // detail/date_time_fwd.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2019 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2023 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

linx64/include/boost/asio/detail/deadline_timer_service.hpp

@@ -2,7 +2,7 @@
 // detail/deadline_timer_service.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2019 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2023 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -17,6 +17,8 @@
 
 #include <boost/asio/detail/config.hpp>
 #include <cstddef>
+#include <boost/asio/associated_cancellation_slot.hpp>
+#include <boost/asio/cancellation_type.hpp>
 #include <boost/asio/error.hpp>
 #include <boost/asio/execution_context.hpp>
 #include <boost/asio/detail/bind_handler.hpp>
@@ -98,7 +100,7 @@ public:
     cancel(impl, ec);
   }
 
-  // Move-construct a new serial port implementation.
+  // Move-construct a new timer implementation.
   void move_construct(implementation_type& impl,
       implementation_type& other_impl)
   {
@@ -111,7 +113,7 @@ public:
     other_impl.might_have_pending_waits = false;
   }
 
-  // Move-assign from another serial port implementation.
+  // Move-assign from another timer implementation.
   void move_assign(implementation_type& impl,
       deadline_timer_service& other_service,
       implementation_type& other_impl)
@@ -130,6 +132,21 @@ public:
     other_impl.might_have_pending_waits = false;
   }
 
+  // Move-construct a new timer implementation.
+  void converting_move_construct(implementation_type& impl,
+      deadline_timer_service&, implementation_type& other_impl)
+  {
+    move_construct(impl, other_impl);
+  }
+
+  // Move-assign from another timer implementation.
+  void converting_move_assign(implementation_type& impl,
+      deadline_timer_service& other_service,
+      implementation_type& other_impl)
+  {
+    move_assign(impl, other_service, other_impl);
+  }
+
   // Cancel any asynchronous wait operations associated with the timer.
   std::size_t cancel(implementation_type& impl, boost::system::error_code& ec)
   {
@@ -231,12 +248,22 @@ public:
   void async_wait(implementation_type& impl,
       Handler& handler, const IoExecutor& io_ex)
   {
+    typename associated_cancellation_slot<Handler>::type slot
+      = boost::asio::get_associated_cancellation_slot(handler);
+
     // Allocate and construct an operation to wrap the handler.
     typedef wait_handler<Handler, IoExecutor> op;
     typename op::ptr p = { boost::asio::detail::addressof(handler),
       op::ptr::allocate(handler), 0 };
     p.p = new (p.v) op(handler, io_ex);
 
+    // Optionally register for per-operation cancellation.
+    if (slot.is_connected())
+    {
+      p.p->cancellation_key_ =
+        &slot.template emplace<op_cancellation>(this, &impl.timer_data);
+    }
+
     impl.might_have_pending_waits = true;
 
     BOOST_ASIO_HANDLER_CREATION((scheduler_.context(),
@@ -266,6 +293,34 @@ private:
 #endif // defined(BOOST_ASIO_WINDOWS_RUNTIME)
   }
 
+  // Helper class used to implement per-operation cancellation.
+  class op_cancellation
+  {
+  public:
+    op_cancellation(deadline_timer_service* s,
+        typename timer_queue<Time_Traits>::per_timer_data* p)
+      : service_(s),
+        timer_data_(p)
+    {
+    }
+
+    void operator()(cancellation_type_t type)
+    {
+      if (!!(type &
+            (cancellation_type::terminal
+              | cancellation_type::partial
+              | cancellation_type::total)))
+      {
+        service_->scheduler_.cancel_timer_by_key(
+            service_->timer_queue_, timer_data_, this);
+      }
+    }
+
+  private:
+    deadline_timer_service* service_;
+    typename timer_queue<Time_Traits>::per_timer_data* timer_data_;
+  };
+
   // The queue of timers.
   timer_queue<Time_Traits> timer_queue_;
 

linx64/include/boost/asio/detail/dependent_type.hpp

@@ -2,7 +2,7 @@
 // detail/dependent_type.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2019 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2023 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

linx64/include/boost/asio/detail/descriptor_ops.hpp

@@ -2,7 +2,7 @@
 // detail/descriptor_ops.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2019 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2023 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -24,6 +24,7 @@
 #include <cstddef>
 #include <boost/asio/error.hpp>
 #include <boost/system/error_code.hpp>
+#include <boost/asio/detail/cstdint.hpp>
 #include <boost/asio/detail/socket_types.hpp>
 
 #include <boost/asio/detail/push_options.hpp>
@@ -51,18 +52,26 @@ enum
 
 typedef unsigned char state_type;
 
-template <typename ReturnType>
-inline ReturnType error_wrapper(ReturnType return_value,
-    boost::system::error_code& ec)
+inline void get_last_error(
+    boost::system::error_code& ec, bool is_error_condition)
 {
-  ec = boost::system::error_code(errno,
-      boost::asio::error::get_system_category());
-  return return_value;
+  if (!is_error_condition)
+  {
+    boost::asio::error::clear(ec);
+  }
+  else
+  {
+    ec = boost::system::error_code(errno,
+        boost::asio::error::get_system_category());
+  }
 }
 
 BOOST_ASIO_DECL int open(const char* path, int flags,
     boost::system::error_code& ec);
 
+BOOST_ASIO_DECL int open(const char* path, int flags, unsigned mode,
+    boost::system::error_code& ec);
+
 BOOST_ASIO_DECL int close(int d, state_type& state,
     boost::system::error_code& ec);
 
@@ -77,17 +86,66 @@ typedef iovec buf;
 BOOST_ASIO_DECL std::size_t sync_read(int d, state_type state, buf* bufs,
     std::size_t count, bool all_empty, boost::system::error_code& ec);
 
+BOOST_ASIO_DECL std::size_t sync_read1(int d, state_type state, void* data,
+    std::size_t size, boost::system::error_code& ec);
+
 BOOST_ASIO_DECL bool non_blocking_read(int d, buf* bufs, std::size_t count,
     boost::system::error_code& ec, std::size_t& bytes_transferred);
 
+BOOST_ASIO_DECL bool non_blocking_read1(int d, void* data, std::size_t size,
+    boost::system::error_code& ec, std::size_t& bytes_transferred);
+
 BOOST_ASIO_DECL std::size_t sync_write(int d, state_type state,
     const buf* bufs, std::size_t count, bool all_empty,
     boost::system::error_code& ec);
 
+BOOST_ASIO_DECL std::size_t sync_write1(int d, state_type state,
+    const void* data, std::size_t size, boost::system::error_code& ec);
+
 BOOST_ASIO_DECL bool non_blocking_write(int d,
     const buf* bufs, std::size_t count,
     boost::system::error_code& ec, std::size_t& bytes_transferred);
 
+BOOST_ASIO_DECL bool non_blocking_write1(int d,
+    const void* data, std::size_t size,
+    boost::system::error_code& ec, std::size_t& bytes_transferred);
+
+#if defined(BOOST_ASIO_HAS_FILE)
+
+BOOST_ASIO_DECL std::size_t sync_read_at(int d, state_type state,
+    uint64_t offset, buf* bufs, std::size_t count, bool all_empty,
+    boost::system::error_code& ec);
+
+BOOST_ASIO_DECL std::size_t sync_read_at1(int d, state_type state,
+    uint64_t offset, void* data, std::size_t size,
+    boost::system::error_code& ec);
+
+BOOST_ASIO_DECL bool non_blocking_read_at(int d, uint64_t offset,
+    buf* bufs, std::size_t count, boost::system::error_code& ec,
+    std::size_t& bytes_transferred);
+
+BOOST_ASIO_DECL bool non_blocking_read_at1(int d, uint64_t offset,
+    void* data, std::size_t size, boost::system::error_code& ec,
+    std::size_t& bytes_transferred);
+
+BOOST_ASIO_DECL std::size_t sync_write_at(int d, state_type state,
+    uint64_t offset, const buf* bufs, std::size_t count, bool all_empty,
+    boost::system::error_code& ec);
+
+BOOST_ASIO_DECL std::size_t sync_write_at1(int d, state_type state,
+    uint64_t offset, const void* data, std::size_t size,
+    boost::system::error_code& ec);
+
+BOOST_ASIO_DECL bool non_blocking_write_at(int d,
+    uint64_t offset, const buf* bufs, std::size_t count,
+    boost::system::error_code& ec, std::size_t& bytes_transferred);
+
+BOOST_ASIO_DECL bool non_blocking_write_at1(int d,
+    uint64_t offset, const void* data, std::size_t size,
+    boost::system::error_code& ec, std::size_t& bytes_transferred);
+
+#endif // defined(BOOST_ASIO_HAS_FILE)
+
 BOOST_ASIO_DECL int ioctl(int d, state_type& state, long cmd,
     ioctl_arg_type* arg, boost::system::error_code& ec);
 

linx64/include/boost/asio/detail/descriptor_read_op.hpp

@@ -2,7 +2,7 @@
 // detail/descriptor_read_op.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2019 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2023 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -26,6 +26,7 @@
 #include <boost/asio/detail/handler_work.hpp>
 #include <boost/asio/detail/memory.hpp>
 #include <boost/asio/detail/reactor_op.hpp>
+#include <boost/asio/dispatch.hpp>
 
 #include <boost/asio/detail/push_options.hpp>
 
@@ -37,9 +38,11 @@ template <typename MutableBufferSequence>
 class descriptor_read_op_base : public reactor_op
 {
 public:
-  descriptor_read_op_base(int descriptor,
-      const MutableBufferSequence& buffers, func_type complete_func)
-    : reactor_op(&descriptor_read_op_base::do_perform, complete_func),
+  descriptor_read_op_base(const boost::system::error_code& success_ec,
+      int descriptor, const MutableBufferSequence& buffers,
+      func_type complete_func)
+    : reactor_op(success_ec,
+        &descriptor_read_op_base::do_perform, complete_func),
       descriptor_(descriptor),
       buffers_(buffers)
   {
@@ -47,14 +50,27 @@ public:
 
   static status do_perform(reactor_op* base)
   {
+    BOOST_ASIO_ASSUME(base != 0);
     descriptor_read_op_base* o(static_cast<descriptor_read_op_base*>(base));
 
-    buffer_sequence_adapter<boost::asio::mutable_buffer,
-        MutableBufferSequence> bufs(o->buffers_);
+    typedef buffer_sequence_adapter<boost::asio::mutable_buffer,
+        MutableBufferSequence> bufs_type;
 
-    status result = descriptor_ops::non_blocking_read(o->descriptor_,
-        bufs.buffers(), bufs.count(), o->ec_, o->bytes_transferred_)
-      ? done : not_done;
+    status result;
+    if (bufs_type::is_single_buffer)
+    {
+      result = descriptor_ops::non_blocking_read1(o->descriptor_,
+          bufs_type::first(o->buffers_).data(),
+          bufs_type::first(o->buffers_).size(),
+          o->ec_, o->bytes_transferred_) ? done : not_done;
+    }
+    else
+    {
+      bufs_type bufs(o->buffers_);
+      result = descriptor_ops::non_blocking_read(o->descriptor_,
+          bufs.buffers(), bufs.count(), o->ec_, o->bytes_transferred_)
+        ? done : not_done;
+    }
 
     BOOST_ASIO_HANDLER_REACTOR_OPERATION((*o, "non_blocking_read",
           o->ec_, o->bytes_transferred_));
@@ -72,16 +88,19 @@ class descriptor_read_op
   : public descriptor_read_op_base<MutableBufferSequence>
 {
 public:
+  typedef Handler handler_type;
+  typedef IoExecutor io_executor_type;
+
   BOOST_ASIO_DEFINE_HANDLER_PTR(descriptor_read_op);
 
-  descriptor_read_op(int descriptor, const MutableBufferSequence& buffers,
+  descriptor_read_op(const boost::system::error_code& success_ec,
+      int descriptor, const MutableBufferSequence& buffers,
       Handler& handler, const IoExecutor& io_ex)
-    : descriptor_read_op_base<MutableBufferSequence>(
+    : descriptor_read_op_base<MutableBufferSequence>(success_ec,
         descriptor, buffers, &descriptor_read_op::do_complete),
       handler_(BOOST_ASIO_MOVE_CAST(Handler)(handler)),
-      io_executor_(io_ex)
+      work_(handler_, io_ex)
   {
-    handler_work<Handler, IoExecutor>::start(handler_, io_executor_);
   }
 
   static void do_complete(void* owner, operation* base,
@@ -89,12 +108,19 @@ public:
       std::size_t /*bytes_transferred*/)
   {
     // Take ownership of the handler object.
+    BOOST_ASIO_ASSUME(base != 0);
     descriptor_read_op* o(static_cast<descriptor_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));
 
+    // Take ownership of the operation's outstanding work.
+    handler_work<Handler, IoExecutor> w(
+        BOOST_ASIO_MOVE_CAST2(handler_work<Handler, IoExecutor>)(
+          o->work_));
+
+    BOOST_ASIO_ERROR_LOCATION(o->ec_);
+
     // 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
@@ -116,9 +142,41 @@ public:
     }
   }
 
+  static void do_immediate(operation* base, bool, const void* io_ex)
+  {
+    // Take ownership of the handler object.
+    BOOST_ASIO_ASSUME(base != 0);
+    descriptor_read_op* o(static_cast<descriptor_read_op*>(base));
+    ptr p = { boost::asio::detail::addressof(o->handler_), o, o };
+
+    BOOST_ASIO_HANDLER_COMPLETION((*o));
+
+    // Take ownership of the operation's outstanding work.
+    immediate_handler_work<Handler, IoExecutor> w(
+        BOOST_ASIO_MOVE_CAST2(handler_work<Handler, IoExecutor>)(
+          o->work_));
+
+    BOOST_ASIO_ERROR_LOCATION(o->ec_);
+
+    // 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_, o->ec_, o->bytes_transferred_);
+    p.h = boost::asio::detail::addressof(handler.handler_);
+    p.reset();
+
+    BOOST_ASIO_HANDLER_INVOCATION_BEGIN((handler.arg1_, handler.arg2_));
+    w.complete(handler, handler.handler_, io_ex);
+    BOOST_ASIO_HANDLER_INVOCATION_END;
+  }
+
 private:
   Handler handler_;
-  IoExecutor io_executor_;
+  handler_work<Handler, IoExecutor> work_;
 };
 
 } // namespace detail

linx64/include/boost/asio/detail/descriptor_write_op.hpp

@@ -2,7 +2,7 @@
 // detail/descriptor_write_op.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2019 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2023 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -37,9 +37,11 @@ template <typename ConstBufferSequence>
 class descriptor_write_op_base : public reactor_op
 {
 public:
-  descriptor_write_op_base(int descriptor,
-      const ConstBufferSequence& buffers, func_type complete_func)
-    : reactor_op(&descriptor_write_op_base::do_perform, complete_func),
+  descriptor_write_op_base(const boost::system::error_code& success_ec,
+      int descriptor, const ConstBufferSequence& buffers,
+      func_type complete_func)
+    : reactor_op(success_ec,
+        &descriptor_write_op_base::do_perform, complete_func),
       descriptor_(descriptor),
       buffers_(buffers)
   {
@@ -47,14 +49,27 @@ public:
 
   static status do_perform(reactor_op* base)
   {
+    BOOST_ASIO_ASSUME(base != 0);
     descriptor_write_op_base* o(static_cast<descriptor_write_op_base*>(base));
 
-    buffer_sequence_adapter<boost::asio::const_buffer,
-        ConstBufferSequence> bufs(o->buffers_);
+    typedef buffer_sequence_adapter<boost::asio::const_buffer,
+        ConstBufferSequence> bufs_type;
 
-    status result = descriptor_ops::non_blocking_write(o->descriptor_,
-        bufs.buffers(), bufs.count(), o->ec_, o->bytes_transferred_)
-      ? done : not_done;
+    status result;
+    if (bufs_type::is_single_buffer)
+    {
+      result = descriptor_ops::non_blocking_write1(o->descriptor_,
+          bufs_type::first(o->buffers_).data(),
+          bufs_type::first(o->buffers_).size(),
+          o->ec_, o->bytes_transferred_) ? done : not_done;
+    }
+    else
+    {
+      bufs_type bufs(o->buffers_);
+      result = descriptor_ops::non_blocking_write(o->descriptor_,
+          bufs.buffers(), bufs.count(), o->ec_, o->bytes_transferred_)
+        ? done : not_done;
+    }
 
     BOOST_ASIO_HANDLER_REACTOR_OPERATION((*o, "non_blocking_write",
           o->ec_, o->bytes_transferred_));
@@ -72,16 +87,19 @@ class descriptor_write_op
   : public descriptor_write_op_base<ConstBufferSequence>
 {
 public:
+  typedef Handler handler_type;
+  typedef IoExecutor io_executor_type;
+
   BOOST_ASIO_DEFINE_HANDLER_PTR(descriptor_write_op);
 
-  descriptor_write_op(int descriptor, const ConstBufferSequence& buffers,
+  descriptor_write_op(const boost::system::error_code& success_ec,
+      int descriptor, const ConstBufferSequence& buffers,
       Handler& handler, const IoExecutor& io_ex)
-    : descriptor_write_op_base<ConstBufferSequence>(
+    : descriptor_write_op_base<ConstBufferSequence>(success_ec,
         descriptor, buffers, &descriptor_write_op::do_complete),
       handler_(BOOST_ASIO_MOVE_CAST(Handler)(handler)),
-      io_executor_(io_ex)
+      work_(handler_, io_ex)
   {
-    handler_work<Handler, IoExecutor>::start(handler_, io_executor_);
   }
 
   static void do_complete(void* owner, operation* base,
@@ -89,12 +107,19 @@ public:
       std::size_t /*bytes_transferred*/)
   {
     // Take ownership of the handler object.
+    BOOST_ASIO_ASSUME(base != 0);
     descriptor_write_op* o(static_cast<descriptor_write_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));
 
+    // Take ownership of the operation's outstanding work.
+    handler_work<Handler, IoExecutor> w(
+        BOOST_ASIO_MOVE_CAST2(handler_work<Handler, IoExecutor>)(
+          o->work_));
+
+    BOOST_ASIO_ERROR_LOCATION(o->ec_);
+
     // 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
@@ -116,9 +141,41 @@ public:
     }
   }
 
+  static void do_immediate(operation* base, bool, const void* io_ex)
+  {
+    // Take ownership of the handler object.
+    BOOST_ASIO_ASSUME(base != 0);
+    descriptor_write_op* o(static_cast<descriptor_write_op*>(base));
+    ptr p = { boost::asio::detail::addressof(o->handler_), o, o };
+
+    BOOST_ASIO_HANDLER_COMPLETION((*o));
+
+    // Take ownership of the operation's outstanding work.
+    immediate_handler_work<Handler, IoExecutor> w(
+        BOOST_ASIO_MOVE_CAST2(handler_work<Handler, IoExecutor>)(
+          o->work_));
+
+    BOOST_ASIO_ERROR_LOCATION(o->ec_);
+
+    // 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_, o->ec_, o->bytes_transferred_);
+    p.h = boost::asio::detail::addressof(handler.handler_);
+    p.reset();
+
+    BOOST_ASIO_HANDLER_INVOCATION_BEGIN((handler.arg1_, handler.arg2_));
+    w.complete(handler, handler.handler_, io_ex);
+    BOOST_ASIO_HANDLER_INVOCATION_END;
+  }
+
 private:
   Handler handler_;
-  IoExecutor io_executor_;
+  handler_work<Handler, IoExecutor> work_;
 };
 
 } // namespace detail

linx64/include/boost/asio/detail/dev_poll_reactor.hpp

@@ -2,7 +2,7 @@
 // detail/dev_poll_reactor.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2019 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2023 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -28,6 +28,7 @@
 #include <boost/asio/detail/op_queue.hpp>
 #include <boost/asio/detail/reactor_op.hpp>
 #include <boost/asio/detail/reactor_op_queue.hpp>
+#include <boost/asio/detail/scheduler_task.hpp>
 #include <boost/asio/detail/select_interrupter.hpp>
 #include <boost/asio/detail/socket_types.hpp>
 #include <boost/asio/detail/timer_queue_base.hpp>
@@ -42,7 +43,8 @@ namespace asio {
 namespace detail {
 
 class dev_poll_reactor
-  : public execution_context_service_base<dev_poll_reactor>
+  : public execution_context_service_base<dev_poll_reactor>,
+    public scheduler_task
 {
 public:
   enum op_types { read_op = 0, write_op = 1,
@@ -85,22 +87,43 @@ public:
       per_descriptor_data& source_descriptor_data);
 
   // Post a reactor operation for immediate completion.
-  void post_immediate_completion(reactor_op* op, bool is_continuation)
-  {
-    scheduler_.post_immediate_completion(op, is_continuation);
-  }
+  void post_immediate_completion(operation* op, bool is_continuation) const;
+
+  // Post a reactor operation for immediate completion.
+  BOOST_ASIO_DECL static void call_post_immediate_completion(
+      operation* op, bool is_continuation, const void* self);
 
   // Start a new operation. The reactor operation will be performed when the
   // given descriptor is flagged as ready, or an error has occurred.
   BOOST_ASIO_DECL void start_op(int op_type, socket_type descriptor,
       per_descriptor_data&, reactor_op* op,
-      bool is_continuation, bool allow_speculative);
+      bool is_continuation, bool allow_speculative,
+      void (*on_immediate)(operation*, bool, const void*),
+      const void* immediate_arg);
+
+  // Start a new operation. The reactor operation will be performed when the
+  // given descriptor is flagged as ready, or an error has occurred.
+  void start_op(int op_type, socket_type descriptor,
+      per_descriptor_data& descriptor_data, reactor_op* op,
+      bool is_continuation, bool allow_speculative)
+  {
+    start_op(op_type, descriptor, descriptor_data,
+        op, is_continuation, allow_speculative,
+        &dev_poll_reactor::call_post_immediate_completion, this);
+  }
 
   // Cancel all operations associated with the given descriptor. The
   // handlers associated with the descriptor will be invoked with the
   // operation_aborted error.
   BOOST_ASIO_DECL void cancel_ops(socket_type descriptor, per_descriptor_data&);
 
+  // Cancel all operations associated with the given descriptor and key. The
+  // handlers associated with the descriptor will be invoked with the
+  // operation_aborted error.
+  BOOST_ASIO_DECL void cancel_ops_by_key(socket_type descriptor,
+      per_descriptor_data& descriptor_data,
+      int op_type, void* cancellation_key);
+
   // Cancel any operations that are running against the descriptor and remove
   // its registration from the reactor. The reactor resources associated with
   // the descriptor must be released by calling cleanup_descriptor_data.
@@ -139,6 +162,12 @@ public:
       typename timer_queue<Time_Traits>::per_timer_data& timer,
       std::size_t max_cancelled = (std::numeric_limits<std::size_t>::max)());
 
+  // Cancel the timer operations associated with the given key.
+  template <typename Time_Traits>
+  void cancel_timer_by_key(timer_queue<Time_Traits>& queue,
+      typename timer_queue<Time_Traits>::per_timer_data* timer,
+      void* cancellation_key);
+
   // Move the timer operations associated with the given timer.
   template <typename Time_Traits>
   void move_timer(timer_queue<Time_Traits>& queue,

linx64/include/boost/asio/detail/epoll_reactor.hpp

@@ -2,7 +2,7 @@
 // detail/epoll_reactor.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2019 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2023 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -25,6 +25,7 @@
 #include <boost/asio/detail/object_pool.hpp>
 #include <boost/asio/detail/op_queue.hpp>
 #include <boost/asio/detail/reactor_op.hpp>
+#include <boost/asio/detail/scheduler_task.hpp>
 #include <boost/asio/detail/select_interrupter.hpp>
 #include <boost/asio/detail/socket_types.hpp>
 #include <boost/asio/detail/timer_queue_base.hpp>
@@ -43,7 +44,8 @@ namespace asio {
 namespace detail {
 
 class epoll_reactor
-  : public execution_context_service_base<epoll_reactor>
+  : public execution_context_service_base<epoll_reactor>,
+    public scheduler_task
 {
 private:
   // The mutex type used by this reactor.
@@ -115,16 +117,30 @@ public:
       per_descriptor_data& source_descriptor_data);
 
   // Post a reactor operation for immediate completion.
-  void post_immediate_completion(reactor_op* op, bool is_continuation)
-  {
-    scheduler_.post_immediate_completion(op, is_continuation);
-  }
+  void post_immediate_completion(operation* op, bool is_continuation) const;
+
+  // Post a reactor operation for immediate completion.
+  BOOST_ASIO_DECL static void call_post_immediate_completion(
+      operation* op, bool is_continuation, const void* self);
 
   // Start a new operation. The reactor operation will be performed when the
   // given descriptor is flagged as ready, or an error has occurred.
   BOOST_ASIO_DECL void start_op(int op_type, socket_type descriptor,
       per_descriptor_data& descriptor_data, reactor_op* op,
-      bool is_continuation, bool allow_speculative);
+      bool is_continuation, bool allow_speculative,
+      void (*on_immediate)(operation*, bool, const void*),
+      const void* immediate_arg);
+
+  // Start a new operation. The reactor operation will be performed when the
+  // given descriptor is flagged as ready, or an error has occurred.
+  void start_op(int op_type, socket_type descriptor,
+      per_descriptor_data& descriptor_data, reactor_op* op,
+      bool is_continuation, bool allow_speculative)
+  {
+    start_op(op_type, descriptor, descriptor_data,
+        op, is_continuation, allow_speculative,
+        &epoll_reactor::call_post_immediate_completion, this);
+  }
 
   // Cancel all operations associated with the given descriptor. The
   // handlers associated with the descriptor will be invoked with the
@@ -132,6 +148,13 @@ public:
   BOOST_ASIO_DECL void cancel_ops(socket_type descriptor,
       per_descriptor_data& descriptor_data);
 
+  // Cancel all operations associated with the given descriptor and key. The
+  // handlers associated with the descriptor will be invoked with the
+  // operation_aborted error.
+  BOOST_ASIO_DECL void cancel_ops_by_key(socket_type descriptor,
+      per_descriptor_data& descriptor_data,
+      int op_type, void* cancellation_key);
+
   // Cancel any operations that are running against the descriptor and remove
   // its registration from the reactor. The reactor resources associated with
   // the descriptor must be released by calling cleanup_descriptor_data.
@@ -171,6 +194,12 @@ public:
       typename timer_queue<Time_Traits>::per_timer_data& timer,
       std::size_t max_cancelled = (std::numeric_limits<std::size_t>::max)());
 
+  // Cancel the timer operations associated with the given key.
+  template <typename Time_Traits>
+  void cancel_timer_by_key(timer_queue<Time_Traits>& queue,
+      typename timer_queue<Time_Traits>::per_timer_data* timer,
+      void* cancellation_key);
+
   // Move the timer operations associated with the given timer.
   template <typename Time_Traits>
   void move_timer(timer_queue<Time_Traits>& queue,

linx64/include/boost/asio/detail/event.hpp

@@ -2,7 +2,7 @@
 // detail/event.hpp
 // ~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2019 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2023 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

linx64/include/boost/asio/detail/eventfd_select_interrupter.hpp

@@ -2,7 +2,7 @@
 // detail/eventfd_select_interrupter.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2019 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2023 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 // Copyright (c) 2008 Roelof Naude (roelof.naude at gmail dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
@@ -41,7 +41,7 @@ public:
   // Interrupt the select call.
   BOOST_ASIO_DECL void interrupt();
 
-  // Reset the select interrupt. Returns true if the call was interrupted.
+  // Reset the select interrupter. Returns true if the reset was successful.
   BOOST_ASIO_DECL bool reset();
 
   // Get the read descriptor to be passed to select.

linx64/include/boost/asio/detail/exception.hpp

@@ -0,0 +1,42 @@
+//
+// detail/exception.hpp
+// ~~~~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2023 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef BOOST_ASIO_DETAIL_EXCEPTION_HPP
+#define BOOST_ASIO_DETAIL_EXCEPTION_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include <boost/asio/detail/config.hpp>
+
+#if defined(BOOST_ASIO_HAS_STD_EXCEPTION_PTR)
+# include <exception>
+#else // defined(BOOST_ASIO_HAS_STD_EXCEPTION_PTR)
+# include <boost/exception_ptr.hpp>
+#endif // defined(BOOST_ASIO_HAS_STD_EXCEPTION_PTR)
+
+namespace boost {
+namespace asio {
+
+#if defined(BOOST_ASIO_HAS_STD_EXCEPTION_PTR)
+using std::exception_ptr;
+using std::current_exception;
+using std::rethrow_exception;
+#else // defined(BOOST_ASIO_HAS_STD_EXCEPTION_PTR)
+using boost::exception_ptr;
+using boost::current_exception;
+using boost::rethrow_exception;
+#endif // defined(BOOST_ASIO_HAS_STD_EXCEPTION_PTR)
+
+} // namespace asio
+} // namespace boost
+
+#endif // BOOST_ASIO_DETAIL_EXCEPTION_HPP

linx64/include/boost/asio/detail/executor_function.hpp

@@ -2,7 +2,7 @@
 // detail/executor_function.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2019 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2023 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -17,6 +17,8 @@
 
 #include <boost/asio/detail/config.hpp>
 #include <boost/asio/detail/handler_alloc_helpers.hpp>
+#include <boost/asio/detail/handler_invoke_helpers.hpp>
+#include <boost/asio/detail/memory.hpp>
 
 #include <boost/asio/detail/push_options.hpp>
 
@@ -24,57 +26,80 @@ namespace boost {
 namespace asio {
 namespace detail {
 
-class executor_function_base
+#if defined(BOOST_ASIO_HAS_MOVE)
+
+// Lightweight, move-only function object wrapper.
+class executor_function
 {
 public:
-  void complete()
+  template <typename F, typename Alloc>
+  explicit executor_function(F f, const Alloc& a)
   {
-    func_(this, true);
+    // Allocate and construct an object to wrap the function.
+    typedef impl<F, Alloc> impl_type;
+    typename impl_type::ptr p = {
+      detail::addressof(a), impl_type::ptr::allocate(a), 0 };
+    impl_ = new (p.v) impl_type(BOOST_ASIO_MOVE_CAST(F)(f), a);
+    p.v = 0;
   }
 
-  void destroy()
+  executor_function(executor_function&& other) BOOST_ASIO_NOEXCEPT
+    : impl_(other.impl_)
   {
-    func_(this, false);
+    other.impl_ = 0;
   }
 
-protected:
-  typedef void (*func_type)(executor_function_base*, bool);
-
-  executor_function_base(func_type func)
-    : func_(func)
+  ~executor_function()
   {
+    if (impl_)
+      impl_->complete_(impl_, false);
   }
 
-  // Prevents deletion through this type.
-  ~executor_function_base()
+  void operator()()
   {
+    if (impl_)
+    {
+      impl_base* i = impl_;
+      impl_ = 0;
+      i->complete_(i, true);
+    }
   }
 
 private:
-  func_type func_;
-};
-
-template <typename Function, typename Alloc>
-class executor_function : public executor_function_base
-{
-public:
-  BOOST_ASIO_DEFINE_TAGGED_HANDLER_ALLOCATOR_PTR(
-      thread_info_base::executor_function_tag, executor_function);
-
-  template <typename F>
-  executor_function(BOOST_ASIO_MOVE_ARG(F) f, const Alloc& allocator)
-    : executor_function_base(&executor_function::do_complete),
-      function_(BOOST_ASIO_MOVE_CAST(F)(f)),
-      allocator_(allocator)
+  // Base class for polymorphic function implementations.
+  struct impl_base
   {
-  }
+    void (*complete_)(impl_base*, bool);
+  };
 
-  static void do_complete(executor_function_base* base, bool call)
+  // Polymorphic function implementation.
+  template <typename Function, typename Alloc>
+  struct impl : impl_base
+  {
+    BOOST_ASIO_DEFINE_TAGGED_HANDLER_ALLOCATOR_PTR(
+        thread_info_base::executor_function_tag, impl);
+
+    template <typename F>
+    impl(BOOST_ASIO_MOVE_ARG(F) f, const Alloc& a)
+      : function_(BOOST_ASIO_MOVE_CAST(F)(f)),
+        allocator_(a)
+    {
+      complete_ = &executor_function::complete<Function, Alloc>;
+    }
+
+    Function function_;
+    Alloc allocator_;
+  };
+
+  // Helper to complete function invocation.
+  template <typename Function, typename Alloc>
+  static void complete(impl_base* base, bool call)
   {
     // Take ownership of the function object.
-    executor_function* o(static_cast<executor_function*>(base));
-    Alloc allocator(o->allocator_);
-    ptr p = { detail::addressof(allocator), o, o };
+    impl<Function, Alloc>* i(static_cast<impl<Function, Alloc>*>(base));
+    Alloc allocator(i->allocator_);
+    typename impl<Function, Alloc>::ptr p = {
+      detail::addressof(allocator), i, i };
 
     // Make a copy of the function so that the memory can be deallocated before
     // the upcall is made. Even if we're not about to make an upcall, a
@@ -82,19 +107,94 @@ public:
     // associated with the function. Consequently, a local copy of the function
     // is required to ensure that any owning sub-object remains valid until
     // after we have deallocated the memory here.
-    Function function(BOOST_ASIO_MOVE_CAST(Function)(o->function_));
+    Function function(BOOST_ASIO_MOVE_CAST(Function)(i->function_));
     p.reset();
 
     // Make the upcall if required.
     if (call)
     {
-      function();
+      boost_asio_handler_invoke_helpers::invoke(function, function);
     }
   }
 
+  impl_base* impl_;
+};
+
+#else // defined(BOOST_ASIO_HAS_MOVE)
+
+// Not so lightweight, copyable function object wrapper.
+class executor_function
+{
+public:
+  template <typename F, typename Alloc>
+  explicit executor_function(const F& f, const Alloc&)
+    : impl_(new impl<typename decay<F>::type>(f))
+  {
+  }
+
+  void operator()()
+  {
+    impl_->complete_(impl_.get());
+  }
+
 private:
-  Function function_;
-  Alloc allocator_;
+  // Base class for polymorphic function implementations.
+  struct impl_base
+  {
+    void (*complete_)(impl_base*);
+  };
+
+  // Polymorphic function implementation.
+  template <typename F>
+  struct impl : impl_base
+  {
+    impl(const F& f)
+      : function_(f)
+    {
+      complete_ = &executor_function::complete<F>;
+    }
+
+    F function_;
+  };
+
+  // Helper to complete function invocation.
+  template <typename F>
+  static void complete(impl_base* i)
+  {
+    static_cast<impl<F>*>(i)->function_();
+  }
+
+  shared_ptr<impl_base> impl_;
+};
+
+#endif // defined(BOOST_ASIO_HAS_MOVE)
+
+// Lightweight, non-owning, copyable function object wrapper.
+class executor_function_view
+{
+public:
+  template <typename F>
+  explicit executor_function_view(F& f) BOOST_ASIO_NOEXCEPT
+    : complete_(&executor_function_view::complete<F>),
+      function_(&f)
+  {
+  }
+
+  void operator()()
+  {
+    complete_(function_);
+  }
+
+private:
+  // Helper to complete function invocation.
+  template <typename F>
+  static void complete(void* f)
+  {
+    (*static_cast<F*>(f))();
+  }
+
+  void (*complete_)(void*);
+  void* function_;
 };
 
 } // namespace detail

linx64/include/boost/asio/detail/executor_op.hpp

@@ -2,7 +2,7 @@
 // detail/executor_op.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2019 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2023 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -47,6 +47,7 @@ public:
       std::size_t /*bytes_transferred*/)
   {
     // Take ownership of the handler object.
+    BOOST_ASIO_ASSUME(base != 0);
     executor_op* o(static_cast<executor_op*>(base));
     Alloc allocator(o->allocator_);
     ptr p = { detail::addressof(allocator), o, o };

linx64/include/boost/asio/detail/fd_set_adapter.hpp

@@ -2,7 +2,7 @@
 // detail/fd_set_adapter.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2019 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2023 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

linx64/include/boost/asio/detail/fenced_block.hpp

@@ -2,7 +2,7 @@
 // detail/fenced_block.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2019 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2023 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

linx64/include/boost/asio/detail/functional.hpp

@@ -2,7 +2,7 @@
 // detail/functional.hpp
 // ~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2019 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2023 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -34,6 +34,12 @@ using boost::function;
 #endif // defined(BOOST_ASIO_HAS_STD_FUNCTION)
 
 } // namespace detail
+
+#if defined(BOOST_ASIO_HAS_STD_REFERENCE_WRAPPER)
+using std::ref;
+using std::reference_wrapper;
+#endif // defined(BOOST_ASIO_HAS_STD_REFERENCE_WRAPPER)
+
 } // namespace asio
 } // namespace boost
 

linx64/include/boost/asio/detail/future.hpp

@@ -2,7 +2,7 @@
 // detail/future.hpp
 // ~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2019 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2023 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)