cTimeSys.h

Go to the documentation of this file.

//
//
 
#ifndef _INC_cTimeSys_H
#define _INC_cTimeSys_H
#ifndef NO_PRAGMA_ONCE
#pragma once
#endif
 
#include "cUnitTestDecl.h"
#include "cDebugAssert.h"
#include <time.h> // timespec
 
namespace Gray
{
        typedef int TIMESECD_t;                 
        typedef float TIMESECF_t;               
 
#if 0 // def USE_64BIT
        typedef UINT64  TIMESYS_t;              
        typedef INT64   TIMESYSD_t;             
#else
        typedef UINT32  TIMESYS_t;              
        typedef INT32   TIMESYSD_t;             
#endif
 
#if defined(__linux__)
        class cTimeSpec : public /* struct*/ timespec
        {
 
        public:
                static const UINT k_FREQ = 1000000000;  // billionths of a sec.
 
                cTimeSpec() noexcept
                {
                        // undefined. may use clock_gettime() on it.
                }
                cTimeSpec(TIMESYSD_t nMilliSeconds) noexcept
                {
                        put_mSec(nMilliSeconds);
                }
                cTimeSpec(TIMESECD_t iSeconds, int iNanoSec) noexcept
                {
                        this->tv_sec = iSeconds;
                        this->tv_nsec = iNanoSec;       // nano = billionths of a sec.
                }
                void put_mSec(TIMESYSD_t nMilliSeconds) noexcept
                {
                        // milliSeconds.
                        this->tv_sec = nMilliSeconds / 1000;
                        this->tv_nsec = (nMilliSeconds % 1000) * 1000000;       // mSec to nano = billionths of a sec.
                }
                TIMESYS_t get_mSec() const noexcept
                {
                        TIMESYS_t nTicks = this->tv_sec * 1000;
                        nTicks += this->tv_nsec / 1000000;      // to mSec from nSec
                        return nTicks;
                }
                UINT64 get_nSec() const noexcept
                {
                        return (((UINT64)this->tv_sec) * cTimeSpec::k_FREQ) + this->tv_nsec;
                }
                void InitTimeNow() noexcept
                {
                        ::clock_gettime(CLOCK_MONOTONIC, this);
                }
                void InitTimeNow1() noexcept
                {
                        ::clock_gettime(CLOCK_REALTIME, this);
                }
        };
#endif
 
        //****************************************************************************
 
        class GRAYCORE_LINK cTimeSys
        {
        public:
                static const TIMESYS_t k_CLEAR = 0;
                static const TIMESYS_t k_FREQ = 1000;           
                static const TIMESYS_t k_INF = UINT_MAX;        
                static const TIMESYSD_t k_DMAX = INT_MAX;       
 
        private:
                TIMESYS_t m_TimeSys;
 
        public:
                cTimeSys() noexcept
                        : m_TimeSys(k_CLEAR)
                {
                }
                cTimeSys(const cTimeSys& t) noexcept
                        : m_TimeSys(t.m_TimeSys)
                {
                }
                cTimeSys(TIMESYS_t t) noexcept
                        : m_TimeSys(t)
                {
                }
 
                static TIMESYS_t inline GetTimeNow() noexcept
                {
#ifdef _WIN32
                        // https://msdn.microsoft.com/en-us/library/windows/desktop/ms724408(v=vs.85).aspx
#if 0 // def USE_64BIT
                        return ::GetTickCount64();              // why not use 64 bits ???
#else
                        return ::GetTickCount();
#endif
#elif defined(__linux__)
                        cTimeSpec tNow;
                        tNow.InitTimeNow();
                        return tNow.get_mSec();
#else
#error NOOS
#endif
                }
 
                static unsigned long GRAYCALL WaitSpin(TIMESYSD_t t);
 
                bool isTimeValid() const noexcept
                {
                        return m_TimeSys > k_CLEAR;
                }
                TIMESYS_t get_TimeSys() const noexcept
                {
                        return m_TimeSys;
                }
 
                void InitTime(TIMESYS_t t = k_CLEAR) noexcept
                {
                        m_TimeSys = t;
                }
                void InitTimeNow() noexcept
                {
                        m_TimeSys = GetTimeNow();
                }
                void InitTimeNowPlusSys(TIMESYSD_t iOffset) noexcept
                {
                        m_TimeSys = GetTimeNow() + iOffset;
                }
                void InitTimeNowPlusSec(float fOffsetSec) noexcept
                {
                        InitTimeNowPlusSys((TIMESYSD_t)(fOffsetSec * k_FREQ));
                }
                bool isTimeFuture() const noexcept
                {
                        return m_TimeSys > GetTimeNow(); // GetTimeNow
                }
 
                TIMESYSD_t get_TimeTilSys() const noexcept
                {
                        if (m_TimeSys == 0)
                                return -k_DMAX;
                        if (m_TimeSys == k_INF)
                                return k_DMAX;
                        return (TIMESYSD_t)(m_TimeSys - GetTimeNow());
                }
                TIMESYSD_t get_AgeSys() const noexcept
                {
                        if (m_TimeSys == 0)
                                return k_DMAX;
                        if (m_TimeSys == k_INF)
                                return -k_DMAX;
                        return (TIMESYSD_t)(GetTimeNow() - m_TimeSys);
                }
 
                TIMESECF_t get_TimeTilSecF() const noexcept
                {
                        return get_TimeTilSys() / (TIMESECF_t)k_FREQ;
                }
                TIMESECF_t get_AgeSecF() const noexcept
                {
                        return get_AgeSys() / (TIMESECF_t)k_FREQ;
                }
                TIMESECD_t get_AgeSec() const noexcept
                {
                        return get_AgeSys() / k_FREQ;
                }
 
                UNITTEST_FRIEND(cTimeSys);
        };
 
        //****************************************************************************
 
#ifdef _WIN32
        typedef LONGLONG TIMEPERF_t;    
#else
        typedef UINT64 TIMEPERF_t;              
#endif
 
        class GRAYCORE_LINK cTimePerf
        {
 
        public:
                TIMEPERF_t m_nTime;                             
#ifdef _WIN32
                static TIMEPERF_t sm_nFreq;             
#else // __linux__
                static const TIMEPERF_t sm_nFreq = cTimeSpec::k_FREQ;   
#endif
 
        public:
                cTimePerf(TIMEPERF_t nTime = 0) noexcept
                        : m_nTime(nTime)
                {
                }
                cTimePerf(int nTime) noexcept
                        : m_nTime(nTime)
                {
                }
                cTimePerf(bool bTrue) noexcept
                {
                        // Indicate I want the current time.
                        if (bTrue)
                                InitTimeNow();
                        else
                                m_nTime = 0;    // The test is turned off. don't record time.
                }
 
                bool isTimeValid() const noexcept
                {
                        return m_nTime != 0;
                }
 
                static bool GRAYCALL InitFreq() noexcept;
                void InitTimeNow() noexcept;
 
                TIMEPERF_t get_Perf() const noexcept
                {
                        return m_nTime;
                }
                TIMEPERF_t GetAgeDiff(cTimePerf tStop) const noexcept
                {
                        return tStop.m_nTime - this->m_nTime;
                }
                TIMEPERF_t get_AgePerf() const noexcept
                {
                        cTimePerf tStop(true);
                        return GetAgeDiff(tStop);
                }
 
                static inline double GRAYCALL ToSeconds(TIMEPERF_t t) noexcept
                {
                        return ((double)t) / ((double)sm_nFreq);
                }
                double get_Seconds() const noexcept
                {
                        // ASSERT( k_nFreq != 0 );
                        return ToSeconds(m_nTime);
                }
                double get_AgeSeconds() const noexcept
                {
                        const TIMEPERF_t tDiff = get_AgePerf();
                        // ASSERT( k_nFreq != 0 );
                        return ToSeconds(tDiff);
                }
 
                static double GRAYCALL ToDays(TIMEPERF_t t) noexcept;
                double get_Days() const noexcept
                {
                        return ToDays(m_nTime);
                }
        };
}
#endif // _INC_cTimeSys_H