CallbackManager.h

#ifndef CALLBACKMANAGER_H_INCLUDED
#define CALLBACKMANAGER_H_INCLUDED
 
#include <map>
 
#include "nta/ThreadPool.h"
 
namespace nta {
    class CallbackManager {
    private:
        struct event {
            uint64_t id;
            uint64_t when;
            uint64_t period;
            Thunk thunk;
        };
 
        static void dispatch();
        static void dequeue(uint64_t id);
 
        static std::map<uint64_t, event> m_active;
        static std::map<uint64_t, std::vector<event*>> m_queue;
 
        static utils::ThreadPool m_pool;
        static std::thread m_dispatcher;
        static std::atomic<uint64_t> m_next;
        // It's been a while since I've written parallel code, but am I overusing this?
        static std::mutex m_mutex;
        static std::condition_variable_any m_cv;
        static bool m_working;
        static uint64_t m_curr_frame;
    public:
        static uint64_t setInterval(const Thunk& thunk, uint64_t when, uint64_t period);
        static uint64_t setTimeout(const Thunk& thunk, uint64_t when);
        static bool delay(uint64_t id, uint64_t when, bool absolute = true);
        static void init();
        static void clear(uint64_t id);
        static void increment_frame();
        static void destroy();
    };
}
 
#endif // CALLBACKMANAGER_H_INCLUDED