Merge pull request #1620 from RobertLeahy/completion_token_20250825

ericniebler · web-flow · commit daf12bcc4643 · 2025-09-07T21:02:18.000-07:00
asioexec::completion_token: Various Fixes/Updates
diff --git a/include/asioexec/as_default_on.hpp b/include/asioexec/as_default_on.hpp
@@ -0,0 +1,50 @@
+/*
+ * SPDX-FileCopyrightText: Copyright (c) 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+ *                         Copyright (c) 2025 Robert Leahy. All rights reserved.
+ * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+ *
+ * Licensed under the Apache License, Version 2.0 with LLVM Exceptions (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * https://llvm.org/LICENSE.txt
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#include <type_traits>
+#include <utility>
+#include <asioexec/asio_config.hpp>
+#include <asioexec/executor_with_default.hpp>
+
+namespace asioexec {
+
+  template <typename CompletionToken, typename IoObject>
+  using as_default_on_t =
+    typename std::remove_cvref_t<IoObject>::template rebind_executor<executor_with_default<
+      std::remove_cvref_t<decltype(std::declval<IoObject&>().get_executor())>,
+      CompletionToken>>::other;
+
+  namespace detail::as_default_on {
+
+    template <typename CompletionToken>
+    struct t {
+      template <typename IoObject>
+      constexpr asioexec::as_default_on_t<CompletionToken, IoObject>
+        operator()(IoObject&& io) const {
+        return asioexec::as_default_on_t<CompletionToken, IoObject>((IoObject&&) io);
+      }
+    };
+
+  } // namespace detail::as_default_on
+
+  template <typename CompletionToken>
+  inline constexpr detail::as_default_on::t<CompletionToken> as_default_on;
+
+} // namespace asioexec
diff --git a/include/asioexec/completion_token.hpp b/include/asioexec/completion_token.hpp
@@ -26,6 +26,8 @@
 #include <tuple>
 #include <type_traits>
 #include <utility>
+#include <version>
+#include <asioexec/as_default_on.hpp>
 #include <asioexec/asio_config.hpp>
 #include <stdexec/execution.hpp>
 
@@ -68,7 +70,32 @@ namespace asioexec {
     };
 
     template <typename T, typename U>
-      requires std::is_same_v<T&&, U&&> || std::is_convertible_v<U&&, T&&>
+    inline constexpr bool at_least_as_const_qualified_v = std::is_const_v<T> || !std::is_const_v<U>;
+    template <typename T, typename U>
+    inline constexpr bool at_least_as_volatile_qualified_v = std::is_volatile_v<T>
+                                                          || !std::is_volatile_v<U>;
+    template <typename T, typename U>
+    inline constexpr bool at_least_as_qualified_v = at_least_as_const_qualified_v<T, U>
+                                                 && at_least_as_volatile_qualified_v<T, U>;
+
+    template <typename T, typename U>
+      requires
+#ifdef __cpp_lib_reference_from_temporary
+      (std::is_convertible_v<U &&, T &&> && !std::reference_converts_from_temporary_v<T &&, U &&>)
+#else
+      (
+        //  Just using is_base_of_v is insufficient because it always reports false for built-in types
+        (std::is_base_of_v<std::remove_cvref_t<T>, std::remove_cvref_t<U>>
+         || std::is_same_v<std::remove_cvref_t<T>, std::remove_cvref_t<U>>)
+        &&
+        //  The returned type must be at least as cv-qualified as the input type (it can be more cv-qualified)
+        at_least_as_qualified_v<std::remove_reference_t<T>, std::remove_reference_t<U>>
+        && (
+          //  Reference type must agree except...
+          (std::is_lvalue_reference_v<T> == std::is_lvalue_reference_v<T>) ||
+          //  ...special rules for const& which allows rvalues to bind thereto
+          (std::is_lvalue_reference_v<T> && std::is_const_v<std::remove_reference_t<T>>) ))
+#endif
     constexpr T&& convert(U&& u) noexcept {
       return static_cast<U&&>(u);
     }
@@ -109,18 +136,6 @@ namespace asioexec {
       ::stdexec::set_stopped_t()
     >;
 
-    struct stop_callback {
-      constexpr explicit stop_callback(asio_impl::cancellation_signal& signal) noexcept
-        : signal_(signal) {
-      }
-
-      void operator()() && noexcept {
-        signal_.emit(asio_impl::cancellation_type::partial);
-      }
-     private:
-      asio_impl::cancellation_signal& signal_;
-    };
-
     template <typename, typename>
     class completion_handler;
 
@@ -141,7 +156,7 @@ namespace asioexec {
       std::recursive_mutex m_;
       frame_* frames_{nullptr};
       std::exception_ptr ex_;
-      completion_handler<Signatures, Receiver>* h_{nullptr};
+      bool abandoned_{false};
 
       class frame_ {
         operation_state_base& self_;
@@ -161,10 +176,11 @@ namespace asioexec {
           if (l_) {
             STDEXEC_ASSERT(self_.frames_ == this);
             self_.frames_ = prev_;
-            if (!self_.frames_ && !self_.h_) {
+            if (!self_.frames_ && self_.abandoned_) {
               //  We are the last frame and the handler is gone so it's up to us to
               //  finalize the operation
               l_.unlock();
+              self_.callback_.reset();
               if (self_.ex_) {
                 ::stdexec::set_error(static_cast<Receiver&&>(self_.r_), std::move(self_.ex_));
               } else {
@@ -206,9 +222,18 @@ namespace asioexec {
         }
       }
      protected:
+      struct on_stop_request_ {
+        void operator()() && noexcept {
+          const std::lock_guard l(self_.m_);
+          self_.signal_.emit(asio_impl::cancellation_type::all);
+        }
+
+        operation_state_base& self_;
+      };
+     public:
       std::optional<::stdexec::stop_callback_for_t<
         ::stdexec::stop_token_of_t<::stdexec::env_of_t<Receiver>>,
-        stop_callback
+        on_stop_request_
       >>
         callback_;
     };
@@ -219,16 +244,10 @@ namespace asioexec {
      public:
       explicit completion_handler(operation_state_base<Signatures, Receiver>& self) noexcept
         : self_(&self) {
-        STDEXEC_ASSERT(!self_->h_);
-        self_->h_ = this;
       }
 
       completion_handler(completion_handler&& other) noexcept
         : self_(std::exchange(other.self_, nullptr)) {
-        if (self_) {
-          const std::lock_guard l(self_->m_);
-          self_->h_ = this;
-        }
       }
 
       completion_handler& operator=(const completion_handler&) = delete;
@@ -239,7 +258,7 @@ namespace asioexec {
           //  it might defer that to the executor frames above us on the call stack
           //  (if any)
           const typename operation_state_base<Signatures, Receiver>::frame_ frame(*self_);
-          self_->h_ = nullptr;
+          self_->abandoned_ = true;
         }
       }
 
@@ -253,6 +272,7 @@ namespace asioexec {
           }
           STDEXEC_ASSERT(!self_->frames_);
         }
+        self_->callback_.reset();
         if (self_->ex_) {
           ::stdexec::set_error(static_cast<Receiver&&>(self_->r_), std::move(self_->ex_));
         } else {
@@ -315,14 +335,16 @@ namespace asioexec {
           if (!base_::ex_) {
             base_::ex_ = std::current_exception();
           }
-          return;
+          //  It's important that we fallthrough here, just because the
+          //  initiating function threw doesn't mean that there's no outstanding
+          //  operations
         }
         //  In the case of an immediate completion *this may already be outside its
         //  lifetime so we can't proceed into the branch
         if (frame) {
           base_::callback_.emplace(
             ::stdexec::get_stop_token(::stdexec::get_env(base_::r_)),
-            stop_callback(base_::signal_));
+            typename base_::on_stop_request_{*this});
         }
       }
     };
@@ -490,7 +512,11 @@ namespace asioexec {
 
   } // namespace detail::completion_token
 
-  struct completion_token_t { };
+  struct completion_token_t {
+    static constexpr auto as_default_on = asioexec::as_default_on<completion_token_t>;
+    template <typename IoObject>
+    using as_default_on_t = asioexec::as_default_on_t<completion_token_t, IoObject>;
+  };
 
   inline const completion_token_t completion_token{};
 
diff --git a/include/asioexec/executor_with_default.hpp b/include/asioexec/executor_with_default.hpp
@@ -0,0 +1,33 @@
+/*
+ * SPDX-FileCopyrightText: Copyright (c) 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+ *                         Copyright (c) 2025 Robert Leahy. All rights reserved.
+ * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+ *
+ * Licensed under the Apache License, Version 2.0 with LLVM Exceptions (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * https://llvm.org/LICENSE.txt
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#include <asioexec/asio_config.hpp>
+
+namespace asioexec {
+
+  template <typename Executor, typename CompletionToken>
+  struct executor_with_default : Executor {
+    using default_completion_token_type = CompletionToken;
+    executor_with_default(const Executor& ex) noexcept
+      : Executor(ex) {
+    }
+  };
+
+} // namespace asioexec
diff --git a/include/asioexec/use_sender.hpp b/include/asioexec/use_sender.hpp
@@ -23,6 +23,7 @@
 #include <system_error>
 #include <type_traits>
 #include <utility>
+#include <asioexec/as_default_on.hpp>
 #include <asioexec/asio_config.hpp>
 #include <asioexec/completion_token.hpp>
 #include <stdexec/execution.hpp>
@@ -196,7 +197,11 @@ namespace asioexec {
 
   } // namespace detail::use_sender
 
-  struct use_sender_t { };
+  struct use_sender_t {
+    static constexpr auto as_default_on = asioexec::as_default_on<use_sender_t>;
+    template <typename IoObject>
+    using as_default_on_t = asioexec::as_default_on_t<use_sender_t, IoObject>;
+  };
 
   inline const use_sender_t use_sender{};
 
diff --git a/test/asioexec/test_completion_token.cpp b/test/asioexec/test_completion_token.cpp
diff --git a/test/asioexec/test_use_sender.cpp b/test/asioexec/test_use_sender.cpp
