kernel_thread.h

Go to the documentation of this file.

#pragma once
#include "services/kernel_intf.h"
 
namespace adtf
{
 
namespace system
{

class kernel_thread
{
    private:
        friend class cKernelThreadHelperRunnable;
        struct ImplBase;
        typedef std::shared_ptr<ImplBase> shared_base_type;
 
        struct ImplBase
        {
              adtf::ucom::object_ptr<adtf::services::IKernel::IThread> m_pKernelThread;
              shared_base_type pThisPtr;
              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:
        kernel_thread();
 
        kernel_thread(const kernel_thread&) = delete;

        kernel_thread(kernel_thread&&);

        template<typename Callable, typename ...Args>
        kernel_thread(const adtf::services::IKernel::tSchedulingInfo& sScheduling, const char* strName,
                      Callable&& pFunc, Args&&... args): kernel_thread()
        {
            m_pCallable = MakeCallable(std::bind(std::forward<Callable>(pFunc),
                                                 std::forward<Args>(args)...));
            Create(strName, sScheduling);
        }

        template<typename Callable, typename ...Args>
        kernel_thread(const char* strName, Callable&& pFunc, Args&&... args):
            kernel_thread(adtf::services::IKernel::tSchedulingInfo(), strName,
                          std::forward<Callable>(pFunc),
                          std::forward<Args>(args)...)
        {
        }

        ~kernel_thread();

        kernel_thread& operator=(kernel_thread&& oOther);

        void Swap(kernel_thread& oOther);

        bool Joinable() const;

        tResult Join(tTimeStamp nTimeout = -1);

        tResult Detach();

        tResult SetScheduling(const adtf::services::IKernel::tSchedulingInfo& sScheduling);

        tResult GetScheduling(adtf::services::IKernel::tSchedulingInfo& sScheduling) const;

        bool IsCurrentThread() const;
 
    private:
        tResult Create(const char* strName, const adtf::services::IKernel::tSchedulingInfo& sScheduling);
};
 
}
 
}