kernel_timer.h

Go to the documentation of this file.

 
#pragma once
#include "services/kernel_intf.h"
 
namespace adtf
{
 
namespace system
{
 
class kernel_timer
{
    private:
        friend class cKernelTimerHelperRunnable;
        struct ImplBase;
        typedef std::shared_ptr<ImplBase> shared_base_type;
 
        struct ImplBase
        {
              adtf::ucom::object_ptr<adtf::services::IKernel::ITimer> m_pKernelTimer;
              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_timer();
 
        kernel_timer(const kernel_timer&) = delete;
 
        kernel_timer(kernel_timer&&);
 
        template<typename Callable, typename ...Args>
        kernel_timer(adtf::services::IKernel::tTimerClock eClock,
                     const adtf::services::IKernel::tSchedulingInfo& sScheduling,
                     const char* strName,
                     tTimeStamp tmPeriod, tTimeStamp tmInitialDelay,
                     Callable&& pFunc, Args&&... args): kernel_timer()
        {
            m_pCallable = MakeCallable(std::bind(std::forward<Callable>(pFunc),
                                                 std::forward<Args>(args)...));
            Create(strName, sScheduling, eClock, tmPeriod, tmInitialDelay);
        }
 
        template<typename Callable, typename ...Args>
        kernel_timer(tTimeStamp tmMaximumExectionTime,
                     adtf::services::IKernel::tTimerClock eClock,
                     const adtf::services::IKernel::tSchedulingInfo& sScheduling,
                     const char* strName,
                     tTimeStamp tmPeriod, tTimeStamp tmInitialDelay, uint32_t nFlags,
                     Callable&& pFunc, Args&&... args): kernel_timer()
        {
            m_pCallable = MakeCallable(std::bind(std::forward<Callable>(pFunc),
                                                 std::forward<Args>(args)...));
            Create(strName, sScheduling, eClock, tmPeriod, tmInitialDelay, tmMaximumExectionTime, nFlags);
        }
 
        template<typename Callable, typename ...Args>
        kernel_timer(const char* strName, tTimeStamp tmPeriod, tTimeStamp tmInitialDelay,
                     Callable&& pFunc, Args&&... args):
            kernel_timer(adtf::services::IKernel::tTimerClock::ADTF,
                         adtf::services::IKernel::tSchedulingInfo(), strName,
                         tmPeriod, tmInitialDelay,
                         std::forward<Callable>(pFunc),
                         std::forward<Args>(args)...)
        {
        }
 
        ~kernel_timer();
 
        kernel_timer& operator=(kernel_timer&& oOther);
 
        void Swap(kernel_timer& oOther);
 
        bool Stoppable() const;
 
        tResult Stop();
 
        tResult SetScheduling(const adtf::services::IKernel::tSchedulingInfo& sScheduling);
 
        tResult GetScheduling(adtf::services::IKernel::tSchedulingInfo& sScheduling) const;
 
    private:
        tResult Create(const char* strName, const adtf::services::IKernel::tSchedulingInfo& sScheduling,
                       adtf::services::IKernel::tTimerClock eClock, tTimeStamp tmPeriod,
                       tTimeStamp tmInitialDelay);
 
        tResult Create(const char* strName, const adtf::services::IKernel::tSchedulingInfo& sScheduling,
                       adtf::services::IKernel::tTimerClock eClock, tTimeStamp tmPeriod,
                       tTimeStamp tmInitialDelay, tTimeStamp tmMaximumExecutionTime, uint32_t nFlags);
};
 
}
 
}