thread_looper.h

Go to the documentation of this file.

 
#ifndef _A_UTILS_THREAD_LOOPER_HEADER_
#define _A_UTILS_THREAD_LOOPER_HEADER_
 
#include <mutex>
#include <future>
 
namespace A_UTILS_NS
{
 
class cThreadLooper: public std::thread, public cLooper
{
    public:
        cThreadLooper() {}
        cThreadLooper(const cThreadLooper&) = delete;
 
        template<typename ...Args>
        cThreadLooper(Args&&... args):
            cLooper(std::forward<Args>(args)...)
        {
            *static_cast<std::thread*>(this) = std::thread(GetCallable());
        }       
 
        cThreadLooper(cThreadLooper&& oOther):
            thread(static_cast<thread&&>(oOther)),
            cLooper(static_cast<cLooper&&>(oOther))
        {
        }
 
        cThreadLooper& operator=(cThreadLooper&& oOther)
        {
            thread::swap(oOther);
            cLooper::Swap(oOther);
            return *this;
        }
 
        ~cThreadLooper()
        {
            if (joinable())
            {
                SetState(cLooper::tLoopState::Destroyed, tFalse);
                join();
            }
        }
};
 
class cThreadLooperWithScheduling: public cThreadLooper
{
    public:
        cThreadLooperWithScheduling() = delete;
        cThreadLooperWithScheduling(const cThreadLooperWithScheduling&) = delete;
        cThreadLooperWithScheduling(cThreadLooperWithScheduling&&) = delete;
 
        template<typename ...Args>
        cThreadLooperWithScheduling(const tSchedulingParameters& sScheduling, Args&&... args):
            cThreadLooper()
        {
            *static_cast<cLooper*>(this) = cLooper(std::forward<Args>(args)...);
            *static_cast<std::thread*>(this) = create_thread_with_scheduling(sScheduling, GetCallable());
        }        
};
 
class cThreadLoop
{
    private:
        cThreadLooper m_oLooper;
        tBool m_bSelfDestruct;
 
#ifdef _DEBUG
        cString m_strName;
#endif
 
    public:
        virtual ~cThreadLoop();
        tResult Create(tBool bSelfDestruct = tFalse);
        tResult Create(const tSchedulingParameters& sScheduling, tBool bSelfDestruct = tFalse);
        tResult Release();
        cLooper::tLoopState GetState();
        tResult SetState(cLooper::tLoopState eState, tBool bWaitForAck = tTrue);
 
 
#ifdef _DEBUG
        tVoid SetName(const tChar* strName);
#endif // _DEBUG
 
    protected:
        virtual tResult LoopFunc() = 0;
 
    private:
        void Loop();
 
    private:
        tVoid SelfDestruct();
 
};
 
}
 
#endif