SLLooper.h

Go to the documentation of this file.

 
 #pragma once
 #include <memory>
 #include <thread>
 #include <future>
 #include <atomic>
 #include <chrono> 
 #include <type_traits> 
 #include "Timer.h"
 #include "EventQueue.h"
 #include "Task.h"
 #include "Awaitable.h"
 #include "TimerManager.h" 
 
 namespace swt {
 template<typename T> class Promise;
 
 template<typename T> class WorkAwaitable;
 class DelayAwaitable;
 template<typename T> class PostAwaitable;
 
 class SLLooper : public std::enable_shared_from_this<SLLooper>
 {
 public:
     SLLooper();
     
     ~SLLooper();
     
     std::shared_ptr<EventQueue> getEventQueue();
 
     // ========== INTERNAL DEBUG API ==========
     
     template<typename F, typename... Args>
     auto post_internal(F&& func, Args&&... args, const char* file, int line, const char* funcname)
         -> std::future<decltype(func(args...))>;
 
     template<typename F, typename... Args>
     auto postDelayed_internal(int64_t delayMs, F&& func, Args&&... args, const char* file, int line, const char* funcname)
         -> std::future<decltype(func(args...))>;
 
     // ========== PUBLIC ASYNC API ==========
 
     template<typename F, typename... Args>
     auto post(F&& func, Args&&... args) -> std::future<decltype(func(args...))>;
     
     template<typename F, typename... Args>
     auto postDelayed(int64_t delayMs, F&& func, Args&&... args) -> std::future<decltype(func(args...))>;
     
     // ========== PROMISE API ==========
 
     template<typename T>
     swt::Promise<T> createPromise();
     
     // ========== CPU-BOUND TASK API ==========
 
     template<typename Func>
     auto postWork(Func&& func) -> swt::Promise<decltype(func())>;
 
     template<typename Func>
     auto postWork(Func&& func, std::chrono::milliseconds timeout) 
         -> swt::Promise<decltype(func())>;
 
     // ========== COROUTINE API ==========
     
     template<typename Func>
     auto awaitWork(Func&& func) -> WorkAwaitable<decltype(func())> {
         return WorkAwaitable<decltype(func())>(shared_from_this(), std::forward<Func>(func));
     }
 
     DelayAwaitable awaitDelay(int delayMs) {
         return DelayAwaitable(shared_from_this(), delayMs);
     }
 
     template<typename Func>
     auto awaitPost(Func&& func) -> PostAwaitable<decltype(func())> {
         return PostAwaitable<decltype(func())>(shared_from_this(), std::forward<Func>(func));
     }
 
     bool loop();
 
     void exit();
 
     // ========== TIMER API (Boost-style) ==========
     
     static const char* getTimerBackend() {
        return TimerManager::getBackendName();
     }
 
     Timer addTimer(std::function<void()> callback, uint64_t delay_ms);
 
     template<typename Rep, typename Period>
     Timer addTimer(std::function<void()> callback, 
                    const std::chrono::duration<Rep, Period>& delay);
 
     Timer addPeriodicTimer(std::function<void()> callback, uint64_t interval_ms);
 
     template<typename Rep, typename Period>
     Timer addPeriodicTimer(std::function<void()> callback,
                           const std::chrono::duration<Rep, Period>& interval);
 
     // ========== CONVENIENCE METHODS ==========
 
     template<typename Function>
     auto postWithTimeout(Function&& func, uint64_t timeout_ms) 
         -> std::enable_if_t<std::is_void_v<std::invoke_result_t<Function>>, Timer>;
         
     // ========== INTERNAL TIMER API ==========
 
     TimerId createTimerInternal(std::function<void()> callback, uint64_t delay_ms, 
                                bool periodic, std::atomic<bool>* cancelled);
 
     bool cancelTimerInternal(TimerId id);
 
     bool hasTimerInternal(TimerId id);
 
     bool restartTimerInternal(TimerId id, uint64_t delay_ms);
 
     size_t getActiveTimerCount();
 
     void initializeTimerManager();
 
     void updateTimerCancelledPtr(TimerId id, std::atomic<bool>* newPtr);
 
 private:
     std::shared_ptr<EventQueue> mEventQueue;     
     std::atomic<bool> mStarted;                      
     std::thread t1;                                  
     std::unique_ptr<TimerManager> mTimerManager;     
 };
 } // namespace swt
 
 // Include template implementations
 #include "SLLooper.tpp"
 #include "Awaitable.h"