Class task

include/stdexec/__detail/__task.hpp:270–533

  // STDEXEC::task
  template <class _Ty = void, class _TaskEnv = env<>>
  class [[nodiscard]] task
  {
    struct __promise;
    template <class _Env>
    using __own_env_t = __task::__environment_type<_TaskEnv, _Env>;
   public:
    using sender_concept       = sender_tag;
    using promise_type         = __promise;
    using allocator_type       = __task::__allocator_type<_TaskEnv>;
    using start_scheduler_type = __task::__start_scheduler_type<_TaskEnv>;
    using stop_source_type     = __task::__stop_source_type<_TaskEnv>;
    using stop_token_type      = __task::__stop_source_token_t<stop_source_type>;
    using error_types          = __task::__error_types<_TaskEnv>;

    constexpr task(task&& __that) noexcept
      : __coro_(std::exchange(__that.__coro_, {}))
    {}

    constexpr ~task()
    {
      if (__coro_)
        STDEXEC::__coroutine_destroy_nothrow(__coro_);
    }

    [[nodiscard]]
    constexpr auto get_env() const noexcept
    {
      return __attrs{};
    }

    // This transforms a task into an __awaiter that can perform symmetric transfer when
    // co_awaited.
    template <class _ParentPromise>
      requires __task::__has_compatible_environment_with<env_of_t<_ParentPromise&>, _TaskEnv>
    [[nodiscard]]
    constexpr auto as_awaitable(_ParentPromise& __parent) && noexcept
    {
      return __awaiter<_ParentPromise>(static_cast<task&&>(*this), __parent);
    }

   private:
    using __on_stopped_t   = __forward_stop_request<stop_source_type>;
    using __stop_variant_t = __variant<stop_source_type, stop_token_type>;

    template <class _Env>
    using __stop_callback_t = stop_callback_for_t<stop_token_of_t<_Env>, __on_stopped_t>;

    template <class _Env>
    using __stop_callback_box_t = __task::__stop_callback_box_t<_Env, stop_source_type>;

    template <class _Env>
    static constexpr bool __needs_stop_callback =
      __not_same_as<stop_token_type, stop_token_of_t<_Env>>;

    template <class _Env>
    static constexpr bool __nothrow_callback_registration = noexcept(
      __declval<__stop_callback_box_t<_Env>&>()
        .__register_callback(__declval<_Env&>(), __declval<__stop_variant_t&>()));