EventQueue.h

Go to the documentation of this file.

 
 #pragma once
 
 #include <iostream>
 #include <mutex>
 #include <thread>
 #include <condition_variable>
 #include <functional>
 #include <future>
 #include <deque>
 #include <optional>
 #include <algorithm>
 #include <variant>
 #include "Message.h"
 
 // Forward declaration
 namespace swt {
     template<typename T> class Promise;
 }
 
 namespace swt {
 class EventQueue
 {
 public:
     enum class QueueItemType { 
         MESSAGE,    
         FUNCTION    
     };
     
     struct QueueItem {
         QueueItemType type;                          
         int64_t whenUs;                             
         std::shared_ptr<Message> message;           
         std::packaged_task<void()> task;           
         QueueItem(std::shared_ptr<Message> msg, int64_t when) 
             : type(QueueItemType::MESSAGE), whenUs(when), message(msg) {}
             
         QueueItem(std::packaged_task<void()>&& t, int64_t when)
             : type(QueueItemType::FUNCTION), whenUs(when), task(std::move(t)) {}
         
         QueueItem(QueueItem&& other) noexcept
             : type(other.type), whenUs(other.whenUs), 
             message(std::move(other.message)), task(std::move(other.task)) {}
         
         QueueItem& operator=(QueueItem&& other) noexcept {
             if (this != &other) {
                 type = other.type;
                 whenUs = other.whenUs;
                 message = std::move(other.message);
                 task = std::move(other.task);
             }
             return *this;
         }
         
         QueueItem(const QueueItem&) = delete;
         
         QueueItem& operator=(const QueueItem&) = delete;
     };
 
 public:
     EventQueue();
     
     ~EventQueue();
     
     // ========== LEGACY MESSAGE API ==========
     
     bool enqueueMessage(const std::shared_ptr<Message>& message, int64_t whenUs);
     
     std::shared_ptr<Message> poll();
 
     bool isQuit();
 
     // ========== MODERN FUNCTION API ==========
 
     template<typename F, typename... Args>
     auto enqueueFunction(F&& func, Args&&... args) -> std::future<decltype(func(args...))>;
     
     template<typename F, typename... Args>  
     auto enqueueFunctionDelayed(int64_t delayMs, F&& func, Args&&... args) -> std::future<decltype(func(args...))>;
     
     // ========== PROMISE INTEGRATION ==========
 
     template<typename T>
     Promise<T> enqueuePromise();
     
     // ========== UNIFIED POLLING ==========
 
     std::optional<QueueItem> pollNext();
     
     // ========== QUEUE CONTROL ==========
 
     void quit();
     
     bool hasMessage(const std::shared_ptr<Handler>& h, int32_t what, void* obj);
     
     int64_t uptimeMicros();
 
 private:
     std::deque<QueueItem> mQueue;                    
     std::shared_ptr<Message> mCurrentMessage;       
     std::mutex iMutex;                              
     bool mStarted;                                  
     mutable bool mQuit;                             
     std::condition_variable mQueueChanged;          
 };
 }
 // Include template implementations
 #include "EventQueue.tpp"