Operation.hpp

#pragma once
 
#include "util/MoveTracker.hpp"
#include "util/Repeat.hpp"
#include "util/async/Concepts.hpp"
#include "util/async/Outcome.hpp"
#include "util/async/context/impl/Cancellation.hpp"
#include "util/async/context/impl/Timer.hpp"
 
#include <fmt/format.h>
 
#include <chrono>
#include <concepts>
#include <condition_variable>
#include <expected>
#include <functional>
#include <future>
#include <memory>
#include <mutex>
#include <optional>
 
namespace util::async {
namespace impl {
 
template <typename OutcomeType>
class BasicOperation {
protected:
    std::future<typename OutcomeType::DataType> future_;
 
public:
    using DataType = typename OutcomeType::DataType;
 
    explicit BasicOperation(OutcomeType* outcome) : future_{outcome->getStdFuture()}
    {
    }
 
    BasicOperation(BasicOperation&&) = default;
 
    BasicOperation(BasicOperation const&) = delete;
 
    [[nodiscard]] auto
    get()
    {
        return future_.get();
    }
 
    void
    wait()
    {
        future_.wait();
    }
};
 
template <typename CtxType, typename OpType>
struct BasicScheduledOperation : util::MoveTracker {
    class State {
        std::mutex m_;
        std::condition_variable ready_;
        std::optional<OpType> op_{std::nullopt};
 
    public:
        void
        emplace(auto&& op)
        {
            std::lock_guard const lock{m_};
            op_.emplace(std::forward<decltype(op)>(op));
            ready_.notify_all();
        }
 
        [[nodiscard]] OpType&
        get()
        {
            std::unique_lock lock{m_};
            ready_.wait(lock, [this] { return op_.has_value(); });
            return op_.value();
        }
    };
 
    std::shared_ptr<State> state = std::make_shared<State>();
    typename CtxType::Timer timer;
 
    BasicScheduledOperation(auto& executor, auto delay, auto&& fn)
        : timer(
              executor,
              delay,
              [state = state, fn = std::forward<decltype(fn)>(fn)](auto ec) mutable {
                  state->emplace(fn(ec));
              }
          )
    {
    }
 
    ~BasicScheduledOperation() override
    {
        if (not wasMoved())
            abort();
    }
 
    BasicScheduledOperation(BasicScheduledOperation const&) = default;
    BasicScheduledOperation&
    operator=(BasicScheduledOperation const&) = default;
    BasicScheduledOperation(BasicScheduledOperation&&) = default;
    BasicScheduledOperation&
    operator=(BasicScheduledOperation&&) = default;
 
    [[nodiscard]] auto
    get()
    {
        return state->get().get();
    }
 
    void
    wait() noexcept
    {
        state->get().wait();
    }
 
    void
    cancel() noexcept
    {
        timer.cancel();
    }
 
    void
    requestStop() noexcept
        requires(SomeStoppableOperation<OpType>)
    {
        state->get().requestStop();
    }
 
    void
    abort() noexcept
    {
        cancel();
 
        if constexpr (SomeStoppableOperation<OpType>)
            requestStop();
    }
};
 
}  // namespace impl

template <typename RetType, typename StopSourceType>
class StoppableOperation : public impl::BasicOperation<StoppableOutcome<RetType, StopSourceType>>,
                           public util::MoveTracker {
    using OutcomeType = StoppableOutcome<RetType, StopSourceType>;
 
    StopSourceType stopSource_;
 
public:
    explicit StoppableOperation(OutcomeType* outcome)
        : impl::BasicOperation<OutcomeType>(outcome), stopSource_(outcome->getStopSource())
    {
    }
 
    ~StoppableOperation() override
    {
        if (not wasMoved())
            requestStop();
    }
 
    StoppableOperation(StoppableOperation const&) = delete;
    StoppableOperation&
    operator=(StoppableOperation const&) = delete;
    StoppableOperation(StoppableOperation&&) = default;
    StoppableOperation&
    operator=(StoppableOperation&&) = default;

    void
    requestStop() noexcept
    {
        stopSource_.requestStop();
    }
};

template <typename RetType>
using Operation = impl::BasicOperation<Outcome<RetType>>;

template <typename CtxType, typename OpType>
using ScheduledOperation = impl::BasicScheduledOperation<CtxType, OpType>;

template <typename CtxType>
class RepeatingOperation : public util::MoveTracker {
    util::Repeat repeat_;
    std::function<void()> action_;
 
public:
    template <std::invocable FnType>
    RepeatingOperation(auto& executor, std::chrono::steady_clock::duration interval, FnType&& fn)
        : repeat_(executor)
        , action_([fn = std::forward<FnType>(fn), &executor] { boost::asio::post(executor, fn); })
    {
        repeat_.start(interval, action_);
    }
 
    ~RepeatingOperation() override
    {
        if (not wasMoved())
            abort();
    }
 
    RepeatingOperation(RepeatingOperation const&) = delete;
    RepeatingOperation&
    operator=(RepeatingOperation const&) = delete;
    RepeatingOperation(RepeatingOperation&&) = default;
    RepeatingOperation&
    operator=(RepeatingOperation&&) = default;

    void
    abort() noexcept
    {
        repeat_.stop();
    }

    void
    invoke()
    {
        action_();
    }
};
 
}  // namespace util::async