home *** CD-ROM | disk | FTP | other *** search
/ Visual Basic Source Code / Visual Basic Source Code.iso / vbsource / dtime / data.1 / Datetime.cpp < prev    next >
Encoding:
C/C++ Source or Header  |  1996-07-08  |  88.6 KB  |  3,782 lines
  1. /*
  2. Module : DATETIME.H
  3. Purpose: Implementation for a number of Date / Time classes
  4. Created: PJN / DATE/1 / 05-05-1995
  5. History: None
  6.  
  7. Copyright (c) 1995 by PJ Naughter.  
  8. All rights reserved.
  9.  
  10. */
  11.  
  12. /////////////////////////////////  Includes  //////////////////////////////////
  13. #include "stdafx.h"
  14. #include "limits.h"
  15. #include "time.h"
  16. #include "stdlib.h"
  17. #include "math.h"                                      
  18. #include "float.h"
  19. #include "win32sup.h"
  20. #include "datetime.h"
  21. #include "resource.h"
  22.  
  23.  
  24.  
  25. //////////////////////////////////  Macros  ///////////////////////////////////
  26. IMPLEMENT_SERIAL(CDate, CObject, 1)
  27. IMPLEMENT_SERIAL(CLTimeSpan, CObject, 1)
  28. IMPLEMENT_SERIAL(CLTimeOfDay, CObject, 1)
  29. IMPLEMENT_SERIAL(CLDate, CObject, 1)
  30.  
  31.  
  32.  
  33. #ifdef _DEBUG
  34. #undef THIS_FILE
  35. static char BASED_CODE THIS_FILE[] = __FILE__;
  36. #define new DEBUG_NEW
  37. #endif
  38.  
  39.  
  40. ////////////////////////////////// Locals /////////////////////////////////////
  41. LONG lfloor(LONG a, LONG b);
  42. void SetFebLength(BOOL bIsLeap);
  43. void ResetFebLength();
  44.  
  45.  
  46.  
  47. ////////////////////////////////// Statics ////////////////////////////////////
  48.  
  49. CString CDate::sm_sBuffer         = _T(""); 
  50. CString CDate::sm_sDefaultFormat  = _T("%d/%m/%c");  
  51. WORD    CDate::sm_wBeginOfWeek    = MONDAY;
  52. LONG    CDate::sm_lEndJulianYear  = 1582;
  53. WORD    CDate::sm_wEndJulianMonth = 10;
  54. WORD    CDate::sm_wEndJulianDay   = 4;
  55. LONG    CDate::sm_lBeginGregYear  = 1582;
  56. WORD    CDate::sm_wBeginGregMonth = 10; 
  57. WORD    CDate::sm_wBeginGregDay   = 15;
  58. BOOL    CDate::sm_bDoAsserts = TRUE;
  59.  
  60. CString CLTimeSpan::sm_sBuffer = _T("");
  61. CString CLTimeSpan::sm_sDefaultFormat = _T("%D %H:%M:%S.%F"); 
  62. BOOL    CLTimeSpan::sm_bDoAsserts = TRUE;
  63.  
  64. CString CLTimeOfDay::sm_sBuffer = _T("");  
  65. CString CLTimeOfDay::sm_sDefaultFormat = _T("%H:%M:%S.%F");
  66. BOOL    CLTimeOfDay::sm_bDoAsserts = TRUE;    
  67.  
  68. CString CLDate::sm_sBuffer = _T("");
  69. CString CLDate::sm_sDefaultFormat = _T("%H:%M:%S.%F %d/%m/%c %t"); 
  70. BOOL    CLDate::sm_bDoAsserts     = TRUE;
  71. BOOL    CLDate::sm_bIsDst         = TRUE;
  72.  
  73.  
  74.  
  75. static const int DeltaTTable[187] =
  76.  {1240, 1150, 1060, 980, 910, 850, 790, 740, 700, 650,
  77.   620, 580, 550, 530, 500, 480, 460, 440, 420, 400, 
  78.   370, 350, 330, 310, 280, 260, 240, 220, 200, 180, 
  79.   160, 140, 130, 120, 110, 100,  90,  90,  90,  90, 
  80.    90,  90,  90,  90, 100, 100, 100, 100, 100, 110, 
  81.   110, 110, 110, 110, 110, 110, 110, 120, 120, 120,
  82.   120, 120, 130, 130, 130, 130, 140, 140, 140, 150,
  83.   150, 150, 150, 160, 160, 160, 160, 160, 170, 170,
  84.   170, 170, 170, 170, 170, 170, 160, 160, 150, 140,
  85.   137, 131, 127, 125, 125, 125, 125, 125, 125, 123,
  86.   120, 114, 106,  96,  86,  75,  66,  60,  57,  56, 
  87.    57,  59,  62,  65,  68,  71,  73,  75,  77,  78,
  88.    79,  75,  64,  54,  29,  16, -10, -27, -36, -47,
  89.   -54, -52, -55, -56, -58, -59, -62, -64, -61, -47,
  90.   -27,   0,  26,  54,  77, 105, 134, 160, 182, 202,
  91.   212, 224, 235, 239, 243, 240, 239, 239, 237, 240,
  92.   243, 253, 262, 273, 282, 291, 300, 307, 314, 322,
  93.   331, 340, 350, 365, 383, 402, 422, 445, 465, 485,
  94.   505, 522, 538, 549, 558, 569, 580};
  95.  
  96. static WORD MonthLength[14] =
  97.   {
  98.   0,  31, 28, 31, 30, 31, 30,
  99.   31, 31, 30, 31, 30, 31, 0};
  100.  
  101.  
  102.  
  103.  
  104. ////////////////////////////////// Implementation /////////////////////////////
  105.             
  106.  
  107.  
  108. //Free Sub-Programs
  109.  
  110. void SetFebLength(BOOL bIsLeap)
  111. {
  112.   MonthLength[2] = (WORD) (28 + bIsLeap);
  113. }
  114.  
  115. void ResetFebLength()
  116. {
  117.   MonthLength[2] = 28;
  118. };
  119.  
  120. LONG lfloor(LONG a, LONG b)
  121. {
  122.   ASSERT(b > 0);
  123.   return (a >= 0L ? a/b : (a%b == 0L) - 1 - labs(a)/b);
  124. }
  125.  
  126.  
  127. //CDate Implementation
  128.  
  129. CDate::CDate(LONG Year, WORD Month, WORD Day)
  130. { 
  131.   Set(Year, Month, Day);
  132. }
  133.  
  134. CDate::CDate(const SYSTEMTIME& st)
  135. {
  136.   Set(st);
  137. }
  138.  
  139. CDate::CDate(LONG Year, WORD Month, WORD WeekOfMonth, WORD DayOfWeek)
  140. {
  141.   Set(Year, Month, WeekOfMonth, DayOfWeek);
  142. }
  143.  
  144. CDate::CDate(LONG Days, DateEpoch e)
  145. {
  146.   Set(Days, e);
  147. }
  148.  
  149. CDate::CDate()
  150. {
  151.   Set();
  152. }
  153.  
  154. CDate::CDate(const CDate& d)
  155. {
  156.   m_lDays = d.m_lDays;
  157.   m_bInGregCalendar = d.m_bInGregCalendar;
  158. }
  159.  
  160. CDate::CDate(const CTime& ctime)
  161. {
  162.   Set(ctime.GetTime()/86400, EPOCH_CTIME);
  163. }
  164.                                      
  165. #ifdef _WIN32
  166. CDate::CDate(const COleDateTime& oleTime)
  167. {
  168.   Set(oleTime);
  169. }                     
  170. #endif
  171.  
  172. CDate& CDate::Set()
  173. {
  174.   m_lDays = LONG_MIN;
  175.   m_bInGregCalendar = FALSE;
  176.   return *this;
  177. }
  178.  
  179. CDate& CDate::Set(LONG Year, WORD Month, WORD Day)
  180. {
  181.   //The following method has been taken from the magazine "Microsoft Systems Journal"
  182.   //I cannot find the copy again, so if anyone recognises the algorithm please let
  183.   //me know so I can credit the author.
  184.  
  185.   if (Month < JANUARY || Month > DECEMBER ||
  186.       Day > DaysInMonth(Month, IsLeap(Year)))
  187.   {
  188.     if (sm_bDoAsserts)
  189.       ASSERT(FALSE);
  190.     Set();
  191.     return *this;
  192.   }
  193.   
  194.   if (((Year > sm_lEndJulianYear) && (Year < sm_lBeginGregYear)) ||
  195.       ((Year == sm_lEndJulianYear) && ((Month > sm_wEndJulianMonth) && (Month < sm_wBeginGregMonth))) ||
  196.       ((Year == sm_lEndJulianYear) && (Month == sm_wEndJulianMonth) && (Day > sm_wEndJulianDay) && (Day < sm_wBeginGregDay)))
  197.   {
  198.     if (sm_bDoAsserts)
  199.       ASSERT(FALSE);
  200.     Set();
  201.     return *this;
  202.   }
  203.  
  204.   SetFebLength(IsLeap(Year));
  205.   m_lDays = (Year-1)*365 + lfloor(Year-1, 4L);
  206.   m_bInGregCalendar = InGregorianCalendar(Year, Month, Day);
  207.   if (m_bInGregCalendar)
  208.     m_lDays += lfloor(Year-1, 400L) - lfloor(Year-1, 100L);
  209.   while (--Month)
  210.     m_lDays += MonthLength[Month];
  211.   m_lDays += Day - 577736L - 2*(!m_bInGregCalendar);
  212.   ResetFebLength();
  213.  
  214.   return *this;
  215. }
  216.  
  217. CDate& CDate::Set(LONG Year, WORD Month, WORD WeekOfMonth, WORD DayOfWeek)
  218. {
  219.   if (WeekOfMonth < 1 || WeekOfMonth > 5 || DayOfWeek < 1 && DayOfWeek > 7)
  220.   {
  221.     if (sm_bDoAsserts)
  222.       ASSERT(FALSE);
  223.     Set();
  224.     return *this;
  225.   }
  226.  
  227.   if (WeekOfMonth < 5)
  228.   {
  229.     CDate FirstMonth(Year, Month, 1);
  230.     if (!FirstMonth.IsValid())
  231.     {
  232.       if (sm_bDoAsserts)
  233.         ASSERT(FALSE);
  234.       Set();
  235.       return *this;
  236.     }
  237.     WORD dow = FirstMonth.GetDayOfWeek();
  238.     WORD Day = (WORD) (((DayOfWeek - dow + 7) % 7) + (7*(WeekOfMonth-1)) + 1);
  239.     Set(Year, Month, Day);
  240.   }
  241.   else  //5 means the last week of the month
  242.   {
  243.     WORD NewMonth = (WORD) (Month + 1);
  244.     LONG NewYear = Year;
  245.     if (NewMonth > DECEMBER)
  246.     {
  247.       Month = 1;
  248.       ++Year;
  249.     }
  250.        
  251.     Set(NewYear, NewMonth, 1, DayOfWeek);
  252.     AddWeek(-1);
  253.   }
  254.  
  255.   return *this;
  256. }
  257.  
  258. CDate& CDate::Set(LONG Days, DateEpoch e)
  259. {
  260.   switch (e)
  261.   {
  262.     case EPOCH_GREG:
  263.     {
  264.       m_lDays = Days;
  265.       break;
  266.     }
  267.     case EPOCH_JD:    
  268.     {
  269.       m_lDays = Days - 2299161;  //-2299161 coresponds to the GDN of JD Epoch namely 1 January -4712 
  270.       break;
  271.     }
  272.     case EPOCH_MJD:   
  273.     {
  274.       m_lDays = Days + 100839L;  //100839 coresponds to the GDN of MJD Epoch namely 17 November 1858 
  275.       break;
  276.     }
  277.     case EPOCH_1900:
  278.     {
  279.       m_lDays = Days + 115860L;  //115860 corresponds to the GDN of 1 January 1900
  280.       break;
  281.     }
  282.     case EPOCH_1950:
  283.     {
  284.       m_lDays = Days + 134122L;  //134122 corresponds to the GDN of 1 January 1950
  285.       break;
  286.     }
  287.     case EPOCH_CTIME:
  288.     {
  289.       m_lDays = Days + 141427L;  //141427 corresponds to the GDN of 1 January 1970
  290.       break;
  291.     }
  292.     case EPOCH_2000:  
  293.     {
  294.       m_lDays = Days + 152384L;  //152384 corresponds to the GDN of 1 January 2000
  295.       break;
  296.     }
  297.     default: ASSERT(FALSE); //should not occur
  298.   }
  299.     
  300.   if (m_lDays > 2146905911)  //Largest valid GDN
  301.   {
  302.     if (sm_bDoAsserts)
  303.       ASSERT(FALSE);
  304.     Set();
  305.   }
  306.  
  307.   m_bInGregCalendar = *this > CDate(sm_lBeginGregYear, sm_wBeginGregMonth, sm_wBeginGregDay);
  308.  
  309.   return *this;
  310. }
  311.  
  312. CDate& CDate::Set(const SYSTEMTIME& st)
  313. {
  314.   Set(st.wYear, st.wMonth, st.wDay);
  315.   return *this;
  316. }
  317.  
  318. CDate& CDate::Set(const CTime& ctime)
  319. {
  320.   return Set(ctime.GetTime()/86400, EPOCH_CTIME);
  321. }
  322.       
  323. #ifdef _WIN32
  324. CDate& CDate::Set(const COleDateTime& oleTime)
  325. {
  326.   return Set((LONG) oleTime.GetYear(), (WORD) oleTime.GetMonth(), (WORD) oleTime.GetDay());
  327. }                     
  328. #endif
  329.  
  330. CDate CDate::CurrentDate()
  331. {   
  332.   #ifdef _WIN32
  333.     SYSTEMTIME st;
  334.     ::GetLocalTime(&st);
  335.     return CDate(st);
  336.   #else      
  337.     time_t csecs = time(NULL);
  338.     tm* ct = localtime(&csecs);
  339.     return CDate((LONG) (ct->tm_year + 1900), (WORD) (ct->tm_mon + 1), (WORD) (ct->tm_mday));
  340.   #endif
  341. }
  342.  
  343. WORD CDate::CurrentMonth()
  344. {              
  345.   return CurrentDate().GetMonth();
  346. }
  347.  
  348. WORD CDate::CurrentDay()
  349. {
  350.   return CurrentDate().GetDay();
  351. }
  352.  
  353. LONG CDate::CurrentYear()
  354. {                               
  355.   return CurrentDate().GetYear();
  356. }
  357.  
  358. WORD CDate::CurrentDayOfWeek()
  359. {            
  360.   return CurrentDate().GetDayOfWeek();
  361. }
  362.  
  363. void CDate::SetBeginingDayOfWeek(WORD BeginOfWeek)
  364. {
  365.   sm_wBeginOfWeek = BeginOfWeek;
  366. }
  367.  
  368. WORD CDate::GetBeginingDayOfWeek()
  369. {
  370.   return sm_wBeginOfWeek;
  371. }
  372.  
  373. void CDate::SetEndJulianCalendar(LONG Year, WORD Month, WORD Day)
  374. {
  375.   sm_lEndJulianYear = Year;
  376.   sm_wEndJulianMonth = Month;
  377.   sm_wEndJulianDay = Day;
  378. }
  379.  
  380. void CDate::SetBeginGregCalendar(LONG Year, WORD Month, WORD Day)
  381. {
  382.   sm_lBeginGregYear = Year;
  383.   sm_wBeginGregMonth = Month;
  384.   sm_wBeginGregDay = Day;
  385. }
  386.  
  387. DateS CDate::GetEndJulianCalendar()
  388. {
  389.   DateS rVal;
  390.   rVal.lYear = sm_lEndJulianYear;
  391.   rVal.wMonth = sm_wEndJulianMonth;
  392.   rVal.wDay = sm_wEndJulianDay;
  393.   rVal.wWday = CDate(sm_lEndJulianYear, sm_wEndJulianMonth, sm_wEndJulianDay).GetDayOfWeek();
  394.   rVal.wYday = DaysSinceJan0(sm_wEndJulianMonth, sm_wEndJulianDay, IsLeap(sm_lEndJulianYear));
  395.   rVal.ct = JULIAN;
  396.   return rVal;
  397. }
  398.  
  399. DateS CDate::GetBeginGregCalendar()
  400. {
  401.   DateS rVal;
  402.   rVal.lYear = sm_lBeginGregYear;
  403.   rVal.wMonth = sm_wBeginGregMonth;
  404.   rVal.wDay = sm_wBeginGregDay;
  405.   rVal.wWday = CDate(sm_lBeginGregYear, sm_wBeginGregMonth, sm_wBeginGregDay).GetDayOfWeek();
  406.   rVal.wYday = DaysSinceJan0(sm_wBeginGregMonth, sm_wBeginGregDay, IsLeap(sm_lBeginGregYear));
  407.   rVal.ct = GREGORIAN;
  408.   return rVal;
  409. }
  410.  
  411. BOOL CDate::InGregorianCalendar(LONG Year, WORD Month, WORD Day)
  412. {
  413.   if (Year == sm_lBeginGregYear)
  414.   {
  415.     if (Month == sm_wBeginGregMonth)
  416.       return (Day >= sm_wBeginGregDay);
  417.     else
  418.       return (Month > sm_wBeginGregMonth);
  419.   }
  420.   else
  421.     return (Year > sm_lBeginGregYear);
  422. }
  423.  
  424. #ifdef _DEBUG
  425. BOOL CDate::SetDoConstructorAsserts(BOOL bDoAsserts)
  426. {
  427.   BOOL bOldDoAsserts = sm_bDoAsserts;
  428.   sm_bDoAsserts = bDoAsserts;
  429.   return bOldDoAsserts;
  430. }
  431. #endif
  432.  
  433. CString& CDate::GetFullStringDayOfWeek(WORD DayOfWeek)
  434. {
  435.   sm_sBuffer.Empty();
  436.   if (DayOfWeek > 0 && DayOfWeek <= 7)
  437.   {
  438.     if (!sm_sBuffer.LoadString(IDS_WEEKDAY1 - 1 + DayOfWeek))
  439.       ASSERT(FALSE);
  440.   }
  441.   return sm_sBuffer;
  442. }
  443.  
  444. CString& CDate::GetAbrStringDayOfWeek(WORD DayOfWeek)
  445. {
  446.   sm_sBuffer.Empty();
  447.   if (DayOfWeek > 0 && DayOfWeek <= 7)
  448.   {
  449.     if (!sm_sBuffer.LoadString(IDS_ABR_WEEKDAY1 - 1 + DayOfWeek))
  450.       ASSERT(FALSE);
  451.   }
  452.   return sm_sBuffer;
  453. }
  454.  
  455. CString& CDate::GetFullStringMonth(WORD Month)
  456. {
  457.   sm_sBuffer.Empty();
  458.   if (Month > 0 && Month <= 12)
  459.   {
  460.     if (!sm_sBuffer.LoadString(IDS_MONTH1 - 1 + Month))
  461.       ASSERT(FALSE);
  462.   }
  463.   return sm_sBuffer;
  464. }
  465.  
  466. CString& CDate::GetAbrStringMonth(WORD Month)
  467. {
  468.   sm_sBuffer.Empty();
  469.   if (Month > 0 && Month <= 12)
  470.   {
  471.     if (!sm_sBuffer.LoadString(IDS_ABR_MONTH1 - 1 + Month))
  472.       ASSERT(FALSE);
  473.   }
  474.   return sm_sBuffer;
  475. }
  476.  
  477. CDate CDate::FirstCurrentMonth()
  478. {
  479.   CDate c = CDate::CurrentDate();
  480.   return CDate(c.GetYear(), c.GetMonth(), 1); 
  481. }
  482.  
  483. CDate CDate::LastCurrentMonth()
  484. {
  485.   CDate c = CDate::CurrentDate();
  486.   return CDate(c.GetYear(), c.GetMonth(), c.DaysInMonth()); 
  487. }
  488.  
  489. CDate CDate::FirstCurrentYear()
  490. {
  491.   CDate c = CDate::CurrentDate();
  492.   return CDate(c.GetYear(), 1, 1); 
  493. }              
  494.  
  495. CDate CDate::LastCurrentYear()
  496. {
  497.   CDate c = CDate::CurrentDate();
  498.   return CDate(c.GetYear(), 12, CDate::DaysInMonth(12, c.IsLeap())); 
  499. }
  500.  
  501. CDate CDate::JDEpoch()
  502. {
  503.   return CDate(0, EPOCH_JD);
  504. }
  505.  
  506. CDate CDate::MJDEpoch()
  507. {
  508.   return CDate(0, EPOCH_MJD);
  509. }
  510.  
  511. CDate CDate::Epoch1900()
  512. {
  513.   return CDate(0, EPOCH_1900);
  514. }
  515.  
  516. CDate CDate::Epoch1950()
  517. {
  518.   return CDate(0, EPOCH_1950);
  519. }
  520.  
  521. CDate CDate::EpochCTime()
  522. {
  523.   return CDate(0, EPOCH_CTIME);
  524. }
  525.  
  526. CDate CDate::Epoch2000()
  527. {
  528.   return CDate(0, EPOCH_2000);
  529. }
  530.  
  531. CDate CDate::GregorianEpoch()
  532. {
  533.   return CDate(0, EPOCH_GREG);
  534. }                 
  535.  
  536. void CDate::ClearStatics()
  537. {
  538.   sm_sBuffer.Empty();
  539.   sm_sDefaultFormat.Empty();
  540. }
  541.  
  542. CDate CDate::NewYearsDay(LONG Year) 
  543. {
  544.   return CDate(Year, JANUARY, 1);
  545. }
  546.  
  547. CDate CDate::ValentinesDay(LONG Year) 
  548. {
  549.   return CDate(Year, FEBRUARY, 14);
  550. }
  551.  
  552. CDate CDate::AshWednesday(LONG Year)
  553. {                                      
  554.   return CDate::EasterSunday(Year) - 39L;    //Ash Wednesday occurs 39 days before Easter Sunday
  555. }
  556.  
  557. CDate CDate::StPatricksDay(LONG Year) 
  558. {
  559.   return CDate(Year, MARCH, 17);
  560. }
  561.  
  562. CDate CDate::GoodFriday(LONG Year)
  563. { 
  564.   return CDate::EasterSunday(Year) - 2L;     //Good Friday occurs 2 days before Easter Sunday
  565. }
  566.  
  567. CDate CDate::EasterSunday(LONG Year)
  568. {
  569.   //The following method has been taken from the book "Astronimical Algorithms" by Jean Meeus
  570.   //which was taken in turn from a book "General Astronomy" by Spencer Jones. It has been 
  571.   //published again in the "Journal of the British Astronomical Association, Vol 88" where
  572.   //it is said that it was devised in 1876 and appeared in Butcher's "Ecclesiastical Calendar"
  573.  
  574.   if (InGregorianCalendar(Year, 4, 1))  //in the Gregorain Calendar, Will possibly give results if Calendar
  575.   {                                     //switches from Julian to Gregorian in March or April because then
  576.     int a = (int) (Year % 19);          //the year may be considered Gregorian or Julian
  577.     int b = (int) (Year / 100);
  578.     int c = (int) (Year % 100);
  579.     int d = b / 4;
  580.     int e = b % 4;
  581.     int f = (b+8) / 25;
  582.     int g = (b - f + 1) / 3;
  583.     int h = (19*a + b - d - g + 15) % 30;
  584.     int i = c / 4;
  585.     int k = c % 4;
  586.     int l = (32 + 2*e + 2*i - h -k) % 7;
  587.     int m = (a + 11*h +22*l) / 451;
  588.     int n = (h + l - 7*m + 114) / 31;
  589.     int p = (h + l - 7*m + 114) % 31;
  590.     return CDate(Year, WORD(n), WORD(p+1));
  591.   }
  592.   else              //in the Julian Calendar
  593.   {                          
  594.     int a = (int) (Year % 4);
  595.     int b = (int) (Year % 7);
  596.     int c = (int) (Year % 19);
  597.     int d = (19*c + 15) % 30;
  598.     int e = (2*a + 4*b - d + 34) % 7;
  599.     int f = (d + e + 114) / 31;
  600.     int g = (d + e + 114) % 31;
  601.     return CDate(Year, (WORD) f, (WORD) (g + 1));
  602.   }  
  603. }
  604.  
  605. CDate CDate::CanadaDay(LONG Year)
  606. {
  607.   return CDate(Year, JULY, 1);
  608. }
  609.  
  610. CDate CDate::IndependenceDay(LONG Year) 
  611. {
  612.   return CDate(Year, JULY, 4);
  613. }
  614.  
  615. CDate CDate::BastilleDay(LONG Year) 
  616. {
  617.   return CDate(Year, JULY, 14);
  618. }
  619.  
  620. CDate CDate::ChristmasDay(LONG Year)  
  621. {
  622.   return CDate(Year, DECEMBER, 25);
  623. }
  624.  
  625. BOOL CDate::IsLeap(LONG Year)
  626. {                
  627.   if (InGregorianCalendar(Year, 1, 1))    //Will give incorrect results if Calendar switches
  628.   {                                       //from Julian to Gregorian in the Year 1600 (if any Country did)
  629.     if ((Year % 100) == 0)                
  630.       return ((Year % 400) == 0) ? TRUE : FALSE;
  631.     else
  632.       return ((Year % 4) == 0) ? TRUE : FALSE;
  633.   }
  634.   else                                        
  635.     return ((Year % 4) == 0) ? TRUE : FALSE;
  636.       
  637. }
  638.  
  639. WORD CDate::DaysInYear(LONG Year)
  640. {
  641.   return IsLeap(Year) ? ((WORD) 366) : ((WORD) 365);
  642. }
  643.  
  644. WORD CDate::DaysInMonth(WORD Month, BOOL IsLeap)
  645. {
  646.   SetFebLength(IsLeap);
  647.   ASSERT(Month >= 1 && Month <= 12);
  648.   WORD r = MonthLength[Month];
  649.   ResetFebLength();
  650.   return r;
  651. }
  652.  
  653. WORD CDate::DaysSinceJan1(WORD Month, WORD Day, BOOL IsLeap)
  654. {
  655.   return (WORD) (DaysSinceJan0(Month, Day, IsLeap) - 1);
  656. }
  657.  
  658.  
  659. WORD CDate::DaysSinceJan0(WORD Month, WORD Day, BOOL IsLeap)
  660. {            
  661.   ASSERT(Month >= JANUARY && Month <= DECEMBER);
  662.   ASSERT(Day <= DaysInMonth(Month, IsLeap) && Day >= 1);
  663.   int k = IsLeap ? 1 : 2;
  664.   WORD rVal = (WORD) ((int(275*Month/9)) - (k*int((Month+9)/12)) + Day - 30);
  665.   return rVal; 
  666. }
  667.  
  668. void CDate::SetDefaultFormat(const CString& Format)
  669. {
  670.   sm_sDefaultFormat = Format;
  671. }
  672.  
  673. CString& CDate::GetDefaultFormat()
  674. {
  675.   return sm_sDefaultFormat;
  676. }
  677.  
  678. WORD CDate::DaysSinceJan1() const
  679. {
  680.   AssertValid();
  681.   return (WORD) (*this - CDate(GetYear(), 1, 1));
  682. }
  683.  
  684. WORD CDate::DaysSinceJan0() const
  685. {
  686.   AssertValid();
  687.   return (WORD) (DaysSinceJan1() + 1);
  688. }
  689.  
  690. DateS CDate::GetDate() const
  691. {
  692.   //See the comment in CDate::Set(LONG Year, WORD Month, WORD Day)
  693.   //for references to where the algorithm is taken from
  694.  
  695.   AssertValid();
  696.   BOOL bIsGreg = InGregorianCalendar();
  697.   BOOL bIsJulian = !bIsGreg;
  698.   DateS ds;
  699.   LONG gdn = m_lDays + 577735L + 2*bIsJulian;
  700.   LONG y4 = 1461L;
  701.   LONG y400 = 146100L - 3*bIsGreg;
  702.   LONG y100 = 36525L - bIsGreg;
  703.   BOOL exception=FALSE;
  704.   ds.lYear = 400*lfloor(gdn, y400);
  705.   gdn -= y400*lfloor(gdn, y400);       //400 year periods
  706.   if (gdn > 0L)
  707.   {
  708.     ds.lYear += 100*lfloor(gdn, y100);  //100 year periods
  709.     gdn -= y100*lfloor(gdn, y100);
  710.     exception = (gdn == 0L && bIsGreg);
  711.     if (gdn > 0L)
  712.     {
  713.       ds.lYear += 4*lfloor(gdn, y4);     //4 year periods
  714.       gdn -= y4*lfloor(gdn, y4);
  715.       if (gdn > 0L)
  716.       {
  717.         int i=0;
  718.         while (gdn > 365 && ++i < 4)
  719.         {
  720.           ds.lYear++;
  721.           gdn -= 365L;
  722.         }
  723.       }
  724.     }
  725.   }
  726.   if (exception)
  727.     gdn = 366L; //occurs once every hundred years with Gregorian calendar
  728.   else
  729.   {
  730.     ds.lYear++;
  731.     gdn++;
  732.   }
  733.   SetFebLength(IsLeap(ds.lYear));
  734.   ds.wMonth = 1;
  735.   while (ds.wMonth < 13 && gdn > ((LONG) MonthLength[ds.wMonth]))
  736.     gdn -= MonthLength[ds.wMonth++];
  737.   if (ds.wMonth == 13)
  738.   {
  739.     ds.wMonth = 1;
  740.     ds.lYear++;
  741.   }
  742.   ResetFebLength();
  743.   ds.wDay = (WORD) gdn;
  744.   ds.wWday = (WORD) ((m_lDays+12)%7 + 1); 
  745.   ds.wYday = DaysSinceJan0(ds.wMonth, ds.wDay, IsLeap(ds.lYear));
  746.  
  747.   return ds;
  748. }
  749.  
  750. WORD CDate::GetDay() const
  751. {
  752.   AssertValid();
  753.   return GetDate().wDay;
  754. }
  755.  
  756. WORD CDate::GetMonth() const
  757. {
  758.   AssertValid();
  759.   return GetDate().wMonth;
  760. }
  761.  
  762. LONG CDate::GetYear() const
  763. {
  764.   AssertValid();
  765.   return GetDate().lYear;
  766. }
  767.  
  768. LONG CDate::GetCEBCEYear(BOOL& IsCE) const
  769. {
  770.   AssertValid();
  771.   LONG Year = GetDate().lYear;
  772.  
  773.   if (Year > 0)
  774.   {
  775.     IsCE = TRUE;
  776.     return Year;
  777.   }
  778.   else
  779.   {
  780.     IsCE = FALSE;
  781.     return labs(GetYear() - 1);
  782.   }
  783. }
  784.  
  785. WORD CDate::Get2DigitYear() const
  786. {
  787.   AssertValid();
  788.   LONG Year = labs(GetYear());
  789.   return (WORD) (Year - ((Year/100)*100));
  790. }
  791.  
  792.  
  793. WORD CDate::GetWeekOfYear() const
  794. {               
  795.   AssertValid(); 
  796.   CDate FirstOfYear(GetYear(), JANUARY, 1, GetBeginingDayOfWeek());
  797.   LONG diff = *this - FirstOfYear;
  798.   if (diff < 0)
  799.     return 0;
  800.   else
  801.     return (WORD) (diff/7 + 1);
  802. }
  803.  
  804.  
  805. WORD CDate::GetWeekOfMonth() const
  806. {                  
  807.   AssertValid();
  808.   CDate FirstOfMonth(GetYear(), GetMonth(), 1, GetBeginingDayOfWeek());
  809.   LONG diff = *this - FirstOfMonth;
  810.   if (diff < 0)
  811.     return 0;
  812.   else
  813.     return (WORD) (diff/7 + 1);
  814. }
  815.  
  816. LONG CDate::Since1900Epoch() const
  817. {
  818.   AssertValid();
  819.   return *this - CDate(1900, 1, 1);
  820. }
  821.  
  822. LONG CDate::Since1950Epoch() const
  823. {
  824.   AssertValid();
  825.   return *this - CDate(1950, 1, 1);
  826. }
  827.  
  828. LONG CDate::SinceCTimeEpoch() const
  829. {
  830.   AssertValid();  
  831.   return *this - CDate(1970, 1, 1);
  832. }
  833.  
  834. LONG CDate::Since2000Epoch() const
  835. {
  836.   AssertValid();
  837.   return *this - CDate(2000, 1, 1);
  838. }
  839.  
  840. LONG CDate::JD() const
  841. {
  842.   AssertValid();
  843.   return *this - JDEpoch();
  844. }
  845.  
  846. LONG CDate::GDN() const
  847. {
  848.   AssertValid();
  849.   return m_lDays;
  850. }
  851.  
  852. BOOL CDate::IsLeap() const
  853. {
  854.   AssertValid();
  855.   return IsLeap(GetYear());
  856. }
  857.  
  858. WORD CDate::DaysInYear() const
  859. { 
  860.   AssertValid();
  861.   return DaysInYear(GetYear());
  862. }
  863.  
  864. WORD CDate::DaysInMonth() const
  865. {
  866.   AssertValid();
  867.   return DaysInMonth(GetMonth(), IsLeap());
  868. }
  869.  
  870. void CDate::AddYear(int Years)
  871. {
  872.   AssertValid();
  873.   LONG Months = Years*12;
  874.   if (Months >= INT_MIN && Months <= INT_MAX)
  875.     AddMonth((int) Months);
  876.   else
  877.   {
  878.     ASSERT(FALSE);
  879.     Set();
  880.   }
  881. }
  882.  
  883. void CDate::AddMonth(int Months)
  884. {
  885.   AssertValid();
  886.   LONG NewMonth = (LONG) GetMonth();
  887.   LONG NewYear = GetYear();
  888.   NewMonth += Months;
  889.   if ((NewMonth > DECEMBER) || (NewMonth < JANUARY))
  890.   {
  891.     NewYear += NewMonth / 12;
  892.     NewMonth = NewMonth % 12;
  893.   }
  894.   if (NewMonth < JANUARY)
  895.   {
  896.     --NewYear;
  897.     NewMonth += 12;
  898.   }
  899.  
  900.   WORD Day = GetDay();
  901.  
  902.   WORD MaxDays = DaysInMonth((WORD) NewMonth, IsLeap(NewYear));
  903.   if (Day > MaxDays)
  904.     Day = MaxDays;
  905.   Set(NewYear, (WORD) NewMonth, Day);
  906. }
  907.  
  908. void CDate::AddWeek(int Weeks)
  909. {
  910.   AssertValid();
  911.   *this += 7L*((LONG)Weeks);
  912. }
  913.  
  914. WORD CDate::GetDayOfWeek() const
  915. {
  916.   AssertValid();
  917.   return GetDate().wWday;
  918. }
  919.  
  920. CString& CDate::GetStringCEBCEYear() const
  921. {
  922.   AssertValid();
  923.   BOOL bIsCEYear;
  924.   LONG lCEYear = GetCEBCEYear(bIsCEYear);
  925.   CString sYear;                    
  926.   sYear.Format(_T("%ld"), lCEYear);
  927.   if (bIsCEYear)
  928.     AfxFormatString1(sm_sBuffer, IDS_CEYEAR, sYear);
  929.   else
  930.     AfxFormatString1(sm_sBuffer, IDS_BCEYEAR, sYear);
  931.   return sm_sBuffer;
  932. }
  933.  
  934. CString& CDate::GetFullStringDayOfWeek() const
  935. {
  936.   AssertValid();
  937.   return GetFullStringDayOfWeek(GetDayOfWeek());
  938. }
  939.  
  940. CString& CDate::GetAbrStringDayOfWeek() const
  941. {
  942.   AssertValid();
  943.   return GetAbrStringDayOfWeek(GetDayOfWeek());
  944. }
  945.  
  946. CString& CDate::GetFullStringMonth() const
  947. {
  948.   AssertValid();
  949.   return GetFullStringMonth(GetMonth());
  950. }
  951.  
  952. CString& CDate::GetAbrStringMonth() const
  953. {
  954.   AssertValid();
  955.   return GetAbrStringMonth(GetMonth());
  956. }
  957.  
  958. SYSTEMTIME CDate::GetSYSTEMTIME() const
  959. {
  960.   AssertValid();
  961.   SYSTEMTIME s;
  962.   s.wYear = 0;
  963.   s.wMonth = 0;
  964.   s.wDayOfWeek = 0;
  965.   s.wDay = 0;
  966.   s.wHour = 0;
  967.   s.wMinute = 0;
  968.   s.wSecond = 0;
  969.   s.wMilliseconds = 0;
  970.  
  971.   DateS ds = GetDate();
  972.  
  973.   //handle range errors
  974.   if ((ds.lYear < 0) || (ds.lYear > USHRT_MAX))
  975.   {
  976.     ASSERT(FALSE);
  977.     s.wYear = 0;
  978.     return s;
  979.   }
  980.   
  981.   s.wYear = (WORD) ds.lYear;
  982.   s.wMonth = ds.wMonth;
  983.   s.wDayOfWeek = (WORD) (ds.wWday - 1);  //SYSTEMTIME uses 0 based indices
  984.   s.wDay = ds.wDay;
  985.  
  986.   return s;
  987. }                
  988.                           
  989. tm CDate::GetTM() const
  990. {
  991.   AssertValid();
  992.   tm rVal;
  993.   
  994.   rVal.tm_sec   = 0;
  995.   rVal.tm_min   = 0;
  996.   rVal.tm_hour  = 0;
  997.   rVal.tm_mday  = 0;
  998.   rVal.tm_mon   = 0;
  999.   rVal.tm_year  = 0;
  1000.   rVal.tm_wday  = 0;
  1001.   rVal.tm_yday  = 0;
  1002.   rVal.tm_isdst = 0;
  1003.  
  1004.   DateS ds = GetDate(); 
  1005.      
  1006. #ifdef _WIN32
  1007.   long MinYear = 1900L + LONG_MIN;
  1008.   long MaxYear = LONG_MAX;
  1009. #else   
  1010.   long MinYear = 1900L + SHRT_MIN;
  1011.   long MaxYear = 1900L + SHRT_MAX;
  1012. #endif
  1013.  
  1014.   //handle range errors
  1015.   if ((ds.lYear < MinYear) || (ds.lYear > MaxYear))
  1016.   {
  1017.     ASSERT(FALSE);
  1018.     return rVal;
  1019.   }
  1020.   
  1021.   rVal.tm_year = (int) (ds.lYear - 1900L);
  1022.   rVal.tm_mon = ds.wMonth - 1;  //tm struct uses 0 based indices
  1023.   rVal.tm_wday = ds.wWday - 1;  //tm struct uses 0 based indices
  1024.   rVal.tm_mday = ds.wDay; 
  1025.   rVal.tm_wday = ds.wYday - 1; //Returns days since Jan 1
  1026.               
  1027.   return rVal;
  1028. }
  1029.  
  1030. BOOL CDate::IsValid() const
  1031. {
  1032.   return (m_lDays == LONG_MIN) ? FALSE : TRUE;
  1033. }
  1034.  
  1035. LONG CDate::Collate() const
  1036. {
  1037.   AssertValid();
  1038.   DateS s;
  1039.   s = GetDate();
  1040.   return (s.lYear*10000) + (s.wMonth*100) + s.wDay;
  1041. }
  1042.  
  1043. BOOL CDate::InGregorianCalendar() const
  1044. {
  1045.   AssertValid();
  1046.   return m_bInGregCalendar;
  1047. }
  1048.  
  1049. CDate CDate::FirstThisMonth() const
  1050. {
  1051.   AssertValid();
  1052.   DateS s=GetDate();
  1053.   return CDate(s.lYear, s.wMonth, 1);  
  1054. }
  1055.  
  1056. CDate CDate::LastThisMonth() const
  1057. {
  1058.   AssertValid();
  1059.   DateS s = GetDate();
  1060.   return CDate(s.lYear, s.wMonth, DaysInMonth(s.wMonth, IsLeap(s.lYear)));  
  1061. }
  1062.  
  1063. CDate CDate::FirstThisYear() const
  1064. {
  1065.   AssertValid();
  1066.   DateS s = GetDate();
  1067.   CDate d(s.lYear, JANUARY, 1);
  1068.   return d;  
  1069. }
  1070.  
  1071. CDate CDate::LastThisYear() const
  1072. {
  1073.   AssertValid();
  1074.   DateS s = GetDate();
  1075.   CDate d(s.lYear, DECEMBER, 1);
  1076.   return d;  
  1077. }
  1078.  
  1079. CDate& CDate::operator=(const CDate& d)
  1080. {
  1081.   m_lDays = d.m_lDays;
  1082.   m_bInGregCalendar = d.m_bInGregCalendar;
  1083.   return *this;
  1084. }
  1085.  
  1086. CDate CDate::operator+(LONG Days) const
  1087. {
  1088.   AssertValid();
  1089.   return CDate(m_lDays + Days, EPOCH_GREG);
  1090. }
  1091.  
  1092. LONG CDate::operator-(const CDate& d) const
  1093. {
  1094.   AssertValid();
  1095.   return m_lDays - d.m_lDays;
  1096. }
  1097.  
  1098. CDate CDate::operator-(LONG Days) const
  1099. {
  1100.   AssertValid();
  1101.   return CDate(m_lDays - Days, EPOCH_GREG);
  1102. }
  1103.  
  1104. CDate& CDate::operator+=(LONG Days)
  1105. {
  1106.   AssertValid();
  1107.   m_lDays += Days;
  1108.   return *this;
  1109. }
  1110.  
  1111. CDate& CDate::operator-=(LONG Days)
  1112. {
  1113.   AssertValid();
  1114.   m_lDays -= Days;
  1115.   return *this;
  1116. }
  1117.  
  1118. CDate& CDate::operator++()
  1119. {
  1120.   AssertValid();
  1121.   m_lDays++;
  1122.   return *this;
  1123. }
  1124.  
  1125. CDate& CDate::operator--()
  1126. {
  1127.   AssertValid();
  1128.   m_lDays--;
  1129.   return *this;
  1130. }
  1131.  
  1132. BOOL CDate::operator==(const CDate& d) const
  1133. {
  1134.   AssertValid();
  1135.   return m_lDays == d.m_lDays;
  1136. }
  1137.  
  1138. BOOL CDate::operator>(const CDate& d) const
  1139. {
  1140.   AssertValid();
  1141.   return m_lDays > d.m_lDays;
  1142. }
  1143.  
  1144. BOOL CDate::operator>=(const CDate& d) const
  1145. {
  1146.   AssertValid();
  1147.   return m_lDays >= d.m_lDays;
  1148. }
  1149.  
  1150. BOOL CDate::operator<(const CDate& d) const
  1151. {
  1152.   AssertValid();
  1153.   return m_lDays < d.m_lDays;
  1154. }
  1155.  
  1156. BOOL CDate::operator<=(const CDate& d) const
  1157. {
  1158.   AssertValid();
  1159.   return m_lDays <= d.m_lDays;
  1160. }
  1161.  
  1162. BOOL CDate::operator!=(const CDate& d) const
  1163. {
  1164.   AssertValid();
  1165.   return m_lDays != d.m_lDays;
  1166. }
  1167.  
  1168. #ifdef _DEBUG
  1169. void CDate::AssertValid() const
  1170. {
  1171.   CObject::AssertValid();
  1172.   ASSERT(IsValid());
  1173. }
  1174. #endif
  1175.  
  1176. #ifdef _DEBUG
  1177. void CDate::Dump(CDumpContext& dc) const
  1178. {
  1179.   CObject::Dump(dc);
  1180.   dc << Format() << _T("\n");
  1181. }
  1182. #endif
  1183.  
  1184. /*    //The Following Format parameters are supported
  1185.  
  1186. %a    Abbreviated weekday name
  1187. %A    Full weekday name
  1188. %b    Abbreviated month name
  1189. %B    Full month name
  1190. %d    Day of month as decimal number (01 - 31)
  1191. %j    Day of year as decimal number (001 - 366)
  1192. %m    Month as decimal number (01 - 12)
  1193. %U    Week of year as decimal number
  1194. %w    Weekday as decimal number (1 - 7; Sunday is 1)
  1195. %x    Short date representation, appropriate to current locale
  1196. %y    Year without century, as decimal number (00 - 99)
  1197. %Y    Year with century, as decimal number
  1198. %c    Year displayed using C.E.(Current Epoch) / B.C.E (Before Current Epoch) convention e.g. -1023 = 1022 BCE
  1199. %#x   Long date representation, appropriate to current locale
  1200. %#d, %#j, %#m, %#U, %#y Remove leading zeros (if any)
  1201. */
  1202. CString& CDate::Format(const CString& sFormat) const
  1203. { 
  1204.   if (!IsValid())
  1205.     sm_sBuffer.Empty();
  1206.   else
  1207.   {
  1208.     CString sBuffer;
  1209.     sm_sBuffer.Empty();
  1210.     CString rVal;
  1211.     int sFmtLength = sFormat.GetLength();
  1212.  
  1213.     for (int i=0; i<sFmtLength; i++)
  1214.     {
  1215.       TCHAR c = sFormat.GetAt(i);
  1216.       if (c == TCHAR('%'))
  1217.       {
  1218.         ++i;
  1219.         if (i < sFmtLength)
  1220.         {
  1221.           c = sFormat.GetAt(i);
  1222.           switch (c)
  1223.           {
  1224.             case TCHAR('a'):
  1225.             {
  1226.               rVal += GetAbrStringDayOfWeek();
  1227.               break;
  1228.             }
  1229.             case TCHAR('A'):
  1230.             {
  1231.               rVal += GetFullStringDayOfWeek();
  1232.               break;
  1233.             }
  1234.             case TCHAR('b'):
  1235.             {
  1236.               rVal += GetAbrStringMonth();
  1237.               break;
  1238.             }
  1239.             case TCHAR('c'):
  1240.             {
  1241.               rVal += GetStringCEBCEYear();
  1242.               break;
  1243.             }
  1244.             case TCHAR('B'):
  1245.             {
  1246.               rVal += GetFullStringMonth();
  1247.               break;
  1248.             }
  1249.             case TCHAR('d'):
  1250.             {
  1251.               sBuffer.Format(_T("%.02d"), GetDay());
  1252.               rVal += sBuffer;
  1253.               break;
  1254.             }
  1255.             case TCHAR('j'):
  1256.             {
  1257.               sBuffer.Format(_T("%.03d"), DaysSinceJan0());
  1258.               rVal += sBuffer;
  1259.               break;
  1260.             }
  1261.             case TCHAR('m'):
  1262.             {
  1263.               sBuffer.Format(_T("%.02d"), GetMonth());
  1264.               rVal += sBuffer;
  1265.               break;
  1266.             }
  1267.             case TCHAR('U'):
  1268.             {
  1269.               sBuffer.Format(_T("%.02d"), GetWeekOfYear());
  1270.               rVal += sBuffer;
  1271.               break;
  1272.             }
  1273.             case TCHAR('w'):
  1274.             {
  1275.               sBuffer.Format(_T("%d"), GetDayOfWeek());
  1276.               rVal += sBuffer;
  1277.               break;
  1278.             }                                   
  1279.             
  1280.           #ifdef _WIN32
  1281.             case TCHAR('x'):
  1282.             {
  1283.               sBuffer.Empty();
  1284.               SYSTEMTIME st = GetSYSTEMTIME();
  1285.               int Res = ::GetDateFormat(LOCALE_USER_DEFAULT,
  1286.                                       DATE_SHORTDATE,
  1287.                                       &st,
  1288.                                       NULL,
  1289.                                       sBuffer.GetBufferSetLength(100),
  1290.                                       100); 
  1291.               if (Res == 0)
  1292.                 TRACE1("GetDateFormat() Failed in CDate::Format(), GetLastError() returned %ul\n", ::GetLastError());
  1293.               sBuffer.ReleaseBuffer();
  1294.               rVal += sBuffer;
  1295.               break;
  1296.             }                 
  1297.           #else
  1298.             #ifndef _WINDLL  //only available when statically linked to CRT
  1299.               case TCHAR('x'):
  1300.               {
  1301.                 sBuffer.Empty();                                            
  1302.                 tm tmCDate = GetTM();
  1303.                 strftime(sBuffer.GetBufferSetLength(200), 200, "%x", &tmCDate);
  1304.                 sBuffer.ReleaseBuffer();
  1305.                 rVal += sBuffer;
  1306.                 break;
  1307.               }    
  1308.             #endif               
  1309.           #endif
  1310.             
  1311.             case TCHAR('y'):
  1312.             {
  1313.               LONG Year = GetYear();
  1314.               sBuffer.Format(_T("%.02d"), Get2DigitYear());
  1315.               rVal += sBuffer;
  1316.               break;
  1317.             }
  1318.             case TCHAR('Y'):
  1319.             {
  1320.               sBuffer.Format(_T("%ld"), GetYear());
  1321.               rVal += sBuffer;
  1322.               break;
  1323.             }
  1324.             case TCHAR('#'):
  1325.             {
  1326.               if (i < sFmtLength)
  1327.               {
  1328.                 ++i;
  1329.                 c = sFormat.GetAt(i);
  1330.                 switch (c)
  1331.                 {
  1332.                   case TCHAR('d'):
  1333.                   {
  1334.                     sBuffer.Format(_T("%d"), GetDay());
  1335.                     rVal += sBuffer;
  1336.                     break;
  1337.                   }
  1338.                   case TCHAR('j'):
  1339.                   {
  1340.                     sBuffer.Format(_T("%d"), DaysSinceJan0());
  1341.                     rVal += sBuffer;
  1342.                     break;
  1343.                   }
  1344.                   case TCHAR('m'):
  1345.                   {
  1346.                     sBuffer.Format(_T("%d"), GetMonth());
  1347.                     rVal += sBuffer;
  1348.                     break;
  1349.                   }
  1350.                   case TCHAR('U'):
  1351.                   {
  1352.                     sBuffer.Format(_T("%d"), GetWeekOfYear());
  1353.                     rVal += sBuffer;
  1354.                     break;
  1355.                   }                                    
  1356.                   
  1357.                 #ifdef _WIN32
  1358.                   case TCHAR('x'):
  1359.                   {
  1360.                     sBuffer.Empty();
  1361.                     SYSTEMTIME st = GetSYSTEMTIME();
  1362.                     int Res = ::GetDateFormat(LOCALE_USER_DEFAULT,
  1363.                                             DATE_LONGDATE,
  1364.                                             &st,
  1365.                                             NULL,
  1366.                                             sBuffer.GetBufferSetLength(100),
  1367.                                             100); 
  1368.                     if (Res == 0)
  1369.                       TRACE1("GetDateFormat() Failed in CDate::Format(), GetLastError() returned %ul\n", ::GetLastError());
  1370.  
  1371.                     sBuffer.ReleaseBuffer();
  1372.                     rVal += sBuffer;
  1373.                     break;
  1374.                   }               
  1375.                 #else   
  1376.                   #ifndef _WINDLL  //only available when statically linked to CRT
  1377.                     case TCHAR('x'):    //Long representation is the same as short representation when not on Win32
  1378.                     {
  1379.                       sBuffer.Empty();                                       
  1380.                       tm tmCDate = GetTM();
  1381.                       strftime(sBuffer.GetBufferSetLength(200), 200, "%x", &tmCDate);
  1382.                       sBuffer.ReleaseBuffer();
  1383.                       rVal += sBuffer;
  1384.                       break;
  1385.                     }                                                            
  1386.                   #endif  
  1387.                 #endif
  1388.                   
  1389.                   case TCHAR('y'):
  1390.                   {
  1391.                     LONG Year = GetYear();
  1392.                     sBuffer.Format(_T("%d"), Get2DigitYear());
  1393.                     rVal += sBuffer;
  1394.                     break;
  1395.                   }
  1396.                   default:
  1397.                   {
  1398.                     rVal += c;
  1399.                     break;
  1400.                   }
  1401.                 }
  1402.               }
  1403.               break;
  1404.             }
  1405.             default:
  1406.             {
  1407.               rVal += c;
  1408.               break;
  1409.             }
  1410.           }
  1411.         }
  1412.       }
  1413.       else
  1414.       {
  1415.         rVal += c;
  1416.       }
  1417.     }
  1418.     sm_sBuffer = rVal;
  1419.   }
  1420.  
  1421.   return sm_sBuffer;
  1422. }
  1423.  
  1424. void CDate::Serialize(CArchive& ar)
  1425. {
  1426.   CObject::Serialize(ar);
  1427.   if(ar.IsStoring())
  1428.   {
  1429.     ar << m_lDays;
  1430.     ar << (WORD) m_bInGregCalendar;
  1431.   }
  1432.   else
  1433.   {
  1434.     ar >> m_lDays;
  1435.     ar >> (WORD&) m_bInGregCalendar;
  1436.   }
  1437. }
  1438.  
  1439. ostream& operator<<(ostream& os, const CDate& date)
  1440. {
  1441.   return os << date.Format();
  1442. }
  1443.  
  1444. CArchive& operator<<(CArchive& ar, CDate& date)
  1445. {
  1446.   ASSERT(ar.IsStoring());
  1447.   date.Serialize(ar);
  1448.   return ar;
  1449. }
  1450.  
  1451. CArchive& operator>>(CArchive& ar, CDate& date)
  1452. {
  1453.   ASSERT(!ar.IsStoring());
  1454.   date.Serialize(ar);
  1455.   return ar;
  1456. }
  1457.  
  1458.  
  1459.  
  1460.  
  1461.  
  1462.  
  1463.  
  1464. //CLTimeSpan Implementation
  1465.  
  1466.  
  1467. CLTimeSpan::CLTimeSpan()
  1468. {
  1469.   Set();
  1470. }
  1471.  
  1472. CLTimeSpan::CLTimeSpan(LONG Day, WORD Hour, WORD Minute, 
  1473.                        WORD Second, WORD MilliSecond)
  1474. {
  1475.   Set(Day, Hour, Minute, Second, MilliSecond);
  1476. }
  1477.  
  1478. CLTimeSpan::CLTimeSpan(const CLTimeSpan& lts)
  1479. {
  1480.   m_dSeconds = lts.m_dSeconds;
  1481. }
  1482.  
  1483. CLTimeSpan::CLTimeSpan(const CTimeSpan& ts)
  1484. {
  1485.   Set(ts);
  1486. }
  1487.  
  1488. CLTimeSpan::CLTimeSpan(const CLTimeOfDay& tod)
  1489. {
  1490.   Set(tod);
  1491. }
  1492.       
  1493. #ifdef _WIN32
  1494. CLTimeSpan::CLTimeSpan(const COleDateTimeSpan& oleTimeSpan)
  1495. {
  1496.   Set(oleTimeSpan);
  1497. }                     
  1498. #endif
  1499.  
  1500. CLTimeSpan::CLTimeSpan(const double& Seconds)
  1501. {                                             
  1502.   Set(Seconds);
  1503. }
  1504.  
  1505. CLTimeSpan& CLTimeSpan::Set()
  1506. {                          
  1507.   m_dSeconds = DBL_MAX;
  1508.   return *this;
  1509. }
  1510.  
  1511. CLTimeSpan& CLTimeSpan::Set(LONG Day, WORD Hour, WORD Minute, 
  1512.                             WORD Second, WORD MilliSecond)
  1513. { 
  1514.   m_dSeconds = Day*86400.0 +
  1515.                Hour*3600.0 +
  1516.                Minute*60.0 +
  1517.                Second      +
  1518.                MilliSecond/1000.0;
  1519.   return *this;
  1520. }                            
  1521.  
  1522. CLTimeSpan& CLTimeSpan::Set(const CTimeSpan& ts)
  1523. {
  1524.   m_dSeconds = ts.GetTotalSeconds();
  1525.   return *this;
  1526. }
  1527.  
  1528. CLTimeSpan& CLTimeSpan::Set(const CLTimeOfDay& tod)
  1529. {
  1530.   Set(0, tod.GetHour(), tod.GetMinute(), tod.GetSecond(), tod.GetMilliSecond());
  1531.   return *this;
  1532. }
  1533.       
  1534. #ifdef _WIN32
  1535. CLTimeSpan& CLTimeSpan::Set(const COleDateTimeSpan& oleTimeSpan)
  1536. {
  1537.   return Set(oleTimeSpan.GetTotalSeconds());
  1538. }                     
  1539. #endif
  1540.  
  1541. CLTimeSpan& CLTimeSpan::Set(const double& Seconds)
  1542. { 
  1543.   if (((Seconds > 0) && (Seconds > ((double)LONG_MAX)*86400)) || 
  1544.       ((Seconds < 0) && (Seconds < ((double)LONG_MIN)*86400)))
  1545.   {
  1546.     if (sm_bDoAsserts)
  1547.       ASSERT(FALSE);
  1548.     Set();
  1549.   }
  1550.   else
  1551.   {
  1552.     double IntPart, fraction;
  1553.     fraction = modf(Seconds, &IntPart);
  1554.     fraction = (floor(fraction*1000 + 0.5))/1000;
  1555.     m_dSeconds = IntPart + fraction;
  1556.   }
  1557.   
  1558.   return *this;
  1559. }
  1560.  
  1561. CLTimeSpan CLTimeSpan::OneCivilYear()
  1562. {
  1563.   return CLTimeSpan(365, 6, 0, 0, 0);
  1564. }
  1565.  
  1566. CLTimeSpan CLTimeSpan::OneDay()
  1567. {
  1568.   return CLTimeSpan(1, 0, 0, 0, 0);
  1569. }
  1570.  
  1571. CLTimeSpan CLTimeSpan::OneHour()
  1572. {
  1573.   return CLTimeSpan(0, 1, 0, 0, 0);
  1574. }
  1575.  
  1576. CLTimeSpan CLTimeSpan::OneMinute()
  1577. {
  1578.   return CLTimeSpan(0, 0, 1, 0, 0);
  1579. }
  1580.  
  1581. CLTimeSpan CLTimeSpan::OneSecond()
  1582. {
  1583.   return CLTimeSpan(0, 0, 0, 1, 0);
  1584. }
  1585.  
  1586. CLTimeSpan CLTimeSpan::OneMilliSecond()
  1587. {
  1588.   return CLTimeSpan(0, 0, 0, 0, 1);
  1589. }
  1590.  
  1591. void CLTimeSpan::SetDefaultFormat(const CString& Format)
  1592. {
  1593.   sm_sDefaultFormat = Format;
  1594. }
  1595.  
  1596. CString& CLTimeSpan::GetDefaultFormat()
  1597. {
  1598.   return sm_sDefaultFormat;
  1599. }
  1600.  
  1601. #ifdef _DEBUG
  1602. BOOL CLTimeSpan::SetDoConstructorAsserts(BOOL bDoAsserts)
  1603. {
  1604.   BOOL bOldDoAsserts = sm_bDoAsserts;
  1605.   sm_bDoAsserts = bDoAsserts;
  1606.   return bOldDoAsserts;
  1607. }
  1608. #endif                     
  1609.  
  1610. void CLTimeSpan::ClearStatics()
  1611. {
  1612.   sm_sBuffer.Empty();
  1613.   sm_sDefaultFormat.Empty();
  1614. }
  1615.                                  
  1616. LONG CLTimeSpan::GetTotalDays() const
  1617. {
  1618.   AssertValid();
  1619.   return (LONG) (m_dSeconds/86400);
  1620. }
  1621.  
  1622. WORD CLTimeSpan::GetHours() const
  1623. {
  1624.   AssertValid();
  1625.   return (WORD) ((fabs(m_dSeconds) - 86400L*fabs(GetTotalDays()))/3600);
  1626. }
  1627.  
  1628. WORD CLTimeSpan::GetMinutes() const
  1629. {
  1630.   AssertValid();
  1631.   return (WORD) ((fabs(m_dSeconds) - 86400L*fabs(GetTotalDays()) - 3600L*GetHours())/60);
  1632. }
  1633.  
  1634. WORD CLTimeSpan::GetSeconds() const
  1635. {
  1636.   AssertValid();
  1637.   return (WORD) (fabs(m_dSeconds) - 86400L*fabs(GetTotalDays()) - 3600L*GetHours() - 60*GetMinutes());
  1638. }                             
  1639.  
  1640. WORD CLTimeSpan::GetMilliSeconds() const
  1641. {
  1642.   AssertValid();
  1643.   double IntPart, fraction;
  1644.   fraction = modf(m_dSeconds, &IntPart);
  1645.   return (WORD) labs(((LONG) (floor(fraction*1000 + 0.5))));
  1646. }
  1647.  
  1648. BOOL CLTimeSpan::IsValid() const
  1649. {
  1650.   return (m_dSeconds != DBL_MAX);
  1651. }
  1652.  
  1653. CLTimeSpan& CLTimeSpan::Negate()
  1654. {
  1655.   AssertValid();
  1656.   m_dSeconds = (-m_dSeconds);
  1657.   return *this;
  1658. }
  1659.  
  1660. BOOL CLTimeSpan::IsPositiveSpan() const
  1661. {
  1662.   AssertValid();
  1663.   return (m_dSeconds >= 0);
  1664. }
  1665.  
  1666. double CLTimeSpan::SecondsAsDouble() const
  1667. {
  1668.   AssertValid();
  1669.   return m_dSeconds;
  1670. }
  1671.  
  1672. BOOL CLTimeSpan::operator==(const CLTimeSpan& TimeSpan) const
  1673. {
  1674.   AssertValid();
  1675.   return (m_dSeconds == TimeSpan.m_dSeconds);
  1676. }
  1677.  
  1678. BOOL CLTimeSpan::operator>(const CLTimeSpan& TimeSpan) const
  1679. {
  1680.   AssertValid();
  1681.   return (m_dSeconds > TimeSpan.m_dSeconds);
  1682. }
  1683.  
  1684. BOOL CLTimeSpan::operator>=(const CLTimeSpan& TimeSpan) const
  1685. {
  1686.   AssertValid();
  1687.   return (m_dSeconds >= TimeSpan.m_dSeconds);
  1688. }
  1689.  
  1690. BOOL CLTimeSpan::operator<(const CLTimeSpan& TimeSpan) const
  1691. {
  1692.   AssertValid();
  1693.   return (m_dSeconds < TimeSpan.m_dSeconds);
  1694. }
  1695.  
  1696. BOOL CLTimeSpan::operator<=(const CLTimeSpan& TimeSpan) const
  1697. {
  1698.   AssertValid();
  1699.   return (m_dSeconds <= TimeSpan.m_dSeconds);
  1700. }
  1701.  
  1702. BOOL CLTimeSpan::operator!=(const CLTimeSpan& TimeSpan) const
  1703. {
  1704.   AssertValid();
  1705.   return (m_dSeconds != TimeSpan.m_dSeconds);
  1706. }
  1707.                                  
  1708. CLTimeSpan& CLTimeSpan::operator=(const CLTimeSpan& TimeSpan)
  1709. { 
  1710.   m_dSeconds = TimeSpan.m_dSeconds;
  1711.   return *this;
  1712. }
  1713.  
  1714. CLTimeSpan CLTimeSpan::operator+(const CLTimeSpan& TimeSpan) const
  1715. {
  1716.   AssertValid();
  1717.   TimeSpan.AssertValid();
  1718.   double rVal = m_dSeconds + TimeSpan.m_dSeconds;
  1719.   return CLTimeSpan(rVal);
  1720. }
  1721.  
  1722. CLTimeSpan CLTimeSpan::operator-(const CLTimeSpan& TimeSpan) const
  1723. {
  1724.   AssertValid();
  1725.   TimeSpan.AssertValid();
  1726.   double rVal = m_dSeconds - TimeSpan.m_dSeconds;
  1727.   return rVal;
  1728. }
  1729.  
  1730. CLTimeSpan& CLTimeSpan::operator+=(CLTimeSpan& TimeSpan)
  1731. {
  1732.   *this = *this + TimeSpan;
  1733.   return *this;
  1734. }
  1735.  
  1736. CLTimeSpan& CLTimeSpan::operator-=(CLTimeSpan& TimeSpan)
  1737. {
  1738.   *this = *this - TimeSpan;
  1739.   return *this;
  1740. }
  1741.  
  1742. CLTimeSpan operator-(const CLTimeSpan& TimeSpan)
  1743. {
  1744.   CLTimeSpan rVal(TimeSpan);
  1745.   return rVal.Negate();
  1746. }
  1747.  
  1748. CLTimeSpan CLTimeSpan::operator*(WORD Multiplier) const
  1749. {
  1750.   return ::operator*(Multiplier, *this);
  1751. }
  1752.  
  1753. CLTimeSpan operator*(WORD Multiplier, const CLTimeSpan& TimeSpan)
  1754. {
  1755.   TimeSpan.AssertValid();
  1756.   double rVal = TimeSpan.m_dSeconds * Multiplier;
  1757.   return CLTimeSpan(rVal);
  1758. }
  1759.  
  1760. CLTimeSpan CLTimeSpan::operator/(WORD divisor) const
  1761. {
  1762.   AssertValid();
  1763.   double rVal = m_dSeconds / ((double) divisor);
  1764.   return CLTimeSpan(rVal);
  1765. }
  1766.  
  1767. CLTimeSpan& CLTimeSpan::operator*=(WORD Multiplier)
  1768. {
  1769.   *this = operator*(Multiplier);
  1770.   return *this;
  1771. }
  1772.  
  1773. CLTimeSpan& CLTimeSpan::operator/=(WORD Divisor)
  1774. {
  1775.   *this = operator/(Divisor);
  1776.   return *this;
  1777. }
  1778.  
  1779. #ifdef _DEBUG
  1780. void CLTimeSpan::AssertValid() const
  1781. {
  1782.   CObject::AssertValid();
  1783.   ASSERT(IsValid());
  1784. }
  1785. #endif
  1786.  
  1787. #ifdef _DEBUG
  1788. void CLTimeSpan::Dump(CDumpContext& dc) const
  1789. {
  1790.   CObject::Dump(dc);
  1791.   dc << Format() << _T("\n");
  1792. }
  1793. #endif
  1794.  
  1795. /*    //The Following Format parameters are supported        
  1796. %D    Total days in this CLTimeSpan
  1797. %H    Hours in this CLTimeSpan (00 - 23)
  1798. %M    Minutes in the current hour in this CLTimeSpan (00 - 59)
  1799. %S    Seconds in the current minute in this CLTimeSpan (00 - 59)
  1800. %F    MilliSeconds in the current second in this CLTimeSpan (000 - 999)
  1801. %%    Percent sign
  1802. %#H, %#M, %#S  Remove leading zeros (if any).
  1803. */
  1804. CString& CLTimeSpan::Format(const CString& sFormat) const
  1805. { 
  1806.   if (!IsValid())
  1807.     sm_sBuffer.Empty();
  1808.   else
  1809.   {
  1810.     CString sBuffer;
  1811.     CString rVal;
  1812.     sm_sBuffer.Empty();
  1813.     int sFmtLength = sFormat.GetLength();
  1814.  
  1815.     for (int i=0; i<sFmtLength; i++)
  1816.     {
  1817.       TCHAR c = sFormat.GetAt(i);
  1818.       if (c == TCHAR('%'))
  1819.       {
  1820.         ++i;
  1821.         if (i < sFmtLength)
  1822.         {
  1823.           c = sFormat.GetAt(i);
  1824.           switch (c)
  1825.           {
  1826.             case TCHAR('D'):
  1827.             {
  1828.               LONG Days = GetTotalDays();
  1829.               sBuffer.Format(_T("%ld"), Days);
  1830.               if (IsPositiveSpan())
  1831.                 rVal += _T("+");
  1832.               else if (Days == 0) //handle neagtive 0
  1833.                 rVal += _T("-");
  1834.               rVal += sBuffer;
  1835.               break;
  1836.             }
  1837.             case TCHAR('H'):
  1838.             {
  1839.               sBuffer.Format(_T("%.02d"), GetHours());
  1840.               rVal += sBuffer;
  1841.               break;
  1842.             }
  1843.             case TCHAR('M'):
  1844.             {
  1845.               sBuffer.Format(_T("%.02d"), GetMinutes());
  1846.               rVal += sBuffer;
  1847.               break;
  1848.             }
  1849.             case TCHAR('S'):
  1850.             {
  1851.               sBuffer.Format(_T("%.02d"), GetSeconds());
  1852.               rVal += sBuffer;
  1853.               break;
  1854.             }
  1855.             case TCHAR('F'):
  1856.             {
  1857.               sBuffer.Format(_T("%.03d"), GetMilliSeconds());
  1858.               rVal += sBuffer;
  1859.               break;
  1860.             }
  1861.             case TCHAR('#'):
  1862.             {
  1863.               if (i < sFmtLength)
  1864.               {
  1865.                 ++i;
  1866.                 c = sFormat.GetAt(i);
  1867.                 switch (c)
  1868.                 {
  1869.                   case TCHAR('H'):
  1870.                   {
  1871.                     sBuffer.Format(_T("%d"), GetHours());
  1872.                     rVal += sBuffer;
  1873.                     break;
  1874.                   }
  1875.                   case TCHAR('M'):
  1876.                   {
  1877.                     sBuffer.Format(_T("%d"), GetMinutes());
  1878.                     rVal += sBuffer;
  1879.                     break;
  1880.                   }
  1881.                   case TCHAR('S'):
  1882.                   {
  1883.                     sBuffer.Format(_T("%d"), GetSeconds());
  1884.                     rVal += sBuffer;
  1885.                     break;
  1886.                   }
  1887.                   default:
  1888.                   {
  1889.                     rVal += c;
  1890.                     break;
  1891.                   }
  1892.                 }
  1893.               break;
  1894.               }
  1895.             }
  1896.             default:
  1897.             {
  1898.               rVal += c;
  1899.               break;
  1900.             }
  1901.           }
  1902.         }
  1903.       }
  1904.       else
  1905.       {
  1906.         rVal += c;
  1907.       }
  1908.     }
  1909.     sm_sBuffer = rVal;
  1910.   }
  1911.   
  1912.   return sm_sBuffer;
  1913. }
  1914.  
  1915. void CLTimeSpan::Serialize(CArchive& ar)
  1916. {
  1917.   CObject::Serialize(ar);
  1918.   if(ar.IsStoring())
  1919.   {
  1920.     ar << m_dSeconds;
  1921.   }
  1922.   else
  1923.   {
  1924.     ar >> m_dSeconds;
  1925.   }
  1926. }
  1927.  
  1928. ostream& operator<<(ostream &os, const CLTimeSpan& TimeSpan)
  1929. {
  1930.   return os << TimeSpan.Format();
  1931. }                  
  1932.  
  1933. CArchive& operator<<(CArchive& ar, CLTimeSpan& TimeSpan)
  1934. {
  1935.   ASSERT(ar.IsStoring());
  1936.   TimeSpan.Serialize(ar);
  1937.   return ar;
  1938. }
  1939.                
  1940. CArchive& operator>>(CArchive& ar, CLTimeSpan& TimeSpan)
  1941. {
  1942.   ASSERT(!ar.IsStoring());
  1943.   TimeSpan.Serialize(ar);
  1944.   return ar;
  1945. }
  1946.  
  1947.  
  1948.  
  1949.  
  1950.  
  1951.  
  1952. //CLTimeOfDay Implementation
  1953.  
  1954. CLTimeOfDay::CLTimeOfDay()
  1955. {
  1956.   Set();
  1957. }
  1958.  
  1959. CLTimeOfDay::CLTimeOfDay(WORD Hour, WORD Minute, 
  1960.            WORD Second, WORD MilliSecond)
  1961. {
  1962.   Set(Hour, Minute, Second, MilliSecond);
  1963. }    
  1964.  
  1965. CLTimeOfDay::CLTimeOfDay(const double& Seconds)
  1966. {
  1967.   Set(Seconds);
  1968. }    
  1969.  
  1970. CLTimeOfDay::CLTimeOfDay(const SYSTEMTIME& st)
  1971. {        
  1972.   Set(st.wHour, st.wMinute, st.wSecond, st.wMilliseconds);
  1973. }
  1974.            
  1975. CLTimeOfDay::CLTimeOfDay(const CLTimeOfDay& ltod)
  1976. {
  1977.   m_dwTotalSeconds = ltod.m_dwTotalSeconds;
  1978.   m_wMilliSeconds = ltod.m_wMilliSeconds;
  1979. }                                
  1980.  
  1981. CLTimeOfDay::CLTimeOfDay(DWORD TotalSeconds, WORD MilliSecond)
  1982. {
  1983.   Set(TotalSeconds, MilliSecond);
  1984. }                                
  1985.  
  1986.  
  1987. CLTimeOfDay& CLTimeOfDay::Set()
  1988. {
  1989.   m_dwTotalSeconds = 86400; //an illegal value
  1990.   m_wMilliSeconds = 0;
  1991.   return *this;
  1992. }
  1993.  
  1994. CLTimeOfDay& CLTimeOfDay::Set(const double& Seconds)
  1995. {
  1996.   if (Seconds < 0)
  1997.   {
  1998.     if (sm_bDoAsserts)
  1999.       ASSERT(FALSE);
  2000.     Set();
  2001.     return *this;
  2002.   }
  2003.   
  2004.   double FracPart, IntPart;
  2005.   FracPart = modf(Seconds, &IntPart);
  2006.   DWORD dwSeconds = (DWORD) IntPart;
  2007.   WORD wMilliSeconds = (WORD) (FracPart*1000 + 0.5);
  2008.   Set(dwSeconds, wMilliSeconds);
  2009.   return *this;
  2010. }
  2011.  
  2012. CLTimeOfDay& CLTimeOfDay::Set(WORD Hour, WORD Minute,
  2013.                 WORD Second, WORD MilliSecond)
  2014. {
  2015.   WORD AdditionalSeconds = (WORD) ((MilliSecond/1000)*1000);
  2016.   LONG lSeconds = Minute + 60L*Hour;
  2017.   lSeconds *= 60;
  2018.   lSeconds += Second + AdditionalSeconds;
  2019.   m_dwTotalSeconds = lSeconds;
  2020.   if (m_dwTotalSeconds >= 86400L)
  2021.   {
  2022.     if (sm_bDoAsserts)
  2023.       ASSERT(FALSE);
  2024.     Set();
  2025.     return *this;
  2026.   }
  2027.   m_wMilliSeconds = (WORD) (MilliSecond - (AdditionalSeconds*1000));
  2028.   return *this;  
  2029. }                
  2030.                                  
  2031. CLTimeOfDay& CLTimeOfDay::Set(DWORD TotalSeconds, WORD MilliSecond)
  2032. {
  2033.   WORD AdditionalSeconds = (WORD) ((MilliSecond/1000)*1000);
  2034.   m_dwTotalSeconds = TotalSeconds + AdditionalSeconds;
  2035.   if (m_dwTotalSeconds >= 86400)
  2036.   {
  2037.     if (sm_bDoAsserts)
  2038.       ASSERT(FALSE);
  2039.     Set();
  2040.     return *this;
  2041.   }
  2042.   m_wMilliSeconds = (WORD) (MilliSecond - (AdditionalSeconds*1000));
  2043.   return *this;  
  2044. }
  2045.                                  
  2046. CLTimeOfDay CLTimeOfDay::CurrentTimeOfDay(TimeFrame tf)
  2047. { 
  2048.   #ifdef _WIN32
  2049.     SYSTEMTIME st;                                
  2050.     switch (tf)
  2051.     {    
  2052.       case UTC:
  2053.         ::GetSystemTime(&st); 
  2054.         break;
  2055.       case LOCAL:
  2056.         ::GetLocalTime(&st); 
  2057.         break;   
  2058.       case ET:
  2059.         ASSERT(FALSE);
  2060.         break;
  2061.       default: ASSERT(FALSE);
  2062.     }    
  2063.         
  2064.     return CLTimeOfDay(st);
  2065.   #else                                        
  2066.     time_t csecs = time(NULL);
  2067.     tm* ct = localtime(&csecs);
  2068.     CLTimeOfDay ctime((WORD) (ct->tm_hour), (WORD) (ct->tm_min), (WORD) (ct->tm_sec), 0);
  2069.     switch (tf)
  2070.     {
  2071.       case UTC:
  2072.         TIME_ZONE_INFORMATION tzi;
  2073.         GetTimeZoneInformation(&tzi);
  2074.         ctime -= CLTimeSpan((double) tzi.Bias);
  2075.         break;
  2076.       case LOCAL:                         
  2077.         {
  2078.         // nothing required;        
  2079.         break;
  2080.         }
  2081.       case ET:
  2082.         ASSERT(FALSE);
  2083.         break;
  2084.       default: ASSERT(FALSE);      
  2085.     }
  2086.   
  2087.     return ctime;
  2088.   #endif
  2089. }
  2090.                                  
  2091. CLTimeOfDay CLTimeOfDay::Midnight()
  2092. {
  2093.   return CLTimeOfDay(0, 0, 0, 0);
  2094. }
  2095.  
  2096. CLTimeOfDay CLTimeOfDay::Midday()
  2097. {
  2098.   return CLTimeOfDay(12, 0, 0, 0);
  2099. }
  2100.  
  2101. void CLTimeOfDay::SetDefaultFormat(const CString& Format)
  2102. {
  2103.   sm_sDefaultFormat = Format;
  2104. }
  2105.  
  2106. CString& CLTimeOfDay::GetDefaultFormat()
  2107. {
  2108.   return sm_sDefaultFormat;
  2109. }
  2110.  
  2111. #ifdef _DEBUG
  2112. BOOL CLTimeOfDay::SetDoConstructorAsserts(BOOL bDoAsserts)
  2113. {
  2114.   BOOL bOldDoAsserts = sm_bDoAsserts;
  2115.   sm_bDoAsserts = bDoAsserts;
  2116.   return bOldDoAsserts;
  2117. }
  2118. #endif                 
  2119.  
  2120. void CLTimeOfDay::ClearStatics()
  2121. {
  2122.   sm_sBuffer.Empty();
  2123.   sm_sDefaultFormat.Empty();
  2124. }
  2125.                                  
  2126. WORD CLTimeOfDay::GetHour() const
  2127. {
  2128.   AssertValid();
  2129.   return (WORD) (m_dwTotalSeconds/3600L);
  2130. }
  2131.  
  2132. WORD CLTimeOfDay::GetMinute() const
  2133. {
  2134.   AssertValid();
  2135.   return (WORD) ((m_dwTotalSeconds - (GetHour()*3600L))/60);
  2136. }
  2137.  
  2138. DWORD CLTimeOfDay::GetTotalSeconds() const
  2139. {
  2140.   AssertValid();
  2141.   return m_dwTotalSeconds;
  2142. }
  2143.  
  2144. WORD CLTimeOfDay::GetSecond() const
  2145. {
  2146.   AssertValid();
  2147.   return (WORD) (m_dwTotalSeconds - (60L * (GetMinute() + (60L*GetHour()))));
  2148. }                                                                
  2149.  
  2150. WORD CLTimeOfDay::GetMilliSecond() const
  2151. {
  2152.   AssertValid();
  2153.   return m_wMilliSeconds;
  2154. }
  2155.  
  2156. WORD CLTimeOfDay::GetAMPMHour() const
  2157. {
  2158.   AssertValid();
  2159.   WORD wHour = GetHour();
  2160.   if (wHour > 12)
  2161.     wHour -= 12;
  2162.   return wHour;
  2163. }                             
  2164.  
  2165. CString& CLTimeOfDay::GetAMPMString() const
  2166. {
  2167.   AssertValid();
  2168.   int nStringID;
  2169.   if (GetHour() > 12)
  2170.     nStringID = IDS_PM;
  2171.   else
  2172.     nStringID = IDS_AM;
  2173.  
  2174.   if (!sm_sBuffer.LoadString(nStringID))
  2175.     ASSERT(FALSE);
  2176.   return sm_sBuffer;
  2177. }
  2178.  
  2179. BOOL CLTimeOfDay::IsValid() const
  2180. {                  
  2181.   if (m_dwTotalSeconds >= 86400) 
  2182.     return FALSE;
  2183.   else
  2184.     return TRUE;  
  2185. }
  2186.  
  2187. ULARGE_INTEGER CLTimeOfDay::Collate() const
  2188. {
  2189.   AssertValid();
  2190.   ULARGE_INTEGER rVal;
  2191.   rVal.LowPart = m_wMilliSeconds;
  2192.   rVal.HighPart = (GetHour()*10000L) + (GetMinute()*100L) + GetSecond();
  2193.   return rVal;
  2194. }
  2195.  
  2196. SYSTEMTIME CLTimeOfDay::GetSYSTEMTIME() const
  2197. {
  2198.   AssertValid();
  2199.   SYSTEMTIME st;
  2200.  
  2201.   st.wYear=0;
  2202.   st.wMonth=0;
  2203.   st.wDayOfWeek=0;
  2204.   st.wDay=0;
  2205.   st.wHour = GetHour();
  2206.   st.wMinute = GetMinute();
  2207.   st.wSecond = GetSecond();
  2208.   st.wMilliseconds = GetMilliSecond();
  2209.   return st;
  2210. }
  2211.  
  2212. tm CLTimeOfDay::GetTM() const
  2213. {
  2214.   AssertValid();
  2215.   tm rVal;
  2216.   
  2217.   rVal.tm_hour  = GetHour();
  2218.   rVal.tm_min   = GetMinute();
  2219.   rVal.tm_sec   = GetSecond();
  2220.   rVal.tm_mday  = 0;
  2221.   rVal.tm_mon   = 0;
  2222.   rVal.tm_year  = 0;
  2223.   rVal.tm_wday  = 0;
  2224.   rVal.tm_yday  = 0;
  2225.   rVal.tm_isdst = 0;
  2226.               
  2227.   return rVal;
  2228. }
  2229.  
  2230. double CLTimeOfDay::SecondsAsDouble() const
  2231. {
  2232.   AssertValid();
  2233.   return m_dwTotalSeconds + m_wMilliSeconds/1000.0;
  2234. }
  2235.  
  2236.  
  2237. CLTimeOfDay& CLTimeOfDay::operator=(const CLTimeOfDay& Tod)
  2238. {               
  2239.   m_dwTotalSeconds = Tod.m_dwTotalSeconds;
  2240.   m_wMilliSeconds = Tod.m_wMilliSeconds;
  2241.   return *this;
  2242. }
  2243.  
  2244. CLTimeOfDay CLTimeOfDay::operator+(const CLTimeSpan& TimeSpan) const
  2245. {
  2246.   AssertValid();
  2247.   CLTimeSpan t = CLTimeSpan(*this) + CLTimeSpan(0, TimeSpan.GetHours(), TimeSpan.GetMinutes(),
  2248.                             TimeSpan.GetSeconds(),  TimeSpan.GetMilliSeconds());
  2249.   return CLTimeOfDay(t.GetHours(), t.GetMinutes(), t.GetSeconds(), t.GetMilliSeconds());
  2250. }
  2251.  
  2252. CLTimeOfDay CLTimeOfDay::operator-(const CLTimeSpan& TimeSpan) const
  2253. {
  2254.   AssertValid();
  2255.   CLTimeSpan t = CLTimeSpan::OneDay() + CLTimeSpan(*this) - 
  2256.                  CLTimeSpan(0, TimeSpan.GetHours(), TimeSpan.GetMinutes(),
  2257.                             TimeSpan.GetSeconds(),  TimeSpan.GetMilliSeconds());
  2258.   //1 Day is used to ensure result "t" does not go negative
  2259.   return CLTimeOfDay(t.GetHours(), t.GetMinutes(), t.GetSeconds(), t.GetMilliSeconds());
  2260. }
  2261.  
  2262. CLTimeOfDay& CLTimeOfDay::operator+=(CLTimeSpan& TimeSpan)
  2263. {
  2264.   *this = *this + TimeSpan;
  2265.   return *this;
  2266. }
  2267.  
  2268. CLTimeOfDay& CLTimeOfDay::operator-=(CLTimeSpan& TimeSpan)
  2269. {
  2270.   *this = *this - TimeSpan;
  2271.   return *this;
  2272. }
  2273.  
  2274. BOOL CLTimeOfDay::operator==(const CLTimeOfDay& Tod) const
  2275. {
  2276.   AssertValid();
  2277.   if ((m_wMilliSeconds == Tod.m_wMilliSeconds) &&
  2278.       (m_dwTotalSeconds == Tod.m_dwTotalSeconds))
  2279.     return TRUE;
  2280.   else
  2281.     return FALSE;    
  2282. }
  2283.  
  2284. BOOL CLTimeOfDay::operator>(const CLTimeOfDay& Tod) const
  2285. {               
  2286.   AssertValid();
  2287.   if (m_dwTotalSeconds == Tod.m_dwTotalSeconds)
  2288.     return (m_wMilliSeconds > Tod.m_wMilliSeconds);
  2289.   else
  2290.     return (m_dwTotalSeconds > Tod.m_dwTotalSeconds);
  2291. }
  2292.  
  2293. BOOL CLTimeOfDay::operator>=(const CLTimeOfDay& Tod) const
  2294. {               
  2295.   AssertValid();
  2296.   if (m_dwTotalSeconds == Tod.m_dwTotalSeconds)
  2297.     return (m_wMilliSeconds >= Tod.m_wMilliSeconds);
  2298.   else
  2299.     return (m_dwTotalSeconds >= Tod.m_dwTotalSeconds);
  2300. }
  2301.  
  2302. BOOL CLTimeOfDay::operator<(const CLTimeOfDay& Tod) const
  2303. {             
  2304.   AssertValid();
  2305.   if (m_dwTotalSeconds == Tod.m_dwTotalSeconds)
  2306.     return (m_wMilliSeconds < Tod.m_wMilliSeconds);
  2307.   else
  2308.     return (m_dwTotalSeconds < Tod.m_dwTotalSeconds);
  2309. }
  2310.  
  2311. BOOL CLTimeOfDay::operator<=(const CLTimeOfDay& Tod) const
  2312. {
  2313.   AssertValid();
  2314.   if (m_dwTotalSeconds == Tod.m_dwTotalSeconds)
  2315.     return (m_wMilliSeconds <= Tod.m_wMilliSeconds);
  2316.   else
  2317.     return (m_dwTotalSeconds <= Tod.m_dwTotalSeconds);
  2318. }
  2319.  
  2320. BOOL CLTimeOfDay::operator!=(const CLTimeOfDay& Tod) const
  2321. {               
  2322.   AssertValid();                  
  2323.   return !operator==(Tod);
  2324. }
  2325.  
  2326. #ifdef _DEBUG
  2327. void CLTimeOfDay::AssertValid() const
  2328. {
  2329.   CObject::AssertValid();
  2330.   ASSERT(IsValid());
  2331. }
  2332. #endif
  2333.  
  2334. #ifdef _DEBUG
  2335. void CLTimeOfDay::Dump(CDumpContext& dc) const
  2336. {
  2337.   CObject::Dump(dc);
  2338.   dc << Format() << _T("\n");
  2339. }
  2340. #endif                       
  2341.  
  2342. /*    //The Following Format parameters are supported        
  2343.  
  2344. %H    Hours in the current day
  2345. %M    Minutes in the current hour
  2346. %h    12 Hour format Hours in this CLTimeSpan (00 - 12)
  2347. %P    AM / PM indicator
  2348. %S    Seconds in the current minute
  2349. %F    MilliSeconds in the current second
  2350. %%    Percent sign       
  2351. %x    Time Of Day representation for current locale        
  2352. %#H, %#h, %#M, %#S  Remove leading zeros (if any).
  2353. */
  2354. CString& CLTimeOfDay::Format(const CString& sFormat) const
  2355. { 
  2356.   if (!IsValid())
  2357.     sm_sBuffer.Empty();
  2358.   else
  2359.   {
  2360.     CString sBuffer;
  2361.     sm_sBuffer.Empty();
  2362.     CString rVal;
  2363.     int sFmtLength = sFormat.GetLength();
  2364.  
  2365.     for (int i=0; i<sFmtLength; i++)
  2366.     {
  2367.       TCHAR c = sFormat.GetAt(i);
  2368.       if (c == TCHAR('%'))
  2369.       {
  2370.         ++i;
  2371.         if (i < sFmtLength)
  2372.         {
  2373.           c = sFormat.GetAt(i);
  2374.           switch (c)
  2375.           {
  2376.             case TCHAR('H'):
  2377.             {
  2378.               sBuffer.Format(_T("%.02d"), GetHour());
  2379.               rVal += sBuffer;
  2380.               break;
  2381.             }
  2382.             case TCHAR('M'):
  2383.             {
  2384.               sBuffer.Format(_T("%.02d"), GetMinute());
  2385.               rVal += sBuffer;
  2386.               break;
  2387.             }
  2388.             case TCHAR('h'):
  2389.             {
  2390.               sBuffer.Format(_T("%.02d"), GetAMPMHour());
  2391.               rVal += sBuffer;
  2392.               break;
  2393.             }
  2394.             case TCHAR('P'):
  2395.             {
  2396.               rVal += GetAMPMString();
  2397.               break;
  2398.             }
  2399.             case TCHAR('S'):
  2400.             {
  2401.               sBuffer.Format(_T("%.02d"), GetSecond());
  2402.               rVal += sBuffer;
  2403.               break;
  2404.             }
  2405.             case TCHAR('F'):
  2406.             {
  2407.               sBuffer.Format(_T("%.03d"), GetMilliSecond());
  2408.               rVal += sBuffer;
  2409.               break;                                              
  2410.             }                                                     
  2411.             
  2412.           #ifdef _WIN32
  2413.             case TCHAR('x'):                                      
  2414.             {
  2415.               sBuffer.Empty();
  2416.               SYSTEMTIME st = GetSYSTEMTIME();
  2417.               int Res = ::GetTimeFormat(LOCALE_USER_DEFAULT,
  2418.                                       LOCALE_NOUSEROVERRIDE,
  2419.                                       &st,
  2420.                                       NULL,
  2421.                                       sBuffer.GetBufferSetLength(100),
  2422.                                       100); 
  2423.               if (Res == 0)
  2424.                 TRACE1("GetDateFormat() Failed in CLTimeSpan::Format(), GetLastError() returned %ul\n", ::GetLastError());
  2425.               sBuffer.ReleaseBuffer();
  2426.               rVal += sBuffer;
  2427.               break;
  2428.             }
  2429.           #endif
  2430.             
  2431.             case TCHAR('#'):
  2432.             {
  2433.               if (i < sFmtLength)
  2434.               {
  2435.                 ++i;
  2436.                 c = sFormat.GetAt(i);
  2437.                 switch (c)
  2438.                 {
  2439.                   case TCHAR('H'):
  2440.                   {
  2441.                     sBuffer.Format(_T("%d"), GetHour());
  2442.                     rVal += sBuffer;
  2443.                     break;
  2444.                   }
  2445.                   case TCHAR('h'):
  2446.                   {
  2447.                     sBuffer.Format(_T("%d"), GetAMPMHour());
  2448.                     rVal += sBuffer;
  2449.                     break;
  2450.                   }
  2451.                   case TCHAR('M'):
  2452.                   {
  2453.                     sBuffer.Format(_T("%d"), GetMinute());
  2454.                     rVal += sBuffer;
  2455.                     break;
  2456.                   }
  2457.                   case TCHAR('S'):
  2458.                   {
  2459.                     sBuffer.Format(_T("%d"), GetSecond());
  2460.                     rVal += sBuffer;
  2461.                     break;
  2462.                   }
  2463.                   default:
  2464.                   {
  2465.                     rVal += c;
  2466.                     break;
  2467.                   }
  2468.                 }
  2469.               }
  2470.               break;
  2471.             }
  2472.             default:
  2473.             {
  2474.               rVal += c;
  2475.               break;
  2476.             }
  2477.           }
  2478.         }
  2479.       }
  2480.       else
  2481.       {
  2482.         rVal += c;
  2483.       }
  2484.     }
  2485.     sm_sBuffer = rVal;
  2486.   }
  2487.   return sm_sBuffer;
  2488. }
  2489.  
  2490.  
  2491. void CLTimeOfDay::Serialize(CArchive& ar)
  2492. {
  2493.   CObject::Serialize(ar);
  2494.   if(ar.IsStoring())
  2495.   {
  2496.     ar << m_dwTotalSeconds;
  2497.     ar << m_wMilliSeconds;
  2498.   }
  2499.   else
  2500.   {
  2501.     ar >> m_dwTotalSeconds;
  2502.     ar >> m_wMilliSeconds;
  2503.   }
  2504. }
  2505.  
  2506. ostream& operator<<(ostream &os, const CLTimeOfDay &TimeOfDay)
  2507. {
  2508.   return os << TimeOfDay.Format();
  2509. }                       
  2510.  
  2511. CArchive& operator<<(CArchive& ar, CLTimeOfDay &TimeOfDay)
  2512. {
  2513.   ASSERT(ar.IsStoring());
  2514.   TimeOfDay.Serialize(ar);
  2515.   return ar;
  2516. }
  2517.  
  2518. CArchive& operator>>(CArchive& ar, CLTimeOfDay &TimeOfDay)
  2519. {
  2520.   ASSERT(!ar.IsStoring());
  2521.   TimeOfDay.Serialize(ar);
  2522.   return ar;
  2523. }
  2524.  
  2525.  
  2526.  
  2527.  
  2528.  
  2529.  
  2530. //CLDate implementation
  2531.  
  2532.  
  2533. CLDate::CLDate()
  2534. {
  2535.   Set();
  2536. }
  2537.   
  2538. CLDate::CLDate(LONG Year, WORD Month, WORD Day, 
  2539.                WORD Hour, WORD Minute, WORD Second,
  2540.                WORD MilliSecond, TimeFrame tf)
  2541. {
  2542.   Set(Year, Month, Day, Hour, Minute, Second, MilliSecond, tf);
  2543. }                                            
  2544.  
  2545.  
  2546. CLDate::CLDate(const SYSTEMTIME& st, TimeFrame tf, BOOL bUseDayOfWeek)
  2547. { 
  2548.   Set(st, tf, bUseDayOfWeek);
  2549. } 
  2550.  
  2551.  
  2552. CLDate::CLDate(LONG Year, WORD Month, WORD WeekOfMonth,
  2553.                WORD DayOfWeek, WORD Hour, WORD Minute, WORD Second,
  2554.                WORD MilliSecond, TimeFrame tf)
  2555. {
  2556.   Set(Year, Month, WeekOfMonth, DayOfWeek, Hour, Minute, Second, MilliSecond, tf);
  2557. }
  2558.                
  2559. CLDate::CLDate(LONG Days, CDate::DateEpoch e, WORD Hour, WORD Minute,
  2560.                WORD Second, WORD MilliSecond, TimeFrame tf)
  2561. {
  2562.   Set(Days, e, Hour, Minute, Second, MilliSecond, tf);
  2563. } 
  2564.  
  2565.  
  2566. CLDate::CLDate(const CDate& Date, const CLTimeOfDay& Tod, TimeFrame tf)
  2567. { 
  2568.   Set(Date, Tod, tf);
  2569. }
  2570.  
  2571. CLDate::CLDate(const CLDate& ld)
  2572. {                                 
  2573.   m_dSeconds = ld.m_dSeconds;
  2574.   m_TimeFrame = ld.m_TimeFrame;
  2575. }
  2576.  
  2577. CLDate::CLDate(const CTime& ct)
  2578. {
  2579.   Set(ct);
  2580. }
  2581.       
  2582. #ifdef _WIN32
  2583. CLDate::CLDate(const COleDateTime& oleTime, TimeFrame tf)
  2584. {
  2585.   Set(oleTime, tf);
  2586. }                     
  2587. #endif
  2588.  
  2589. CLDate& CLDate::Set()
  2590. {
  2591.   m_dSeconds = DBL_MAX;
  2592.   return *this;
  2593. }
  2594.  
  2595. CLDate& CLDate::Set(LONG Year, WORD Month, WORD Day,
  2596.                     WORD Hour, WORD Minute, WORD Second,
  2597.                     WORD MilliSecond, TimeFrame tf)
  2598. {              
  2599.   m_TimeFrame = tf;
  2600.  
  2601.   CDate Date(Year, Month, Day);
  2602.   CLTimeOfDay Tod(Hour, Minute, Second, MilliSecond);
  2603.  
  2604.   m_dSeconds = Date.GDN()*86400.0 +
  2605.          Tod.GetTotalSeconds() +
  2606.          Tod.GetMilliSecond()/1000.0;
  2607.  
  2608.   if (tf == LOCAL)
  2609.     CheckForValidLocalDate();
  2610.   return *this;
  2611. }
  2612.                     
  2613. CLDate& CLDate::Set(const SYSTEMTIME& st, TimeFrame tf, BOOL bUseDayOfWeek)
  2614. {
  2615.   if (bUseDayOfWeek)  //Using Day-in-month format
  2616.   {
  2617.     if (st.wYear)     //an absolute year, wDayOfWeek is 0 based
  2618.       Set(st.wYear, st.wMonth, st.wDay, (WORD)(st.wDayOfWeek+1), st.wHour, 
  2619.           st.wMinute, st.wSecond, st.wMilliseconds, tf);
  2620.     else              //use the current year
  2621.       Set(CurrentTime(tf).GetCDate().GetYear(), st.wMonth, st.wDay, 
  2622.           (WORD)(st.wDayOfWeek+1), st.wHour, st.wMinute, st.wSecond, st.wMilliseconds, tf);
  2623.   }
  2624.   else
  2625.   {
  2626.     if (st.wYear)     //an absolute year
  2627.       Set(st.wYear, st.wMonth, st.wDay, st.wHour, st.wMinute, st.wSecond, st.wMilliseconds, tf);
  2628.     else              //use the current year
  2629.       Set(CurrentTime(tf).GetCDate().GetYear(), st.wMonth, st.wDay, 
  2630.           st.wHour, st.wMinute, st.wSecond, st.wMilliseconds, tf);
  2631.   }
  2632.  
  2633.   return *this;
  2634. }
  2635.  
  2636.  
  2637. CLDate& CLDate::Set(LONG Year, WORD Month, WORD WeekOfMonth, 
  2638.                     WORD DayOfWeek, WORD Hour, WORD Minute, WORD Second,
  2639.                     WORD MilliSecond, TimeFrame tf)
  2640. {
  2641.   m_TimeFrame = tf;
  2642.  
  2643.   CDate Date(Year, Month, WeekOfMonth, DayOfWeek);
  2644.   CLTimeOfDay Tod(Hour, Minute, Second, MilliSecond);
  2645.  
  2646.   m_dSeconds = Date.GDN()*86400.0 +
  2647.          Tod.GetTotalSeconds() +
  2648.          Tod.GetMilliSecond()/1000.0;
  2649.  
  2650.   if (tf == LOCAL)
  2651.     CheckForValidLocalDate();
  2652.   return *this;
  2653. }
  2654.                     
  2655. CLDate& CLDate::Set(LONG Days, CDate::DateEpoch e, WORD Hour, WORD Minute,
  2656.                     WORD Second, WORD MilliSecond, TimeFrame tf)
  2657. {
  2658.   m_TimeFrame = tf;
  2659.  
  2660.   CDate Date(Days, e);
  2661.   CLTimeOfDay Tod(Hour, Minute, Second, MilliSecond);
  2662.  
  2663.   m_dSeconds = Date.GDN()*86400.0 +
  2664.          Tod.GetTotalSeconds() +
  2665.          Tod.GetMilliSecond()/1000.0;
  2666.  
  2667.   if (tf == LOCAL)
  2668.     CheckForValidLocalDate();
  2669.   return *this;
  2670. }
  2671.  
  2672. CLDate& CLDate::Set(const CTime& ct)
  2673. {
  2674.   m_TimeFrame = UTC;
  2675.   tm* pTM = ct.GetGmtTm();
  2676.   Set(pTM->tm_year + 1900, (WORD) (pTM->tm_mon+1), (WORD) pTM->tm_mday, 
  2677.          (WORD) pTM->tm_hour, (WORD) pTM->tm_min, (WORD) pTM->tm_sec, 0, UTC);
  2678.   return *this;  
  2679. }
  2680.  
  2681. CLDate& CLDate::Set(const CDate& Date, const CLTimeOfDay& Tod, TimeFrame tf)
  2682. {
  2683.   m_TimeFrame = tf;
  2684.  
  2685.   m_dSeconds = Date.GDN()*86400.0 +
  2686.          Tod.GetTotalSeconds() +
  2687.          Tod.GetMilliSecond()/1000.0;
  2688.  
  2689.  
  2690.   if (tf == LOCAL)
  2691.     CheckForValidLocalDate();
  2692.   return *this;  
  2693. }
  2694.       
  2695. #ifdef _WIN32
  2696. CLDate& CLDate::Set(const COleDateTime& oleTime, TimeFrame tf)
  2697. {
  2698.   return Set((LONG) oleTime.GetYear(), (WORD) oleTime.GetMonth(), (WORD) oleTime.GetDay(),
  2699.              (WORD) oleTime.GetHour(), (WORD) oleTime.GetMinute(), (WORD) oleTime.GetSecond(), 0, tf);
  2700. }                     
  2701. #endif
  2702.  
  2703. void CLDate::CheckForValidLocalDate()
  2704. {
  2705.   //Should only be called when tested a LOCAL CLDate
  2706.   ASSERT(m_TimeFrame == LOCAL);
  2707.  
  2708.   TIME_ZONE_INFORMATION tzi;
  2709.   ASSERT(::GetTimeZoneInformation(&tzi) != TIME_ZONE_ID_UNKNOWN);
  2710.   
  2711.   //Set the TimeFrame to UTC so that we do not need to perform DST conversions in
  2712.   //the following arithmetic
  2713.   m_TimeFrame = UTC;
  2714.  
  2715.   CLDate BeginDaylightTime;
  2716.   LONG ThisYear = GetCDate().GetYear();
  2717.   if (tzi.DaylightDate.wYear == 0)  //Using Day-in-month format
  2718.     BeginDaylightTime.Set(ThisYear, tzi.DaylightDate.wMonth, tzi.DaylightDate.wDay, (WORD)(tzi.DaylightDate.wDayOfWeek+1),
  2719.                           tzi.DaylightDate.wHour, tzi.DaylightDate.wMinute, tzi.DaylightDate.wSecond, tzi.DaylightDate.wMilliseconds, UTC);
  2720.   else
  2721.     BeginDaylightTime.Set(tzi.DaylightDate.wYear, tzi.DaylightDate.wMonth, tzi.DaylightDate.wDay, tzi.DaylightDate.wHour,
  2722.                           tzi.DaylightDate.wMinute, tzi.DaylightDate.wSecond, tzi.DaylightDate.wMilliseconds, UTC);
  2723.  
  2724.   CLDate BeginStandardTime;
  2725.   if (tzi.StandardDate.wYear == 0)  //Using Day-in-month format
  2726.     BeginStandardTime.Set(ThisYear, tzi.StandardDate.wMonth, tzi.StandardDate.wDay, (WORD)(tzi.StandardDate.wDayOfWeek+1),
  2727.                           tzi.StandardDate.wHour, tzi.StandardDate.wMinute, tzi.StandardDate.wSecond, tzi.StandardDate.wMilliseconds, UTC);
  2728.   else
  2729.     BeginStandardTime.Set(tzi.StandardDate.wYear, tzi.StandardDate.wMonth, tzi.StandardDate.wDay, tzi.StandardDate.wHour, 
  2730.                           tzi.StandardDate.wMinute, tzi.StandardDate.wSecond, tzi.StandardDate.wMilliseconds, UTC);
  2731.  
  2732.  
  2733. #ifdef _DEBUG
  2734.   CString& s = BeginDaylightTime.Format();
  2735.   s = BeginStandardTime.Format();
  2736. #endif
  2737.  
  2738.   if (tzi.DaylightBias > 0)
  2739.   {
  2740.     //A CLDate which specifies a date which occurs twice
  2741.     CLDate StartNonUnique(BeginDaylightTime - CLTimeSpan(0, 0, (WORD) tzi.DaylightBias, 0, 0));
  2742.     if ((*this >= StartNonUnique) && (*this < BeginDaylightTime))
  2743.     {
  2744.       TRACE0("A CLDate using a LOCAL timeframe tried to be constructed which represents a non unique absolute time\n"); 
  2745.       if (sm_bDoAsserts)
  2746.         ASSERT(FALSE);
  2747.       Set();
  2748.       return;
  2749.     }
  2750.  
  2751.     //A CLDate which specifies a date which does not occur
  2752.     CLDate EndSkip(BeginStandardTime + CLTimeSpan(0, 0, (WORD) tzi.DaylightBias, 0, 0));
  2753.     if ((*this > BeginStandardTime) && (*this < EndSkip))
  2754.     {
  2755.       TRACE0("A CLDate using a LOCAL timeframe tried to be constructed which does not occur\n");
  2756.       if (sm_bDoAsserts)
  2757.         ASSERT(FALSE);
  2758.       Set();
  2759.       return;
  2760.     }
  2761.  
  2762.   }
  2763.   else if (tzi.DaylightBias < 0)
  2764.   {
  2765.     //A CLDate which specifies a date which does not occur
  2766.     CLDate EndSkip(BeginDaylightTime + CLTimeSpan(0, 0, (WORD) -tzi.DaylightBias, 0, 0));
  2767.     if ((*this > BeginDaylightTime) && (*this < EndSkip))
  2768.     {
  2769.       TRACE0("A CLDate using a LOCAL timeframe tried to be constructed which does not occur\n"); 
  2770.       if (sm_bDoAsserts)
  2771.         ASSERT(FALSE);
  2772.       Set();
  2773.       return;
  2774.     }
  2775.  
  2776.     //A CLDate which specifies a date which occurs twice
  2777.     CLDate StartNonUnique(BeginStandardTime - CLTimeSpan(0, 0, (WORD) -tzi.DaylightBias, 0, 0));
  2778.     if ((*this >= StartNonUnique) && 
  2779.         (*this <= BeginStandardTime) )
  2780.     {
  2781.       TRACE0("A CLDate using a LOCAL timeframe tried to be constructed which represents a non unique absolute time\n"); 
  2782.       if (sm_bDoAsserts)
  2783.         ASSERT(FALSE);
  2784.       Set();
  2785.       return;
  2786.     }
  2787.   }
  2788.  
  2789.   //return the timeframe back to local
  2790.   m_TimeFrame = LOCAL;
  2791. }
  2792.                     
  2793. CLDate CLDate::CurrentTime(TimeFrame tf)
  2794. {                                      
  2795.   #ifdef _WIN32
  2796.     SYSTEMTIME st;
  2797.     ::GetSystemTime(&st);
  2798.     CLDate rVal(st, UTC);
  2799.     rVal.SetTimeFrame(tf);
  2800.     return rVal; 
  2801.   #else         
  2802.     time_t csecs = time(NULL);
  2803.     tm* ct = localtime(&csecs);
  2804.     //Constructed using UTC timeframe to avoid check for valid timeframe
  2805.     CLDate rVal((LONG) (ct->tm_year+1900), (WORD) (ct->tm_mon+1), (WORD) (ct->tm_mday),
  2806.                 (WORD) (ct->tm_hour), (WORD) (ct->tm_min), (WORD) (ct->tm_sec), 0, UTC);
  2807.     rVal.m_TimeFrame = LOCAL;            
  2808.     rVal.SetTimeFrame(tf);
  2809.     return rVal;
  2810.   #endif
  2811. }
  2812.  
  2813. void CLDate::SetDefaultFormat(const CString& Format)
  2814. {
  2815.   sm_sDefaultFormat = Format;
  2816. }
  2817.  
  2818. CString& CLDate::GetDefaultFormat()
  2819. {
  2820.   return sm_sDefaultFormat;
  2821. }
  2822.  
  2823. CLTimeSpan CLDate::DeltaT(CLDate& d)
  2824. {
  2825.   CLTimeSpan Tspan(d - CLDate(CDate::Epoch2000(), CLTimeOfDay(0, 0, 0, 0), d.GetTimeFrame()));
  2826.   double T = Tspan.GetTotalDays()/36525.0;
  2827.   double S;
  2828.  
  2829.   double y = 2000 + T * 100;
  2830.   if (y > 2000)
  2831.     S = 102.3 + T * (123.5 + T * 32.5);
  2832.   else if (y < 1620)
  2833.   {
  2834.     if (y < 948)
  2835.       S = 2715.6 + T * (573.36 + T * 46.5);
  2836.     else 
  2837.       S = 50.6 + T * (67.5 + T * 22.5);
  2838.   }
  2839.   else /* Interpolate from the static data table */
  2840.   {
  2841.     int Index = (int)((y - 1620) / 2);
  2842.     if (Index > 185)
  2843.       Index = 185;
  2844.     y = y / 2 - Index - 810;
  2845.     S = (DeltaTTable[Index] + (DeltaTTable[Index + 1] - DeltaTTable[Index]) * y) / 10;
  2846.   }
  2847.  
  2848.   return CLTimeSpan(S);
  2849. }
  2850.  
  2851. BOOL CLDate::CurrentlyInDST()
  2852. {
  2853.   TIME_ZONE_INFORMATION tzi;
  2854.   return ::GetTimeZoneInformation(&tzi) == TIME_ZONE_ID_DAYLIGHT;
  2855. }
  2856.  
  2857. CLTimeSpan CLDate::DaylightBias()
  2858. {
  2859.   TIME_ZONE_INFORMATION tzi;
  2860.   ASSERT(::GetTimeZoneInformation(&tzi) != TIME_ZONE_ID_UNKNOWN);
  2861.  
  2862.   CLTimeSpan rVal;
  2863.   if (tzi.DaylightBias > 0)
  2864.     rVal = CLTimeSpan(0, 0, (WORD) tzi.DaylightBias, 0, 0);
  2865.   else
  2866.   {
  2867.     rVal = CLTimeSpan(0, 0, (WORD) -tzi.DaylightBias, 0, 0);
  2868.     rVal.Negate();
  2869.   }
  2870.   return rVal;
  2871. }
  2872.  
  2873. CLTimeSpan CLDate::TimezoneBias()
  2874. {
  2875.   TIME_ZONE_INFORMATION tzi;
  2876.   ASSERT(::GetTimeZoneInformation(&tzi) != TIME_ZONE_ID_UNKNOWN);
  2877.  
  2878.   CLTimeSpan rVal;
  2879.   LONG tzBias = tzi.StandardBias + tzi.Bias;
  2880.   if (tzBias > 0)
  2881.     rVal = CLTimeSpan(0, 0, (WORD) tzBias, 0, 0);
  2882.   else
  2883.   {
  2884.     rVal = CLTimeSpan(0, 0, (WORD) -tzBias, 0, 0);
  2885.     rVal.Negate();
  2886.   }
  2887.   return rVal;
  2888. }
  2889.  
  2890. CString& CLDate::DaylightName()
  2891. {
  2892.   TIME_ZONE_INFORMATION tzi;
  2893.   ASSERT(::GetTimeZoneInformation(&tzi) != TIME_ZONE_ID_UNKNOWN);
  2894.   CString sName(tzi.DaylightName);
  2895.   sm_sBuffer = sName;
  2896.   return sm_sBuffer;
  2897. }
  2898.  
  2899. CString& CLDate::StandardName()
  2900. {
  2901.   TIME_ZONE_INFORMATION tzi;
  2902.   ASSERT(::GetTimeZoneInformation(&tzi) != TIME_ZONE_ID_UNKNOWN);
  2903.   CString sName(tzi.StandardName);
  2904.   sm_sBuffer = sName;
  2905.   return sm_sBuffer;
  2906. }
  2907.  
  2908. #ifdef _DEBUG
  2909. BOOL CLDate::SetDoConstructorAsserts(BOOL bDoAsserts)
  2910. {
  2911.   BOOL bOldDoAsserts = sm_bDoAsserts;
  2912.   sm_bDoAsserts = bDoAsserts;
  2913.   return bOldDoAsserts;
  2914. }
  2915. #endif            
  2916.  
  2917. void CLDate::ClearStatics()
  2918. {
  2919.   sm_sBuffer.Empty();
  2920.   sm_sDefaultFormat.Empty();
  2921. }
  2922.  
  2923. CDate CLDate::GetCDate() const
  2924. {
  2925.   AssertValid();
  2926.   return CDate((LONG) (m_dSeconds/86400.0), CDate::EPOCH_GREG);
  2927. }
  2928.  
  2929. CLTimeOfDay CLDate::GetCLTimeOfDay() const
  2930. {
  2931.   AssertValid();
  2932.   return CLTimeOfDay(m_dSeconds - GetCDate().GDN()*86400.0);
  2933. }
  2934.  
  2935. DateLS CLDate::GetDate() const
  2936. {
  2937.   DateLS rVal;
  2938.   DateS ds = GetCDate().GetDate();
  2939.  
  2940.   rVal.lYear = ds.lYear; 
  2941.   rVal.wMonth = ds.wMonth;
  2942.   rVal.wDay = ds.wDay;
  2943.   rVal.wWday = ds.wWday;
  2944.   rVal.wYday = ds.wYday;
  2945.   rVal.ct = ds.ct;
  2946.   rVal.tf = m_TimeFrame;
  2947.   CLTimeOfDay tod(GetCLTimeOfDay());
  2948.   rVal.wHour = tod.GetHour();
  2949.   rVal.wMinute = tod.GetMinute();
  2950.   rVal.wSecond = tod.GetSecond();
  2951.   rVal.wMilliSeconds = tod.GetMilliSecond();
  2952.   
  2953.   return rVal;
  2954. };
  2955.  
  2956. SYSTEMTIME CLDate::GetSYSTEMTIME() const
  2957. {
  2958.   SYSTEMTIME s = GetCDate().GetSYSTEMTIME();
  2959.   CLTimeOfDay tod(GetCLTimeOfDay());
  2960.  
  2961.   s.wHour = tod.GetHour();
  2962.   s.wMinute = tod.GetMinute();
  2963.   s.wSecond = tod.GetSecond();
  2964.   s.wMilliseconds = tod.GetMilliSecond();
  2965.  
  2966.   return s;
  2967. }                         
  2968.  
  2969. tm CLDate::GetTM()
  2970. {
  2971.   AssertValid();
  2972.  
  2973.   tm rVal;                
  2974.   rVal.tm_sec   = 0;
  2975.   rVal.tm_min   = 0;
  2976.   rVal.tm_hour  = 0;
  2977.   rVal.tm_mday  = 0;
  2978.   rVal.tm_mon   = 0;
  2979.   rVal.tm_year  = 0;
  2980.   rVal.tm_wday  = 0;
  2981.   rVal.tm_yday  = 0;
  2982.   rVal.tm_isdst = 0;
  2983.  
  2984.   DateLS ds = GetDate();
  2985.  
  2986. #ifdef _WIN32
  2987.   long MinYear = 1900L + LONG_MIN;
  2988.   long MaxYear = LONG_MAX;
  2989. #else
  2990.   long MinYear = 1900L + SHRT_MIN;
  2991.   long MaxYear = 1900L + SHRT_MAX;
  2992. #endif
  2993.  
  2994.   //handle range errors
  2995.   if ((ds.lYear < MinYear) || (ds.lYear > MaxYear))
  2996.   {
  2997.     ASSERT(FALSE);
  2998.     return rVal;
  2999.   }
  3000.   
  3001.   rVal.tm_hour = ds.wHour;
  3002.   rVal.tm_min = ds.wMinute;
  3003.   rVal.tm_sec = ds.wSecond;
  3004.   rVal.tm_year = (int) (ds.lYear - 1900L);
  3005.   rVal.tm_mon = ds.wMonth - 1;  //tm struct uses 0 based indices
  3006.   rVal.tm_wday = ds.wWday - 1;  //tm struct uses 0 based indices
  3007.   rVal.tm_mday = ds.wDay;
  3008.   rVal.tm_wday = ds.wYday - 1; //Returns days since Jan 1
  3009.   rVal.tm_isdst = IsDST();
  3010.               
  3011.   return rVal;
  3012. }
  3013.  
  3014. TimeFrame CLDate::GetTimeFrame() const
  3015. {
  3016.   AssertValid();
  3017.   return m_TimeFrame;
  3018. }
  3019.  
  3020. TimeFrame CLDate::SetTimeFrame(TimeFrame tf)
  3021. {
  3022.   if (tf == m_TimeFrame)  //quick return
  3023.     return tf;
  3024.     
  3025.   TimeFrame OldTF = m_TimeFrame;   
  3026.  
  3027.   switch (m_TimeFrame)
  3028.   {
  3029.     case LOCAL:
  3030.     {
  3031.       switch (tf)
  3032.       {
  3033.         case UTC:
  3034.         {
  3035.           //pretend that timeframe is UTC to avoid recursion in the arithmetic
  3036.           m_TimeFrame = UTC;
  3037.  
  3038.           *this += TimezoneBias();
  3039.           if (DST())
  3040.             *this += DaylightBias();
  3041.           break;
  3042.         }
  3043.         case ET:
  3044.         {
  3045.           SetTimeFrame(UTC);
  3046.           SetTimeFrame(ET);
  3047.           break;
  3048.         }
  3049.         default: ASSERT(FALSE);
  3050.       }
  3051.       break;
  3052.     }
  3053.     case ET:
  3054.     {
  3055.       switch (tf)
  3056.       {
  3057.         case UTC:
  3058.         {
  3059.           *this -= DeltaT();
  3060.           break;
  3061.         }
  3062.         case LOCAL:
  3063.         {
  3064.           SetTimeFrame(UTC);
  3065.           SetTimeFrame(LOCAL);
  3066.           break;
  3067.         }
  3068.         default: ASSERT(FALSE);
  3069.       }
  3070.       break;
  3071.     }
  3072.     case UTC:
  3073.     {
  3074.       switch (tf)
  3075.       {
  3076.         case LOCAL:
  3077.         {
  3078.           *this -= TimezoneBias();
  3079.           if (DST())
  3080.           {
  3081.             *this -= DaylightBias();
  3082.             sm_bIsDst = TRUE;
  3083.           }
  3084.           else
  3085.             sm_bIsDst = FALSE;
  3086.           break;
  3087.         }
  3088.         case ET:
  3089.         {
  3090.           *this += DeltaT();
  3091.           break;
  3092.         }
  3093.         default: ASSERT(FALSE);
  3094.       }
  3095.       break;
  3096.     }
  3097.  
  3098.     default: ASSERT(FALSE);
  3099.   }
  3100.  
  3101.   m_TimeFrame = tf;
  3102.   return OldTF;
  3103. };
  3104.  
  3105. BOOL CLDate::IsDST()
  3106. {
  3107.   AssertValid();
  3108.   BOOL rVal;  
  3109.   TimeFrame OldTF = GetTimeFrame();
  3110.   if (OldTF != LOCAL)
  3111.   {
  3112.     SetTimeFrame(LOCAL);
  3113.     rVal = sm_bIsDst;
  3114.   }
  3115.   else
  3116.     rVal = DST();
  3117.   return rVal;
  3118. }
  3119.  
  3120. BOOL CLDate::DST()
  3121. {
  3122.   AssertValid();
  3123.   BOOL rVal = TRUE;
  3124.   TIME_ZONE_INFORMATION tzi;
  3125.   ASSERT(::GetTimeZoneInformation(&tzi) != TIME_ZONE_ID_UNKNOWN);
  3126.  
  3127.   long lYear = GetCDate().GetYear();
  3128.  
  3129.   //SYSTEMTIME can only accomadate a WORD sized year
  3130.   //so we always return FALSE if outside of this range
  3131.   if ((lYear > SHRT_MAX) || (lYear < 0))
  3132.     rVal = FALSE;
  3133.  
  3134.   if (rVal)
  3135.   {
  3136.     TimeFrame OldTF = m_TimeFrame;
  3137.     m_TimeFrame = UTC;
  3138.  
  3139.     BOOL bUseDayOfWeek = FALSE;
  3140.     if (tzi.DaylightDate.wYear == 0)
  3141.     {
  3142.       bUseDayOfWeek = TRUE;
  3143.       tzi.DaylightDate.wYear = (WORD) lYear;
  3144.     }
  3145.  
  3146.     CLDate BeginDST(tzi.DaylightDate, UTC, bUseDayOfWeek);
  3147.  
  3148. #ifdef _DEBUG
  3149.     CString& s = BeginDST.Format();
  3150. #endif
  3151.  
  3152.     bUseDayOfWeek = FALSE;
  3153.     if (tzi.StandardDate.wYear == 0)
  3154.     {
  3155.       bUseDayOfWeek = TRUE;
  3156.       tzi.StandardDate.wYear = (WORD) lYear;
  3157.     }
  3158.  
  3159.     CLDate EndDST(tzi.StandardDate, UTC, bUseDayOfWeek);
  3160. #ifdef _DEBUG
  3161.     s = EndDST.Format();
  3162. #endif
  3163.   
  3164.     rVal = rVal && (*this >= BeginDST && *this < EndDST);
  3165.  
  3166.     m_TimeFrame = OldTF;
  3167.   }
  3168.   
  3169.   return rVal;
  3170. }
  3171.  
  3172. CString& CLDate::GetStringTimeFrame() const
  3173. {
  3174.   switch (m_TimeFrame)
  3175.   {
  3176.     case UTC:   
  3177.       if (!sm_sBuffer.LoadString(IDS_UTC))
  3178.         ASSERT(FALSE);
  3179.       break;
  3180.     case ET:  
  3181.       if (!sm_sBuffer.LoadString(IDS_ET))
  3182.         ASSERT(FALSE);
  3183.       break;
  3184.     case LOCAL: 
  3185.       if (!sm_sBuffer.LoadString(IDS_LOCAL))
  3186.         ASSERT(FALSE);
  3187.       break;
  3188.     default:  
  3189.       ASSERT(FALSE);
  3190.       break;
  3191.   }
  3192.   return sm_sBuffer;
  3193. }
  3194.  
  3195. double CLDate::GDNAsDouble() const
  3196. {
  3197.   AssertValid();
  3198.   return m_dSeconds/86400;
  3199. }
  3200.  
  3201. double CLDate::GSNAsDouble() const
  3202. {
  3203.   AssertValid();
  3204.   return m_dSeconds;
  3205. }
  3206.  
  3207.  
  3208. void CLDate::AddYear(int Years)
  3209. {
  3210.   AssertValid();
  3211.   CDate Date(GetCDate());
  3212.   CLTimeOfDay Tod(GetCLTimeOfDay());
  3213.   Date.AddYear(Years);
  3214.   Set(Date, Tod, m_TimeFrame);
  3215. }
  3216.  
  3217. void CLDate::AddMonth(int Months)
  3218. {
  3219.   AssertValid();
  3220.   CDate Date(GetCDate());
  3221.   CLTimeOfDay Tod(GetCLTimeOfDay());
  3222.   Date.AddMonth(Months);
  3223.   Set(Date, Tod, m_TimeFrame);
  3224. }
  3225.  
  3226. void CLDate::AddWeek(int Weeks)
  3227. {
  3228.   AssertValid();
  3229.  
  3230.   CDate Date(GetCDate());
  3231.   CLTimeOfDay Tod(GetCLTimeOfDay());
  3232.   Date.AddWeek(Weeks);
  3233.   Set(Date, Tod, m_TimeFrame);
  3234. }
  3235.  
  3236. BOOL CLDate::IsValid() const
  3237. {
  3238.   return (m_dSeconds != DBL_MAX);
  3239. }
  3240.  
  3241. CLTimeSpan CLDate::DeltaT()
  3242. {
  3243.   AssertValid();
  3244.   return DeltaT(*this);
  3245. }
  3246.  
  3247. CLDate& CLDate::operator=(const CLDate& d) 
  3248. {
  3249.   m_TimeFrame = d.m_TimeFrame;
  3250.   m_dSeconds = d.m_dSeconds;
  3251.  
  3252.   return *this;
  3253. }              
  3254.  
  3255. CLDate CLDate::operator+(const CLTimeSpan& TimeSpan)
  3256. {
  3257.   AssertValid();
  3258.   TimeSpan.AssertValid();
  3259.  
  3260.   //Because LOCAL Time is not a continous timeframe convert if necessary
  3261.   TimeFrame OldTF = GetTimeFrame();
  3262.   if (GetTimeFrame() == LOCAL)
  3263.     SetTimeFrame(UTC);
  3264.  
  3265.  
  3266.   double s = m_dSeconds + TimeSpan.m_dSeconds;
  3267.   CLDate rVal;
  3268.   rVal.m_dSeconds = s;
  3269.   rVal.m_TimeFrame = m_TimeFrame;
  3270.  
  3271.   SetTimeFrame(OldTF);
  3272.   rVal.SetTimeFrame(OldTF);
  3273.  
  3274.   return rVal;
  3275. }
  3276.  
  3277. CLTimeSpan CLDate::operator-(CLDate& ld)
  3278. {
  3279.   AssertValid();
  3280.   ld.AssertValid();
  3281.  
  3282.   //Because LOCAL Time is not a continous timeframe convert if necessary
  3283.   TimeFrame OldTF1 = GetTimeFrame();
  3284.   TimeFrame OldTF2 = ld.GetTimeFrame();
  3285.   if (!((OldTF1 == ET) && (OldTF2 == ET)))
  3286.   {
  3287.     TimeFrame OldTF1 = SetTimeFrame(UTC);
  3288.     TimeFrame OldTF2 = ld.SetTimeFrame(UTC);
  3289.   }
  3290.  
  3291.  
  3292.   double s = m_dSeconds - ld.m_dSeconds;
  3293.   CLTimeSpan rVal(s);
  3294.  
  3295.   SetTimeFrame(OldTF1);
  3296.   ld.SetTimeFrame(OldTF2);
  3297.  
  3298.   return rVal;
  3299. }
  3300.  
  3301. CLDate CLDate::operator-(const CLTimeSpan& TimeSpan)
  3302. {
  3303.   AssertValid();
  3304.   TimeSpan.AssertValid();
  3305.  
  3306.   //Because LOCAL Time is not a continous timeframe convert if necessary
  3307.   TimeFrame OldTF = GetTimeFrame();
  3308.   if (GetTimeFrame() == LOCAL)
  3309.     SetTimeFrame(UTC);
  3310.  
  3311.  
  3312.   double s = m_dSeconds - TimeSpan.m_dSeconds;
  3313.   CLDate rVal;
  3314.   rVal.m_dSeconds = s;
  3315.   rVal.m_TimeFrame = m_TimeFrame;
  3316.  
  3317.  
  3318.   return rVal;
  3319. }
  3320.  
  3321. CLDate& CLDate::operator+=(const CLTimeSpan& TimeSpan)
  3322. {
  3323.   *this = *this + TimeSpan;
  3324.   return *this;
  3325. }
  3326.  
  3327. CLDate& CLDate::operator-=(const CLTimeSpan& TimeSpan)
  3328. {
  3329.   *this = *this - TimeSpan;
  3330.   return *this;
  3331. }
  3332.  
  3333. CLDate& CLDate::operator++()
  3334. {
  3335.   AssertValid();
  3336.   m_dSeconds += 86400;
  3337.   return *this;
  3338. }
  3339.  
  3340. CLDate& CLDate::operator--()
  3341. {
  3342.   AssertValid();
  3343.   m_dSeconds -= 86400;
  3344.   return *this;
  3345. }
  3346.   
  3347. BOOL CLDate::operator==(CLDate& ld)
  3348. {
  3349.   AssertValid();
  3350.   
  3351.   //Because LOCAL Time is not a continous timeframe convert if necessary
  3352.   TimeFrame OldTF1 = GetTimeFrame();
  3353.   TimeFrame OldTF2 = ld.GetTimeFrame();
  3354.   if (!((OldTF1 == ET) && (OldTF2 == ET)))
  3355.   {
  3356.     TimeFrame OldTF1 = SetTimeFrame(UTC);
  3357.     TimeFrame OldTF2 = ld.SetTimeFrame(UTC);
  3358.   }
  3359.  
  3360.   BOOL rVal = (m_dSeconds == ld.m_dSeconds);
  3361.  
  3362.   SetTimeFrame(OldTF1);
  3363.   ld.SetTimeFrame(OldTF2);
  3364.  
  3365.   return rVal;
  3366. }
  3367.  
  3368. BOOL CLDate::operator>(CLDate& ld)
  3369. {
  3370.   AssertValid();
  3371.  
  3372.   //Because LOCAL Time is not a continous timeframe convert if necessary
  3373.   TimeFrame OldTF1 = GetTimeFrame();
  3374.   TimeFrame OldTF2 = ld.GetTimeFrame();
  3375.   if (!((OldTF1 == ET) && (OldTF2 == ET)))
  3376.   {
  3377.     TimeFrame OldTF1 = SetTimeFrame(UTC);
  3378.     TimeFrame OldTF2 = ld.SetTimeFrame(UTC);
  3379.   }
  3380.  
  3381.   BOOL rVal = (m_dSeconds > ld.m_dSeconds);
  3382.  
  3383.   SetTimeFrame(OldTF1);
  3384.   ld.SetTimeFrame(OldTF2);
  3385.  
  3386.   return rVal;
  3387. }
  3388.  
  3389. BOOL CLDate::operator>=(CLDate& ld)
  3390. {
  3391.   AssertValid();
  3392.  
  3393.   //Because LOCAL Time is not a continous timeframe convert if necessary
  3394.   TimeFrame OldTF1 = GetTimeFrame();
  3395.   TimeFrame OldTF2 = ld.GetTimeFrame();
  3396.   if (!((OldTF1 == ET) && (OldTF2 == ET)))
  3397.   {
  3398.     TimeFrame OldTF1 = SetTimeFrame(UTC);
  3399.     TimeFrame OldTF2 = ld.SetTimeFrame(UTC);
  3400.   }
  3401.  
  3402.   BOOL rVal = (m_dSeconds >= ld.m_dSeconds);
  3403.  
  3404.   SetTimeFrame(OldTF1);
  3405.   ld.SetTimeFrame(OldTF2);
  3406.  
  3407.   return rVal;
  3408. }
  3409.  
  3410. BOOL CLDate::operator<(CLDate& ld)
  3411. {
  3412.   AssertValid();
  3413.  
  3414.   //Because LOCAL Time is not a continous timeframe convert if necessary
  3415.   TimeFrame OldTF1 = GetTimeFrame();
  3416.   TimeFrame OldTF2 = ld.GetTimeFrame();
  3417.   if (!((OldTF1 == ET) && (OldTF2 == ET)))
  3418.   {
  3419.     TimeFrame OldTF1 = SetTimeFrame(UTC);
  3420.     TimeFrame OldTF2 = ld.SetTimeFrame(UTC);
  3421.   }
  3422.  
  3423.   BOOL rVal = (m_dSeconds < ld.m_dSeconds);
  3424.  
  3425.   SetTimeFrame(OldTF1);
  3426.   ld.SetTimeFrame(OldTF2);
  3427.  
  3428.   return rVal;
  3429. }
  3430.  
  3431. BOOL CLDate::operator<=(CLDate& ld)
  3432. {
  3433.   AssertValid();
  3434.  
  3435.   //Because LOCAL Time is not a continous timeframe convert if necessary
  3436.   TimeFrame OldTF1 = GetTimeFrame();
  3437.   TimeFrame OldTF2 = ld.GetTimeFrame();
  3438.   if (!((OldTF1 == ET) && (OldTF2 == ET)))
  3439.   {
  3440.     TimeFrame OldTF1 = SetTimeFrame(UTC);
  3441.     TimeFrame OldTF2 = ld.SetTimeFrame(UTC);
  3442.   }
  3443.  
  3444.   BOOL rVal = (m_dSeconds <= ld.m_dSeconds);
  3445.  
  3446.   SetTimeFrame(OldTF1);
  3447.   ld.SetTimeFrame(OldTF2);
  3448.  
  3449.   return rVal;
  3450. }
  3451.  
  3452. BOOL CLDate::operator!=(CLDate& ld)
  3453. {
  3454.   AssertValid();
  3455.   return !operator==(ld);
  3456. }
  3457.  
  3458. #ifdef _DEBUG
  3459. void CLDate::AssertValid() const       
  3460. {
  3461.   CObject::AssertValid();
  3462.   ASSERT(IsValid());
  3463. }
  3464. #endif
  3465.  
  3466. #ifdef _DEBUG
  3467. void CLDate::Dump(CDumpContext& dc) const
  3468. {
  3469.   CObject::Dump(dc);
  3470.   dc << Format() << _T("\n");
  3471. }
  3472. #endif           
  3473.  
  3474. /*
  3475. CString CLDate::Format(const CString& sFormat=CDate::m_sDefaultFormat) const
  3476. %a    Abbreviated weekday name
  3477. %A    Full weekday name
  3478. %b    Abbreviated month name
  3479. %B    Full month name
  3480. %d    Day of month as decimal number (01 - 31)
  3481. %j    Day of year as decimal number (001 - 366)
  3482. %m    Month as decimal number (01 - 12)
  3483. %P    AM / PM indicator
  3484. %U    Week of year as decimal number
  3485. %w    Weekday as decimal number (1 - 7; Sunday is 1)
  3486. %x    Date representation for current locale,  namely 
  3487.         Date representation + " " + Time Representation for current locale
  3488. %y    Year without century, as decimal number (00 - 99)
  3489. %Y    Year with century, as decimal number
  3490. %c    Year displayed using C.E.(Current Epoch) / B.C.E (Before Current Epoch) convention e.g. -1023 = 1022 BCE
  3491. %t    String containing a representation of the TimeFrame ("UTC", "LOCAL" or "ET")
  3492.  
  3493. %H    Hours in the day
  3494. %h    12 Hour format Hours in (00 - 12)
  3495. %M    Minutes in the hour
  3496. %S    Seconds in the minute
  3497. %F    MilliSeconds in the second
  3498. %%    Percent sign        
  3499.  
  3500.  
  3501. //may also need to include full windows escape character
  3502.  
  3503. %%    Percent sign
  3504.  
  3505. As in the printf function, the # flag may prefix any formatting code. 
  3506. In that case, the meaning of the format code is changed as follows.
  3507.  
  3508. Format Code Meaning
  3509. %#x Long date representation, appropriate to current locale, namely
  3510.       Long Date representation + " " + Time Representation for current locale
  3511.  
  3512.  
  3513. %#d, %#j, %#m, %#U, %#w, %#y, %#H, %#h, %#M, %#S  Remove leading zeros (if any).
  3514. */
  3515. CString& CLDate::Format(const CString& sFormat) const
  3516. { 
  3517.   if (!IsValid())
  3518.     sm_sBuffer.Empty();
  3519.   else
  3520.   {
  3521.     CString sBuffer;
  3522.     sm_sBuffer.Empty();
  3523.     CString rVal;
  3524.     int sFmtLength = sFormat.GetLength();
  3525.  
  3526.     for (int i=0; i<sFmtLength; i++)
  3527.     {
  3528.       TCHAR c = sFormat.GetAt(i);
  3529.       if (c == '%')
  3530.       {
  3531.         ++i;
  3532.         if (i < sFmtLength)
  3533.         {
  3534.           c = sFormat.GetAt(i);
  3535.           switch (c)
  3536.           {
  3537.             case TCHAR('H'):
  3538.             {
  3539.               sBuffer.Format(_T("%.02d"), GetCLTimeOfDay().GetHour());
  3540.               rVal += sBuffer;
  3541.               break;
  3542.             }
  3543.             case TCHAR('h'):
  3544.             {
  3545.               sBuffer.Format(_T("%.02d"), GetCLTimeOfDay().GetAMPMHour());
  3546.               rVal += sBuffer;
  3547.               break;
  3548.             }
  3549.             case TCHAR('M'):
  3550.             {
  3551.               sBuffer.Format(_T("%.02d"), GetCLTimeOfDay().GetMinute());
  3552.               rVal += sBuffer;
  3553.               break;
  3554.             }
  3555.             case TCHAR('P'):
  3556.             {
  3557.               rVal += GetCLTimeOfDay().GetAMPMString();
  3558.               break;
  3559.             }
  3560.             case TCHAR('S'):
  3561.             {
  3562.               sBuffer.Format(_T("%.02d"), GetCLTimeOfDay().GetSecond());
  3563.               rVal += sBuffer;
  3564.               break;
  3565.             }
  3566.             case TCHAR('F'):
  3567.             {
  3568.               sBuffer.Format(_T("%.03d"), GetCLTimeOfDay().GetMilliSecond());
  3569.               rVal += sBuffer;
  3570.               break;
  3571.             }
  3572.             case TCHAR('a'):
  3573.             {
  3574.               rVal += GetCDate().GetAbrStringDayOfWeek();
  3575.               break;
  3576.             }
  3577.             case TCHAR('A'):
  3578.             {
  3579.               rVal += GetCDate().GetFullStringDayOfWeek();
  3580.               break;
  3581.             }
  3582.             case TCHAR('b'):
  3583.             {
  3584.               rVal += GetCDate().GetAbrStringMonth();
  3585.               break;
  3586.             }
  3587.             case TCHAR('B'):
  3588.             {
  3589.               rVal += GetCDate().GetFullStringMonth();
  3590.               break;
  3591.             }
  3592.             case TCHAR('c'):
  3593.             {
  3594.               rVal += GetCDate().GetStringCEBCEYear();
  3595.               break;
  3596.             }
  3597.             case TCHAR('d'):
  3598.             {
  3599.               sBuffer.Format(_T("%.02d"), GetCDate().GetDay());
  3600.               rVal += sBuffer;
  3601.               break;
  3602.             }
  3603.             case TCHAR('j'):
  3604.             {
  3605.               sBuffer.Format(_T("%.03d"), GetCDate().DaysSinceJan0());
  3606.               rVal += sBuffer;
  3607.               break;
  3608.             }
  3609.             case TCHAR('m'):
  3610.             {
  3611.               sBuffer.Format(_T("%.02d"), GetCDate().GetMonth());
  3612.               rVal += sBuffer;
  3613.               break;
  3614.             }
  3615.             case TCHAR('t'):
  3616.             {
  3617.               rVal += GetStringTimeFrame();
  3618.               break;
  3619.             }
  3620.             case TCHAR('U'):
  3621.             {
  3622.               sBuffer.Format(_T("%.02d"), GetCDate().GetWeekOfYear());
  3623.               rVal += sBuffer;
  3624.               break;
  3625.             }
  3626.             case TCHAR('w'):
  3627.             {
  3628.               sBuffer.Format(_T("%d"), GetCDate().GetDayOfWeek());
  3629.               rVal += sBuffer;
  3630.               break;
  3631.             }
  3632.             case TCHAR('x'):
  3633.             {
  3634.               rVal += GetCDate().Format(_T("%x")) + _T(" ") + GetCLTimeOfDay().Format(_T("%x"));
  3635.               break;
  3636.             }
  3637.             case TCHAR('y'):
  3638.             {
  3639.               LONG Year = GetCDate().GetYear();
  3640.               sBuffer.Format(_T("%.02d"), GetCDate().Get2DigitYear());
  3641.               rVal += sBuffer;
  3642.               break;
  3643.             }
  3644.             case TCHAR('Y'):
  3645.             {
  3646.               sBuffer.Format(_T("%ld"), GetCDate().GetYear());
  3647.               rVal += sBuffer;
  3648.               break;
  3649.             }
  3650.             case TCHAR('#'):
  3651.             {
  3652.               if (i < sFmtLength)
  3653.               {
  3654.                 ++i;
  3655.                 c = sFormat.GetAt(i);
  3656.                 switch (c)
  3657.                 {
  3658.                   case TCHAR('d'):
  3659.                   {
  3660.                     sBuffer.Format(_T("%d"), GetCDate().GetDay());
  3661.                     rVal += sBuffer;
  3662.                     break;
  3663.                   }
  3664.                   case TCHAR('j'):
  3665.                   {
  3666.                     sBuffer.Format(_T("%d"), GetCDate().DaysSinceJan0());
  3667.                     rVal += sBuffer;
  3668.                     break;
  3669.                   }
  3670.                   case TCHAR('m'):
  3671.                   {
  3672.                     sBuffer.Format(_T("%d"), GetCDate().GetMonth());
  3673.                     rVal += sBuffer;
  3674.                     break;
  3675.                   }
  3676.                   case TCHAR('U'):
  3677.                   {
  3678.                     sBuffer.Format(_T("%d"), GetCDate().GetWeekOfYear());
  3679.                     rVal += sBuffer;
  3680.                     break;
  3681.                   }
  3682.                   case TCHAR('x'):
  3683.                   {
  3684.                     rVal += GetCDate().Format(_T("%#x")) + _T(" ") + GetCLTimeOfDay().Format(_T("%x"));
  3685.                     break;
  3686.                   }
  3687.                   case TCHAR('y'):
  3688.                   {
  3689.                     LONG Year = GetCDate().GetYear();
  3690.                     sBuffer.Format(_T("%d"), GetCDate().Get2DigitYear());
  3691.                     rVal += sBuffer;
  3692.                     break;
  3693.                   }
  3694.                   case TCHAR('H'):
  3695.                   {
  3696.                     sBuffer.Format(_T("%d"), GetCLTimeOfDay().GetHour());
  3697.                     rVal += sBuffer;
  3698.                     break;
  3699.                   }
  3700.                   case TCHAR('h'):
  3701.                   {
  3702.                     sBuffer.Format(_T("%d"), GetCLTimeOfDay().GetAMPMHour());
  3703.                     rVal += sBuffer;
  3704.                     break;
  3705.                   }
  3706.                   case TCHAR('M'):
  3707.                   {
  3708.                     sBuffer.Format(_T("%d"), GetCLTimeOfDay().GetMinute());
  3709.                     rVal += sBuffer;
  3710.                     break;
  3711.                   }
  3712.                   case TCHAR('S'):
  3713.                   {
  3714.                     sBuffer.Format(_T("%d"), GetCLTimeOfDay().GetSecond());
  3715.                     rVal += sBuffer;
  3716.                     break;
  3717.                   }
  3718.                   default:
  3719.                   {
  3720.                     rVal += c;
  3721.                     break;
  3722.                   }
  3723.                 }
  3724.               }
  3725.               break;
  3726.             }
  3727.             default:
  3728.             {
  3729.               rVal += c;
  3730.               break;
  3731.             }
  3732.           }
  3733.         }
  3734.       }
  3735.       else
  3736.       {
  3737.         rVal += c;
  3738.       }
  3739.     }
  3740.     sm_sBuffer = rVal;
  3741.   }
  3742.  
  3743.   return sm_sBuffer;
  3744. }
  3745.  
  3746. void CLDate::Serialize(CArchive& ar)
  3747. {
  3748.   CObject::Serialize(ar);
  3749.   if(ar.IsStoring())
  3750.   {
  3751.     ar << m_dSeconds;
  3752.     ar << (WORD) m_TimeFrame;
  3753.   }
  3754.   else
  3755.   {
  3756.     ar >> m_dSeconds;
  3757.     ar >> (WORD&) m_TimeFrame;
  3758.   }
  3759. }
  3760.  
  3761. ostream& operator<<(ostream& os, const CLDate& ld)
  3762. {
  3763.   return os << ld.Format();
  3764. }
  3765.  
  3766. CArchive& operator<<(CArchive& ar, CLDate& ld)
  3767. {
  3768.   ASSERT(ar.IsStoring());
  3769.   ld.Serialize(ar);
  3770.   return ar;
  3771. }
  3772.  
  3773. CArchive& operator>>(CArchive& ar, CLDate& ld)
  3774. {
  3775.   ASSERT(!ar.IsStoring());
  3776.   ld.Serialize(ar);
  3777.   return ar;
  3778. }
  3779.  
  3780.  
  3781.  
  3782.