scope.h

Go to the documentation of this file.

#pragma once
 
#include "di/execution/algorithm/ensure_started.h"
#include "di/execution/algorithm/just.h"
#include "di/execution/algorithm/start_detached.h"
#include "di/execution/concepts/sender.h"
#include "di/execution/concepts/sender_in.h"
#include "di/execution/interface/get_env.h"
#include "di/execution/meta/env_of.h"
#include "di/execution/query/get_allocator.h"
#include "di/execution/sequence/sequence_sender.h"
#include "di/function/tag_invoke.h"
#include "di/meta/operations.h"
#include "di/meta/vocab.h"
#include "di/util/reference_wrapper.h"
#include "di/util/unwrap_reference.h"
 
namespace di::execution {
namespace request_stop_ns {
    template<typename Scope>
    concept MemberInvocable = requires(meta::UnwrapReference<Scope>& scope) { scope.request_stop(); };
 
    struct Function {
        template<typename Scope>
        requires(MemberInvocable<Scope> || concepts::TagInvocable<Function, meta::UnwrapReference<Scope>&>)
        auto operator()(Scope& scope) const -> bool {
            if constexpr (MemberInvocable<Scope>) {
                static_assert(concepts::BooleanTestable<decltype(unwrap_reference(scope).request_stop())>,
                              "request_stop() member function must return a boolean.");
                return unwrap_reference(scope).request_stop();
            } else {
                static_assert(concepts::BooleanTestable<meta::TagInvokeResult<Function, meta::UnwrapReference<Scope>&>>,
                              "request_stop() customizations must return a boolean.");
                return tag_invoke(*this, unwrap_reference(scope));
            }
        }
    };
}

constexpr inline auto request_stop = request_stop_ns::Function {};
 
namespace nest_ns {
    struct Function {
        template<typename Scope, concepts::Sender Send>
        requires(concepts::TagInvocable<Function, meta::UnwrapReference<Scope>&, Send>)
        auto operator()(Scope& scope, Send&& sender) const {
            static_assert(concepts::Sender<meta::TagInvokeResult<Function, meta::UnwrapReference<Scope>&, Send&&>>,
                          "nest() customizations must return a Sender.");
            return tag_invoke(*this, unwrap_reference(scope), util::forward<Send>(sender));
        }
    };
}

constexpr inline auto nest = nest_ns::Function {};
 
namespace spawn_ns {
    struct Function {
        template<typename Scope, concepts::NextSender<meta::EnvOf<Scope>> Send>
        auto operator()(Scope& scope, Send&& sender) const {
            if constexpr (concepts::TagInvocable<Function, meta::UnwrapReference<Scope>&, Send&&>) {
                static_assert(
                    concepts::MaybeFallible<meta::TagInvokeResult<Function, meta::UnwrapReference<Scope>&, Send&&>,
                                            void>,
                    "spawn() customizations must return a maybe fallible void.");
                return tag_invoke(*this, unwrap_reference(scope), util::forward<Send>(sender));
            } else {
                auto allocator = get_allocator(get_env(scope));
                return start_detached(nest(scope, util::forward<Send>(sender)), util::move(allocator));
            }
        }
    };
}

constexpr inline auto spawn = spawn_ns::Function {};
 
namespace spawn_future_ns {
    struct Function {
        template<typename Scope, concepts::SenderIn<meta::EnvOf<Scope>> Send>
        auto operator()(Scope& scope, Send&& sender) const {
            if constexpr (concepts::TagInvocable<Function, meta::UnwrapReference<Scope>&, Send>) {
                static_assert(
                    concepts::Sender<
                        meta::UnwrapExpected<meta::TagInvokeResult<Function, meta::UnwrapReference<Scope>&, Send&&>>>,
                    "nest() customizations must return a maybe fallible Sender.");
                return tag_invoke(*this, unwrap_reference(scope), util::forward<Send>(sender));
            } else {
                auto allocator = get_allocator(get_env(scope));
                return ensure_started(nest(scope, util::forward<Send>(sender)), util::move(allocator));
            }
        }
    };
}

constexpr inline auto spawn_future = spawn_future_ns::Function {};

template<typename T>
concept Scope = requires(T& scope) {
    request_stop(scope);
    nest(scope, stopped);
    spawn(scope, stopped);
    spawn_future(scope, stopped);
};
}