cTimeInt.h

Go to the documentation of this file.

//
//
 
#ifndef _INC_cTimeInt_H
#define _INC_cTimeInt_H
#ifndef NO_PRAGMA_ONCE
#pragma once
#endif
 
#include "cString.h"
#include "cTimeFile.h"
 
namespace Gray
{
#ifndef _MFC_VER
        class GRAYCORE_LINK CTime
        {
 
        protected:
                TIMESEC_t m_time;       
 
        public:
                CTime(TIMESEC_t nTime = ((TIMESEC_t)0)) noexcept
                : m_time(nTime)
                {
                }
                CTime(const cTimeFile& fileTime, int nDST = -1);
 
                const CTime& operator=(const CTime& timeSrc) noexcept
                {
                        m_time = timeSrc.m_time;
                        return *this;
                }
                const CTime& operator=(TIMESEC_t nTime) noexcept
                {
                        m_time = nTime;
                        return *this;
                }
 
                bool operator<=(TIMESEC_t nTime) const noexcept
                {
                        return(m_time <= nTime);
                }
                bool operator==(TIMESEC_t nTime) const noexcept
                {
                        return(m_time == nTime);
                }
                bool operator!=(TIMESEC_t nTime) const noexcept
                {
                        return(m_time != nTime);
                }
                bool operator>=(CTime ttime) const noexcept
                {
                        return(m_time >= ttime.m_time);
                }
 
                operator TIMESEC_t() const noexcept
                {
                        return m_time;
                }
                TIMESEC_t GetTime() const noexcept      // Assume time in seconds. (MFC like)
                {
                        return m_time;
                }
                TIMESEC_t GetTotalSeconds() const noexcept
                {
                        return m_time;
                }
        };
 
        class GRAYCORE_LINK cTimeSpan
        {
        public:
                int m_nDiffSeconds;
        public:
                cTimeSpan()
                {
                }
        };
#endif
 
        class GRAYCORE_LINK cTimeInt    
        : public CTime          
        {
 
                typedef CTime SUPER_t;
 
        public:
                static const TIMESEC_t k_nZero = ((TIMESEC_t)0);                
                static const TIMESEC_t k_nY2K = ((TIMESEC_t)0x386d4380);        
 
        protected:
                bool InitTimeUnits(const cTimeUnits& rTu);
 
        public:
                cTimeInt()      // init to zero
                {}
                cTimeInt(TIMESEC_t time) : CTime(time)
                {}
                cTimeInt(const cTimeFile& fileTime) : CTime(fileTime, -1)
                {
                }
                cTimeInt(const cTimeUnits& rTu)
                {
                        InitTimeUnits(rTu);
                }
                static TIMESEC_t GRAYCALL GetTimeFromDays(double dTimeDays) noexcept;
 
                cTimeInt(double dTimeDays) : CTime(GetTimeFromDays(dTimeDays))
                {
                }
 
                static cTimeInt GRAYCALL GetTimeFromStr(const GChar_t* pszDateTime, TZ_TYPE nTimeZoneOffset)
                {
                        // Ignore HRESULT.
                        cTimeInt t;
                        t.SetTimeStr(pszDateTime, nTimeZoneOffset);
                        return t;
                }
 
#ifdef _MFC_VER
                TIMESEC_t GetTime() const       // Assume time in total seconds. (MFC like)
                { return (TIMESEC_t) SUPER_t::GetTime(); } // convert 64 bit time to old 32 bit form?
#endif
 
                static cTimeInt GRAYCALL GetTimeNow() noexcept;
 
                static cTimeInt GRAYCALL GetCurrentTime() noexcept
                {
                        return GetTimeNow();
                }
 
                void InitTimeNow();
                void InitTimeNowPlusSec(TIMESECD_t iOffsetInSeconds);
                void InitTime(TIMESEC_t nTime = k_nZero);
 
                cTimeFile GetAsFileTime() const;
                bool GetTimeUnits(OUT cTimeUnits& rTu, TZ_TYPE nTimeZoneOffset= TZ_UTC) const;
 
                // non MFC CTime operations.
                TIMESECD_t GetSecondsSince(const cTimeInt& time) const
                {
                        return((TIMESECD_t)(GetTime() - time.GetTime()));
                }
                TIMESECD_t get_TimeTilSec() const
                {
                        cTimeInt timeNow;
                        timeNow.InitTimeNow();
                        return((TIMESECD_t)(GetTime() - timeNow.GetTime()));
                }
                TIMESECD_t get_AgeSec() const
                {
                        return(-get_TimeTilSec());
                }
                bool isTimeFuture() const
                {
                        return((unsigned)GetTime() > (unsigned)GetTimeNow().GetTime());
                }
 
                static inline bool IsTimeValid(TIMESEC_t nTime)
                {
                        return(nTime > k_nZero);
                }
                bool isTimeValid() const
                {
                        return(IsTimeValid((TIMESEC_t)GetTime()));
                }
                int get_TotalDays() const // like in COleDateTimeSpan
                {
                        return((int)(GetTime() / cTimeUnits::k_nSecondsPerDay));
                }
 
                // to/from strings.
                HRESULT SetTimeStr(const GChar_t* pszTimeDate, TZ_TYPE nTimeZoneOffset = TZ_LOCAL);
                StrLen_t GetTimeFormStr(GChar_t* pszOut, StrLen_t iOutSizeMax, const GChar_t* pszFormat, TZ_TYPE nTimeZoneOffset = TZ_LOCAL) const;
                cString GetTimeFormStr(const GChar_t* pszFormat = nullptr, TZ_TYPE nTimeZoneOffset = TZ_LOCAL) const;
                cString GetTimeFormStr(TIME_FORMAT_TYPE eFormat, TZ_TYPE nTimeZoneOffset = TZ_LOCAL) const
                {
                        return GetTimeFormStr((const GChar_t*)eFormat, nTimeZoneOffset);
                }
 
                static cString GRAYCALL GetTimeSpanStr(TIMESECD_t dwSeconds, TIMEUNIT_TYPE eUnitHigh = TIMEUNIT_Day, int iUnitsDesired = 2, bool bShortText = false);
                static cString GRAYCALL GetTimeDeltaBriefStr(TIMESECD_t dwSeconds);
                static cString GRAYCALL GetTimeDeltaSecondsStr(TIMESECD_t dwSeconds);
 
                UNITTEST_FRIEND(cTimeInt);
        };
 
};
 
#endif // _INC_cTimeInt_H