action_queue.hpp

#pragma once
 
#include <boost/asio/io_context.hpp>
#include <boost/asio/strand.hpp>
 
#include <queue>
 
namespace malloy::detail
{

    template<typename Executor>
    class action_queue
    {
        using act_t  = std::function<void(const std::function<void()>&)>;
        using acts_t = std::queue<act_t>;
        using ioc_t  = boost::asio::strand<Executor>;
 
    public:
        explicit
        action_queue(ioc_t ioc) :
            m_ioc{std::move(ioc)}
        {
        }

        void
        push(act_t act)
        {
            boost::asio::dispatch(m_ioc, [this, act = std::move(act)]() mutable -> void {
                m_acts.push(std::move(act));
                if (!m_currently_running_act) {
                    run();
                }
            });
        }

        void
        run()
        {
            m_running = true;
            exe_next();
        }
 
    private:
        void
        exe_next()
        {
            // Running now...
            m_currently_running_act = true;
 
            // Execute
            boost::asio::dispatch(m_ioc, [this] {
                if (!m_acts.empty()) {
                    auto act = std::move(m_acts.front());
                    m_acts.pop();
                    std::invoke(std::move(act), [this] {
                        if (!m_acts.empty())
                            exe_next();
                        else
                            m_currently_running_act = false;
                    });
                }
 
                // Nothing left to do...
                else
                    m_currently_running_act = false;
            });
        }
 
        acts_t m_acts;
        ioc_t m_ioc;
        std::atomic_bool m_running{false};
        std::atomic_bool m_currently_running_act{false};
    };
 
}    // namespace malloy::detail