AnyExecutionContext.hpp

#pragma once
 
#include "util/async/AnyOperation.hpp"
#include "util/async/AnyStopToken.hpp"
#include "util/async/AnyStrand.hpp"
#include "util/async/Concepts.hpp"
#include "util/async/impl/ErasedOperation.hpp"
 
#include <any>
#include <chrono>
#include <functional>
#include <memory>
#include <optional>
#include <type_traits>
#include <utility>
 
namespace util::async {

class AnyExecutionContext {
public:
    template <NotSameAs<AnyExecutionContext> CtxType>
    /* implicit */
    AnyExecutionContext(CtxType& ctx) : pimpl_{std::make_shared<Model<CtxType&>>(ctx)}
    {
    }

    template <RValueNotSameAs<AnyExecutionContext> CtxType>
    /* implicit */
    AnyExecutionContext(CtxType&& ctx)
        : pimpl_{std::make_shared<Model<CtxType>>(std::forward<CtxType>(ctx))}
    {
    }
 
    AnyExecutionContext(AnyExecutionContext const&) = default;
    AnyExecutionContext(AnyExecutionContext&&) = default;
    AnyExecutionContext&
    operator=(AnyExecutionContext const&) = default;
    AnyExecutionContext&
    operator=(AnyExecutionContext&&) = default;
    ~AnyExecutionContext() = default;

    [[nodiscard]] auto
    execute(SomeHandlerWithoutStopToken auto&& fn)
    {
        using RetType = std::decay_t<std::invoke_result_t<decltype(fn)>>;
        static_assert(not std::is_same_v<RetType, std::any>);
 
        return AnyOperation<RetType>(
            pimpl_->execute([fn = std::forward<decltype(fn)>(fn)] mutable -> std::any {
                if constexpr (std::is_void_v<RetType>) {
                    std::invoke(std::forward<decltype(fn)>(fn));
                    return {};
                } else {
                    return std::make_any<RetType>(std::invoke(std::forward<decltype(fn)>(fn)));
                }
            })
        );
    }

    [[nodiscard]] auto
    execute(SomeHandlerWith<AnyStopToken> auto&& fn)
    {
        using RetType = std::decay_t<std::invoke_result_t<decltype(fn), AnyStopToken>>;
        static_assert(not std::is_same_v<RetType, std::any>);
 
        return AnyOperation<RetType>(pimpl_->execute(
            [fn = std::forward<decltype(fn)>(fn)](auto stopToken) mutable -> std::any {
                if constexpr (std::is_void_v<RetType>) {
                    std::invoke(std::forward<decltype(fn)>(fn), std::move(stopToken));
                    return {};
                } else {
                    return std::make_any<RetType>(
                        std::invoke(std::forward<decltype(fn)>(fn), std::move(stopToken))
                    );
                }
            }
        ));
    }

    [[nodiscard]] auto
    execute(SomeHandlerWith<AnyStopToken> auto&& fn, SomeStdDuration auto timeout)
    {
        using RetType = std::decay_t<std::invoke_result_t<decltype(fn), AnyStopToken>>;
        static_assert(not std::is_same_v<RetType, std::any>);
 
        return AnyOperation<RetType>(pimpl_->execute(
            [fn = std::forward<decltype(fn)>(fn)](auto stopToken) mutable -> std::any {
                if constexpr (std::is_void_v<RetType>) {
                    std::invoke(std::forward<decltype(fn)>(fn), std::move(stopToken));
                    return {};
                } else {
                    return std::make_any<RetType>(
                        std::invoke(std::forward<decltype(fn)>(fn), std::move(stopToken))
                    );
                }
            },
            std::chrono::duration_cast<std::chrono::milliseconds>(timeout)
        ));
    }

    [[nodiscard]] auto
    scheduleAfter(SomeStdDuration auto delay, SomeHandlerWith<AnyStopToken> auto&& fn)
    {
        using RetType = std::decay_t<std::invoke_result_t<decltype(fn), AnyStopToken>>;
        static_assert(not std::is_same_v<RetType, std::any>);
 
        auto const millis = std::chrono::duration_cast<std::chrono::milliseconds>(delay);
        return AnyOperation<RetType>(pimpl_->scheduleAfter(
            millis, [fn = std::forward<decltype(fn)>(fn)](auto stopToken) mutable -> std::any {
                if constexpr (std::is_void_v<RetType>) {
                    std::invoke(std::forward<decltype(fn)>(fn), std::move(stopToken));
                    return {};
                } else {
                    return std::make_any<RetType>(
                        std::invoke(std::forward<decltype(fn)>(fn), std::move(stopToken))
                    );
                }
            }
        ));
    }

    [[nodiscard]] auto
    scheduleAfter(SomeStdDuration auto delay, SomeHandlerWith<AnyStopToken, bool> auto&& fn)
    {
        using RetType = std::decay_t<std::invoke_result_t<decltype(fn), AnyStopToken, bool>>;
        static_assert(not std::is_same_v<RetType, std::any>);
 
        auto const millis = std::chrono::duration_cast<std::chrono::milliseconds>(delay);
        return AnyOperation<RetType>(pimpl_->scheduleAfter(
            millis,
            [fn = std::forward<decltype(fn)>(fn)](auto stopToken, auto cancelled) mutable
                -> std::any {
                if constexpr (std::is_void_v<RetType>) {
                    std::invoke(std::forward<decltype(fn)>(fn), std::move(stopToken), cancelled);
                    return {};
                } else {
                    return std::make_any<RetType>(
                        std::invoke(std::forward<decltype(fn)>(fn), std::move(stopToken), cancelled)
                    );
                }
            }
        ));
    }

    [[nodiscard]] auto
    executeRepeatedly(SomeStdDuration auto interval, SomeHandlerWithoutStopToken auto&& fn)
    {
        using RetType = std::decay_t<std::invoke_result_t<decltype(fn)>>;
        static_assert(not std::is_same_v<RetType, std::any>);
 
        auto const millis = std::chrono::duration_cast<std::chrono::milliseconds>(interval);
        return AnyOperation<RetType>(  //
            pimpl_->executeRepeatedly(
                millis, [fn = std::forward<decltype(fn)>(fn)] mutable -> std::any {
                    std::invoke(std::forward<decltype(fn)>(fn));
                    return {};
                }
            )
        );
    }

    void
    submit(SomeHandlerWithoutStopToken auto&& fn)
    {
        pimpl_->submit(std::forward<decltype(fn)>(fn));
    }

    [[nodiscard]] auto
    makeStrand()
    {
        return pimpl_->makeStrand();
    }

    void
    stop() const
    {
        pimpl_->stop();
    }

    void
    join() const
    {
        pimpl_->join();
    }
 
private:
    struct Concept {
        virtual ~Concept() = default;
 
        virtual impl::ErasedOperation
        execute(
            std::function<std::any(AnyStopToken)>,
            std::optional<std::chrono::milliseconds> timeout = std::nullopt
        ) = 0;
        virtual impl::ErasedOperation execute(std::function<std::any()>) = 0;
        virtual impl::ErasedOperation
            scheduleAfter(std::chrono::milliseconds, std::function<std::any(AnyStopToken)>) = 0;
        virtual impl::ErasedOperation scheduleAfter(
            std::chrono::milliseconds,
            std::function<std::any(AnyStopToken, bool)>
        ) = 0;
        virtual impl::ErasedOperation
            executeRepeatedly(std::chrono::milliseconds, std::function<std::any()>) = 0;
        virtual void submit(std::function<void()>) = 0;
        virtual AnyStrand
        makeStrand() = 0;
        virtual void
        stop() const = 0;
        virtual void
        join() const = 0;
    };
 
    template <typename CtxType>
    struct Model : Concept {
        CtxType ctx;
 
        template <typename Type>
        Model(Type&& ctx) : ctx(std::forward<Type>(ctx))
        {
        }
 
        impl::ErasedOperation
        execute(
            std::function<std::any(AnyStopToken)> fn,
            std::optional<std::chrono::milliseconds> timeout
        ) override
        {
            return ctx.execute(std::move(fn), timeout);
        }
 
        impl::ErasedOperation
        execute(std::function<std::any()> fn) override
        {
            return ctx.execute(std::move(fn));
        }
 
        impl::ErasedOperation
        scheduleAfter(
            std::chrono::milliseconds delay,
            std::function<std::any(AnyStopToken)> fn
        ) override
        {
            return ctx.scheduleAfter(delay, std::move(fn));
        }
 
        impl::ErasedOperation
        scheduleAfter(
            std::chrono::milliseconds delay,
            std::function<std::any(AnyStopToken, bool)> fn
        ) override
        {
            return ctx.scheduleAfter(delay, std::move(fn));
        }
 
        impl::ErasedOperation
        executeRepeatedly(std::chrono::milliseconds interval, std::function<std::any()> fn) override
        {
            return ctx.executeRepeatedly(interval, std::move(fn));
        }
 
        void
        submit(std::function<void()> fn) override
        {
            return ctx.submit(std::move(fn));
        }
 
        AnyStrand
        makeStrand() override
        {
            return ctx.makeStrand();
        }
 
        void
        stop() const override
        {
            ctx.stop();
        }
 
        void
        join() const override
        {
            ctx.join();
        }
    };
 
private:
    std::shared_ptr<Concept> pimpl_;
};
 
}  // namespace util::async