cTimer.h

Go to the documentation of this file.

//
//
 
#ifndef _INC_cTimer_H
#define _INC_cTimer_H
#ifndef NO_PRAGMA_ONCE
#pragma once
#endif
 
#include "../GrayLibBase.h"
#include "GrayCore/include/cTimeSys.h"
#include "GrayCore/include/cArraySortRef.h"
#include "GrayCore/include/cRefPtr.h"
#include "GrayCore/include/cUnitTestDecl.h"
 
namespace GrayLib
{
        UNITTEST2_PREDEF(cTimer);
        class cTimerGroup;
 
        class GRAYLIB_LINK cTimerInst : public cRefBase
        {
 
                friend class cTimerGroup;
        private:
                cTimerGroup* m_pTimerGroup;     
                cTimeSys m_tCallNext;           
        protected:
                virtual void OnTimer();
        public:
                cTimerInst(cTimerGroup* pTimerGroup = nullptr, TIMESYS_t tCallNext = cTimeSys::k_CLEAR);
                virtual ~cTimerInst();
 
                TIMESYS_t get_SortValue() const noexcept
                {
                        return m_tCallNext.get_TimeSys();
                }
 
                bool SetTimer(TIMESYS_t tCallNext);
                void KillTimer();
        };
        typedef cRefPtr<cTimerInst> cTimerInstPtr;
 
        typedef void (GRAYCALL* TIMER_FUNC_t)(cTimerInst* pTimer, UINT_PTR nUserArg);   // like FARPROC
 
        class GRAYLIB_LINK cTimerFunc : public cTimerInst
        {
        private:
                TIMER_FUNC_t m_pFunc;           
                UINT_PTR m_nUserArg;            
 
        protected:
                virtual void OnTimer() override
                {
                        m_pFunc(this, m_nUserArg);
                }
 
        public:
                cTimerFunc(TIMER_FUNC_t pFunc, UINT_PTR nUserArg, cTimerGroup* pTimerGroup = nullptr, TIMESYS_t tCallNext = cTimeSys::k_CLEAR)
                : cTimerInst(pTimerGroup, tCallNext)
                , m_pFunc(pFunc)
                , m_nUserArg(nUserArg)
                {
                }
        };
        typedef cRefPtr<cTimerFunc> cTimerFuncPtr;
 
        class GRAYLIB_LINK cTimerGroup
        {
                friend class cTimerInst;
 
        private:
                cArraySortValue<cTimerInst, TIMESYS_t> m_aTimersTick;   
                cArraySortHash<cTimerInst, HASHCODE_t> m_aTimersHash;   
 
        public:
                cTimerGroup(void);
                ~cTimerGroup(void);
 
                ITERATE_t get_TimerQty() const
                {
                        return m_aTimersHash.GetSize();
                }
 
                void DeleteTimerInst(cTimerInst* pTimer);
                void AddTimerInst(cTimerInst* pTimer);
                cTimerFuncPtr AddTimerFunc(TIMER_FUNC_t pFunc, UINT_PTR nUserArg, TIMESYS_t tCallNext = cTimeSys::k_CLEAR);
 
                TIMESYSD_t get_TimeTilNext() const;
                void TickTimers();
 
                UNITTEST_FRIEND(cTimer );
        };
};
#endif // _INC_cTimer_H