X-Git-Url: https://git.saurik.com/wxWidgets.git/blobdiff_plain/b76b015ed9231ffe128ddba9fb35e37b4be9764d..5357c8e8b3da95c225e686a195002df5712446b8:/include/wx/datetime.h?ds=sidebyside diff --git a/include/wx/datetime.h b/include/wx/datetime.h index bf7cab1fcc..c0091ce142 100644 --- a/include/wx/datetime.h +++ b/include/wx/datetime.h @@ -10,8 +10,8 @@ // Licence: wxWindows license ///////////////////////////////////////////////////////////////////////////// -#ifndef _WX_TIME_H -#define _WX_TIME_H +#ifndef _WX_DATETIME_H +#define _WX_DATETIME_H #ifdef __GNUG__ #pragma interface "datetime.h" @@ -26,16 +26,25 @@ class WXDLLEXPORT wxDateTime; class WXDLLEXPORT wxTimeSpan; class WXDLLEXPORT wxDateSpan; +// don't use inline functions in debug builds - we don't care about +// performances and this only leads to increased rebuild time (because every +// time an inline method is changed, all files including the header must be +// rebuilt) +#ifdef __WXDEBUG__ + #define inline +#endif // Debug + /* * TODO Well, everything :-) * - * 1. Time zones with minutes (make wxTimeZone a class) - * 2. getdate() function like under Solaris - * 3. text conversion for wxDateSpan + * + 1. Time zones with minutes (make TimeZone a class) + * 2. getdate() function like under Solaris + * + 3. text conversion for wxDateSpan + * 4. pluggable modules for the workdays calculations */ /* - The three classes declared in this header represent: + The three (main) classes declared in this header represent: 1. An absolute moment in the time (wxDateTime) 2. A difference between two moments in the time, positive or negative @@ -106,10 +115,45 @@ public: // Note that GMT12 and GMT_12 are not the same: there is a difference // of exactly one day between them - // Universal Coordinated Time + // some symbolic names for TZ + + // Europe + WET = GMT0, // Western Europe Time + WEST = GMT1, // Western Europe Summer Time + CET = GMT1, // Central Europe Time + CEST = GMT2, // Central Europe Summer Time + EET = GMT2, // Eastern Europe Time + EEST = GMT3, // Eastern Europe Summer Time + MSK = GMT3, // Moscow Time + MSD = GMT4, // Moscow Summer Time + + // US and Canada + AST = GMT_4, // Atlantic Standard Time + ADT = GMT_3, // Atlantic Daylight Time + EST = GMT_5, // Eastern Standard Time + EDT = GMT_4, // Eastern Daylight Saving Time + CST = GMT_6, // Central Standard Time + CDT = GMT_5, // Central Daylight Saving Time + MST = GMT_7, // Mountain Standard Time + MDT = GMT_6, // Mountain Daylight Saving Time + PST = GMT_8, // Pacific Standard Time + PDT = GMT_7, // Pacific Daylight Saving Time + HST = GMT_10, // Hawaiian Standard Time + AKST = GMT_9, // Alaska Standard Time + AKDT = GMT_8, // Alaska Daylight Saving Time + + // Australia + + A_WST = GMT8, // Western Standard Time + A_CST = GMT12 + 1, // Central Standard Time (+9.5) + A_EST = GMT10, // Eastern Standard Time + A_ESST = GMT11, // Eastern Summer Time + + // TODO add more symbolic timezone names here + + // Universal Coordinated Time = the new and politically correct name + // for GMT UTC = GMT0 - - // TODO add symbolic names for TZ (EST, MET, ...)? }; // the calendar systems we know about: notice that it's valid (for @@ -279,19 +323,39 @@ public: // helper classes // ------------------------------------------------------------------------ + // a class representing a time zone: basicly, this is just an offset + // (in seconds) from GMT + class TimeZone + { + public: + TimeZone(TZ tz); + TimeZone(wxDateTime_t offset = 0) { m_offset = offset; } + + int GetOffset() const { return m_offset; } + + private: + // offset for this timezone from GMT in seconds + int m_offset; + }; + // standard struct tm is limited to the years from 1900 (because // tm_year field is the offset from 1900), so we use our own struct // instead to represent broken down time + // + // NB: this struct should always be kept normalized (i.e. mon should + // be < 12, 1 <= day <= 31 &c), so use AddMonths(), AddDays() + // instead of modifying the member fields directly! struct Tm { - wxDateTime_t sec, min, hour, - mday, mon, year; + wxDateTime_t msec, sec, min, hour, mday; + Month mon; + int year; // default ctor inits the object to an invalid value Tm(); - // ctor from struct tm - Tm(const struct tm& tm); + // ctor from struct tm and the timezone + Tm(const struct tm& tm, const TimeZone& tz); // check that the given date/time is valid (in Gregorian calendar) bool IsValid() const; @@ -305,30 +369,24 @@ public: return (WeekDay)wday; } + // add the given number of months to the date keeping it normalized + void AddMonths(int monDiff); + + // add the given number of months to the date keeping it normalized + void AddDays(int dayDiff); + private: // compute the weekday from other fields void ComputeWeekDay(); + // the timezone we correspond to + TimeZone m_tz; + // these values can't be accessed directly because they're not always // computed and we calculate them on demand wxDateTime_t wday, yday; }; - // a class representing a time zone: basicly, this is just an offset - // (in minutes) from GMT - class TimeZone - { - public: - TimeZone(TZ tz); - TimeZone(wxDateTime_t offset) { m_offset = offset; } - - wxDateTime_t GetOffset() const { return m_offset; } - - private: - // offset for this timezone from GMT in minutes - wxDateTime_t m_offset; - }; - // static methods // ------------------------------------------------------------------------ @@ -350,7 +408,10 @@ public: static Month GetCurrentMonth(Calendar cal = Gregorian); // returns TRUE if the given year is a leap year in the given calendar - static bool IsLeapYear(int year, Calendar cal = Gregorian); + static bool IsLeapYear(int year = Inv_Year, Calendar cal = Gregorian); + + // get the century (19 for 1999, 20 for 2000 and -5 for 492 BC) + static int GetCentury(int year = Inv_Year); // returns the number of days in this year (356 or 355 for Gregorian // calendar usually :-) @@ -385,9 +446,6 @@ public: // constructors: you should test whether the constructor succeeded with // IsValid() function. The values Inv_Month and Inv_Year for the // parameters mean take current month and/or year values. - // - // All new wxDateTime correspond to the local time, use ToUTC() or - // MakeUTC() to get the time in UTC/GMT. // ------------------------------------------------------------------------ // default ctor does not initialize the object, use Set()! @@ -400,6 +458,9 @@ public: // from broken down time/date (any range) inline wxDateTime(const Tm& tm); + // from JDN (beware of rounding errors) + inline wxDateTime(double jdn); + // from separate values for each component, date set to today inline wxDateTime(wxDateTime_t hour, wxDateTime_t minute = 0, @@ -435,6 +496,9 @@ public: // set to given broken down time/date inline wxDateTime& Set(const Tm& tm); + // set to given JDN (beware of rounding errors) + wxDateTime& Set(double jdn); + // set to given time, date = today wxDateTime& Set(wxDateTime_t hour, wxDateTime_t minute = 0, @@ -493,12 +557,12 @@ public: // of the month (see helper function SetToLastWeekDay()) bool SetToWeekDay(WeekDay weekday, int n = 1, - wxDateTime_t month = Inv_Month, + Month month = Inv_Month, int year = Inv_Year); // sets to the last weekday in the given month, year inline bool SetToLastWeekDay(WeekDay weekday, - wxDateTime_t month = Inv_Month, + Month month = Inv_Month, int year = Inv_Year); // sets the date to the given day of the given week in the year, @@ -506,8 +570,10 @@ public: // numWeek is > 53) bool SetToTheWeek(wxDateTime_t numWeek, WeekDay weekday = Mon); - // get the century (19 for 1999, 20 for 2000 and -5 for 492 BC) - int GetCentury() const; + // sets the date to the last day of the given (or current) month or the + // given (or current) year + wxDateTime& SetToLastMonthDay(Month month = Inv_Month, + int year = Inv_Year); // The definitions below were taken verbatim from // @@ -531,32 +597,33 @@ public: // of days relative to a base date of December 31 of the year 0. Thus // January 1 of the year 1 is Rata Die day 1. - // get the Julian Day number - long GetJulianDay() const; + // get the Julian Day number (the fractional part specifies the time of + // the day, related to noon - beware of rounding errors!) + double GetJulianDayNumber() const; // get the Rata Die number - long GetRataDie() const; + double GetRataDie() const; // TODO algorithms for calculating some important dates, such as // religious holidays (Easter...) or moon/solar eclipses? Some // algorithms can be found in the calendar FAQ - // timezone stuff: by default, we always work with local times, to get - // anything else, it should be requested explicitly + // timezone stuff: a wxDateTime object constructed using given + // day/month/year/hour/min/sec values correspond to this moment in local + // time. Using the functions below, it may be converted to another time + // zone (for example, the Unix epoch is wxDateTime(1, Jan, 1970).ToGMT()) + // + // Converting to the local time zone doesn't do anything. // ------------------------------------------------------------------------ - // get the time corresponding to this one in UTC/GMT - wxDateTime ToUTC() const; - wxDateTime ToGMT() const { return ToUTC(); } - - // transform this object to UTC/GMT - wxDateTime& MakeUTC(); - wxDateTime& MakeGMT() { return MakeUTC(); } - - // generic version: transform time to any given timezone - wxDateTime ToTimezone(const TimeZone& tz); + // transform to any given timezone + inline wxDateTime ToTimezone(const TimeZone& tz) const; wxDateTime& MakeTimezone(const TimeZone& tz); + // transform to GMT/UTC + wxDateTime ToGMT() const { return ToTimezone(GMT0); } + wxDateTime& MakeGMT() { return MakeTimezone(GMT0); } + // accessors: many of them take the timezone parameter which indicates the // timezone for which to make the calculations and the default value means // to do it for the current timezone of this machine (even if the function @@ -568,40 +635,52 @@ public: // the functions which failed to convert the date to supported range) inline bool IsValid() const { return this != &ms_InvDateTime; } - // get the broken down date/time representation - Tm GetTm() const; + // get the broken down date/time representation in the given timezone + // + // If you wish to get several time components (day, month and year), + // consider getting the whole Tm strcuture first and retrieving the + // value from it - this is much more efficient + Tm GetTm(const TimeZone& tz = Local) const; // get the number of seconds since the Unix epoch - returns (time_t)-1 // if the value is out of range inline time_t GetTicks() const; // get the year (returns Inv_Year if date is invalid) - int GetYear() const { return GetTm().year; } + int GetYear(const TimeZone& tz = Local) const + { return GetTm(tz).year; } // get the month (Inv_Month if date is invalid) - Month GetMonth() const { return (Month)GetTm().mon; } + Month GetMonth(const TimeZone& tz = Local) const + { return (Month)GetTm(tz).mon; } // get the month day (in 1..31 range, 0 if date is invalid) - wxDateTime_t GetDay() const { return GetTm().mday; } + wxDateTime_t GetDay(const TimeZone& tz = Local) const + { return GetTm(tz).mday; } // get the day of the week (Inv_WeekDay if date is invalid) - WeekDay GetDayOfWeek() const { return GetTm().GetWeekDay(); } + WeekDay GetWeekDay(const TimeZone& tz = Local) const + { return GetTm(tz).GetWeekDay(); } // get the hour of the day - wxDateTime_t GetHour() const { return GetTm().hour; } + wxDateTime_t GetHour(const TimeZone& tz = Local) const + { return GetTm(tz).hour; } // get the minute - wxDateTime_t GetMinute() const { return GetTm().min; } + wxDateTime_t GetMinute(const TimeZone& tz = Local) const + { return GetTm(tz).min; } // get the second - wxDateTime_t GetSecond() const { return GetTm().sec; } + wxDateTime_t GetSecond(const TimeZone& tz = Local) const + { return GetTm(tz).sec; } // get milliseconds - wxDateTime_t GetMillisecond() const { return m_time.GetLo() % 1000; } + wxDateTime_t GetMillisecond(const TimeZone& tz = Local) const + { return GetTm(tz).msec; } // get the day since the year start (1..366, 0 if date is invalid) - wxDateTime_t GetDayOfYear() const; + wxDateTime_t GetDayOfYear(const TimeZone& tz = Local) const; // get the week number since the year start (1..52, 0 if date is // invalid) - wxDateTime_t GetWeekOfYear() const; + wxDateTime_t GetWeekOfYear(const TimeZone& tz = Local) const; // is this date a work day? This depends on a country, of course, // because the holidays are different in different countries bool IsWorkDay(Country country = Country_Default, - TimeZone zone = Local) const; + const TimeZone& tz = Local) const; // is this date later than Gregorian calendar introduction for the // given country (see enum GregorianAdoption)? @@ -611,11 +690,12 @@ public: // adoption of the Gregorian calendar is simply unknown. bool IsGregorianDate(GregorianAdoption country = Gr_Standard) const; - // is daylight savings time in effect at this moment? + // is daylight savings time in effect at this moment according to the + // rules of the specified country? // // Return value is > 0 if DST is in effect, 0 if it is not and -1 if // the information is not available (this is compatible with ANSI C) - int IsDST(Country country = Country_Default, TimeZone zone = Local) const; + int IsDST(Country country = Country_Default) const; // comparison (see also functions below for operator versions) // ------------------------------------------------------------------------ @@ -689,7 +769,8 @@ public: // argument corresponds to the preferred date and time representation // for the current locale) and returns the string containing the // resulting text representation - wxString Format(const wxChar *format = _T("%c")) const; + wxString Format(const wxChar *format = _T("%c"), + const TimeZone& tz = Local) const; // preferred date representation for the current locale wxString FormatDate() const { return Format(_T("%x")); } // preferred time representation for the current locale @@ -701,10 +782,17 @@ public: // get the internal representation inline wxLongLong GetValue() const; -private: // a helper function to get the current time_t - static inline time_t GetTimeNow() { return time((time_t *)NULL); } + static time_t GetTimeNow() { return time((time_t *)NULL); } + + // another one to get the current time broken down + static struct tm *GetTmNow() + { + time_t t = GetTimeNow(); + return localtime(&t); + } +private: // the current country - as it's the same for all program objects (unless // it runs on a _really_ big cluster system :-), this is a static member: // see SetCountry() and GetCountry() @@ -721,7 +809,7 @@ private: // returns TRUE if we fall in range in which we can use standard ANSI C // functions - inline IsInStdRange() const; + inline bool IsInStdRange() const; // the internal representation of the time is the amount of milliseconds // elapsed since the origin which is set by convention to the UNIX/C epoch @@ -741,25 +829,25 @@ public: // constructors // ------------------------------------------------------------------------ + // return the timespan for the given number of seconds + static wxTimeSpan Seconds(int sec) { return wxTimeSpan(0, 0, sec); } + + // return the timespan for the given number of minutes + static wxTimeSpan Minutes(int min) { return wxTimeSpan(0, min, 0 ); } + + // return the timespan for the given number of hours + static wxTimeSpan Hours(int hours) { return wxTimeSpan(hours, 0, 0); } + // default ctor constructs the 0 time span wxTimeSpan() { } // from separate values for each component, date set to 0 (hours are // not restricted to 0..24 range, neither are minutes, seconds or // milliseconds) - wxTimeSpan(int hours, - int minutes = 0, - int seconds = 0, - int milliseconds = 0); - // from separate values for each component with explicit date (none of - // the parameters isn't restricted to any range) - wxTimeSpan(int years, - int months, - int days, - int hours = 0, - int minutes = 0, - int seconds = 0, - int milliseconds = 0); + inline wxTimeSpan(int hours, + int minutes = 0, + int seconds = 0, + int milliseconds = 0); // from internal representation wxTimeSpan(wxLongLong diff) : m_diff(diff) { } @@ -827,16 +915,9 @@ public: // timespans are equal in absolute value. bool IsShorterThan(const wxTimeSpan& t) const { return !IsLongerThan(t); } - // breaking into years, ..., days, ..., seconds: all these functions - // behave like GetYears() which returns 1 for the timespan of 1 year and 1 - // day, but 0 (and not -1) for the negative timespan of 1 year without 1 - // day. IOW, (ts - wxTimeSpan(ts.GetYears())).GetYears() is always 0. + // breaking into days, hours, minutes and seconds // ------------------------------------------------------------------------ - // get the max number of years in this timespan - inline int GetYears() const; - // get the max number of months in this timespan - inline int GetMonths() const; // get the max number of weeks in this timespan inline int GetWeeks() const; // get the max number of days in this timespan @@ -846,7 +927,7 @@ public: // get the max number of minutes in this timespan inline int GetMinutes() const; // get the max number of seconds in this timespan - inline int GetSeconds() const; + inline wxLongLong GetSeconds() const; // get the number of milliseconds in this timespan wxLongLong GetMilliseconds() const { return m_diff; } @@ -859,11 +940,11 @@ public: // resulting text representation. Notice that only some of format // specifiers valid for wxDateTime are valid for wxTimeSpan: hours, // minutes and seconds make sense, but not "PM/AM" string for example. - wxString Format(const char *format = "%c") const; + wxString Format(const wxChar *format = _T("%c")) const; // preferred date representation for the current locale - wxString FormatDate() const { return Format("%x"); } + wxString FormatDate() const { return Format(_T("%x")); } // preferred time representation for the current locale - wxString FormatTime() const { return Format("%X"); } + wxString FormatTime() const { return Format(_T("%X")); } // implementation // ------------------------------------------------------------------------ @@ -907,7 +988,25 @@ public: // ------------------------------------------------------------------------ // this many years/months/weeks/days - wxDateSpan(int years, int months, int weeks, int days); + wxDateSpan(int years = 0, int months = 0, int weeks = 0, int days = 0) + { + m_years = years; + m_months = months; + m_weeks = weeks; + m_days = days; + } + + // get an object for the given number of days + static wxDateSpan Days(int days) { return wxDateSpan(0, 0, 0, days); } + + // get an object for the given number of weeks + static wxDateSpan Weeks(int weeks) { return wxDateSpan(0, 0, weeks, 0); } + + // get an object for the given number of months + static wxDateSpan Months(int mon) { return wxDateSpan(0, mon, 0, 0); } + + // get an object for the given number of years + static wxDateSpan Years(int years) { return wxDateSpan(years, 0, 0, 0); } // default copy ctor is ok @@ -971,6 +1070,23 @@ WXDLLEXPORT_DATA(extern wxDateSpan) wxMonth; WXDLLEXPORT_DATA(extern wxDateSpan) wxWeek; WXDLLEXPORT_DATA(extern wxDateSpan) wxDay; +// ============================================================================ +// inline functions implementation +// ============================================================================ + +// don't include inline functions definitions when we're included from anything +// else than datetime.cpp in debug builds: this minimizes rebuilds if we change +// some inline function and the performance doesn't matter in the debug builds. + +#if !defined(__WXDEBUG__) || defined(wxDEFINE_TIME_CONSTANTS) + #define INCLUDED_FROM_WX_DATETIME_H + #include "wx/datetime.inl" + #undef INCLUDED_FROM_WX_DATETIME_H +#endif + +// if we defined it to be empty above, restore it now +#undef inline + // ============================================================================ // binary operators // ============================================================================ @@ -1088,315 +1204,4 @@ inline WXDLLEXPORT wxDateSpan operator+(const wxDateSpan& rt1, rt1.GetDays() + rt2.GetDays()); } -// ============================================================================ -// inline functions implementation -// ============================================================================ - -// ---------------------------------------------------------------------------- -// wxDateTime statics -// ---------------------------------------------------------------------------- - -/* static */ -wxDateTime::Country wxDateTime::GetCountry() -{ - return ms_country; -} - -// ---------------------------------------------------------------------------- -// wxDateTime construction -// ---------------------------------------------------------------------------- - -// only define this once, when included from datetime.cpp -#ifdef wxDEFINE_TIME_CONSTANTS - const unsigned int wxDateTime::TIME_T_FACTOR = 1000; -#endif // wxDEFINE_TIME_CONSTANTS - -wxDateTime::IsInStdRange() const -{ - return m_time >= 0l && (m_time / (long)TIME_T_FACTOR) < LONG_MAX; -} - -/* static */ -wxDateTime wxDateTime::Now() -{ - return wxDateTime(GetTimeNow()); -} - -wxDateTime& wxDateTime::Set(time_t timet) -{ - m_time = timet * TIME_T_FACTOR; - - return *this; -} - -wxDateTime& wxDateTime::SetToCurrent() -{ - return Set(GetTimeNow()); -} - -wxDateTime::wxDateTime(time_t timet) -{ - Set(timet); -} - -wxDateTime::wxDateTime(const struct tm& tm) -{ - Set(tm); -} - -wxDateTime::wxDateTime(const Tm& tm) -{ - Set(tm); -} - -wxDateTime& wxDateTime::Set(const Tm& tm) -{ - wxASSERT_MSG( tm.IsValid(), _T("invalid broken down date/time") ); - - return Set(tm.mday, (Month)tm.mon, tm.year, tm.hour, tm.min, tm.sec); -} - -wxDateTime::wxDateTime(wxDateTime_t hour, - wxDateTime_t minute, - wxDateTime_t second, - wxDateTime_t millisec) -{ - Set(hour, minute, second, millisec); -} - -wxDateTime::wxDateTime(wxDateTime_t day, - Month month, - int year, - wxDateTime_t hour, - wxDateTime_t minute, - wxDateTime_t second, - wxDateTime_t millisec) -{ - Set(day, month, year, hour, minute, second, millisec); -} - -// ---------------------------------------------------------------------------- -// wxDateTime accessors -// ---------------------------------------------------------------------------- - -wxLongLong wxDateTime::GetValue() const -{ - wxASSERT_MSG( IsValid(), "invalid wxDateTime"); - - return m_time; -} - -time_t wxDateTime::GetTicks() const -{ - wxASSERT_MSG( IsValid(), "invalid wxDateTime"); - if ( !IsInStdRange() ) - { - return (time_t)-1; - } - - return (time_t)((m_time / (long)TIME_T_FACTOR).GetLo()); -} - -bool wxDateTime::SetToLastWeekDay(WeekDay weekday, - wxDateTime_t month, - int year) -{ - SetToWeekDay(weekday, -1, month, year); -} - -// ---------------------------------------------------------------------------- -// wxDateTime comparison -// ---------------------------------------------------------------------------- - -bool wxDateTime::IsEqualTo(const wxDateTime& datetime) const -{ - wxASSERT_MSG( IsValid() && datetime.IsValid(), "invalid wxDateTime"); - - return m_time == datetime.m_time; -} - -bool wxDateTime::operator==(const wxDateTime& datetime) const -{ - return IsEqualTo(datetime); -} - -bool wxDateTime::operator!=(const wxDateTime& datetime) const -{ - return !IsEqualTo(datetime); -} - -bool wxDateTime::IsEarlierThan(const wxDateTime& datetime) const -{ - wxASSERT_MSG( IsValid() && datetime.IsValid(), "invalid wxDateTime"); - - return m_time < datetime.m_time; -} - -bool wxDateTime::IsLaterThan(const wxDateTime& datetime) const -{ - wxASSERT_MSG( IsValid() && datetime.IsValid(), "invalid wxDateTime"); - - return m_time > datetime.m_time; -} - -bool wxDateTime::IsStrictlyBetween(const wxDateTime& t1, - const wxDateTime& t2) const -{ - // no need for assert, will be checked by the functions we call - return IsLaterThan(t1) && IsEarlierThan(t2); -} - -bool wxDateTime::IsBetween(const wxDateTime& t1, const wxDateTime& t2) const -{ - // no need for assert, will be checked by the functions we call - return IsEqualTo(t1) || IsEqualTo(t2) || IsStrictlyBetween(t1, t2); -} - -// ---------------------------------------------------------------------------- -// wxDateTime arithmetics -// ---------------------------------------------------------------------------- - -wxDateTime& wxDateTime::Add(const wxTimeSpan& diff) -{ - wxASSERT_MSG( IsValid(), "invalid wxDateTime"); - - m_time += diff.GetValue(); - - return *this; -} - -wxDateTime& wxDateTime::operator+=(const wxTimeSpan& diff) -{ - return Add(diff); -} - -wxDateTime& wxDateTime::Substract(const wxTimeSpan& diff) -{ - wxASSERT_MSG( IsValid(), "invalid wxDateTime"); - - m_time -= diff.GetValue(); - - return *this; -} - -wxDateTime& wxDateTime::operator-=(const wxTimeSpan& diff) -{ - return Substract(diff); -} - -wxTimeSpan wxDateTime::Substract(const wxDateTime& datetime) const -{ - wxASSERT_MSG( IsValid() && datetime.IsValid(), "invalid wxDateTime"); - - return wxTimeSpan(datetime.GetValue() - GetValue()); -} - -wxTimeSpan wxDateTime::operator-(const wxDateTime& datetime) const -{ - return Substract(datetime); -} - -wxDateTime& wxDateTime::Substract(const wxDateSpan& diff) -{ - return Add(diff.Negate()); -} - -wxDateTime& wxDateTime::operator-=(const wxDateSpan& diff) -{ - return Substract(diff); -} - -wxDateTime& wxDateTime::operator+=(const wxDateSpan& diff) -{ - return Add(diff); -} - -// ---------------------------------------------------------------------------- -// wxTimeSpan -// ---------------------------------------------------------------------------- - -wxTimeSpan& wxTimeSpan::Add(const wxTimeSpan& diff) -{ - m_diff += diff.GetValue(); - - return *this; -} - -wxTimeSpan& wxTimeSpan::Substract(const wxTimeSpan& diff) -{ - m_diff -= diff.GetValue(); - - return *this; -} - -wxTimeSpan& wxTimeSpan::Multiply(int n) -{ - m_diff *= n; - - return *this; -} - -wxTimeSpan wxTimeSpan::operator*(int n) const -{ - wxTimeSpan result(*this); - result.Multiply(n); - - return result; -} - -wxTimeSpan wxTimeSpan::Abs() const -{ - return wxTimeSpan(GetValue().Abs()); -} - -bool wxTimeSpan::IsEqualTo(const wxTimeSpan& ts) const -{ - return GetValue() == ts.GetValue(); -} - -bool wxTimeSpan::IsLongerThan(const wxTimeSpan& ts) const -{ - return Abs() > ts.Abs(); -} - -// ---------------------------------------------------------------------------- -// wxDateSpan -// ---------------------------------------------------------------------------- - -wxDateSpan& -wxDateSpan::operator+=(const wxDateSpan& other) -{ - m_years += other.m_years; - m_months += other.m_months; - m_weeks += other.m_weeks; - m_days += other.m_days; - - return *this; -} - -wxDateSpan& wxDateSpan::operator*=(int factor) -{ - m_years *= m_years; - m_months *= m_months; - m_weeks *= m_weeks; - m_days *= m_days; - - return *this; -} - -wxDateSpan wxDateSpan::Negate() const -{ - return wxDateSpan(-m_years, -m_months, -m_weeks, -m_days); -} - -wxDateSpan& wxDateSpan::Neg() -{ - m_years = -m_years; - m_months = -m_months; - m_weeks = -m_weeks; - m_days = -m_days; - - return *this; -} - -#endif // _WX_TIME_H +#endif // _WX_DATETIME_H