Amebis/wxWidgets
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

even more wxDateTime work (completely broken for now, but support for the

Browse Source 
full date range almost finished)


git-svn-id: https://svn.wxwidgets.org/svn/wx/wxWidgets/trunk@4793 c3d73ce0-8a6f-49c7-b76d-6d57e0e08775
This commit is contained in:
Vadim Zeitlin
1999-12-02 01:01:26 +00:00
parent f151e8b583
commit e6ec579c77
4 changed files with 350 additions and 41 deletions
Download Patch File Download Diff File Expand all files Collapse all files

30
include/wx/datetime.h
View File

@@ -331,7 +331,7 @@ public:
// instead of modifying the member fields directly!
struct Tm
{
wxDateTime_t sec, min, hour, mday;
wxDateTime_t msec, sec, min, hour, mday;
Month mon;
int year;
@@ -354,10 +354,10 @@ public:
}
// add the given number of months to the date keeping it normalized
void AddMonths(wxDateTime_t monDiff);
void AddMonths(int monDiff);
// add the given number of months to the date keeping it normalized
void AddDays(wxDateTime_t dayDiff);
void AddDays(int dayDiff);
private:
// compute the weekday from other fields
@@ -457,6 +457,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,
@@ -492,6 +495,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,
@@ -590,11 +596,12 @@ 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
@@ -899,16 +906,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
@@ -918,7 +918,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; }

40
include/wx/datetime.inl
View File

@@ -75,6 +75,11 @@ wxDateTime::wxDateTime(const Tm& tm)
Set(tm);
}
wxDateTime::wxDateTime(double jdn)
{
Set(jdn);
}
wxDateTime& wxDateTime::Set(const Tm& tm)
{
wxASSERT_MSG( tm.IsValid(), _T("invalid broken down date/time") );
@@ -257,7 +262,7 @@ wxDateTime wxDateTime::ToLocalTime(const wxDateTime::TimeZone& tz) const
}
// ----------------------------------------------------------------------------
// wxTimeSpan
// wxTimeSpan construction
// ----------------------------------------------------------------------------
wxTimeSpan::wxTimeSpan(int hours, int minutes, int seconds, int milliseconds)
@@ -272,6 +277,39 @@ wxTimeSpan::wxTimeSpan(int hours, int minutes, int seconds, int milliseconds)
m_diff += milliseconds;
}
// ----------------------------------------------------------------------------
// wxTimeSpan accessors
// ----------------------------------------------------------------------------
wxLongLong wxTimeSpan::GetSeconds() const
{
return m_diff / 1000l;
}
int wxTimeSpan::GetMinutes() const
{
return (GetSeconds() / 60l).GetLo();
}
int wxTimeSpan::GetHours() const
{
return GetMinutes() / 60;
}
int wxTimeSpan::GetDays() const
{
return GetHours() / 24;
}
int wxTimeSpan::GetWeeks() const
{
return GetDays() / 7;
}
// ----------------------------------------------------------------------------
// wxTimeSpan arithmetics
// ----------------------------------------------------------------------------
wxTimeSpan& wxTimeSpan::Add(const wxTimeSpan& diff)
{
m_diff += diff.GetValue();

35
samples/console/console.cpp
View File

@@ -32,8 +32,8 @@
//#define TEST_ARRAYS
//#define TEST_LOG
//#define TEST_STRINGS
#define TEST_THREADS
//#define TEST_TIME
//#define TEST_THREADS
#define TEST_TIME
//#define TEST_LONGLONG
// ============================================================================
@@ -187,12 +187,39 @@ static void TestTimeZones()
wxDateTime now = wxDateTime::Now();
printf("Current GMT time:\t%s\n", now.ToGMT().Format().c_str());
//printf("Unix epoch (GMT):\t%s\n", wxDateTime((time_t)0).MakeGMT().Format().c_str());
//TODO printf("Unix epoch (GMT):\t%s\n", wxDateTime((time_t)0).MakeGMT().Format().c_str());
printf("Current time in Paris:\t%s\n", now.ToTimezone(wxDateTime::CET).Format().c_str());
printf(" Moscow:\t%s\n", now.ToTimezone(wxDateTime::MSK).Format().c_str());
printf(" New York:\t%s\n", now.ToTimezone(wxDateTime::EST).Format().c_str());
}
// test some minimal support for the dates outside the standard range
static void TestTimeRange()
{
puts("\n*** wxDateTime out-of-standard-range dates test ***");
printf("JDN 0: \t%s\n",
wxDateTime(0.0).Format().c_str());
printf("Jan 1, 1AD:\t%s\n",
wxDateTime(1, wxDateTime::Jan, 1).Format().c_str());
printf("May 29, 2099:\t%s\n",
wxDateTime(29, wxDateTime::May, 2099).Format().c_str());
}
// test conversions to JDN &c
static void TestTimeJulian()
{
puts("\n*** wxDateTime to JDN test ***");
printf("JDN of current time:\t%f\n", wxDateTime::Now().GetJulianDayNumber());
printf("JDN of Jan 1, 1900: \t%f\n",
wxDateTime(1, wxDateTime::Jan, 1900).GetJulianDayNumber());
printf("JDN of Jan 1, 1BC: \t%f\n",
wxDateTime(1, wxDateTime::Jan, 0).GetJulianDayNumber());
printf("JDN 0: \t%f\n",
wxDateTime(24, wxDateTime::Nov, -4713, 12, 0, 0).GetJulianDayNumber());
}
#endif // TEST_TIME
// ----------------------------------------------------------------------------
@@ -593,6 +620,8 @@ int main(int argc, char **argv)
TestTimeStatic();
TestTimeSet();
TestTimeZones();
TestTimeRange();
TestTimeJulian();
#endif // TEST_TIME
wxUninitialize();

286
src/common/datetime.cpp
View File

@@ -44,19 +44,18 @@
// constants
// ----------------------------------------------------------------------------
// note that all these constants should be signed or we'd get some big
// surprizes with C integer arithmetics
// some trivial ones
static const int MONTHS_IN_YEAR = 12;
static const int SECONDS_IN_MINUTE = 60;
// the number of days in month in Julian/Gregorian calendar: the first line is
// for normal years, the second one is for the leap ones
static wxDateTime::wxDateTime_t gs_daysInMonth[2][MONTHS_IN_YEAR] =
{
{ 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 },
{ 31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 }
};
static const long SECONDS_PER_DAY = 86400l;
static const long MILLISECONDS_PER_DAY = 86400000l;
// this is the integral part of JDN of the midnight of Jan 1, 1970
// (i.e. JDN(Jan 1, 1970) = 2440587.5)
static const int EPOCH_JDN = 2440587;
// ----------------------------------------------------------------------------
// globals
@@ -76,7 +75,15 @@ static wxDateTime::wxDateTime_t gs_daysInMonth[2][MONTHS_IN_YEAR] =
static inline
wxDateTime::wxDateTime_t GetNumOfDaysInMonth(int year, wxDateTime::Month month)
{
return gs_daysInMonth[wxDateTime::IsLeapYear(year)][month];
// the number of days in month in Julian/Gregorian calendar: the first line
// is for normal years, the second one is for the leap ones
static wxDateTime::wxDateTime_t daysInMonth[2][MONTHS_IN_YEAR] =
{
{ 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 },
{ 31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 }
};
return daysInMonth[wxDateTime::IsLeapYear(year)][month];
}
// ensure that the timezone variable is set by calling localtime
@@ -89,7 +96,10 @@ static int GetTimeZone()
if ( !s_timezoneSet )
{
(void)localtime(0);
// just call localtime() instead of figurin out whether this system
// supports tzset(), _tzset() or something else
time_t t;
(void)localtime(&t);
s_timezoneSet = TRUE;
}
@@ -97,6 +107,46 @@ static int GetTimeZone()
return (int)timezone;
}
// return the integral part of the JDN for the midnight of the given date (to
// get the real JDN you need to add 0.5, this is, in fact, JDN of the noon of
// the previous day)
static long GetTruncatedJDN(wxDateTime::wxDateTime_t day,
wxDateTime::Month mon,
int year)
{
// CREDIT: the algorithm was taken from Peter Baum's home page
// the algorithm assumes Jan == 1
int month = mon + 1;
// we want the leap day (Feb 29) be at the end of the year, so we count
// March as the first month
if ( month < wxDateTime::Mar + 1 )
{
month += MONTHS_IN_YEAR;
year--;
}
// this table contains the number of the days before the 1st of the each
// month (in a non leap year) with the third value corresponding to March
// (and the last one to February)
static const int monthOffsets[14] =
{
0, 31, 61, 92, 122, 153, 184, 214, 245, 275, 306
};
// and now add contributions of all terms together to get the result (you'd
// better see the Web page for the description if you want to understand
// why it works (if it does :-))
return day +
// linear approximation for months
monthOffsets[month - (wxDateTime::Mar + 1)] +
// the year contribution
365*year + year/4 - year/100 + year/400 +
// 1721119.5 is the JDN of the midnight of Mar 1, year 0
1721118;
}
// this function is a wrapper around strftime(3)
static wxString CallStrftime(const wxChar *format, const tm* tm)
{
@@ -152,12 +202,13 @@ wxDateTime::Tm::Tm()
year = (wxDateTime_t)wxDateTime::Inv_Year;
mon = wxDateTime::Inv_Month;
mday = 0;
hour = min = sec = 0;
hour = min = sec = msec = 0;
wday = wxDateTime::Inv_WeekDay;
}
wxDateTime::Tm::Tm(const struct tm& tm)
{
msec = 0;
sec = tm.tm_sec;
min = tm.tm_min;
hour = tm.tm_hour;
@@ -173,7 +224,7 @@ 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)) &&
(hour < 24) && (min < 60) && (sec < 62);
(hour < 24) && (min < 60) && (sec < 62) && (msec < 1000);
}
void wxDateTime::Tm::ComputeWeekDay()
@@ -181,7 +232,7 @@ void wxDateTime::Tm::ComputeWeekDay()
wxFAIL_MSG(_T("TODO"));
}
void wxDateTime::Tm::AddMonths(wxDateTime::wxDateTime_t monDiff)
void wxDateTime::Tm::AddMonths(int monDiff)
{
// normalize the months field
while ( monDiff < -mon )
@@ -198,10 +249,10 @@ void wxDateTime::Tm::AddMonths(wxDateTime::wxDateTime_t monDiff)
mon = (wxDateTime::Month)(mon + monDiff);
wxASSERT_MSG( mon >= 0 && mon < 12, _T("logic error") );
wxASSERT_MSG( mon >= 0 && mon < MONTHS_IN_YEAR, _T("logic error") );
}
void wxDateTime::Tm::AddDays(wxDateTime::wxDateTime_t dayDiff)
void wxDateTime::Tm::AddDays(int dayDiff)
{
// normalize the days field
mday += dayDiff;
@@ -536,12 +587,25 @@ wxDateTime& wxDateTime::Set(wxDateTime_t day,
{
// do time calculations ourselves: we want to calculate the number of
// milliseconds between the given date and the epoch
wxFAIL_MSG(_T("TODO"));
// get the JDN for the midnight of this day
m_time = GetTruncatedJDN(day, month, year);
m_time -= EPOCH_JDN;
m_time *= SECONDS_PER_DAY * TIME_T_FACTOR;
Add(wxTimeSpan(hour, minute, second, millisec));
}
return *this;
}
wxDateTime& wxDateTime::Set(double jdn)
{
m_time = (jdn - 0.5 - EPOCH_JDN) * TIME_T_FACTOR;
return *this;
}
// ----------------------------------------------------------------------------
// time_t <-> broken down time conversions
// ----------------------------------------------------------------------------
@@ -563,9 +627,50 @@ wxDateTime::Tm wxDateTime::GetTm() const
}
else
{
wxFAIL_MSG(_T("TODO"));
// CREDIT: the algorithm was taken from Peter Baum's home page
return Tm();
// calculate the Gregorian date from JDN for the midnight of our date
wxLongLong timeMidnight = m_time;
long timeOnly = (m_time % MILLISECONDS_PER_DAY).GetLo();
timeMidnight -= timeOnly;
// TODO this probably could be optimised somehow...
double jdn = (timeMidnight / MILLISECONDS_PER_DAY).GetLo();
jdn += EPOCH_JDN + 0.5;
long z = jdn - 1721118.5;
double r = jdn - 1721118.5 - z;
double g = z - 0.25;
long a = g/36524.25; // number of days per year
long b = a - a / 4;
int year = (b + g) / 365.25;
long c = b + z - 365.25*year;
int month = (5*c + 456)/153;
int day = c - (153*month - 457)/5 + (r < 0.5 ? 0 : 1);
if ( month > 12 )
{
year++;
month -= 12;
}
Tm tm;
tm.year = year;
tm.mon = (Month)(month - 1); // algorithm yields 1 for January, not 0
tm.mday = 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.min = timeOnly % 60;
timeOnly -= tm.min;
tm.hour = timeOnly / 60;
return tm;
}
}
@@ -744,6 +849,29 @@ bool wxDateTime::SetToWeekDay(WeekDay weekday,
}
}
// ----------------------------------------------------------------------------
// Julian day number conversion and related stuff
// ----------------------------------------------------------------------------
double wxDateTime::GetJulianDayNumber() const
{
Tm tm(GetTm());
double result = GetTruncatedJDN(tm.mday, tm.mon, tm.year);
// add the part GetTruncatedJDN() neglected
result += 0.5;
// and now add the time: 86400 sec = 1 JDN
return result + ((double)(60*(60*tm.hour + tm.min) + tm.sec)) / 86400;
}
double wxDateTime::GetRataDie() const
{
// March 1 of the year 0 is Rata Die day -306 and JDN 1721119.5
return GetJulianDayNumber() - 1721119.5 - 306;
}
// ----------------------------------------------------------------------------
// timezone stuff
// ----------------------------------------------------------------------------
@@ -771,6 +899,8 @@ wxDateTime& wxDateTime::MakeLocalTime(const TimeZone& tz)
wxString wxDateTime::Format(const wxChar *format) const
{
wxCHECK_MSG( format, _T(""), _T("NULL format in wxDateTime::Format") );
time_t time = GetTicks();
if ( time != (time_t)-1 )
{
@@ -784,9 +914,48 @@ wxString wxDateTime::Format(const wxChar *format) const
}
else
{
wxFAIL_MSG(_T("TODO"));
// 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)
return _T("");
// find the YEAR
int yearReal = GetYear();
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 )
{
replacement << (wxChar)-1;
}
// replace all occurences of year with it
bool wasReplaced = fmt.Replace(strYear, replacement) > 0;
// use strftime() to format the same date but in supported year
wxDateTime dt(*this);
dt.SetYear(year);
wxString str = dt.Format(format);
// now replace the occurence of 1999 with the real year
wxString strYearReal;
strYearReal.Printf(_T("%d"), yearReal);
str.Replace(strYear, strYearReal);
// and replace back all occurences of replacement string
if ( wasReplaced )
str.Replace(replacement, strYear);
return str;
}
}
@@ -794,11 +963,84 @@ wxString wxDateTime::Format(const wxChar *format) const
// wxTimeSpan
// ============================================================================
// not all strftime(3) format specifiers make sense here because, for example,
// a time span doesn't have a year nor a timezone
//
// Here are the ones which are supported (all of them are supported by strftime
// as well):
// %H hour in 24 hour format
// %M minute (00 - 59)
// %S second (00 - 59)
// %% percent sign
//
// Also, for MFC CTimeSpan compatibility, we support
// %D number of days
//
// And, to be better than MFC :-), we also have
// %E number of wEeks
// %l milliseconds (000 - 999)
wxString wxTimeSpan::Format(const wxChar *format) const
{
wxFAIL_MSG( _T("TODO") );
wxCHECK_MSG( format, _T(""), _T("NULL format in wxTimeSpan::Format") );
wxString str;
str.Alloc(strlen(format));
for ( const wxChar *pch = format; pch; pch++ )
{
wxChar ch = *pch;
if ( ch == '%' )
{
wxString tmp;
ch = *pch++;
switch ( ch )
{
default:
wxFAIL_MSG( _T("invalid format character") );
// fall through
case '%':
// will get to str << ch below
break;
case 'D':
tmp.Printf(_T("%d"), GetDays());
break;
case 'E':
tmp.Printf(_T("%d"), GetWeeks());
break;
case 'H':
tmp.Printf(_T("%02d"), GetHours());
break;
case 'l':
tmp.Printf(_T("%03d"), GetMilliseconds());
break;
case 'M':
tmp.Printf(_T("%02d"), GetMinutes());
break;
case 'S':
tmp.Printf(_T("%02d"), GetSeconds());
break;
}
if ( !!tmp )
{
str += tmp;
// skip str += ch below
continue;
}
}
str += ch;
}
return str;
}