X-Git-Url: https://git.saurik.com/wxWidgets.git/blobdiff_plain/151d66be0fb2af0b98e40e8e0d62e9b6bb7b1c2e..5ea6dbbfff67d1dfad08044ab721ba56425ef6e1:/src/common/datetime.cpp?ds=inline diff --git a/src/common/datetime.cpp b/src/common/datetime.cpp index 815813e151..93c8dc6b84 100644 --- a/src/common/datetime.cpp +++ b/src/common/datetime.cpp @@ -75,6 +75,10 @@ #include "wx/datetime.h" +#ifndef WX_TIMEZONE + #define WX_TIMEZONE timezone +#endif + // ---------------------------------------------------------------------------- // constants // ---------------------------------------------------------------------------- @@ -151,7 +155,7 @@ static int GetTimeZone() s_timezoneSet = TRUE; } - return (int)timezone; + return (int)WX_TIMEZONE; } // return the integral part of the JDN for the midnight of the given date (to @@ -271,13 +275,16 @@ bool wxDateTime::Tm::IsValid() const { // we allow for the leap seconds, although we don't use them (yet) return (year != wxDateTime::Inv_Year) && (mon != wxDateTime::Inv_Month) && - (mday < GetNumOfDaysInMonth(year, mon)) && + (mday <= GetNumOfDaysInMonth(year, mon)) && (hour < 24) && (min < 60) && (sec < 62) && (msec < 1000); } void wxDateTime::Tm::ComputeWeekDay() { - wxFAIL_MSG(_T("TODO")); + // compute the week day from day/month/year: we use the dumbest algorithm + // possible: just compute our JDN and then use the (simple to derive) + // formula: weekday = (JDN + 1.5) % 7 + wday = (wxDateTime::WeekDay)(GetTruncatedJDN(mday, mon, year) + 2) % 7; } void wxDateTime::Tm::AddMonths(int monDiff) @@ -293,6 +300,8 @@ void wxDateTime::Tm::AddMonths(int monDiff) while ( monDiff + mon > MONTHS_IN_YEAR ) { year++; + + monDiff -= MONTHS_IN_YEAR; } mon = (wxDateTime::Month)(mon + monDiff); @@ -414,12 +423,6 @@ int wxDateTime::GetCentury(int year) return year > 0 ? year / 100 : year / 100 - 1; } -/* static */ -void wxDateTime::SetCountry(wxDateTime::Country country) -{ - ms_country = country; -} - /* static */ int wxDateTime::ConvertYearToBC(int year) { @@ -538,9 +541,288 @@ wxString wxDateTime::GetWeekDayName(wxDateTime::WeekDay wday, bool abbr) // and offset it by the number of days needed to get the correct wday tm.tm_mday += wday; + // call mktime() to normalize it... + (void)mktime(&tm); + + // ... and call strftime() return CallStrftime(abbr ? _T("%a") : _T("%A"), &tm); } +// ---------------------------------------------------------------------------- +// Country stuff: date calculations depend on the country (DST, work days, +// ...), so we need to know which rules to follow. +// ---------------------------------------------------------------------------- + +/* static */ +wxDateTime::Country wxDateTime::GetCountry() +{ + if ( ms_country == Country_Unknown ) + { + // try to guess from the time zone name + time_t t = time(NULL); + struct tm *tm = localtime(&t); + + wxString tz = CallStrftime(_T("%Z"), tm); + if ( tz == _T("WET") || tz == _T("WEST") ) + { + ms_country = UK; + } + else if ( tz == _T("CET") || tz == _T("CEST") ) + { + ms_country = Country_EEC; + } + else if ( tz == _T("MSK") || tz == _T("MSD") ) + { + ms_country = Russia; + } + else if ( tz == _T("AST") || tz == _T("ADT") || + tz == _T("EST") || tz == _T("EDT") || + tz == _T("CST") || tz == _T("CDT") || + tz == _T("MST") || tz == _T("MDT") || + tz == _T("PST") || tz == _T("PDT") ) + { + ms_country = USA; + } + else + { + // well, choose a default one + ms_country = USA; + } + } + + return ms_country; +} + +/* static */ +void wxDateTime::SetCountry(wxDateTime::Country country) +{ + ms_country = country; +} + +/* static */ +bool wxDateTime::IsWestEuropeanCountry(Country country) +{ + if ( country == Country_Default ) + { + country = GetCountry(); + } + + return (Country_WesternEurope_Start <= country) && + (country <= Country_WesternEurope_End); +} + +// ---------------------------------------------------------------------------- +// DST calculations: we use 3 different rules for the West European countries, +// USA and for the rest of the world. This is undoubtedly false for many +// countries, but I lack the necessary info (and the time to gather it), +// please add the other rules here! +// ---------------------------------------------------------------------------- + +/* static */ +bool wxDateTime::IsDSTApplicable(int year, Country country) +{ + if ( year == Inv_Year ) + { + // take the current year if none given + year = GetCurrentYear(); + } + + if ( country == Country_Default ) + { + country = GetCountry(); + } + + switch ( country ) + { + case USA: + case UK: + // DST was first observed in the US and UK during WWI, reused + // during WWII and used again since 1966 + return year >= 1966 || + (year >= 1942 && year <= 1945) || + (year == 1918 || year == 1919); + + default: + // assume that it started after WWII + return year > 1950; + } +} + +/* static */ +wxDateTime wxDateTime::GetBeginDST(int year, Country country) +{ + if ( year == Inv_Year ) + { + // take the current year if none given + year = GetCurrentYear(); + } + + if ( country == Country_Default ) + { + country = GetCountry(); + } + + if ( !IsDSTApplicable(year, country) ) + { + return ms_InvDateTime; + } + + wxDateTime dt; + + if ( IsWestEuropeanCountry(country) || (country == Russia) ) + { + // DST begins at 1 a.m. GMT on the last Sunday of March + if ( !dt.SetToLastWeekDay(Sun, Mar, year) ) + { + // weird... + wxFAIL_MSG( _T("no last Sunday in March?") ); + } + + dt += wxTimeSpan::Hours(1); + + dt.MakeGMT(); + } + else switch ( country ) + { + case USA: + switch ( year ) + { + case 1918: + case 1919: + // don't know for sure - assume it was in effect all year + + case 1943: + case 1944: + case 1945: + dt.Set(1, Jan, year); + break; + + case 1942: + // DST was installed Feb 2, 1942 by the Congress + dt.Set(2, Feb, year); + break; + + // Oil embargo changed the DST period in the US + case 1974: + dt.Set(6, Jan, 1974); + break; + + case 1975: + dt.Set(23, Feb, 1975); + break; + + default: + // before 1986, DST begun on the last Sunday of April, but + // in 1986 Reagan changed it to begin at 2 a.m. of the + // first Sunday in April + if ( year < 1986 ) + { + if ( !dt.SetToLastWeekDay(Sun, Apr, year) ) + { + // weird... + wxFAIL_MSG( _T("no first Sunday in April?") ); + } + } + else + { + if ( !dt.SetToWeekDay(Sun, 1, Apr, year) ) + { + // weird... + wxFAIL_MSG( _T("no first Sunday in April?") ); + } + } + + dt += wxTimeSpan::Hours(2); + + // TODO what about timezone?? + } + + break; + + default: + // assume Mar 30 as the start of the DST for the rest of the world + // - totally bogus, of course + dt.Set(30, Mar, year); + } + + return dt; +} + +/* static */ +wxDateTime wxDateTime::GetEndDST(int year, Country country) +{ + if ( year == Inv_Year ) + { + // take the current year if none given + year = GetCurrentYear(); + } + + if ( country == Country_Default ) + { + country = GetCountry(); + } + + if ( !IsDSTApplicable(year, country) ) + { + return ms_InvDateTime; + } + + wxDateTime dt; + + if ( IsWestEuropeanCountry(country) || (country == Russia) ) + { + // DST ends at 1 a.m. GMT on the last Sunday of October + if ( !dt.SetToLastWeekDay(Sun, Oct, year) ) + { + // weirder and weirder... + wxFAIL_MSG( _T("no last Sunday in October?") ); + } + + dt += wxTimeSpan::Hours(1); + + dt.MakeGMT(); + } + else switch ( country ) + { + case USA: + switch ( year ) + { + case 1918: + case 1919: + // don't know for sure - assume it was in effect all year + + case 1943: + case 1944: + dt.Set(31, Dec, year); + break; + + case 1945: + // the time was reset after the end of the WWII + dt.Set(30, Sep, year); + break; + + default: + // DST ends at 2 a.m. on the last Sunday of October + if ( !dt.SetToLastWeekDay(Sun, Oct, year) ) + { + // weirder and weirder... + wxFAIL_MSG( _T("no last Sunday in October?") ); + } + + dt += wxTimeSpan::Hours(2); + + // TODO what about timezone?? + } + break; + + default: + // assume October 26th as the end of the DST - totally bogus too + dt.Set(26, Oct, year); + } + + return dt; +} + // ---------------------------------------------------------------------------- // constructors and assignment operators // ---------------------------------------------------------------------------- @@ -553,9 +835,25 @@ wxDateTime& wxDateTime::Set(const struct tm& tm) struct tm tm2(tm); time_t timet = mktime(&tm2); - if ( timet == (time_t)(-1) ) + if ( timet == (time_t)-1 ) { - wxFAIL_MSG(_T("Invalid time")); + // mktime() rather unintuitively fails for Jan 1, 1970 if the hour is + // less than timezone - try to make it work for this case + if ( tm2.tm_year == 70 && tm2.tm_mon == 0 && tm2.tm_mday == 1 ) + { + // add timezone to make sure that date is in range + tm2.tm_sec -= GetTimeZone(); + + timet = mktime(&tm2); + if ( timet != (time_t)-1 ) + { + timet += GetTimeZone(); + + return Set(timet); + } + } + + wxFAIL_MSG( _T("mktime() failed") ); return ms_InvDateTime; } @@ -685,100 +983,112 @@ wxDateTime::Tm wxDateTime::GetTm(const TimeZone& tz) const { // we are working with local time tm = localtime(&time); + + // should never happen + wxCHECK_MSG( tm, Tm(), _T("gmtime() failed") ); } else { time += tz.GetOffset(); - tm = gmtime(&time); - } + if ( time >= 0 ) + { + tm = gmtime(&time); - // should never happen - wxCHECK_MSG( tm, Tm(), _T("gmtime() failed") ); + // should never happen + wxCHECK_MSG( tm, Tm(), _T("gmtime() failed") ); + } + else + { + tm = (struct tm *)NULL; + } + } - return Tm(*tm, tz); + if ( tm ) + { + return Tm(*tm, tz); + } + //else: use generic code below } - else - { - // remember the time and do the calculations with the date only - this - // eliminates rounding errors of the floating point arithmetics - wxLongLong timeMidnight = m_time + tz.GetOffset() * 1000; + // remember the time and do the calculations with the date only - this + // eliminates rounding errors of the floating point arithmetics - long timeOnly = (timeMidnight % MILLISECONDS_PER_DAY).ToLong(); + wxLongLong timeMidnight = m_time + tz.GetOffset() * 1000; - // we want to always have positive time and timeMidnight to be really - // the midnight before it - if ( timeOnly < 0 ) - { - timeOnly = MILLISECONDS_PER_DAY + timeOnly; - } + long timeOnly = (timeMidnight % MILLISECONDS_PER_DAY).ToLong(); - timeMidnight -= timeOnly; + // we want to always have positive time and timeMidnight to be really + // the midnight before it + if ( timeOnly < 0 ) + { + timeOnly = MILLISECONDS_PER_DAY + timeOnly; + } - // calculate the Gregorian date from JDN for the midnight of our date: - // this will yield day, month (in 1..12 range) and year + timeMidnight -= timeOnly; - // actually, this is the JDN for the noon of the previous day - long jdn = (timeMidnight / MILLISECONDS_PER_DAY).ToLong() + EPOCH_JDN; + // calculate the Gregorian date from JDN for the midnight of our date: + // this will yield day, month (in 1..12 range) and year - // CREDIT: code below is by Scott E. Lee (but bugs are mine) + // actually, this is the JDN for the noon of the previous day + long jdn = (timeMidnight / MILLISECONDS_PER_DAY).ToLong() + EPOCH_JDN; - wxASSERT_MSG( jdn > -2, _T("JDN out of range") ); + // CREDIT: code below is by Scott E. Lee (but bugs are mine) - // calculate the century - int temp = (jdn + JDN_OFFSET) * 4 - 1; - int century = temp / DAYS_PER_400_YEARS; + wxASSERT_MSG( jdn > -2, _T("JDN out of range") ); - // then the year and day of year (1 <= dayOfYear <= 366) - temp = ((temp % DAYS_PER_400_YEARS) / 4) * 4 + 3; - int year = (century * 100) + (temp / DAYS_PER_4_YEARS); - int dayOfYear = (temp % DAYS_PER_4_YEARS) / 4 + 1; + // calculate the century + int temp = (jdn + JDN_OFFSET) * 4 - 1; + int century = temp / DAYS_PER_400_YEARS; - // and finally the month and day of the month - temp = dayOfYear * 5 - 3; - int month = temp / DAYS_PER_5_MONTHS; - int day = (temp % DAYS_PER_5_MONTHS) / 5 + 1; + // then the year and day of year (1 <= dayOfYear <= 366) + temp = ((temp % DAYS_PER_400_YEARS) / 4) * 4 + 3; + int year = (century * 100) + (temp / DAYS_PER_4_YEARS); + int dayOfYear = (temp % DAYS_PER_4_YEARS) / 4 + 1; - // month is counted from March - convert to normal - if ( month < 10 ) - { - month += 3; - } - else - { - year += 1; - month -= 9; - } + // and finally the month and day of the month + temp = dayOfYear * 5 - 3; + int month = temp / DAYS_PER_5_MONTHS; + int day = (temp % DAYS_PER_5_MONTHS) / 5 + 1; + + // month is counted from March - convert to normal + if ( month < 10 ) + { + month += 3; + } + else + { + year += 1; + month -= 9; + } - // year is offset by 4800 - year -= 4800; + // year is offset by 4800 + year -= 4800; - // check that the algorithm gave us something reasonable - wxASSERT_MSG( (0 < month) && (month <= 12), _T("invalid month") ); - wxASSERT_MSG( (1 <= day) && (day < 32), _T("invalid day") ); - wxASSERT_MSG( (INT_MIN <= year) && (year <= INT_MAX), - _T("year range overflow") ); + // check that the algorithm gave us something reasonable + wxASSERT_MSG( (0 < month) && (month <= 12), _T("invalid month") ); + wxASSERT_MSG( (1 <= day) && (day < 32), _T("invalid day") ); + wxASSERT_MSG( (INT_MIN <= year) && (year <= INT_MAX), + _T("year range overflow") ); - // construct Tm from these values - Tm tm; - tm.year = (int)year; - tm.mon = (Month)(month - 1); // algorithm yields 1 for January, not 0 - tm.mday = (wxDateTime_t)day; - tm.msec = timeOnly % 1000; - timeOnly -= tm.msec; - timeOnly /= 1000; // now we have time in seconds + // construct Tm from these values + Tm tm; + tm.year = (int)year; + tm.mon = (Month)(month - 1); // algorithm yields 1 for January, not 0 + tm.mday = (wxDateTime_t)day; + tm.msec = timeOnly % 1000; + timeOnly -= tm.msec; + timeOnly /= 1000; // now we have time in seconds - tm.sec = timeOnly % 60; - timeOnly -= tm.sec; - timeOnly /= 60; // now we have time in minutes + tm.sec = timeOnly % 60; + timeOnly -= tm.sec; + timeOnly /= 60; // now we have time in minutes - tm.min = timeOnly % 60; - timeOnly -= tm.min; + tm.min = timeOnly % 60; + timeOnly -= tm.min; - tm.hour = timeOnly / 60; + tm.hour = timeOnly / 60; - return tm; - } + return tm; } wxDateTime& wxDateTime::SetYear(int year) @@ -921,9 +1231,9 @@ bool wxDateTime::SetToWeekDay(WeekDay weekday, // add advance n-1 weeks more diff += 7*(n - 1); - dt -= wxDateSpan::Days(diff); + dt += wxDateSpan::Days(diff); } - else + else // count from the end of the month { // get the last day of the month dt.SetToLastMonthDay(month, year); @@ -937,7 +1247,7 @@ bool wxDateTime::SetToWeekDay(WeekDay weekday, diff += 7; // and rewind n-1 weeks from there - diff += 7*(n - 1); + diff += 7*(-n - 1); dt -= wxDateSpan::Days(diff); } @@ -956,6 +1266,46 @@ bool wxDateTime::SetToWeekDay(WeekDay weekday, } } +wxDateTime::wxDateTime_t wxDateTime::GetDayOfYear(const TimeZone& tz) const +{ + // this array contains the cumulated number of days in all previous months + // for normal and leap years + static const wxDateTime_t cumulatedDays[2][MONTHS_IN_YEAR] = + { + { 0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334 }, + { 0, 31, 60, 91, 121, 152, 182, 213, 244, 274, 305, 335 } + }; + + Tm tm(GetTm(tz)); + + return cumulatedDays[IsLeapYear(tm.year)][tm.mon] + tm.mday; +} + +wxDateTime::wxDateTime_t wxDateTime::GetWeekOfYear(const TimeZone& tz) const +{ + // the first week of the year is the one which contains Jan, 4 (according + // to ISO standard rule), so the year day N0 = 4 + 7*W always lies in the + // week W+1. As any day N = 7*W + 4 + (N - 4)%7, it lies in the same week + // as N0 or in the next one. + + // TODO this surely may be optimized - I got confused while writing it + + wxDateTime_t nDayInYear = GetDayOfYear(tz); + + // the week day of the day lying in the first week + WeekDay wdayStart = wxDateTime(4, Jan, GetYear()).GetWeekDay(); + + wxDateTime_t week = (nDayInYear - 4) / 7 + 1; + + // notice that Sunday shoould be counted as 7, not 0 here! + if ( ((nDayInYear - 4) % 7) + (!wdayStart ? 7 : wdayStart) > 7 ) + { + week++; + } + + return week; +} + // ---------------------------------------------------------------------------- // Julian day number conversion and related stuff // ---------------------------------------------------------------------------- @@ -1001,9 +1351,15 @@ int wxDateTime::IsDST(wxDateTime::Country country) const } else { - // wxFAIL_MSG( _T("TODO") ); + int year = GetYear(); - return -1; + if ( !IsDSTApplicable(year, country) ) + { + // no DST time in this year in this country + return -1; + } + + return IsBetween(GetBeginDST(year, country), GetEndDST(year, country)); } } @@ -1038,64 +1394,111 @@ wxString wxDateTime::Format(const wxChar *format, const TimeZone& tz) const { // we are working with local time tm = localtime(&time); + + // should never happen + wxCHECK_MSG( tm, wxEmptyString, _T("localtime() failed") ); } else { time += tz.GetOffset(); - tm = gmtime(&time); - } + if ( time >= 0 ) + { + tm = gmtime(&time); - // should never happen - wxCHECK_MSG( tm, _T(""), _T("gmtime() failed") ); + // should never happen + wxCHECK_MSG( tm, wxEmptyString, _T("gmtime() failed") ); + } + else + { + tm = (struct tm *)NULL; + } + } - return CallStrftime(format, tm); - } - else - { - // use a hack and still use strftime(): make a copy of the format and - // replace all occurences of YEAR in it with some unique string not - // appearing anywhere else in it, then use strftime() to format the - // date in year YEAR and then replace YEAR back by the real year and - // the unique replacement string back with YEAR where YEAR is any year - // in the range supported by strftime() (1970 - 2037) which is equal to - // the real year modulo 28 (so the week days coincide for them) - - // find the YEAR - int yearReal = GetYear(tz); - int year = 1970 + yearReal % 28; - - wxString strYear; - strYear.Printf(_T("%d"), year); - - // find a string not occuring in format (this is surely not optimal way - // of doing it... improvements welcome!) - wxString fmt = format; - wxString replacement = (wxChar)-1; - while ( fmt.Find(replacement) != wxNOT_FOUND ) + if ( tm ) { - replacement << (wxChar)-1; + return CallStrftime(format, tm); } + //else: use generic code below + } + + // use a hack and still use strftime(): first find the YEAR which is a year + // in the strftime() range (1970 - 2038) whose Jan 1 falls on the same week + // day as the Jan 1 of the real year. Then make a copy of the format and + // replace all occurences of YEAR in it with some unique string not + // appearing anywhere else in it, then use strftime() to format the date in + // year YEAR and then replace YEAR back by the real year and the unique + // replacement string back with YEAR. Notice that "all occurences of YEAR" + // means all occurences of 4 digit as well as 2 digit form! - // replace all occurences of year with it - bool wasReplaced = fmt.Replace(strYear, replacement) > 0; + // NB: may be it would be simpler to "honestly" reimplement strftime()? - // use strftime() to format the same date but in supported year - wxDateTime dt(*this); - dt.SetYear(year); - wxString str = dt.Format(format, tz); + // find the YEAR: normally, for any year X, Jan 1 or the year X + 28 is the + // same weekday as Jan 1 of X (because the weekday advances by 1 for each + // normal X and by 2 for each leap X, hence by 5 every 4 years or by 35 + // which is 0 mod 7 every 28 years) but this rule breaks down if there are + // years between X and Y which are divisible by 4 but not leap (i.e. + // divisible by 100 but not 400), hence the correction. - // now replace the occurence of 1999 with the real year - wxString strYearReal; - strYearReal.Printf(_T("%d"), yearReal); - str.Replace(strYear, strYearReal); + int yearReal = GetYear(tz); + int year = 1970 + yearReal % 28; - // and replace back all occurences of replacement string - if ( wasReplaced ) - str.Replace(replacement, strYear); + int nCenturiesInBetween = (year / 100) - (yearReal / 100); + int nLostWeekDays = nCenturiesInBetween - (nCenturiesInBetween / 400); - return str; + // we have to gain back the "lost" weekdays... + while ( (nLostWeekDays % 7) != 0 ) + { + nLostWeekDays += year++ % 4 ? 1 : 2; + } + + // at any rate, we can't go further than 1997 + 28! + wxASSERT_MSG( year < 2030, _T("logic error in wxDateTime::Format") ); + + wxString strYear, strYear2; + strYear.Printf(_T("%d"), year); + strYear2.Printf(_T("%d"), year % 100); + + // find two strings not occuring in format (this is surely not optimal way + // of doing it... improvements welcome!) + wxString fmt = format; + wxString replacement = (wxChar)-1; + while ( fmt.Find(replacement) != wxNOT_FOUND ) + { + replacement << (wxChar)-1; + } + + wxString replacement2 = (wxChar)-2; + while ( fmt.Find(replacement) != wxNOT_FOUND ) + { + replacement << (wxChar)-2; } + + // replace all occurences of year with it + bool wasReplaced = fmt.Replace(strYear, replacement) > 0; + if ( !wasReplaced ) + wasReplaced = fmt.Replace(strYear2, replacement2) > 0; + + // use strftime() to format the same date but in supported year + wxDateTime dt(*this); + dt.SetYear(year); + wxString str = dt.Format(format, tz); + + // now replace the occurence of 1999 with the real year + wxString strYearReal, strYearReal2; + strYearReal.Printf(_T("%04d"), yearReal); + strYearReal2.Printf(_T("%02d"), yearReal % 100); + str.Replace(strYear, strYearReal); + str.Replace(strYear2, strYearReal2); + + // and replace back all occurences of replacement string + if ( wasReplaced ) + { + str.Replace(replacement2, strYear2); + str.Replace(replacement, strYear); + } + + return str; } // ============================================================================ @@ -1157,7 +1560,7 @@ wxString wxTimeSpan::Format(const wxChar *format) const break; case 'l': - tmp.Printf(_T("%03d"), GetMilliseconds()); + tmp.Printf(_T("%03d"), GetMilliseconds().GetValue()); break; case 'M': @@ -1165,7 +1568,7 @@ wxString wxTimeSpan::Format(const wxChar *format) const break; case 'S': - tmp.Printf(_T("%02d"), GetSeconds()); + tmp.Printf(_T("%02d"), GetSeconds().GetValue()); break; }