Concepts.hpp

#pragma once
 
#include <boost/asio/spawn.hpp>
 
#include <chrono>
#include <concepts>
#include <functional>
#include <optional>
#include <type_traits>
 
namespace util::async {

struct ExecutionContextTag {
    virtual ~ExecutionContextTag() = default;
};

template <typename T>
concept SomeExecutionContext = std::derived_from<std::remove_cvref_t<T>, ExecutionContextTag>;

template <typename T>
concept SomeStoppable = requires(T v) {
    { v.requestStop() } -> std::same_as<void>;
};

template <typename T>
concept SomeCancellable = requires(T v) {
    { v.cancel() } -> std::same_as<void>;
};

template <typename T>
concept SomeAwaitable = requires(T v) {
    { v.wait() } -> std::same_as<void>;
};

template <typename T>
concept SomeAbortable = requires(T v) {
    { v.abort() } -> std::same_as<void>;
};

template <typename T>
concept SomeOperation = SomeAwaitable<T> or SomeAbortable<T>;

template <typename T>
concept SomeOperationWithData = SomeOperation<T> and requires(T v) {
    { v.get() };
};

template <typename T>
concept SomeForceInvocableOperation = SomeOperation<T> and requires(T v) {
    { v.invoke() };
};

template <typename T>
concept SomeStoppableOperation = SomeOperation<T> and SomeStoppable<T>;

template <typename T>
concept SomeCancellableOperation = SomeOperation<T> and SomeCancellable<T>;

template <typename T>
concept SomeOutcome = requires(T v) {
    { v.getOperation() } -> SomeOperation;
};

template <typename T>
concept SomeStopToken = requires(T v) {
    { v.isStopRequested() } -> std::same_as<bool>;
};

template <typename T>
concept SomeYieldStopSource = requires(T v, boost::asio::yield_context yield) {
    { v[yield] } -> SomeStopToken;
};

template <typename T>
concept SomeSimpleStopSource = requires(T v) {
    { v.getToken() } -> SomeStopToken;
};

template <typename T>
concept SomeStopSource = (SomeSimpleStopSource<T> or SomeYieldStopSource<T>) and SomeStoppable<T>;

template <typename T>
concept SomeStopSourceProvider = requires(T v) {
    { v.getStopSource() } -> SomeStopSource;
};

template <typename T>
concept SomeStoppableOutcome = SomeOutcome<T> and SomeStopSourceProvider<T>;

template <typename T>
concept SomeHandlerWithoutStopToken = requires(T fn) {
    { std::invoke(fn) };
};

template <typename T, typename... Args>
concept SomeHandlerWith = requires(T fn) {
    { std::invoke(fn, std::declval<Args>()...) };
};

template <typename T>
concept SomeStdDuration = requires {
    // Thank you Ed Catmur for this trick.
    // See
    // https://stackoverflow.com/questions/74383254/concept-that-models-only-the-stdchrono-duration-types
    []<typename Rep, typename Period>(  //
        std::type_identity<std::chrono::duration<Rep, Period>>
    ) {}(std::type_identity<std::decay_t<T>>());
};

template <typename T>
concept SomeStdOptional = requires {
    []<typename Type>(  //
        std::type_identity<std::optional<Type>>
    ) {}(std::type_identity<std::decay_t<T>>());
};

template <typename T>
concept SomeOptStdDuration = SomeStdOptional<T> and SomeStdDuration<decltype(T{}.value())>;

template <typename T, typename Erased>
concept NotSameAs = not std::is_same_v<std::decay_t<T>, Erased>;

template <typename T, typename Erased>
concept RValueNotSameAs = requires(T&& t) {
    requires std::is_rvalue_reference_v<decltype(t)>;
    requires NotSameAs<T, Erased>;
};
 
}  // namespace util::async