cTimeDouble.h

Go to the documentation of this file.

//
//
 
#ifndef _INC_cTimeDouble_H
#define _INC_cTimeDouble_H
#ifndef NO_PRAGMA_ONCE
#pragma once
#endif
 
#include "cString.h"
#include "cTimeUnits.h"
#include "cTimeFile.h"
 
namespace Gray
{
        class GRAYCORE_LINK cTimeDouble
        {
        public:
                static const int k_nDaysDiffTimeInt = 25569;    
                static const double k_nY2K;             
                static const double k_nY10;             
                static const int k_nZero = 0;   
 
        protected:
                double  m_dateTime;     
 
        protected:
                bool InitTimeUnits(const cTimeUnits& rTu);
                void DecodeDate(cTimeUnits& rTu) const;
 
        public:
                cTimeDouble(const cTimeDouble& dt)
                        : m_dateTime(dt.m_dateTime)
                {
                }
                cTimeDouble(const double dTime = k_nZero)
                        : m_dateTime(dTime)
                {
                }
 
                static cTimeDouble GRAYCALL EncodeSeconds(double s);
                static cTimeDouble GRAYCALL EncodeTime(short h, short m, short s, short ms = 0);
                static cTimeDouble GRAYCALL EncodeDate(short year = 0, short month = 0, short day = 0);
                static cTimeDouble GRAYCALL GetTimeFromSec(TIMESEC_t nTimeSec);
 
                cTimeDouble(const TIMESEC_t nTimeSec)
                        : m_dateTime(GetTimeFromSec(nTimeSec))
                {
                }
 
                static cTimeDouble GRAYCALL GetTimeFromFile(const cTimeFile& ft);
                cTimeDouble(const cTimeFile& ft)
                        : m_dateTime(GetTimeFromFile(ft))
                {
                }
 
                static cTimeDouble GRAYCALL GetTimeFromStr(const GChar_t* pszDateTime, TZ_TYPE nTimeZoneOffset)
                {
                        // Ignore HRESULT.
                        cTimeDouble t;
                        t.SetTimeStr(pszDateTime, nTimeZoneOffset);
                        return t;
                }
                cTimeDouble(const cTimeUnits& rTu)
                {
                        InitTimeUnits(rTu);
                }
 
                void InitTime(double dTime = k_nZero)
                {
                        m_dateTime = dTime;     
                }
                void InitTimeNow();
 
                static inline bool IsTimeValid(double dTime)
                {
                        return(dTime > k_nZero);
                }
                bool isTimeValid() const
                {
                        return IsTimeValid(m_dateTime);
                }
                double get_Double() const
                {
                        return m_dateTime;
                }
                double get_Days() const
                {
                        return m_dateTime;
                }
                operator double(void) const
                {
                        return m_dateTime;
                }
 
                void operator = (const cTimeDouble& date)
                {
                        m_dateTime = date.m_dateTime;
                }
                void operator = (const GChar_t* pszDateTime)
                {
                        SetTimeStr(pszDateTime, TZ_UTC);
                }
 
                cTimeDouble operator + (int  i)
                {
                        return cTimeDouble(m_dateTime + i);
                }
                cTimeDouble operator - (int  i)
                {
                        return cTimeDouble(m_dateTime - i);
                }
                cTimeDouble operator + (const cTimeDouble& dt)
                {
                        return cTimeDouble(m_dateTime + dt.m_dateTime);
                }
                cTimeDouble operator - (const cTimeDouble& dt)
                {
                        return cTimeDouble(m_dateTime - dt.m_dateTime);
                }
 
                cTimeDouble& operator += (int idays)    
                {
                        m_dateTime += idays;
                        return *this;
                }
                cTimeDouble& operator -= (int idays)    
                {
                        m_dateTime -= idays;
                        return *this;
                }
                cTimeDouble& operator += (const cTimeDouble& dt)
                {
                        m_dateTime += dt.m_dateTime;
                        return *this;
                }
                cTimeDouble& operator -= (const cTimeDouble& dt)
                {
                        m_dateTime -= dt.m_dateTime;
                        return *this;
                }
 
                cTimeDouble& operator ++ ()     
                {
                        m_dateTime += 1;
                        return *this;
                }
                cTimeDouble& operator ++ (int)  
                {
                        m_dateTime += 1; // add a day
                        return *this;
                }
                cTimeDouble& operator -- ()     
                {
                        m_dateTime -= 1;
                        return *this;
                }
                cTimeDouble& operator -- (int)  
                {
                        m_dateTime -= 1;
                        return *this;
                }
 
                friend bool operator <  (const cTimeDouble &dt1, const cTimeDouble &dt2);
                friend bool operator <= (const cTimeDouble &dt1, const cTimeDouble &dt2);
                friend bool operator >  (const cTimeDouble &dt1, const cTimeDouble &dt2);
                friend bool operator >= (const cTimeDouble &dt1, const cTimeDouble &dt2);
                friend bool operator == (const cTimeDouble &dt1, const cTimeDouble &dt2);
                friend bool operator != (const cTimeDouble &dt1, const cTimeDouble &dt2);
 
                static cTimeDouble GRAYCALL GetTimeNow();
                static cTimeDouble GRAYCALL Date();
                static cTimeDouble GRAYCALL Time();
 
                cTimeFile GetAsFileTime() const;
                bool GetTimeUnits(OUT cTimeUnits& rTu, TZ_TYPE nTimeZoneOffset) const;
 
                TIMEDOW_TYPE get_DayOfWeek() const;      
 
                unsigned GetDate() const             
                {
                        return unsigned(m_dateTime);
                }
 
                double get_DaysTil() const
                {
                        return(get_Double() - GetTimeNow());
                }
                double get_DaysAge() const
                {
                        return(-get_DaysTil());
                }
 
                // to/from strings.
                HRESULT SetTimeStr(const GChar_t* pszDateTime, TZ_TYPE nTimeZoneOffset = TZ_UTC);
                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(double dDays, TIMEUNIT_TYPE eUnitHigh = TIMEUNIT_Day, int iUnitsDesired = 2, bool bShortText = false);
 
                UNITTEST_FRIEND(cTimeDouble);
        };
 
        bool inline operator < (const cTimeDouble &dt1, const cTimeDouble &dt2)
        {
                return(dt1.m_dateTime < dt2.m_dateTime);
        }
        bool inline operator <= (const cTimeDouble &dt1, const cTimeDouble &dt2)
        {
                return((dt1.m_dateTime <= dt2.m_dateTime));
        }
        bool inline operator > (const cTimeDouble &dt1, const cTimeDouble &dt2)
        {
                return(dt1.m_dateTime > dt2.m_dateTime);
        }
        bool inline operator >= (const cTimeDouble &dt1, const cTimeDouble &dt2)
        {
                return((dt1.m_dateTime >= dt2.m_dateTime));
        }
        bool inline operator == (const cTimeDouble &dt1, const cTimeDouble &dt2)
        {
                return(dt1.m_dateTime == dt2.m_dateTime);
        }
        bool inline operator != (const cTimeDouble &dt1, const cTimeDouble &dt2)
        {
                return(dt1.m_dateTime != dt2.m_dateTime);
        }
};
#endif // _INC_cTimeDouble_H