cTimeUnits.h

Go to the documentation of this file.

//
//
 
#ifndef _INC_cTimeUnits_H
#define _INC_cTimeUnits_H
#ifndef NO_PRAGMA_ONCE
#pragma once
#endif
 
#include "StrConst.h"
#include "StrArg.h"
#include "cUnitTestDecl.h"
#include "cDebugAssert.h"
#include "HResult.h"
#include <time.h>       // system time_t for count of seconds. int32 or int64.
 
namespace Gray
{
        // Base type used for cTimeInt Might be 64 bits ?? or _USE_32BIT_TIME_T
        typedef time_t TIMESEC_t;       
        typedef int TIMESECD_t;         
 
        typedef short TIMEUNIT_t;       
 
        enum TZ_TYPE
        {
 
                TZ_UTC = 0,                             
                TZ_GMT = 0,                             
                TZ_AST = (4 * 60),
                TZ_EDT = (4 * 60),              
                TZ_EST = (5 * 60),              
                TZ_CST = (6 * 60),
                TZ_MST = (7 * 60),
                TZ_PST = (8 * 60),              
                TZ_MAX = (24 * 60),             
                TZ_LOCAL = 0x7FFF,              
        };
 
        enum TIME_FORMAT_TYPE
        {
 
                // enum cdtdate_format_type {cdtMDY, cdtDAY, cdtMONTH, cdtFULL, cdtEUROPEAN};
 
                TIME_FORMAT_DEFAULT = 0,        
                TIME_FORMAT_DB,                         
                TIME_FORMAT_TZ,                         
 
                TIME_FORMAT_AMERICAN,           
                TIME_FORMAT_HTTP,                       
                TIME_FORMAT_SMTP,                       
 
                TIME_FORMAT_ISO,                        
                TIME_FORMAT_ISO_TZ,                     
                TIME_FORMAT_ASN,                        
 
 
                TIME_FORMAT_QTY,
        };
 
        enum TIMEDOW_TYPE
        {
                TIMEDOW_Sun = 0,        
                TIMEDOW_Mon,
                TIMEDOW_Tue,
                TIMEDOW_Wed,
                TIMEDOW_Thu,
                TIMEDOW_Fri,
                TIMEDOW_Sat,
                TIMEDOW_QTY,    
        };
 
        enum TIMEMONTH_TYPE
        {
                TIMEMONTH_Jan = 0,      
                TIMEMONTH_Feb,
                TIMEMONTH_Mar,
                TIMEMONTH_Apr,
                TIMEMONTH_May,
                TIMEMONTH_Jun,
                TIMEMONTH_Jul,
                TIMEMONTH_Aug,
                TIMEMONTH_Sep,
                TIMEMONTH_Oct,
                TIMEMONTH_Nov,
                TIMEMONTH_Dec = 11,
                TIMEMONTH_QTY = 12,
        };
 
        struct CTimeUnit
        {
                const GChar_t* m_pszUnitNameL;  
                const GChar_t* m_pszUnitNameS;  
                TIMEUNIT_t m_uMin;
                TIMEUNIT_t m_uMax;
                WORD m_uSubRatio;                               
                TIMESECD_t m_nUnitSeconds;              
                double m_dUnitDays;                             
        };
 
        enum TIMEUNIT_TYPE
        {
                TIMEUNIT_UNUSED = -1,   
                TIMEUNIT_Year = 0,              
                TIMEUNIT_Month,                 
                TIMEUNIT_Day,                   
                TIMEUNIT_Hour,                  
                TIMEUNIT_Minute,                
                TIMEUNIT_Second,                
                TIMEUNIT_Millisecond,   
                TIMEUNIT_Microsecond,   
                TIMEUNIT_TZ,                    
                TIMEUNIT_QTY,                   
                // used for parsing only.
                TIMEUNIT_DOW,                   
                TIMEUNIT_Ignore,                
                TIMEUNIT_Numeric,               
                TIMEUNIT_QTY2,                  
        };
 
        class GRAYCORE_LINK cTimeUnits
        {
 
        public:
                TIMEUNIT_t m_wYear;                     
                TIMEUNIT_t m_wMonth;            
                TIMEUNIT_t m_wDay;                      
                TIMEUNIT_t m_wHour;                     
                TIMEUNIT_t m_wMinute;           
                TIMEUNIT_t m_wSecond;           
                TIMEUNIT_t m_wMillisecond;      
                TIMEUNIT_t m_wMicrosecond;      
 
                TIMEUNIT_t m_nTZ;                       
 
                static const TIMESECD_t k_nSecondsPerDay = (24 * 60 * 60);              
                static const TIMESECD_t k_nSecondsPerHour = (60 * 60);          
                static const int k_nMinutesPerDay = (24 * 60);          
                static const int k_nMicroSeconds = 1000000;                     
 
                static const CTimeUnit k_Units[TIMEUNIT_QTY];                   
                static const GChar_t* k_StrFormats[TIME_FORMAT_QTY + 1];        
 
                static const BYTE k_MonthDays[2][TIMEMONTH_QTY];                
                static const WORD k_MonthDaySums[2][TIMEMONTH_QTY + 1]; 
 
                // may change for language ?
                static const GChar_t* const k_MonthName[TIMEMONTH_QTY + 1];             
                static const GChar_t* const k_MonthAbbrev[TIMEMONTH_QTY + 1];   
 
                static const GChar_t* const k_DayName[TIMEDOW_QTY + 1];         
                static const GChar_t* const k_DayAbbrev[TIMEDOW_QTY + 1];       
 
                static const GChar_t k_TimeSeparator = ':';                             
                static const GChar_t k_Seps[3]; // Normal valid string separators. "/:" = all sm_DateSeparator or sm_TimeSeparator
                static const GChar_t k_SepsAll[8];      // All/Any separator that might occur in k_StrFormats.
 
                // May change for regional preferences ?
                static GChar_t sm_DateSeparator;                        
                static bool sm_time24Mode;                                      
 
        public:
#ifdef _WIN32
                cTimeUnits(const SYSTEMTIME& sysTime);
                bool GetSys(SYSTEMTIME& sysTime) const noexcept;
                void SetSys(const SYSTEMTIME& sysTime);
#endif
                void SetZeros();
                bool InitTimeNow(TZ_TYPE nTimeZoneOffset = TZ_LOCAL);
 
                COMPARE_TYPE Compare(cTimeUnits& b) const;
                bool isTimeFuture() const;
                bool isTimePast() const
                {
                        return !isTimeFuture();
                }
 
                TIMEDOW_TYPE get_DOW() const  
                {
                        return GetDOW(m_wYear, m_wMonth, m_wDay);
                }
                int get_DOY() const
                {
                        return GetDOY(m_wYear, m_wMonth, m_wDay);
                }
                TIMEMONTH_TYPE get_Month() const
                {
                        return (TIMEMONTH_TYPE)(m_wMonth - 1);
                }
 
                bool IsValidUnit(TIMEUNIT_TYPE i) const;
                bool isValidTimeUnits() const;
                bool isReasonableTimeUnits() const;
 
                TIMEUNIT_t GetUnit(TIMEUNIT_TYPE i) const
                {
                        ASSERT(IS_INDEX_GOOD(i, TIMEUNIT_QTY));
                        return (&m_wYear)[i];
                }
                TIMEUNIT_t GetUnit0(TIMEUNIT_TYPE i) const
                {
                        // Zero based units.
                        return GetUnit(i) - k_Units[i].m_uMin;
                }
                void SetUnit(TIMEUNIT_TYPE i, TIMEUNIT_t wVal)
                {
                        ASSERT(IS_INDEX_GOOD(i, TIMEUNIT_QTY));
                        (&m_wYear)[i] = wVal;
                }
 
                bool operator == (const cTimeUnits& rTu) const
                {
                        return(!::memcmp(this, &rTu, sizeof(rTu)));     // All of it ?
                }
 
                void put_DosDate(UINT32 ulDosDate);
                UINT32 get_DosDate() const;
 
                void AddMonths(int iMonths);
                void AddDays(int iDays);
                void AddSeconds(TIMESECD_t nSeconds);
                void AddTZ(TZ_TYPE nTimeZoneOffset);
 
                bool isInDST() const;
 
                StrLen_t GetFormStr(GChar_t* pszOut, StrLen_t iOutSizeMax, const GChar_t* pszFormat) const;
                StrLen_t GetFormStr(GChar_t* pszOut, StrLen_t iOutSizeMax, TIME_FORMAT_TYPE eFormat = TIME_FORMAT_DEFAULT) const
                {
                        return GetFormStr(pszOut, iOutSizeMax, (const GChar_t*)eFormat);
                }
                HRESULT SetTimeStr(const GChar_t* pszDateTime, TZ_TYPE nTimeZoneOffset);
                StrLen_t GetTimeSpanStr(GChar_t* pszOut, StrLen_t iOutSizeMax, TIMEUNIT_TYPE eUnitHigh = TIMEUNIT_Day, int iUnitsDesired = 2, bool bShortText = false) const;
 
                static int GRAYCALL IsLeapYear(TIMEUNIT_t wYear);
                static int GRAYCALL GetLeapYearsSince2K(TIMEUNIT_t wYear);
                static TIMEDOW_TYPE GRAYCALL GetDOW(TIMEUNIT_t wYear, TIMEUNIT_t wMonth, TIMEUNIT_t wDay);
                static int GRAYCALL GetDOY(TIMEUNIT_t wYear, TIMEUNIT_t wMonth, TIMEUNIT_t wDay);
 
                TIMESECD_t get_SecondOfDay() const
                {
                        return m_wSecond + (m_wMinute * 60) + (TIMESECD_t)(m_wHour * 60 * 60);
                }
                bool isValidMonth() const
                {
                        return m_wMonth >= 1 && m_wMonth <= 12;
                }
                TIMEUNIT_t get_DaysInMonth() const
                {
                        // How many days in m_wMonth ?
                        ASSERT_THROW(isValidMonth());
                        int iLeapYear = IsLeapYear(m_wYear);
                        return k_MonthDays[iLeapYear][m_wMonth - 1];
                }
                TIMEUNIT_t get_DayOfYear() const
                {
                        // What day of m_wYear is this ?
                        ASSERT_THROW(isValidMonth());
                        int iLeapYear = IsLeapYear(m_wYear);
                        return k_MonthDaySums[iLeapYear][m_wMonth - 1] + (m_wDay - 1);
                }
                TIMEUNIT_t get_DaysInYear() const
                {
                        // How many days in m_wYear ?
                        return (IsLeapYear(m_wYear) == 0) ? 365 : 366;
                }
 
                cTimeUnits(void)
                {
                        SetZeros();     // a valid time?
                }
                cTimeUnits(TIMEUNIT_t wYear, TIMEUNIT_t wMonth, TIMEUNIT_t wDay, TIMEUNIT_t wHour = 0, TIMEUNIT_t wMinute = 0, TIMEUNIT_t wSecond = 0, TIMEUNIT_t wMilliseconds = 0, TIMEUNIT_t wMicroseconds = 0, TZ_TYPE nTZ = TZ_UTC)
                        : m_wYear(wYear)
                        , m_wMonth(wMonth)
                        , m_wDay(wDay)
                        , m_wHour(wHour)
                        , m_wMinute(wMinute)
                        , m_wSecond(wSecond)
                        , m_wMillisecond(wMilliseconds)
                        , m_wMicrosecond(wMicroseconds)
                        , m_nTZ((TIMEUNIT_t)nTZ)
                {
                }
 
                UNITTEST_FRIEND(cTimeUnits);
        };
 
        //*******************************************************
        struct cTimeParserUnit
        {
 
                TIMEUNIT_TYPE m_Type;   
                TIMEUNIT_t m_nValue;    
                StrLen_t m_iOffsetSep;  
                GChar_t m_Separator;            
 
                void Init()
                {
                        m_Type = TIMEUNIT_UNUSED;
                        m_nValue = -1;          // not set yet.
                        m_iOffsetSep = -1;
                        m_Separator = -1;       // not set yet.
                }
                TIMEUNIT_TYPE get_HashCode() const noexcept     // should be only one of each type.
                {
                        return m_Type;
                }
                TIMEUNIT_t get_SortValue() const noexcept
                {
                        return m_nValue;
                }
        };
 
        class GRAYCORE_LINK cTimeParser
        {
 
        public:
                cTimeParserUnit m_Unit[TIMEUNIT_QTY2];          
                int m_iUnitsParsed;             
                int m_iUnitsMatched;    
 
        public:
                static bool GRAYCALL TestMatchUnit(const cTimeParserUnit& u, TIMEUNIT_TYPE t);
                static TIMEUNIT_TYPE GRAYCALL GetTypeFromFormatCode(GChar_t ch);
                int FindType(TIMEUNIT_TYPE t) const;
                void SetUnitFormats(const GChar_t* pszFormat);
 
                StrLen_t ParseNamedUnit(const GChar_t* pszName);
                HRESULT ParseString(const GChar_t* pszTimeString, const GChar_t* pszSeparators = nullptr);
                bool isMatched() const
                {
                        return m_iUnitsMatched > 0;
                }
                StrLen_t GetMatchedLength() const
                {
                        ASSERT(m_iUnitsMatched <= m_iUnitsParsed);
                        if (m_iUnitsMatched <= 0)
                                return 0;
                        int i = m_iUnitsMatched - 1;
                        ASSERT(IS_INDEX_GOOD_ARRAY(i, m_Unit));
                        return m_Unit[i].m_iOffsetSep;
                }
 
                bool TestMatchFormat(const cTimeParser& parserFormat, bool bTrimJunk = false);
                bool TestMatch(const GChar_t* pszFormat);
                bool TestMatches(const GChar_t** ppStrFormats = nullptr);
 
                HRESULT GetTimeUnits(OUT cTimeUnits& tu) const;
 
                cTimeParser()
                        : m_iUnitsParsed(0)
                        , m_iUnitsMatched(0)
                {
                        m_Unit[0].Init();
                }
                cTimeParser(const GChar_t* pszTimeString)
                        : m_iUnitsParsed(0)
                        , m_iUnitsMatched(0)
                {
                        ParseString(pszTimeString);
                }
                cTimeParser(const GChar_t* pszTimeString, const GChar_t** ppStrFormats)
                        : m_iUnitsParsed(0)
                        , m_iUnitsMatched(0)
                {
                        // Matches
                        ParseString(pszTimeString);
                        TestMatches(ppStrFormats);
                }
        };
}
#endif