Repeat.hpp

#pragma once
 
#include "util/Assert.hpp"
 
#include <boost/asio/any_io_executor.hpp>
#include <boost/asio/io_context.hpp>
#include <boost/asio/post.hpp>
#include <boost/asio/steady_timer.hpp>
#include <boost/asio/strand.hpp>
 
#include <atomic>
#include <chrono>
#include <concepts>
#include <memory>
#include <semaphore>
#include <utility>
 
namespace util {

class Repeat {
    struct Control {
        boost::asio::steady_timer timer;
        boost::asio::strand<boost::asio::any_io_executor> strand;
        std::atomic_bool stopping{true};
        std::binary_semaphore semaphore{0};
 
        Control(auto& ctx) : timer(ctx), strand(boost::asio::make_strand(ctx))
        {
        }
    };
 
    std::shared_ptr<Control> control_;
 
public:
    Repeat(auto& ctx) : control_(std::make_unique<Control>(ctx))
    {
    }
 
    Repeat(Repeat const&) = delete;
    Repeat&
    operator=(Repeat const&) = delete;
    Repeat(Repeat&&) = default;
    Repeat&
    operator=(Repeat&&) = default;

    void
    stop();

    template <std::invocable Action>
    void
    start(std::chrono::steady_clock::duration interval, Action&& action)
    {
        ASSERT(control_->stopping, "Should be stopped before starting");
        control_->stopping = false;
        startImpl(control_, interval, std::forward<Action>(action));
    }
 
private:
    template <std::invocable Action>
    static void
    startImpl(
        std::shared_ptr<Control> control,
        std::chrono::steady_clock::duration interval,
        Action&& action
    )
    {
        boost::asio::post(
            control->strand, [control, interval, action = std::forward<Action>(action)]() mutable {
                if (control->stopping) {
                    control->semaphore.release();
                    return;
                }
 
                control->timer.expires_after(interval);
                control->timer.async_wait(
                    [control,
                     interval,
                     action = std::forward<Action>(action)](auto const& ec) mutable {
                        if (ec or control->stopping) {
                            control->semaphore.release();
                            return;
                        }
                        action();
 
                        startImpl(std::move(control), interval, std::forward<Action>(action));
                    }
                );
            }
        );
    }
};
 
}  // namespace util