simple_dispatcher.h

#pragma once
#include <asyncpp/dispatcher.h>
 
#include <atomic>
#include <condition_variable>
#include <deque>
#include <mutex>
 
namespace asyncpp {
 
    class simple_dispatcher : public dispatcher {
        std::mutex m_mtx;
        std::condition_variable m_cv;
        std::deque<std::function<void()>> m_queue;
        std::atomic<bool> m_done = false;
 
    public:
        void push(std::function<void()> cbfn) override {
            if (!cbfn) return;
            std::unique_lock lck{m_mtx};
            m_queue.emplace_back(std::move(cbfn));
            m_cv.notify_all();
        }
 
        void stop() noexcept {
            std::unique_lock lck{m_mtx};
            m_done = true;
            m_cv.notify_all();
        }
 
        void run() {
            dispatcher* const old_dispatcher = dispatcher::current(this);
            while (!m_done) {
                std::unique_lock lck{m_mtx};
                if (m_queue.empty()) {
                    m_cv.wait(lck);
                    continue;
                }
                auto cbfn = std::move(m_queue.front());
                m_queue.pop_front();
                lck.unlock();
                if (cbfn) cbfn();
            }
            dispatcher::current(old_dispatcher);
        }
    };
} // namespace asyncpp