eventloop.h

Go to the documentation of this file.

 
#pragma once
 
#include <variant>
#include <functional>
#include <promeki/core/namespace.h>
#include <promeki/core/atomic.h>
#include <promeki/core/queue.h>
#include <promeki/core/list.h>
#include <promeki/core/timestamp.h>
#include <promeki/core/event.h>
 
PROMEKI_NAMESPACE_BEGIN
 
class ObjectBase;
 
class EventLoop {
        public:
                enum ProcessEventsFlag : uint32_t {
                        ExcludeTimers       = 0x01,  
                        ExcludePosted       = 0x02,  
                        WaitForMore         = 0x04   
                };
 
                static EventLoop *current();
 
                EventLoop();
 
                ~EventLoop();
 
                EventLoop(const EventLoop &) = delete;
                EventLoop &operator=(const EventLoop &) = delete;
 
                int exec();
 
                void processEvents(uint32_t flags = 0, unsigned int timeoutMs = 0);
 
                void quit(int returnCode = 0);
 
                void postCallable(std::function<void()> func);
 
                void postEvent(ObjectBase *receiver, Event *event);
 
                int startTimer(ObjectBase *receiver, unsigned int intervalMs,
                               bool singleShot = false);
 
                int startTimer(unsigned int intervalMs,
                               std::function<void()> func,
                               bool singleShot = false);
 
                void stopTimer(int timerId);
 
                bool isRunning() const { return _running.value(); }
 
                int exitCode() const { return _exitCode.value(); }
 
        private:
                struct CallableItem { std::function<void()> func; };
                struct EventItem { ObjectBase *receiver; Event *event; };
                struct QuitItem { int code; };
                using Item = std::variant<CallableItem, EventItem, QuitItem>;
 
                struct TimerInfo {
                        int                     id;
                        ObjectBase              *receiver;      
                        std::function<void()>   func;           
                        unsigned int            intervalMs;
                        bool                    singleShot;
                        TimeStamp               nextFire;
                };
 
                static thread_local EventLoop   *_current;
 
                Queue<Item>                     _queue;
                Atomic<bool>                    _running;
                Atomic<int>                     _exitCode;
                List<TimerInfo>                 _timers;
                Atomic<int>                     _nextTimerId{1};
 
                bool dispatchItem(Item &item);
                void processTimers();
                unsigned int nextTimerTimeout() const;
};
 
PROMEKI_NAMESPACE_END