cTimeTick.h

Go to the documentation of this file.

//
 
#ifndef _INC_cTimeTick_H
#define _INC_cTimeTick_H
#ifndef NO_PRAGMA_ONCE
#pragma once
#endif
 
#include "../GrayLibBase.h"
#include "GrayCore/include/cTimeSys.h"
#include "GrayCore/include/cLogMgr.h"
#include "GrayCore/include/cThreadLock.h"
 
namespace GrayLib
{
        UNITTEST2_PREDEF(cTimeTick);
 
        typedef UINT TIMETICK_t; 
        typedef int TIMETICKD_t; 
        // Must define m_nTimeFreq locally
 
        class GRAYLIB_LINK cTimeTickBase
        {
 
        protected:
                TIMETICK_t m_PrivateTime;       
        public:
                static const TIMETICK_t k_NEVER = ((TIMETICK_t)(-1));
        public:
                bool isTimeValid() const noexcept
                {
                        return(m_PrivateTime != k_NEVER);
                }
                bool isTimeFuture() const noexcept
                {
                        return(m_PrivateTime > GetTickCount().m_PrivateTime);
                }
                void InitTime(TIMETICK_t lTimeBase = k_NEVER) noexcept
                {
                        m_PrivateTime = lTimeBase;
                }
                void InitTimeNow()
                {
                        m_PrivateTime = GetTickCount().m_PrivateTime;
                }
                void InitTimeNowPlusTicks(TIMETICKD_t iOffsetTicks)
                {
                        // NOTE: Assume iOffset is in m_nTimeFreq
                        m_PrivateTime = GetTickCount().m_PrivateTime + iOffsetTicks;
                }
                TIMETICK_t get_TimeTicks() const noexcept
                {
                        return m_PrivateTime;
                }
                operator TIMETICK_t() const noexcept
                {
                        return m_PrivateTime;
                }
                int GetTimeSinceTick(const cTimeTickBase& time) const noexcept
                {
                        return(m_PrivateTime - time.m_PrivateTime);
                }
                TIMETICKD_t get_TimeTilTick() const
                {
                        return(m_PrivateTime - GetTickCount().m_PrivateTime);
                }
                TIMETICKD_t get_AgeTick() const
                {
                        return(-get_TimeTilTick());
                }
 
                void InitTimeNowPlusSec(TIMESECF_t fOffsetSec);
                TIMESECF_t get_TimeTilSec() const;
                TIMESECF_t get_AgeSec() const
                {
                        return(-get_TimeTilSec());
                }
 
                cTimeTickBase operator+(TIMETICKD_t iTimeDiff) const
                {
                        cTimeTickBase time;
                        time.m_PrivateTime = m_PrivateTime + iTimeDiff;
                        return(time);
                }
                cTimeTickBase operator-(TIMETICKD_t iTimeDiff) const
                {
                        cTimeTickBase time;
                        time.m_PrivateTime = m_PrivateTime - iTimeDiff;
                        return(time);
                }
                int operator-(cTimeTickBase time) const
                {
                        return(m_PrivateTime - time.m_PrivateTime);
                }
                bool operator==(cTimeTickBase time) const
                {
                        return(m_PrivateTime == time.m_PrivateTime);
                }
                bool operator!=(cTimeTickBase time) const
                {
                        return(m_PrivateTime != time.m_PrivateTime);
                }
                bool operator<(cTimeTickBase time) const
                {
                        return(m_PrivateTime < time.m_PrivateTime);
                }
                bool operator>(cTimeTickBase time) const
                {
                        return(m_PrivateTime>time.m_PrivateTime);
                }
                bool operator<=(cTimeTickBase time) const
                {
                        return(m_PrivateTime <= time.m_PrivateTime);
                }
                bool operator>=(cTimeTickBase time) const
                {
                        return(m_PrivateTime >= time.m_PrivateTime);
                }
 
                // define this function locally.
                static cTimeTickBase GRAYCALL GetTickCount(); 
                static TIMETICK_t GRAYCALL GetTickFreq(); // static
        };
 
        class GRAYLIB_LINK cTimeTick : public cTimeTickBase
        {
        public:
                cTimeTick()
                {
                        InitTime();
                }
                explicit cTimeTick(TIMETICK_t lTimeBase)
                {
                        InitTime(lTimeBase);
                }
                cTimeTick(const cTimeTickBase& time)
                {
                        InitTime(time.get_TimeTicks());
                }
        };
 
        class GRAYLIB_LINK cTimeTickMaster
        : public cSingletonStatic<cTimeTickMaster>
        , public cTimeTick
        {
                typedef cTimeTick SUPER_t;
 
        public:
                const TIMETICK_t m_nTimeFreq;   
        protected:
                mutable cThreadLockCount m_Lock;                        
                TIMETICK_t m_nTimeDiv;          
                cTimeSys m_TimeSysLast;         
 
        public:
                cTimeTickMaster(TIMETICK_t nTimeFreq = cTimeSys::k_FREQ, TIMETICK_t lTimeBase = 1);     // TIMETICK_FREQ, TIMETICK_FREQ
                ~cTimeTickMaster();
 
                bool AdvanceTimeSpec();         // tick forward the time.
                void InitTime(TIMETICK_t lTimeBase);
 
                UNITTEST_FRIEND(cTimeTick );
        };
 
        inline TIMETICK_t GRAYCALL cTimeTickBase::GetTickFreq() // static
        {
                if (cTimeTickMaster::isSingleCreated())
                {
                        return cTimeTickMaster::I().m_nTimeFreq;
                }
                return cTimeSys::k_FREQ;
        }
 
        inline cTimeTickBase GRAYCALL cTimeTickBase::GetTickCount() // static
        {
 
                if (cTimeTickMaster::isSingleCreated())
                {
                        return *cTimeTickMaster::get_Single();  // must call AdvanceTime() periodically!
                }
 
                // Just make up a default time.
                // ASSERT(m_nTimeFreq==cTimeSys::k_FREQ);
                cTimeTickBase servtime;
                servtime.InitTime(cTimeSys::GetTimeNow());
                return servtime;
        }
 
        inline void cTimeTickBase::InitTimeNowPlusSec(TIMESECF_t fOffsetSec)
        {
                m_PrivateTime = GetTickCount().get_TimeTicks() + (TIMETICK_t)(fOffsetSec * GetTickFreq());
        }
        inline TIMESECF_t cTimeTickBase::get_TimeTilSec() const
        {
                return((m_PrivateTime - GetTickCount().get_TimeTicks()) / ((TIMESECF_t)(GetTickFreq())));
        }
};
#endif // _INC_cTimeTick_H