home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 10 Tools / 10-Tools.zip / wxos2240.zip / wxWindows-2.4.0 / include / wx / datetime.inl < prev    next >
Text File  |  2002-11-04  |  15KB  |  553 lines
  1. /////////////////////////////////////////////////////////////////////////////
  2. // Name:        wx/datetime.inl
  3. // Purpose:     definition of inline functions of wxDateTime and related
  4. //              classes declared in datetime.h
  5. // Author:      Vadim Zeitlin
  6. // Remarks:     having the inline functions here allows us to minimize the
  7. //              dependencies (and hence the rebuild time) in debug builds.
  8. // Modified by:
  9. // Created:     30.11.99
  10. // RCS-ID:      $Id: datetime.inl,v 1.22.2.1 2002/10/24 16:10:56 VZ Exp $
  11. // Copyright:   (c) 1999 Vadim Zeitlin <zeitlin@dptmaths.ens-cachan.fr>
  12. // Licence:     wxWindows license
  13. /////////////////////////////////////////////////////////////////////////////
  14.  
  15. #ifndef INCLUDED_FROM_WX_DATETIME_H
  16.     #error "This file is only included by wx/datetime.h, don't include it manually!"
  17. #endif
  18.  
  19. // ----------------------------------------------------------------------------
  20. // private macros
  21. // ----------------------------------------------------------------------------
  22.  
  23. #define MILLISECONDS_PER_DAY 86400000l
  24.  
  25. // some broken compilers (HP-UX CC) refuse to compile the "normal" version, but
  26. // using a temp variable always might prevent other compilers from optimising
  27. // it away - hence use of this ugly macro
  28. #ifndef __HPUX__
  29.     #define MODIFY_AND_RETURN(op) return wxDateTime(*this).op
  30. #else
  31.     #define MODIFY_AND_RETURN(op) wxDateTime dt(*this); dt.op; return dt
  32. #endif
  33.  
  34. // ----------------------------------------------------------------------------
  35. // wxDateTime construction
  36. // ----------------------------------------------------------------------------
  37.  
  38. // only define this once, when included from datetime.cpp
  39. #ifdef wxDEFINE_TIME_CONSTANTS
  40.     const long wxDateTime::TIME_T_FACTOR = 1000l;
  41. #endif // wxDEFINE_TIME_CONSTANTS
  42.  
  43. inline bool wxDateTime::IsInStdRange() const
  44. {
  45.     return m_time >= 0l && (m_time / TIME_T_FACTOR) < LONG_MAX;
  46. }
  47.  
  48. /* static */
  49. inline wxDateTime wxDateTime::Now()
  50. {
  51.     return wxDateTime(*GetTmNow());
  52. }
  53.  
  54. /* static */
  55. inline wxDateTime wxDateTime::Today()
  56. {
  57.     struct tm *time = GetTmNow();
  58.     time->tm_hour = 0;
  59.     time->tm_min = 0;
  60.     time->tm_sec = 0;
  61.  
  62.     return wxDateTime(*time);
  63. }
  64.  
  65. #if (!(defined(__VISAGECPP__) && __IBMCPP__ >= 400))
  66. inline wxDateTime& wxDateTime::Set(time_t timet)
  67. {
  68.     // assign first to avoid long multiplication overflow!
  69.     m_time = timet - WX_TIME_BASE_OFFSET ;
  70.     m_time *= TIME_T_FACTOR;
  71.  
  72.     return *this;
  73. }
  74. #endif
  75.  
  76. inline wxDateTime& wxDateTime::SetToCurrent()
  77. {
  78.     *this = Now();
  79.     return *this;
  80. }
  81.  
  82. #if (!(defined(__VISAGECPP__) && __IBMCPP__ >= 400))
  83. inline wxDateTime::wxDateTime(time_t timet)
  84. {
  85.     Set(timet);
  86. }
  87. #endif
  88.  
  89. inline wxDateTime::wxDateTime(const struct tm& tm)
  90. {
  91.     Set(tm);
  92. }
  93.  
  94. inline wxDateTime::wxDateTime(const Tm& tm)
  95. {
  96.     Set(tm);
  97. }
  98.  
  99. inline wxDateTime::wxDateTime(double jdn)
  100. {
  101.     Set(jdn);
  102. }
  103.  
  104. inline wxDateTime& wxDateTime::Set(const Tm& tm)
  105. {
  106.     wxASSERT_MSG( tm.IsValid(), _T("invalid broken down date/time") );
  107.  
  108.     return Set(tm.mday, (Month)tm.mon, tm.year, tm.hour, tm.min, tm.sec);
  109. }
  110.  
  111. inline wxDateTime::wxDateTime(wxDateTime_t hour,
  112.                               wxDateTime_t minute,
  113.                               wxDateTime_t second,
  114.                               wxDateTime_t millisec)
  115. {
  116.     Set(hour, minute, second, millisec);
  117. }
  118.  
  119. inline wxDateTime::wxDateTime(wxDateTime_t day,
  120.                               Month        month,
  121.                               int          year,
  122.                               wxDateTime_t hour,
  123.                               wxDateTime_t minute,
  124.                               wxDateTime_t second,
  125.                               wxDateTime_t millisec)
  126. {
  127.     Set(day, month, year, hour, minute, second, millisec);
  128. }
  129.  
  130. // ----------------------------------------------------------------------------
  131. // wxDateTime accessors
  132. // ----------------------------------------------------------------------------
  133.  
  134. inline wxLongLong wxDateTime::GetValue() const
  135. {
  136.     wxASSERT_MSG( IsValid(), _T("invalid wxDateTime"));
  137.  
  138.     return m_time;
  139. }
  140.  
  141. inline time_t wxDateTime::GetTicks() const
  142. {
  143.     wxASSERT_MSG( IsValid(), _T("invalid wxDateTime"));
  144.     if ( !IsInStdRange() )
  145.     {
  146.         return (time_t)-1;
  147.     }
  148.  
  149.     return (time_t)((m_time / (long)TIME_T_FACTOR).GetLo())+WX_TIME_BASE_OFFSET ;
  150. }
  151.  
  152. inline bool wxDateTime::SetToLastWeekDay(WeekDay weekday,
  153.                                          Month month,
  154.                                          int year)
  155. {
  156.     return SetToWeekDay(weekday, -1, month, year);
  157. }
  158.  
  159. inline wxDateTime wxDateTime::GetWeekDayInSameWeek(WeekDay weekday,
  160.                                                    WeekFlags flags) const
  161. {
  162.     MODIFY_AND_RETURN( SetToWeekDayInSameWeek(weekday) );
  163. }
  164.  
  165. inline wxDateTime wxDateTime::GetNextWeekDay(WeekDay weekday) const
  166. {
  167.     MODIFY_AND_RETURN( SetToNextWeekDay(weekday) );
  168. }
  169.  
  170. inline wxDateTime wxDateTime::GetPrevWeekDay(WeekDay weekday) const
  171. {
  172.     MODIFY_AND_RETURN( SetToPrevWeekDay(weekday) );
  173. }
  174.  
  175. inline wxDateTime wxDateTime::GetWeekDay(WeekDay weekday,
  176.                                          int n,
  177.                                          Month month,
  178.                                          int year) const
  179. {
  180.     wxDateTime dt(*this);
  181.  
  182.     return dt.SetToWeekDay(weekday, n, month, year) ? dt : wxInvalidDateTime;
  183. }
  184.  
  185. inline wxDateTime wxDateTime::GetLastWeekDay(WeekDay weekday,
  186.                                              Month month,
  187.                                              int year)
  188. {
  189.     wxDateTime dt(*this);
  190.  
  191.     return dt.SetToLastWeekDay(weekday, month, year) ? dt : wxInvalidDateTime;
  192. }
  193.  
  194. inline wxDateTime wxDateTime::GetWeek(wxDateTime_t numWeek,
  195.                                       WeekDay weekday,
  196.                                       WeekFlags flags) const
  197. {
  198.     wxDateTime dt(*this);
  199.  
  200.     return dt.SetToTheWeek(numWeek, weekday, flags) ? dt : wxInvalidDateTime;
  201. }
  202.  
  203. inline wxDateTime wxDateTime::GetLastMonthDay(Month month, int year) const
  204. {
  205.     MODIFY_AND_RETURN( SetToLastMonthDay(month, year) );
  206. }
  207.  
  208. inline wxDateTime wxDateTime::GetYearDay(wxDateTime_t yday) const
  209. {
  210.     MODIFY_AND_RETURN( SetToYearDay(yday) );
  211. }
  212.  
  213. // ----------------------------------------------------------------------------
  214. // wxDateTime comparison
  215. // ----------------------------------------------------------------------------
  216.  
  217. inline bool wxDateTime::IsEqualTo(const wxDateTime& datetime) const
  218. {
  219.     wxASSERT_MSG( IsValid() && datetime.IsValid(), _T("invalid wxDateTime"));
  220.  
  221.     return m_time == datetime.m_time;
  222. }
  223.  
  224. inline bool wxDateTime::IsEarlierThan(const wxDateTime& datetime) const
  225. {
  226.     wxASSERT_MSG( IsValid() && datetime.IsValid(), _T("invalid wxDateTime"));
  227.  
  228.     return m_time < datetime.m_time;
  229. }
  230.  
  231. inline bool wxDateTime::IsLaterThan(const wxDateTime& datetime) const
  232. {
  233.     wxASSERT_MSG( IsValid() && datetime.IsValid(), _T("invalid wxDateTime"));
  234.  
  235.     return m_time > datetime.m_time;
  236. }
  237.  
  238. inline bool wxDateTime::IsStrictlyBetween(const wxDateTime& t1,
  239.                                           const wxDateTime& t2) const
  240. {
  241.     // no need for assert, will be checked by the functions we call
  242.     return IsLaterThan(t1) && IsEarlierThan(t2);
  243. }
  244.  
  245. inline bool wxDateTime::IsBetween(const wxDateTime& t1,
  246.                                   const wxDateTime& t2) const
  247. {
  248.     // no need for assert, will be checked by the functions we call
  249.     return IsEqualTo(t1) || IsEqualTo(t2) || IsStrictlyBetween(t1, t2);
  250. }
  251.  
  252. inline bool wxDateTime::IsSameDate(const wxDateTime& dt) const
  253. {
  254.     Tm tm1 = GetTm(),
  255.        tm2 = dt.GetTm();
  256.  
  257.     return tm1.year == tm2.year &&
  258.            tm1.mon == tm2.mon &&
  259.            tm1.mday == tm2.mday;
  260. }
  261.  
  262. inline bool wxDateTime::IsSameTime(const wxDateTime& dt) const
  263. {
  264.     // notice that we can't do something like this:
  265.     //
  266.     //    m_time % MILLISECONDS_PER_DAY == dt.m_time % MILLISECONDS_PER_DAY
  267.     //
  268.     // because we have also to deal with (possibly) different DST settings!
  269.     Tm tm1 = GetTm(),
  270.        tm2 = dt.GetTm();
  271.  
  272.     return tm1.hour == tm2.hour &&
  273.            tm1.min == tm2.min &&
  274.            tm1.sec == tm2.sec &&
  275.            tm1.msec == tm2.msec;
  276. }
  277.  
  278. inline bool wxDateTime::IsEqualUpTo(const wxDateTime& dt,
  279.                                     const wxTimeSpan& ts) const
  280. {
  281.     return IsBetween(dt.Subtract(ts), dt.Add(ts));
  282. }
  283.  
  284. // ----------------------------------------------------------------------------
  285. // wxDateTime arithmetics
  286. // ----------------------------------------------------------------------------
  287.  
  288. inline wxDateTime wxDateTime::Add(const wxTimeSpan& diff) const
  289. {
  290.     wxASSERT_MSG( IsValid(), _T("invalid wxDateTime"));
  291.  
  292.     return wxDateTime(m_time + diff.GetValue());
  293. }
  294.  
  295. inline wxDateTime& wxDateTime::Add(const wxTimeSpan& diff)
  296. {
  297.     wxASSERT_MSG( IsValid(), _T("invalid wxDateTime"));
  298.  
  299.     m_time += diff.GetValue();
  300.  
  301.     return *this;
  302. }
  303.  
  304. inline wxDateTime& wxDateTime::operator+=(const wxTimeSpan& diff)
  305. {
  306.     return Add(diff);
  307. }
  308.  
  309. inline wxDateTime wxDateTime::Subtract(const wxTimeSpan& diff) const
  310. {
  311.     wxASSERT_MSG( IsValid(), _T("invalid wxDateTime"));
  312.  
  313.     return wxDateTime(m_time - diff.GetValue());
  314. }
  315.  
  316. inline wxDateTime& wxDateTime::Subtract(const wxTimeSpan& diff)
  317. {
  318.     wxASSERT_MSG( IsValid(), _T("invalid wxDateTime"));
  319.  
  320.     m_time -= diff.GetValue();
  321.  
  322.     return *this;
  323. }
  324.  
  325. inline wxDateTime& wxDateTime::operator-=(const wxTimeSpan& diff)
  326. {
  327.     return Subtract(diff);
  328. }
  329.  
  330. inline wxTimeSpan wxDateTime::Subtract(const wxDateTime& datetime) const
  331. {
  332.     wxASSERT_MSG( IsValid() && datetime.IsValid(), _T("invalid wxDateTime"));
  333.  
  334.     return wxTimeSpan(GetValue() - datetime.GetValue());
  335. }
  336.  
  337. inline wxDateTime wxDateTime::Add(const wxDateSpan& diff) const
  338. {
  339.     return wxDateTime(*this).Add(diff);
  340. }
  341.  
  342. inline wxDateTime& wxDateTime::Subtract(const wxDateSpan& diff)
  343. {
  344.     return Add(diff.Negate());
  345. }
  346.  
  347. inline wxDateTime wxDateTime::Subtract(const wxDateSpan& diff) const
  348. {
  349.     return wxDateTime(*this).Subtract(diff);
  350. }
  351.  
  352. inline wxDateTime& wxDateTime::operator-=(const wxDateSpan& diff)
  353. {
  354.     return Subtract(diff);
  355. }
  356.  
  357. inline wxDateTime& wxDateTime::operator+=(const wxDateSpan& diff)
  358. {
  359.     return Add(diff);
  360. }
  361.  
  362. // ----------------------------------------------------------------------------
  363. // wxDateTime and timezones
  364. // ----------------------------------------------------------------------------
  365.  
  366. inline wxDateTime wxDateTime::ToTimezone(const wxDateTime::TimeZone& tz,
  367.                                          bool noDST) const
  368. {
  369.     MODIFY_AND_RETURN( MakeTimezone(tz, noDST) );
  370. }
  371.  
  372. // ----------------------------------------------------------------------------
  373. // wxTimeSpan construction
  374. // ----------------------------------------------------------------------------
  375.  
  376. inline wxTimeSpan::wxTimeSpan(long hours,
  377.                               long minutes,
  378.                               long seconds,
  379.                               long milliseconds)
  380. {
  381.     // assign first to avoid precision loss
  382.     m_diff = hours;
  383.     m_diff *= 60l;
  384.     m_diff += minutes;
  385.     m_diff *= 60l;
  386.     m_diff += seconds;
  387.     m_diff *= 1000l;
  388.     m_diff += milliseconds;
  389. }
  390.  
  391. // ----------------------------------------------------------------------------
  392. // wxTimeSpan accessors
  393. // ----------------------------------------------------------------------------
  394.  
  395. inline wxLongLong wxTimeSpan::GetSeconds() const
  396. {
  397.     return m_diff / 1000l;
  398. }
  399.  
  400. inline int wxTimeSpan::GetMinutes() const
  401. {
  402.     return (GetSeconds() / 60l).GetLo();
  403. }
  404.  
  405. inline int wxTimeSpan::GetHours() const
  406. {
  407.     return GetMinutes() / 60;
  408. }
  409.  
  410. inline int wxTimeSpan::GetDays() const
  411. {
  412.     return GetHours() / 24;
  413. }
  414.  
  415. inline int wxTimeSpan::GetWeeks() const
  416. {
  417.     return GetDays() / 7;
  418. }
  419.  
  420. // ----------------------------------------------------------------------------
  421. // wxTimeSpan arithmetics
  422. // ----------------------------------------------------------------------------
  423.  
  424. inline wxTimeSpan wxTimeSpan::Add(const wxTimeSpan& diff) const
  425. {
  426.     return wxTimeSpan(m_diff + diff.GetValue());
  427. }
  428.  
  429. inline wxTimeSpan& wxTimeSpan::Add(const wxTimeSpan& diff)
  430. {
  431.     m_diff += diff.GetValue();
  432.  
  433.     return *this;
  434. }
  435.  
  436. inline wxTimeSpan wxTimeSpan::Subtract(const wxTimeSpan& diff) const
  437. {
  438.     return wxTimeSpan(m_diff - diff.GetValue());
  439. }
  440.  
  441. inline wxTimeSpan& wxTimeSpan::Subtract(const wxTimeSpan& diff)
  442. {
  443.     m_diff -= diff.GetValue();
  444.  
  445.     return *this;
  446. }
  447.  
  448. inline wxTimeSpan& wxTimeSpan::Multiply(int n)
  449. {
  450.     m_diff *= (long)n;
  451.  
  452.     return *this;
  453. }
  454.  
  455. inline wxTimeSpan wxTimeSpan::Multiply(int n) const
  456. {
  457.     return wxTimeSpan(m_diff * (long)n);
  458. }
  459.  
  460. inline wxTimeSpan wxTimeSpan::Abs() const
  461. {
  462.     return wxTimeSpan(GetValue().Abs());
  463. }
  464.  
  465. inline bool wxTimeSpan::IsEqualTo(const wxTimeSpan& ts) const
  466. {
  467.     return GetValue() == ts.GetValue();
  468. }
  469.  
  470. inline bool wxTimeSpan::IsLongerThan(const wxTimeSpan& ts) const
  471. {
  472.     return GetValue().Abs() > ts.GetValue().Abs();
  473. }
  474.  
  475. // ----------------------------------------------------------------------------
  476. // wxDateSpan
  477. // ----------------------------------------------------------------------------
  478.  
  479. inline wxDateSpan& wxDateSpan::operator+=(const wxDateSpan& other)
  480. {
  481.     m_years += other.m_years;
  482.     m_months += other.m_months;
  483.     m_weeks += other.m_weeks;
  484.     m_days += other.m_days;
  485.  
  486.     return *this;
  487. }
  488.  
  489. inline wxDateSpan& wxDateSpan::Add(const wxDateSpan& other)
  490. {
  491.     return *this += other;
  492. }
  493.  
  494. inline wxDateSpan wxDateSpan::Add(const wxDateSpan& other) const
  495. {
  496.     wxDateSpan ds(*this);
  497.     ds.Add(other);
  498.     return ds;
  499. }
  500.  
  501. inline wxDateSpan& wxDateSpan::Multiply(int factor)
  502. {
  503.     m_years *= factor;
  504.     m_months *= factor;
  505.     m_weeks *= factor;
  506.     m_days *= factor;
  507.  
  508.     return *this;
  509. }
  510.  
  511. inline wxDateSpan wxDateSpan::Multiply(int factor) const
  512. {
  513.     wxDateSpan ds(*this);
  514.     ds.Multiply(factor);
  515.     return ds;
  516. }
  517.  
  518. inline wxDateSpan wxDateSpan::Negate() const
  519. {
  520.     return wxDateSpan(-m_years, -m_months, -m_weeks, -m_days);
  521. }
  522.  
  523. inline wxDateSpan& wxDateSpan::Neg()
  524. {
  525.     m_years = -m_years;
  526.     m_months = -m_months;
  527.     m_weeks = -m_weeks;
  528.     m_days = -m_days;
  529.  
  530.     return *this;
  531. }
  532.  
  533. inline wxDateSpan& wxDateSpan::operator-=(const wxDateSpan& other)
  534. {
  535.     return *this += other.Negate();
  536. }
  537.  
  538. inline wxDateSpan& wxDateSpan::Subtract(const wxDateSpan& other)
  539. {
  540.     return *this -= other;
  541. }
  542.  
  543. inline wxDateSpan wxDateSpan::Subtract(const wxDateSpan& other) const
  544. {
  545.     wxDateSpan ds(*this);
  546.     ds.Subtract(other);
  547.     return ds;
  548. }
  549.  
  550. #undef MILLISECONDS_PER_DAY
  551.  
  552. #undef MODIFY_AND_RETURN
  553.