Awaitable.h

Go to the documentation of this file.

 
 #pragma once
 
 #include <coroutine>
 #include <exception>
 #include <optional>
 #include <memory>
 #include <functional>
 
 namespace swt {
 
 // Forward declaration
 class SLLooper;
 
 template<typename T>
 class WorkAwaitable {
 private:
     std::shared_ptr<SLLooper> mLooper;        
     std::function<T()> mFunc;                 
     mutable std::optional<T> mResult;         
     mutable std::exception_ptr mException;    
     mutable bool mReady = false;              
 
 public:
     template<typename Func>
     WorkAwaitable(std::shared_ptr<SLLooper> looper, Func&& func)
         : mLooper(looper), mFunc(std::forward<Func>(func)) {}
 
     bool await_ready() const noexcept { return mReady; }
     
     void await_suspend(std::coroutine_handle<> handle) const noexcept;
 
     auto await_resume() const -> T {
         if (mException) std::rethrow_exception(mException);
         if (mResult.has_value()) return std::move(mResult.value());
         throw std::runtime_error("Work not completed");
     }
 
     std::shared_ptr<SLLooper> getLooper() const { return mLooper; }
     
     std::function<T()> getFunc() const { return mFunc; }
     
     void setResult(T result) const { 
         mResult = result;
         mReady = true; 
     }
     
     void setException(std::exception_ptr ex) const { 
         mException = ex; 
         mReady = true; 
     }
 };
 
 template<>
 class WorkAwaitable<void> {
 private:
     std::shared_ptr<SLLooper> mLooper;        
     std::function<void()> mFunc;              
     mutable std::exception_ptr mException;    
     mutable bool mReady = false;              
 
 public:
     template<typename Func>
     WorkAwaitable(std::shared_ptr<SLLooper> looper, Func&& func)
         : mLooper(looper), mFunc(std::forward<Func>(func)) {}
 
     bool await_ready() const noexcept { return mReady; }
     
     void await_suspend(std::coroutine_handle<> handle) const noexcept;
 
     void await_resume() const {
         if (mException) std::rethrow_exception(mException);
         if (!mReady) throw std::runtime_error("Work not completed");
     }
 
     std::shared_ptr<SLLooper> getLooper() const { return mLooper; }
     
     std::function<void()> getFunc() const { return mFunc; }
     
     void setResult() const { mReady = true; }
     
     void setException(std::exception_ptr ex) const { 
         mException = ex; 
         mReady = true; 
     }
 };
 
 class DelayAwaitable {
 private:
     std::shared_ptr<SLLooper> mLooper;        
     int mDelayMs;                             
     mutable bool mReady = false;              
 
 public:
     DelayAwaitable(std::shared_ptr<SLLooper> looper, int delayMs)
         : mLooper(looper), mDelayMs(delayMs) {}
 
     bool await_ready() const noexcept { return mReady; }
     
     void await_suspend(std::coroutine_handle<> handle) const noexcept;
     
     void await_resume() const noexcept {}
 
     int getDelayMs() const { return mDelayMs; }
     
     std::shared_ptr<SLLooper> getLooper() const { return mLooper; }
     
     void setReady() const { mReady = true; }
 };
 
 template<typename T>
 class PostAwaitable {
 private:
     std::shared_ptr<SLLooper> mLooper;        
     std::function<T()> mFunc;                 
     mutable std::optional<T> mResult;         
     mutable std::exception_ptr mException;    
     mutable bool mReady = false;              
 
 public:
     template<typename Func>
     PostAwaitable(std::shared_ptr<SLLooper> looper, Func&& func)
         : mLooper(looper), mFunc(std::forward<Func>(func)) {}
 
     bool await_ready() const noexcept { return mReady; }
     
     void await_suspend(std::coroutine_handle<> handle) const noexcept;
 
     auto await_resume() const -> T {
         if (mException) std::rethrow_exception(mException);
         if (mResult.has_value()) return std::move(mResult.value());
         throw std::runtime_error("Post not completed");
     }
 
     std::function<T()> getFunc() const { return mFunc; }
     
     std::shared_ptr<SLLooper> getLooper() const { return mLooper; }
     
     void setResult(T result) const { 
         mResult = result;
         mReady = true; 
     }
     
     void setException(std::exception_ptr ex) const { 
         mException = ex; 
         mReady = true; 
     }
 };
 
 template<>
 class PostAwaitable<void> {
 private:
     std::shared_ptr<SLLooper> mLooper;        
     std::function<void()> mFunc;              
     mutable std::exception_ptr mException;    
     mutable bool mReady = false;              
 
 public:
     template<typename Func>
     PostAwaitable(std::shared_ptr<SLLooper> looper, Func&& func)
         : mLooper(looper), mFunc(std::forward<Func>(func)) {}
 
     bool await_ready() const noexcept { return mReady; }
     
     void await_suspend(std::coroutine_handle<> handle) const noexcept;
 
     void await_resume() const {
         if (mException) std::rethrow_exception(mException);
     }
 
     std::function<void()> getFunc() const { return mFunc; }
     
     std::shared_ptr<SLLooper> getLooper() const { return mLooper; }
     
     void setResult() const { mReady = true; }
     
     void setException(std::exception_ptr ex) const { 
         mException = ex; 
         mReady = true; 
     }
 };
 
 } // namespace swt