Thirdparty: update Asio to 1.20

Author: tstenner

thirdparty/asio/asio/cancellation_state.hpp

@@ -86,13 +86,38 @@ class cancellation_state
   }
 
   /// 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>
   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 asio::cancellation_type_t filter(
+   *     asio::cancellation_type_t); @endcode
+   *
+   * The library provides the following pre-defined cancellation filters:
+   *
+   * @li asio::disable_cancellation
+   * @li asio::enable_terminal_cancellation
+   * @li asio::enable_partial_cancellation
+   * @li asio::enable_total_cancellation
+   */
   template <typename CancellationSlot, typename Filter>
   ASIO_CONSTEXPR cancellation_state(CancellationSlot slot, Filter filter)
     : impl_(slot.is_connected()
@@ -102,6 +127,29 @@ class cancellation_state
   }
 
   /// 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 asio::cancellation_type_t in_filter(
+   *     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 asio::cancellation_type_t out_filter(
+   *     asio::cancellation_type_t); @endcode
+   *
+   * The library provides the following pre-defined cancellation filters:
+   *
+   * @li asio::disable_cancellation
+   * @li asio::enable_terminal_cancellation
+   * @li asio::enable_partial_cancellation
+   * @li asio::enable_total_cancellation
+   */
   template <typename CancellationSlot, typename InFilter, typename OutFilter>
   ASIO_CONSTEXPR cancellation_state(CancellationSlot slot,
       InFilter in_filter, OutFilter out_filter)
@@ -122,7 +170,7 @@ class cancellation_state
     return impl_ ? impl_->signal_.slot() : cancellation_slot();
   }
 
-  /// Returns specified cancellation types have been triggered.
+  /// Returns the cancellation types that have been triggered.
   cancellation_type_t cancelled() const ASIO_NOEXCEPT
   {
     return impl_ ? impl_->cancelled_ : cancellation_type_t();

thirdparty/asio/asio/co_spawn.hpp

@@ -95,6 +95,11 @@ struct awaitable_signature<awaitable<void, Executor>>
  *     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 asio::this_coro::reset_cancellation_state.
  */
 template <typename Executor, typename T, typename AwaitableExecutor,
     ASIO_COMPLETION_TOKEN_FOR(
@@ -151,6 +156,11 @@ co_spawn(const Executor& ex, awaitable<T, AwaitableExecutor> a,
  *   echo(std::move(my_tcp_socket)),
  *   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 asio::this_coro::reset_cancellation_state.
  */
 template <typename Executor, typename AwaitableExecutor,
     ASIO_COMPLETION_TOKEN_FOR(
@@ -215,6 +225,11 @@ co_spawn(const Executor& ex, awaitable<void, AwaitableExecutor> a,
  *     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 asio::this_coro::reset_cancellation_state.
  */
 template <typename ExecutionContext, typename T, typename AwaitableExecutor,
     ASIO_COMPLETION_TOKEN_FOR(
@@ -274,6 +289,11 @@ co_spawn(ExecutionContext& ctx, awaitable<T, AwaitableExecutor> a,
  *   echo(std::move(my_tcp_socket)),
  *   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 asio::this_coro::reset_cancellation_state.
  */
 template <typename ExecutionContext, typename AwaitableExecutor,
     ASIO_COMPLETION_TOKEN_FOR(
@@ -309,7 +329,6 @@ co_spawn(ExecutionContext& ctx, awaitable<void, AwaitableExecutor> a,
  * Otherwise, the function signature of the completion handler must be:
  * @code void handler(std::exception_ptr, R); @endcode
  *
- *
  * @par Example
  * @code
  * asio::awaitable<std::size_t> echo(tcp::socket socket)
@@ -361,6 +380,11 @@ co_spawn(ExecutionContext& ctx, awaitable<void, AwaitableExecutor> a,
  *     }
  *   }, 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 asio::this_coro::reset_cancellation_state.
  */
 template <typename Executor, typename F,
     ASIO_COMPLETION_TOKEN_FOR(typename detail::awaitable_signature<
@@ -392,7 +416,6 @@ co_spawn(const Executor& ex, F&& f,
  * Otherwise, the function signature of the completion handler must be:
  * @code void handler(std::exception_ptr, R); @endcode
  *
- *
  * @par Example
  * @code
  * asio::awaitable<std::size_t> echo(tcp::socket socket)
@@ -444,6 +467,11 @@ co_spawn(const Executor& ex, F&& f,
  *     }
  *   }, 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 asio::this_coro::reset_cancellation_state.
  */
 template <typename ExecutionContext, typename F,
     ASIO_COMPLETION_TOKEN_FOR(typename detail::awaitable_signature<

thirdparty/asio/asio/experimental/coro.hpp

@@ -956,7 +956,7 @@ struct coro_promise final :
   }
 
   template <execution_context Context, typename... Args>
-  coro_promise(Context& ctx, Args &&...) noexcept
+  coro_promise(Context&& ctx, Args&&...) noexcept
     : executor_(ctx.get_executor())
   {
   }

thirdparty/asio/asio/experimental/detail/coro_promise_allocator.hpp

@@ -42,7 +42,7 @@ struct coro_promise_allocator
   }
 
   template <execution_context Context, typename... Args>
-  void* operator new(const std::size_t size, Context& ctx, Args&&... args)
+  void* operator new(const std::size_t size, Context&& ctx, Args&&... args)
   {
     return coro_promise_allocator::operator new(size,
         ctx.get_executor(), std::forward<Args>(args)...);
@@ -89,7 +89,7 @@ struct coro_promise_allocator<Coroutine, Executor, Allocator, true>
 
   template <execution_context Context, typename... Args>
   void* operator new(const std::size_t size,
-      Context& ctx, Args&&... args) noexcept
+      Context&& ctx, Args&&... args) noexcept
   {
     return coro_promise_allocator::operator new(size,
         ctx.get_executor(), std::forward<Args>(args)...);

thirdparty/asio/asio/experimental/detail/partial_promise.hpp

@@ -94,9 +94,10 @@ namespace std {
 
 template<typename ... Args>
 struct coroutine_traits<
-    std::experimental::coroutine_handle<coro::partial_promise>, Args...>
+    coroutine_handle<asio::experimental::detail::partial_promise>,
+    Args...>
 {
-  using promise_type = coro::partial_promise;
+  using promise_type = asio::experimental::detail::partial_promise;
 };
 
 } // namespace std

thirdparty/asio/asio/experimental/parallel_group.hpp

@@ -98,6 +98,10 @@ void parallel_group_launch(Condition cancellation_condition, Handler handler,
 } // namespace detail
 
 /// A group of asynchronous operations that may be launched in parallel.
+/**
+ * See the documentation for asio::experimental::make_parallel_group for
+ * a usage example.
+ */
 template <typename... Ops>
 class parallel_group
 {
@@ -113,6 +117,27 @@ class parallel_group
       typename detail::parallel_op_signature<Ops>::type...>::type signature;
 
   /// Initiate an asynchronous wait for the group of operations.
+  /**
+   * Launches the group and asynchronously waits for completion.
+   *
+   * @param cancellation_condition A function object, called on completion of
+   * an operation within the group, that is used to determine whether to cancel
+   * the remaining operations. The function object is passed the arguments of
+   * the completed operation's handler. To trigger cancellation of the remaining
+   * operations, it must return a asio::cancellation_type value other
+   * than <tt>asio::cancellation_type::none</tt>.
+   *
+   * @param token A completion token whose signature is comprised of
+   * a @c std::array<std::size_t, N> indicating the completion order of the
+   * operations, followed by all operations' completion handler arguments.
+   *
+   * The library provides the following @c cancellation_condition types:
+   *
+   * @li asio::experimental::wait_for_all
+   * @li asio::experimental::wait_for_one
+   * @li asio::experimental::wait_for_one_error
+   * @li asio::experimental::wait_for_one_success
+   */
   template <typename CancellationCondition,
       ASIO_COMPLETION_TOKEN_FOR(signature) CompletionToken>
   auto async_wait(CancellationCondition cancellation_condition,
@@ -138,6 +163,42 @@ class parallel_group
 };
 
 /// Create a group of operations that may be launched in parallel.
+/**
+ * For example:
+ * @code asio::experimental::make_parallel_group(
+ *    [&](auto token)
+ *    {
+ *      return in.async_read_some(asio::buffer(data), token);
+ *    },
+ *    [&](auto token)
+ *    {
+ *      return timer.async_wait(token);
+ *    }
+ *  ).async_wait(
+ *    asio::experimental::wait_for_all(),
+ *    [](
+ *        std::array<std::size_t, 2> completion_order,
+ *        std::error_code ec1, std::size_t n1,
+ *        std::error_code ec2
+ *    )
+ *    {
+ *      switch (completion_order[0])
+ *      {
+ *      case 0:
+ *        {
+ *          std::cout << "descriptor finished: " << ec1 << ", " << n1 << "\n";
+ *        }
+ *        break;
+ *      case 1:
+ *        {
+ *          std::cout << "timer finished: " << ec2 << "\n";
+ *        }
+ *        break;
+ *      }
+ *    }
+ *  );
+ * @endcode
+ */
 template <typename... Ops>
 inline parallel_group<Ops...> make_parallel_group(Ops... ops)
 {

thirdparty/asio/asio/experimental/promise.hpp

@@ -89,7 +89,7 @@ struct promise<void(Ts...), Executor>
 
   void cancel(cancellation_type level = cancellation_type::all)
   {
-    if (impl_)
+    if (impl_ && !impl_->done)
     {
       asio::dispatch(impl_->executor,
           [level, impl = impl_]{impl->cancel.emit(level);});
@@ -145,7 +145,7 @@ struct promise<void(Ts...), Executor>
         {
           [ct, s=self]<std::size_t... Idx>(std::index_sequence<Idx...>)
           {
-            (get<Idx>(s->tup).cancel(ct), ... );
+            (std::get<Idx>(s->tup).cancel(ct), ... );
           }(std::make_index_sequence<sizeof...(Ps)>{});
         }
       };
@@ -225,7 +225,7 @@ struct promise<void(Ts...), Executor>
         {
           [level, s=self]<std::size_t... Idx>(std::index_sequence<Idx...>)
           {
-            (get<Idx>(s->tup).cancel(level), ... );
+            (std::get<Idx>(s->tup).cancel(level), ... );
           }(std::make_index_sequence<sizeof...(Ps)>{});
         }
       };
@@ -246,10 +246,11 @@ struct promise<void(Ts...), Executor>
         {
           return [impl]<typename... Args>(Args&& ... args)
           {
-            get<I>(impl->partial_result).emplace(std::forward<Args>(args)...);
-            if ((get<Idx>(impl->partial_result) && ...)) // we're done.
+            std::get<I>(impl->partial_result).emplace(
+                std::forward<Args>(args)...);
+            if ((std::get<Idx>(impl->partial_result) && ...)) // we're done.
             {
-              impl->result = {*get<Idx>(impl->partial_result)...};
+              impl->result = {*std::get<Idx>(impl->partial_result)...};
 
               impl->done = true;
               if (auto f = std::exchange(impl->completion, nullptr); !!f)