looper.h

Go to the documentation of this file.

 
#ifndef _A_UTILS_LOOPER_HEADER_
#define _A_UTILS_LOOPER_HEADER_
 
#include <mutex>
#include <future>
 
namespace A_UTILS_NS
{
class cLooper
{
    public:
        enum class tLoopState
        {
            Destroyed,
            Suspended,
            Running
        };
 
    private:
        struct ImplBase;
        typedef std::shared_ptr<ImplBase> shared_base_type;
 
        struct ImplBase
        {
            tLoopState              m_eLoopState;
            tBool                   m_bStateAcked = tTrue;
            std::promise<void>      m_oLoopStateAck;
            std::mutex              m_oStateMutex;
            std::condition_variable m_oWakeup;
 
            inline virtual ~ImplBase() {}
            virtual void Run() = 0;
        };
 
        template<typename Callable>
        struct Impl : public ImplBase
        {
            Callable pFunc;
 
            Impl(Callable&& pFunc) : pFunc(std::forward<Callable>(pFunc))
            {
            }
 
            void Run()
            {
                pFunc();
            }
        };
 
        template<typename Callable>
        std::shared_ptr<Impl<Callable>> MakeCallable(Callable&& pFunc)
        {
            return std::make_shared<Impl<Callable>>(std::forward<Callable>(pFunc));
        }
 
        shared_base_type m_pCallable;
 
    public:
        cLooper();
        cLooper(cLooper&&);
 
        cLooper(const cLooper&) = delete;
 
        template<typename ...Args>
        cLooper(Args&&... args): cLooper(tLoopState::Running, std::forward<Args>(args)...)
        {
        }
 
        template<typename Callable, typename ...Args>
        cLooper(tLoopState eState, Callable&& pFunc, Args&&... args)
        {
            m_pCallable = MakeCallable(std::bind(std::forward<Callable>(pFunc),
                                                 std::forward<Args>(args)...));
            ResetLoop(eState);
        }
 
        virtual ~cLooper();
 
        cLooper& operator=(cLooper&& oOther);
 
        tLoopState GetState();
        tResult SetState(tLoopState eState, tBool bWaitForAck = tTrue);
        tVoid ResetLoop(tLoopState eInitialState = tLoopState::Running);
 
        tVoid Swap(cLooper& oOther);
 
        std::function<void()> GetCallable()
        {
            return std::bind(CallableHelper, m_pCallable);
        }
 
    private:
        static tVoid CallableHelper(shared_base_type pImpl);
};
 
}
 
#endif