sdk/lib/atl/atltime.h

   1 // PROJECT:        ReactOS ATL CTime, CFileTime, CTimeSpan, CFileTimeSpan
   2 // LICENSE:        Public Domain
   3 // PURPOSE:        Provides compatibility to Microsoft ATL
   4 // PROGRAMMERS:    Benedikt Freisen
   5
   6 #ifndef __ATLTIME_H__
   7 #define __ATLTIME_H__
   8
   9 // WARNING: Untested code
  10
  11 #pragma once
  12
  13 #include <atlcore.h>
  14 #include <windows.h>
  15 #include <atlstr.h>
  16 #include <time.h>
  17 #include <oledb.h>
  18
  19 namespace ATL
  20 {
  21
  22 class CTimeSpan
  23 {
  24     __time64_t m_nSpan;
  25 public:
  26     CTimeSpan() throw()
  27     {
  28         // leave uninitialized
  29     }
  30
  31     CTimeSpan(__time64_t time) throw()
  32     {
  33         m_nSpan = time;
  34     }
  35
  36     CTimeSpan(LONG lDays, int nHours, int nMins, int nSecs) throw()
  37     {
  38         ATLASSERT(lDays >= 0 && nHours >= 0 && nHours <= 23 && nMins >= 0 && nMins <= 59 && nSecs >= 0 && nSecs <= 59);
  39         m_nSpan = ((((LONGLONG)lDays) * 24 + nHours) * 60 + nMins) * 60 + nSecs;
  40     }
  41
  42     CString Format(LPCSTR pFormat) const
  43     {
  44         struct tm time;
  45         _localtime64_s(&time, &m_nSpan);
  46         CStringA strTime;
  47         strftime(strTime.GetBuffer(256), 256, pFormat, &time);
  48         strTime.ReleaseBuffer();
  49         return CString(strTime);
  50     }
  51
  52     CString Format(LPCTSTR pszFormat) const
  53     {
  54         struct tm time;
  55         _localtime64_s(&time, &m_nSpan);
  56         CString strTime;
  57 #ifdef UNICODE
  58         wcsftime(strTime.GetBuffer(256), 256, pszFormat, &time);
  59 #else
  60         strftime(strTime.GetBuffer(256), 256, pszFormat, &time);
  61 #endif
  62         strTime.ReleaseBuffer();
  63         return strTime;
  64     }
  65
  66     CString Format(UINT nID) const
  67     {
  68         struct tm time;
  69         _localtime64_s(&time, &m_nSpan);
  70         CString strFormat;
  71         strFormat.LoadString(nID);
  72         CString strTime;
  73 #ifdef UNICODE
  74         wcsftime(strTime.GetBuffer(256), 256, strFormat, &time);
  75 #else
  76         strftime(strTime.GetBuffer(256), 256, strFormat, &time);
  77 #endif
  78         strTime.ReleaseBuffer();
  79         return strTime;
  80     }
  81
  82     LONGLONG GetTotalHours() const throw()
  83     {
  84         return m_nSpan / 60 / 60;
  85     }
  86
  87     LONGLONG GetTotalMinutes() const throw()
  88     {
  89         return m_nSpan / 60;
  90     }
  91
  92     LONGLONG GetTotalSeconds() const throw()
  93     {
  94         return m_nSpan;
  95     }
  96
  97     LONGLONG GetDays() const throw()
  98     {
  99         return m_nSpan / 60 / 60 / 24;
 100     }
 101
 102     LONG GetHours() const throw()
 103     {
 104         return GetTotalHours() - GetDays() * 24;
 105     }
 106
 107     LONG GetMinutes() const throw()
 108     {
 109         return GetTotalMinutes() - GetTotalHours() * 60;
 110     }
 111
 112     LONG GetSeconds() const throw()
 113     {
 114         return GetTotalSeconds() - GetTotalMinutes() * 60;
 115     }
 116
 117     __time64_t GetTimeSpan() const throw()
 118     {
 119         return m_nSpan;
 120     }
 121
 122 //     CArchive& Serialize64(CArchive& ar)  // MFC only
 123 //     {
 124 //         // TODO
 125 //     }
 126
 127 };
 128
 129 class CTime
 130 {
 131     __time64_t m_nTime;
 132 public:
 133     CTime() throw()
 134     {
 135         // leave uninitialized
 136     }
 137
 138     CTime(__time64_t time) throw()
 139     {
 140         m_nTime = time;
 141     }
 142
 143     CTime(int nYear, int nMonth, int nDay, int nHour, int nMin, int nSec, int nDST = -1)
 144     {
 145         struct tm time;
 146         time.tm_year = nYear;
 147         time.tm_mon = nMonth;
 148         time.tm_mday = nDay;
 149         time.tm_hour = nHour;
 150         time.tm_min = nMin;
 151         time.tm_sec = nSec;
 152         time.tm_isdst = nDST;
 153         m_nTime = _mktime64(&time);
 154     }
 155
 156     CTime(WORD wDosDate, WORD wDosTime, int nDST = -1)
 157     {
 158         FILETIME ft;
 159         DosDateTimeToFileTime(wDosDate, wDosTime, &ft);
 160         SYSTEMTIME st;
 161         FileTimeToSystemTime(&ft, &st);
 162         struct tm time;
 163         time.tm_year = st.wYear;
 164         time.tm_mon = st.wMonth;
 165         time.tm_wday = st.wDayOfWeek;
 166         time.tm_hour = st.wHour;
 167         time.tm_min = st.wMinute;
 168         time.tm_sec = st.wSecond;
 169         time.tm_isdst = nDST;
 170         m_nTime = _mktime64(&time);
 171     }
 172
 173     CTime(const SYSTEMTIME& st, int nDST = -1) throw()
 174     {
 175         struct tm time;
 176         time.tm_year = st.wYear;
 177         time.tm_mon = st.wMonth;
 178         time.tm_wday = st.wDayOfWeek;
 179         time.tm_hour = st.wHour;
 180         time.tm_min = st.wMinute;
 181         time.tm_sec = st.wSecond;
 182         time.tm_isdst = nDST;
 183         m_nTime = _mktime64(&time);
 184     }
 185
 186     CTime(const FILETIME& ft, int nDST = -1)
 187     {
 188         SYSTEMTIME st;
 189         FileTimeToSystemTime(&ft, &st);
 190         struct tm time;
 191         time.tm_year = st.wYear;
 192         time.tm_mon = st.wMonth;
 193         time.tm_wday = st.wDayOfWeek;
 194         time.tm_hour = st.wHour;
 195         time.tm_min = st.wMinute;
 196         time.tm_sec = st.wSecond;
 197         time.tm_isdst = nDST;
 198         m_nTime = _mktime64(&time);
 199     }
 200
 201     CTime(const DBTIMESTAMP& dbts, int nDST = -1) throw()
 202     {
 203         struct tm time;
 204         time.tm_year = dbts.year;
 205         time.tm_mon = dbts.month;
 206         time.tm_hour = dbts.hour;
 207         time.tm_min = dbts.minute;
 208         time.tm_sec = dbts.second;
 209         time.tm_isdst = nDST;
 210         m_nTime = _mktime64(&time);
 211     }
 212
 213     CString Format(LPCTSTR pszFormat) const
 214     {
 215         struct tm time;
 216         _localtime64_s(&time, &m_nTime);
 217         CString strTime;
 218 #ifdef UNICODE
 219         wcsftime(strTime.GetBuffer(256), 256, pszFormat, &time);
 220 #else
 221         strftime(strTime.GetBuffer(256), 256, pszFormat, &time);
 222 #endif
 223         strTime.ReleaseBuffer();
 224         return strTime;
 225     }
 226
 227     CString Format(UINT nFormatID) const
 228     {
 229         struct tm time;
 230         _localtime64_s(&time, &m_nTime);
 231         CString strFormat;
 232         strFormat.LoadString(nFormatID);
 233         CString strTime;
 234 #ifdef UNICODE
 235         wcsftime(strTime.GetBuffer(256), 256, strFormat, &time);
 236 #else
 237         strftime(strTime.GetBuffer(256), 256, strFormat, &time);
 238 #endif
 239         strTime.ReleaseBuffer();
 240         return strTime;
 241     }
 242
 243     CString FormatGmt(LPCTSTR pszFormat) const
 244     {
 245         struct tm time;
 246         _gmtime64_s(&time, &m_nTime);
 247         CString strTime;
 248 #ifdef UNICODE
 249         wcsftime(strTime.GetBuffer(256), 256, pszFormat, &time);
 250 #else
 251         strftime(strTime.GetBuffer(256), 256, pszFormat, &time);
 252 #endif
 253         strTime.ReleaseBuffer();
 254         return strTime;
 255     }
 256
 257     CString FormatGmt(UINT nFormatID) const
 258     {
 259         struct tm time;
 260         _gmtime64_s(&time, &m_nTime);
 261         CString strFormat;
 262         strFormat.LoadString(nFormatID);
 263         CString strTime;
 264 #ifdef UNICODE
 265         wcsftime(strTime.GetBuffer(256), 256, strFormat, &time);
 266 #else
 267         strftime(strTime.GetBuffer(256), 256, strFormat, &time);
 268 #endif
 269         strTime.ReleaseBuffer();
 270         return strTime;
 271     }
 272
 273     bool GetAsDBTIMESTAMP(DBTIMESTAMP& dbts) const throw()
 274     {
 275         struct tm time;
 276         _gmtime64_s(&time, &m_nTime);
 277         dbts.year = time.tm_year;
 278         dbts.month = time.tm_mon;
 279         dbts.day = time.tm_mday;
 280         dbts.hour = time.tm_hour;
 281         dbts.minute = time.tm_min;
 282         dbts.second = time.tm_sec;
 283         dbts.fraction = 0;
 284         return true;  // TODO: error handling?
 285     }
 286
 287     bool GetAsSystemTime(SYSTEMTIME& st) const throw()
 288     {
 289         struct tm time;
 290         _gmtime64_s(&time, &m_nTime);
 291         st.wYear = time.tm_year;
 292         st.wMonth = time.tm_mon;
 293         st.wDayOfWeek = time.tm_wday;
 294         st.wDay = time.tm_mday;
 295         st.wHour = time.tm_hour;
 296         st.wMinute = time.tm_min;
 297         st.wSecond = time.tm_sec;
 298         st.wMilliseconds = 0;
 299         return true;  // TODO: error handling?
 300     }
 301
 302     static CTime WINAPI GetCurrentTime() throw()
 303     {
 304         __time64_t time;
 305         _time64(&time);
 306         return CTime(time);
 307     }
 308
 309     int GetDay() const throw()
 310     {
 311         struct tm time;
 312         _localtime64_s(&time, &m_nTime);
 313         return time.tm_mday;
 314     }
 315
 316     int GetDayOfWeek() const throw()
 317     {
 318         struct tm time;
 319         _localtime64_s(&time, &m_nTime);
 320         return time.tm_wday;
 321     }
 322
 323     struct tm* GetGmtTm(struct tm* ptm) const
 324     {
 325         _gmtime64_s(ptm, &m_nTime);
 326         return ptm;
 327     }
 328
 329     int GetHour() const throw()
 330     {
 331         struct tm time;
 332         _localtime64_s(&time, &m_nTime);
 333         return time.tm_hour;
 334     }
 335
 336     struct tm* GetLocalTm(struct tm* ptm) const
 337     {
 338         _localtime64_s(ptm, &m_nTime);
 339         return ptm;
 340     }
 341
 342     int GetMinute() const throw()
 343     {
 344         struct tm time;
 345         _localtime64_s(&time, &m_nTime);
 346         return time.tm_min;
 347     }
 348
 349     int GetMonth() const throw()
 350     {
 351         struct tm time;
 352         _localtime64_s(&time, &m_nTime);
 353         return time.tm_mon;
 354     }
 355
 356     int GetSecond() const throw()
 357     {
 358         struct tm time;
 359         _localtime64_s(&time, &m_nTime);
 360         return time.tm_sec;
 361     }
 362
 363     __time64_t GetTime() const throw()
 364     {
 365         return m_nTime;
 366     }
 367
 368     int GetYear()
 369     {
 370         struct tm time;
 371         _localtime64_s(&time, &m_nTime);
 372         return time.tm_year;
 373     }
 374
 375 //     CArchive& Serialize64(CArchive& ar)  // MFC only
 376 //     {
 377 //         // TODO
 378 //     }
 379
 380     CTime operator+(CTimeSpan timeSpan) const throw()
 381     {
 382         return CTime(m_nTime + timeSpan.GetTimeSpan());
 383     }
 384
 385     CTime operator-(CTimeSpan timeSpan) const throw()
 386     {
 387         return CTime(m_nTime - timeSpan.GetTimeSpan());
 388     }
 389
 390     CTimeSpan operator-(CTime time) const throw()
 391     {
 392         return CTimeSpan(m_nTime - time.GetTime());
 393     }
 394
 395     CTime& operator+=(CTimeSpan span) throw()
 396     {
 397         m_nTime += span.GetTimeSpan();
 398         return *this;
 399     }
 400
 401     CTime& operator-=(CTimeSpan span) throw()
 402     {
 403         m_nTime -= span.GetTimeSpan();
 404         return *this;
 405     }
 406
 407     CTime& operator=(__time64_t time) throw()
 408     {
 409         m_nTime = time;
 410         return *this;
 411     }
 412
 413     bool operator==(CTime time) const throw()
 414     {
 415         return m_nTime == time.GetTime();
 416     }
 417
 418     bool operator!=(CTime time) const throw()
 419     {
 420         return m_nTime != time.GetTime();
 421     }
 422
 423     bool operator<(CTime time) const throw()
 424     {
 425         return m_nTime < time.GetTime();
 426     }
 427
 428     bool operator>(CTime time) const throw()
 429     {
 430         return m_nTime > time.GetTime();
 431     }
 432
 433     bool operator<=(CTime time) const throw()
 434     {
 435         return m_nTime <= time.GetTime();
 436     }
 437
 438     bool operator>=(CTime time) const throw()
 439     {
 440         return m_nTime >= time.GetTime();
 441     }
 442
 443 };
 444
 445 class CFileTimeSpan
 446 {
 447     LONGLONG m_nSpan;
 448 public:
 449     CFileTimeSpan() throw()
 450     {
 451         m_nSpan = 0;
 452     }
 453
 454     CFileTimeSpan(const CFileTimeSpan& span) throw()
 455     {
 456         m_nSpan = span.GetTimeSpan();
 457     }
 458
 459     CFileTimeSpan(LONGLONG nSpan) throw()
 460     {
 461         m_nSpan = nSpan;
 462     }
 463
 464     LONGLONG GetTimeSpan() const throw()
 465     {
 466         return m_nSpan;
 467     }
 468
 469     void SetTimeSpan(LONGLONG nSpan) throw()
 470     {
 471         m_nSpan = nSpan;
 472     }
 473
 474     CFileTimeSpan operator-(CFileTimeSpan span) const throw()
 475     {
 476         return CFileTimeSpan(m_nSpan - span.GetTimeSpan());
 477     }
 478
 479     bool operator!=(CFileTimeSpan span) const throw()
 480     {
 481         return m_nSpan != span.GetTimeSpan();
 482     }
 483
 484     CFileTimeSpan operator+(CFileTimeSpan span) const throw()
 485     {
 486         return CFileTimeSpan(m_nSpan + span.GetTimeSpan());
 487     }
 488
 489     CFileTimeSpan& operator+=(CFileTimeSpan span) throw()
 490     {
 491         m_nSpan += span.GetTimeSpan();
 492         return *this;
 493     }
 494
 495     bool operator<(CFileTimeSpan span) const throw()
 496     {
 497         return m_nSpan < span.GetTimeSpan();
 498     }
 499
 500     bool operator<=(CFileTimeSpan span) const throw()
 501     {
 502         return m_nSpan <= span.GetTimeSpan();
 503     }
 504
 505     CFileTimeSpan& operator=(const CFileTimeSpan& span) throw()
 506     {
 507         m_nSpan = span.GetTimeSpan();
 508         return *this;
 509     }
 510
 511     CFileTimeSpan& operator-=(CFileTimeSpan span) throw()
 512     {
 513         m_nSpan -= span.GetTimeSpan();
 514         return *this;
 515     }
 516
 517     bool operator==(CFileTimeSpan span) const throw()
 518     {
 519         return m_nSpan == span.GetTimeSpan();
 520     }
 521
 522     bool operator>(CFileTimeSpan span) const throw()
 523     {
 524         return m_nSpan > span.GetTimeSpan();
 525     }
 526
 527     bool operator>=(CFileTimeSpan span) const throw()
 528     {
 529         return m_nSpan >= span.GetTimeSpan();
 530     }
 531
 532 };
 533
 534 class CFileTime : public FILETIME
 535 {
 536 public:
 537     static const ULONGLONG Millisecond = 10000;
 538     static const ULONGLONG Second = Millisecond * 1000;
 539     static const ULONGLONG Minute = Second * 60;
 540     static const ULONGLONG Hour = Minute * 60;
 541     static const ULONGLONG Day = Hour * 24;
 542     static const ULONGLONG Week = Day * 7;
 543
 544     CFileTime() throw()
 545     {
 546         this->dwLowDateTime = 0;
 547         this->dwHighDateTime = 0;
 548     }
 549
 550     CFileTime(const FILETIME& ft) throw()
 551     {
 552         this->dwLowDateTime = ft.dwLowDateTime;
 553         this->dwHighDateTime = ft.dwHighDateTime;
 554     }
 555
 556     CFileTime(ULONGLONG nTime) throw()
 557     {
 558         this->dwLowDateTime = (DWORD) nTime;
 559         this->dwHighDateTime = nTime >> 32;
 560     }
 561
 562     static CFileTime GetCurrentTime() throw()
 563     {
 564         FILETIME ft;
 565         GetSystemTimeAsFileTime(&ft);
 566         return CFileTime(ft);
 567     }
 568
 569     ULONGLONG GetTime() const throw()
 570     {
 571         return ((ULONGLONG)this->dwLowDateTime) | (((ULONGLONG)this->dwHighDateTime) << 32);
 572     }
 573
 574     CFileTime LocalToUTC() const throw()
 575     {
 576         FILETIME ft;
 577         LocalFileTimeToFileTime(this, &ft);
 578         return CFileTime(ft);
 579     }
 580
 581     void SetTime(ULONGLONG nTime) throw()
 582     {
 583         this->dwLowDateTime = (DWORD) nTime;
 584         this->dwHighDateTime = nTime >> 32;
 585     }
 586
 587     CFileTime UTCToLocal() const throw()
 588     {
 589         FILETIME ft;
 590         FileTimeToLocalFileTime(this, &ft);
 591         return CFileTime(ft);
 592     }
 593
 594     CFileTime operator-(CFileTimeSpan span) const throw()
 595     {
 596         return CFileTime(this->GetTime() - span.GetTimeSpan());
 597     }
 598
 599     CFileTimeSpan operator-(CFileTime ft) const throw()
 600     {
 601         return CFileTimeSpan(this->GetTime() - ft.GetTime());
 602     }
 603
 604     bool operator!=(CFileTime ft) const throw()
 605     {
 606         return this->GetTime() != ft.GetTime();
 607     }
 608
 609     CFileTime operator+(CFileTimeSpan span) const throw()
 610     {
 611         return CFileTime(this->GetTime() + span.GetTimeSpan());
 612     }
 613
 614     CFileTime& operator+=(CFileTimeSpan span) throw()
 615     {
 616         this->SetTime(this->GetTime() + span.GetTimeSpan());
 617         return *this;
 618     }
 619
 620     bool operator<(CFileTime ft) const throw()
 621     {
 622         return this->GetTime() < ft.GetTime();
 623     }
 624
 625     bool operator<=(CFileTime ft) const throw()
 626     {
 627         return this->GetTime() <= ft.GetTime();
 628     }
 629
 630     CFileTime& operator=(const FILETIME& ft) throw()
 631     {
 632         this->dwLowDateTime = ft.dwLowDateTime;
 633         this->dwHighDateTime = ft.dwHighDateTime;
 634         return *this;
 635     }
 636
 637     CFileTime& operator-=(CFileTimeSpan span) throw()
 638     {
 639         this->SetTime(this->GetTime() - span.GetTimeSpan());
 640         return *this;
 641     }
 642
 643     bool operator==(CFileTime ft) const throw()
 644     {
 645         return this->GetTime() == ft.GetTime();
 646     }
 647
 648     bool operator>(CFileTime ft) const throw()
 649     {
 650         return this->GetTime() > ft.GetTime();
 651     }
 652
 653     bool operator>=(CFileTime ft) const throw()
 654     {
 655         return this->GetTime() >= ft.GetTime();
 656     }
 657
 658 };
 659
 660 }  // namespace ATL
 661
 662 #endif