]>
Commit | Line | Data |
---|---|---|
0979c962 VZ |
1 | ///////////////////////////////////////////////////////////////////////////// |
2 | // Name: wx/datetime.h | |
3 | // Purpose: declarations of time/date related classes (wxDateTime, | |
4 | // wxTimeSpan) | |
5 | // Author: Vadim Zeitlin | |
6 | // Modified by: | |
7 | // Created: 10.02.99 | |
8 | // RCS-ID: $Id$ | |
9 | // Copyright: (c) 1998 Vadim Zeitlin <zeitlin@dptmaths.ens-cachan.fr> | |
65571936 | 10 | // Licence: wxWindows licence |
0979c962 VZ |
11 | ///////////////////////////////////////////////////////////////////////////// |
12 | ||
2f02cb89 VZ |
13 | #ifndef _WX_DATETIME_H |
14 | #define _WX_DATETIME_H | |
0979c962 | 15 | |
2b5f62a0 VZ |
16 | #include "wx/defs.h" |
17 | ||
e421922f VZ |
18 | #if wxUSE_DATETIME |
19 | ||
9b4da627 VZ |
20 | #ifdef __WXWINCE__ |
21 | #include "wx/msw/wince/time.h" | |
22 | #elif !defined(__WXPALMOS5__) | |
23 | #include <time.h> | |
24 | #endif // OS | |
5e967044 | 25 | |
b76b015e | 26 | #include <limits.h> // for INT_MIN |
0979c962 VZ |
27 | |
28 | #include "wx/longlong.h" | |
254696bb | 29 | #include "wx/anystr.h" |
0979c962 | 30 | |
b5dbe15d VS |
31 | class WXDLLIMPEXP_FWD_BASE wxDateTime; |
32 | class WXDLLIMPEXP_FWD_BASE wxTimeSpan; | |
33 | class WXDLLIMPEXP_FWD_BASE wxDateSpan; | |
154014d6 VZ |
34 | #ifdef __WXMSW__ |
35 | struct _SYSTEMTIME; | |
36 | #endif | |
0979c962 | 37 | |
df5168c4 | 38 | #include "wx/dynarray.h" |
2f02cb89 | 39 | |
5b781a67 SC |
40 | // not all c-runtimes are based on 1/1/1970 being (time_t) 0 |
41 | // set this to the corresponding value in seconds 1/1/1970 has on your | |
42 | // systems c-runtime | |
43 | ||
92f89387 SC |
44 | #define WX_TIME_BASE_OFFSET 0 |
45 | ||
0979c962 | 46 | /* |
f6bcfd97 | 47 | * TODO |
0979c962 | 48 | * |
299fcbfe | 49 | * + 1. Time zones with minutes (make TimeZone a class) |
4f6aed9c | 50 | * ? 2. getdate() function like under Solaris |
299fcbfe | 51 | * + 3. text conversion for wxDateSpan |
4f6aed9c VZ |
52 | * + 4. pluggable modules for the workdays calculations |
53 | * 5. wxDateTimeHolidayAuthority for Easter and other christian feasts | |
0979c962 VZ |
54 | */ |
55 | ||
56 | /* | |
299fcbfe | 57 | The three (main) classes declared in this header represent: |
0979c962 VZ |
58 | |
59 | 1. An absolute moment in the time (wxDateTime) | |
60 | 2. A difference between two moments in the time, positive or negative | |
61 | (wxTimeSpan) | |
62 | 3. A logical difference between two dates expressed in | |
63 | years/months/weeks/days (wxDateSpan) | |
64 | ||
65 | The following arithmetic operations are permitted (all others are not): | |
66 | ||
67 | addition | |
68 | -------- | |
69 | ||
70 | wxDateTime + wxTimeSpan = wxDateTime | |
71 | wxDateTime + wxDateSpan = wxDateTime | |
72 | wxTimeSpan + wxTimeSpan = wxTimeSpan | |
73 | wxDateSpan + wxDateSpan = wxDateSpan | |
74 | ||
f6bcfd97 | 75 | subtraction |
0979c962 VZ |
76 | ------------ |
77 | wxDateTime - wxDateTime = wxTimeSpan | |
cd0b1709 VZ |
78 | wxDateTime - wxTimeSpan = wxDateTime |
79 | wxDateTime - wxDateSpan = wxDateTime | |
0979c962 VZ |
80 | wxTimeSpan - wxTimeSpan = wxTimeSpan |
81 | wxDateSpan - wxDateSpan = wxDateSpan | |
82 | ||
83 | multiplication | |
84 | -------------- | |
85 | wxTimeSpan * number = wxTimeSpan | |
cd0b1709 | 86 | number * wxTimeSpan = wxTimeSpan |
0979c962 | 87 | wxDateSpan * number = wxDateSpan |
cd0b1709 | 88 | number * wxDateSpan = wxDateSpan |
0979c962 VZ |
89 | |
90 | unitary minus | |
91 | ------------- | |
92 | -wxTimeSpan = wxTimeSpan | |
93 | -wxDateSpan = wxDateSpan | |
cd0b1709 VZ |
94 | |
95 | For each binary operation OP (+, -, *) we have the following operatorOP=() as | |
f6bcfd97 | 96 | a method and the method with a symbolic name OPER (Add, Subtract, Multiply) |
cd0b1709 VZ |
97 | as a synonym for it and another const method with the same name which returns |
98 | the changed copy of the object and operatorOP() as a global function which is | |
99 | implemented in terms of the const version of OPEN. For the unary - we have | |
100 | operator-() as a method, Neg() as synonym for it and Negate() which returns | |
101 | the copy of the object with the changed sign. | |
0979c962 VZ |
102 | */ |
103 | ||
2ef31e80 VZ |
104 | // an invalid/default date time object which may be used as the default |
105 | // argument for arguments of type wxDateTime; it is also returned by all | |
106 | // functions returning wxDateTime on failure (this is why it is also called | |
107 | // wxInvalidDateTime) | |
b5dbe15d | 108 | class WXDLLIMPEXP_FWD_BASE wxDateTime; |
2ef31e80 | 109 | |
a243da29 PC |
110 | extern WXDLLIMPEXP_DATA_BASE(const char) wxDefaultDateTimeFormat[]; |
111 | extern WXDLLIMPEXP_DATA_BASE(const char) wxDefaultTimeSpanFormat[]; | |
bddd7a8d | 112 | extern WXDLLIMPEXP_DATA_BASE(const wxDateTime) wxDefaultDateTime; |
1aaf88d2 | 113 | |
2ef31e80 VZ |
114 | #define wxInvalidDateTime wxDefaultDateTime |
115 | ||
48fd6e9d FM |
116 | |
117 | // ---------------------------------------------------------------------------- | |
118 | // conditional compilation | |
119 | // ---------------------------------------------------------------------------- | |
120 | ||
dd36b5a3 VZ |
121 | // if configure detected strftime(), we have it too |
122 | #ifdef HAVE_STRFTIME | |
123 | #define wxHAS_STRFTIME | |
124 | // suppose everyone else has strftime except Win CE unless VC8 is used | |
125 | #elif !defined(__WXWINCE__) || defined(__VISUALC8__) | |
126 | #define wxHAS_STRFTIME | |
48fd6e9d FM |
127 | #endif |
128 | ||
0979c962 | 129 | // ---------------------------------------------------------------------------- |
cd0b1709 | 130 | // wxDateTime represents an absolute moment in the time |
0979c962 | 131 | // ---------------------------------------------------------------------------- |
b76b015e | 132 | |
bddd7a8d | 133 | class WXDLLIMPEXP_BASE wxDateTime |
0979c962 VZ |
134 | { |
135 | public: | |
136 | // types | |
137 | // ------------------------------------------------------------------------ | |
138 | ||
cd0b1709 VZ |
139 | // a small unsigned integer type for storing things like minutes, |
140 | // seconds &c. It should be at least short (i.e. not char) to contain | |
141 | // the number of milliseconds - it may also be 'int' because there is | |
142 | // no size penalty associated with it in our code, we don't store any | |
143 | // data in this format | |
0979c962 VZ |
144 | typedef unsigned short wxDateTime_t; |
145 | ||
f0f951fa VZ |
146 | // constants |
147 | // ------------------------------------------------------------------------ | |
148 | ||
0979c962 | 149 | // the timezones |
b76b015e | 150 | enum TZ |
0979c962 VZ |
151 | { |
152 | // the time in the current time zone | |
153 | Local, | |
154 | ||
4c51a665 | 155 | // zones from GMT (= Greenwich Mean Time): they're guaranteed to be |
0979c962 VZ |
156 | // consequent numbers, so writing something like `GMT0 + offset' is |
157 | // safe if abs(offset) <= 12 | |
158 | ||
159 | // underscore stands for minus | |
160 | GMT_12, GMT_11, GMT_10, GMT_9, GMT_8, GMT_7, | |
161 | GMT_6, GMT_5, GMT_4, GMT_3, GMT_2, GMT_1, | |
162 | GMT0, | |
163 | GMT1, GMT2, GMT3, GMT4, GMT5, GMT6, | |
34f90a1c | 164 | GMT7, GMT8, GMT9, GMT10, GMT11, GMT12, GMT13, |
0979c962 VZ |
165 | // Note that GMT12 and GMT_12 are not the same: there is a difference |
166 | // of exactly one day between them | |
167 | ||
fcc3d7cb VZ |
168 | // some symbolic names for TZ |
169 | ||
170 | // Europe | |
171 | WET = GMT0, // Western Europe Time | |
172 | WEST = GMT1, // Western Europe Summer Time | |
173 | CET = GMT1, // Central Europe Time | |
174 | CEST = GMT2, // Central Europe Summer Time | |
175 | EET = GMT2, // Eastern Europe Time | |
176 | EEST = GMT3, // Eastern Europe Summer Time | |
177 | MSK = GMT3, // Moscow Time | |
178 | MSD = GMT4, // Moscow Summer Time | |
179 | ||
180 | // US and Canada | |
181 | AST = GMT_4, // Atlantic Standard Time | |
182 | ADT = GMT_3, // Atlantic Daylight Time | |
183 | EST = GMT_5, // Eastern Standard Time | |
184 | EDT = GMT_4, // Eastern Daylight Saving Time | |
185 | CST = GMT_6, // Central Standard Time | |
186 | CDT = GMT_5, // Central Daylight Saving Time | |
187 | MST = GMT_7, // Mountain Standard Time | |
188 | MDT = GMT_6, // Mountain Daylight Saving Time | |
189 | PST = GMT_8, // Pacific Standard Time | |
190 | PDT = GMT_7, // Pacific Daylight Saving Time | |
191 | HST = GMT_10, // Hawaiian Standard Time | |
192 | AKST = GMT_9, // Alaska Standard Time | |
193 | AKDT = GMT_8, // Alaska Daylight Saving Time | |
194 | ||
195 | // Australia | |
196 | ||
197 | A_WST = GMT8, // Western Standard Time | |
34f90a1c | 198 | A_CST = GMT13 + 1, // Central Standard Time (+9.5) |
fcc3d7cb VZ |
199 | A_EST = GMT10, // Eastern Standard Time |
200 | A_ESST = GMT11, // Eastern Summer Time | |
201 | ||
34f90a1c VZ |
202 | // New Zealand |
203 | NZST = GMT12, // Standard Time | |
204 | NZDT = GMT13, // Daylight Saving Time | |
205 | ||
fcc3d7cb VZ |
206 | // TODO add more symbolic timezone names here |
207 | ||
208 | // Universal Coordinated Time = the new and politically correct name | |
209 | // for GMT | |
0979c962 | 210 | UTC = GMT0 |
0979c962 VZ |
211 | }; |
212 | ||
213 | // the calendar systems we know about: notice that it's valid (for | |
214 | // this classes purpose anyhow) to work with any of these calendars | |
215 | // even with the dates before the historical appearance of the | |
216 | // calendar | |
217 | enum Calendar | |
218 | { | |
219 | Gregorian, // current calendar | |
220 | Julian // calendar in use since -45 until the 1582 (or later) | |
221 | ||
222 | // TODO Hebrew, Chinese, Maya, ... (just kidding) (or then may be not?) | |
223 | }; | |
224 | ||
225 | // these values only are used to identify the different dates of | |
226 | // adoption of the Gregorian calendar (see IsGregorian()) | |
227 | // | |
228 | // All data and comments taken verbatim from "The Calendar FAQ (v 2.0)" | |
e9670814 | 229 | // by Claus Tøndering, http://www.pip.dknet.dk/~c-t/calendar.html |
0979c962 VZ |
230 | // except for the comments "we take". |
231 | // | |
232 | // Symbol "->" should be read as "was followed by" in the comments | |
233 | // which follow. | |
234 | enum GregorianAdoption | |
235 | { | |
236 | Gr_Unknown, // no data for this country or it's too uncertain to use | |
237 | Gr_Standard, // on the day 0 of Gregorian calendar: 15 Oct 1582 | |
238 | ||
239 | Gr_Alaska, // Oct 1867 when Alaska became part of the USA | |
240 | Gr_Albania, // Dec 1912 | |
241 | ||
242 | Gr_Austria = Gr_Unknown, // Different regions on different dates | |
243 | Gr_Austria_Brixen, // 5 Oct 1583 -> 16 Oct 1583 | |
244 | Gr_Austria_Salzburg = Gr_Austria_Brixen, | |
245 | Gr_Austria_Tyrol = Gr_Austria_Brixen, | |
246 | Gr_Austria_Carinthia, // 14 Dec 1583 -> 25 Dec 1583 | |
247 | Gr_Austria_Styria = Gr_Austria_Carinthia, | |
248 | ||
249 | Gr_Belgium, // Then part of the Netherlands | |
250 | ||
251 | Gr_Bulgaria = Gr_Unknown, // Unknown precisely (from 1915 to 1920) | |
252 | Gr_Bulgaria_1, // 18 Mar 1916 -> 1 Apr 1916 | |
253 | Gr_Bulgaria_2, // 31 Mar 1916 -> 14 Apr 1916 | |
254 | Gr_Bulgaria_3, // 3 Sep 1920 -> 17 Sep 1920 | |
255 | ||
256 | Gr_Canada = Gr_Unknown, // Different regions followed the changes in | |
257 | // Great Britain or France | |
258 | ||
259 | Gr_China = Gr_Unknown, // Different authorities say: | |
260 | Gr_China_1, // 18 Dec 1911 -> 1 Jan 1912 | |
261 | Gr_China_2, // 18 Dec 1928 -> 1 Jan 1929 | |
262 | ||
263 | Gr_Czechoslovakia, // (Bohemia and Moravia) 6 Jan 1584 -> 17 Jan 1584 | |
264 | Gr_Denmark, // (including Norway) 18 Feb 1700 -> 1 Mar 1700 | |
265 | Gr_Egypt, // 1875 | |
266 | Gr_Estonia, // 1918 | |
267 | Gr_Finland, // Then part of Sweden | |
268 | ||
269 | Gr_France, // 9 Dec 1582 -> 20 Dec 1582 | |
270 | Gr_France_Alsace, // 4 Feb 1682 -> 16 Feb 1682 | |
271 | Gr_France_Lorraine, // 16 Feb 1760 -> 28 Feb 1760 | |
272 | Gr_France_Strasbourg, // February 1682 | |
273 | ||
274 | Gr_Germany = Gr_Unknown, // Different states on different dates: | |
275 | Gr_Germany_Catholic, // 1583-1585 (we take 1584) | |
276 | Gr_Germany_Prussia, // 22 Aug 1610 -> 2 Sep 1610 | |
277 | Gr_Germany_Protestant, // 18 Feb 1700 -> 1 Mar 1700 | |
278 | ||
279 | Gr_GreatBritain, // 2 Sep 1752 -> 14 Sep 1752 (use 'cal(1)') | |
280 | ||
281 | Gr_Greece, // 9 Mar 1924 -> 23 Mar 1924 | |
282 | Gr_Hungary, // 21 Oct 1587 -> 1 Nov 1587 | |
283 | Gr_Ireland = Gr_GreatBritain, | |
284 | Gr_Italy = Gr_Standard, | |
285 | ||
286 | Gr_Japan = Gr_Unknown, // Different authorities say: | |
287 | Gr_Japan_1, // 19 Dec 1872 -> 1 Jan 1873 | |
288 | Gr_Japan_2, // 19 Dec 1892 -> 1 Jan 1893 | |
289 | Gr_Japan_3, // 18 Dec 1918 -> 1 Jan 1919 | |
290 | ||
291 | Gr_Latvia, // 1915-1918 (we take 1915) | |
292 | Gr_Lithuania, // 1915 | |
293 | Gr_Luxemburg, // 14 Dec 1582 -> 25 Dec 1582 | |
294 | Gr_Netherlands = Gr_Belgium, // (including Belgium) 1 Jan 1583 | |
295 | ||
296 | // this is too weird to take into account: the Gregorian calendar was | |
297 | // introduced twice in Groningen, first time 28 Feb 1583 was followed | |
298 | // by 11 Mar 1583, then it has gone back to Julian in the summer of | |
299 | // 1584 and then 13 Dec 1700 -> 12 Jan 1701 - which is | |
300 | // the date we take here | |
301 | Gr_Netherlands_Groningen, // 13 Dec 1700 -> 12 Jan 1701 | |
302 | Gr_Netherlands_Gelderland, // 30 Jun 1700 -> 12 Jul 1700 | |
303 | Gr_Netherlands_Utrecht, // (and Overijssel) 30 Nov 1700->12 Dec 1700 | |
304 | Gr_Netherlands_Friesland, // (and Drenthe) 31 Dec 1700 -> 12 Jan 1701 | |
305 | ||
306 | Gr_Norway = Gr_Denmark, // Then part of Denmark | |
307 | Gr_Poland = Gr_Standard, | |
308 | Gr_Portugal = Gr_Standard, | |
309 | Gr_Romania, // 31 Mar 1919 -> 14 Apr 1919 | |
310 | Gr_Russia, // 31 Jan 1918 -> 14 Feb 1918 | |
311 | Gr_Scotland = Gr_GreatBritain, | |
312 | Gr_Spain = Gr_Standard, | |
313 | ||
314 | // Sweden has a curious history. Sweden decided to make a gradual | |
315 | // change from the Julian to the Gregorian calendar. By dropping every | |
316 | // leap year from 1700 through 1740 the eleven superfluous days would | |
317 | // be omitted and from 1 Mar 1740 they would be in sync with the | |
318 | // Gregorian calendar. (But in the meantime they would be in sync with | |
319 | // nobody!) | |
320 | // | |
321 | // So 1700 (which should have been a leap year in the Julian calendar) | |
322 | // was not a leap year in Sweden. However, by mistake 1704 and 1708 | |
323 | // became leap years. This left Sweden out of synchronisation with | |
324 | // both the Julian and the Gregorian world, so they decided to go back | |
325 | // to the Julian calendar. In order to do this, they inserted an extra | |
326 | // day in 1712, making that year a double leap year! So in 1712, | |
327 | // February had 30 days in Sweden. | |
328 | // | |
329 | // Later, in 1753, Sweden changed to the Gregorian calendar by | |
330 | // dropping 11 days like everyone else. | |
331 | Gr_Sweden = Gr_Finland, // 17 Feb 1753 -> 1 Mar 1753 | |
332 | ||
333 | Gr_Switzerland = Gr_Unknown,// Different cantons used different dates | |
334 | Gr_Switzerland_Catholic, // 1583, 1584 or 1597 (we take 1584) | |
335 | Gr_Switzerland_Protestant, // 31 Dec 1700 -> 12 Jan 1701 | |
336 | ||
337 | Gr_Turkey, // 1 Jan 1927 | |
338 | Gr_USA = Gr_GreatBritain, | |
339 | Gr_Wales = Gr_GreatBritain, | |
340 | Gr_Yugoslavia // 1919 | |
341 | }; | |
342 | ||
343 | // the country parameter is used so far for calculating the start and | |
344 | // the end of DST period and for deciding whether the date is a work | |
345 | // day or not | |
346 | // | |
347 | // TODO move this to intl.h | |
5e967044 JS |
348 | |
349 | // Required for WinCE | |
350 | #ifdef USA | |
351 | #undef USA | |
352 | #endif | |
353 | ||
0979c962 VZ |
354 | enum Country |
355 | { | |
356 | Country_Unknown, // no special information for this country | |
357 | Country_Default, // set the default country with SetCountry() method | |
239446b4 | 358 | // or use the default country with any other |
0979c962 VZ |
359 | |
360 | // TODO add more countries (for this we must know about DST and/or | |
361 | // holidays for this country) | |
239446b4 VZ |
362 | |
363 | // Western European countries: we assume that they all follow the same | |
364 | // DST rules (true or false?) | |
365 | Country_WesternEurope_Start, | |
366 | Country_EEC = Country_WesternEurope_Start, | |
0979c962 | 367 | France, |
239446b4 VZ |
368 | Germany, |
369 | UK, | |
370 | Country_WesternEurope_End = UK, | |
371 | ||
372 | Russia, | |
0979c962 VZ |
373 | USA |
374 | }; | |
0979c962 VZ |
375 | // symbolic names for the months |
376 | enum Month | |
377 | { | |
378 | Jan, Feb, Mar, Apr, May, Jun, Jul, Aug, Sep, Oct, Nov, Dec, Inv_Month | |
379 | }; | |
380 | ||
381 | // symbolic names for the weekdays | |
382 | enum WeekDay | |
383 | { | |
384 | Sun, Mon, Tue, Wed, Thu, Fri, Sat, Inv_WeekDay | |
385 | }; | |
386 | ||
387 | // invalid value for the year | |
388 | enum Year | |
389 | { | |
b76b015e VZ |
390 | Inv_Year = SHRT_MIN // should hold in wxDateTime_t |
391 | }; | |
392 | ||
f0f951fa VZ |
393 | // flags for GetWeekDayName and GetMonthName |
394 | enum NameFlags | |
395 | { | |
396 | Name_Full = 0x01, // return full name | |
397 | Name_Abbr = 0x02 // return abbreviated name | |
398 | }; | |
399 | ||
9d9b7755 VZ |
400 | // flags for GetWeekOfYear and GetWeekOfMonth |
401 | enum WeekFlags | |
402 | { | |
403 | Default_First, // Sunday_First for US, Monday_First for the rest | |
404 | Monday_First, // week starts with a Monday | |
405 | Sunday_First // week starts with a Sunday | |
406 | }; | |
407 | ||
b76b015e VZ |
408 | // helper classes |
409 | // ------------------------------------------------------------------------ | |
410 | ||
299fcbfe VZ |
411 | // a class representing a time zone: basicly, this is just an offset |
412 | // (in seconds) from GMT | |
bddd7a8d | 413 | class WXDLLIMPEXP_BASE TimeZone |
299fcbfe VZ |
414 | { |
415 | public: | |
416 | TimeZone(TZ tz); | |
1cf57808 VZ |
417 | |
418 | // create time zone object with the given offset | |
419 | TimeZone(long offset = 0) { m_offset = offset; } | |
420 | ||
421 | static TimeZone Make(long offset) | |
422 | { | |
423 | TimeZone tz; | |
424 | tz.m_offset = offset; | |
425 | return tz; | |
426 | } | |
299fcbfe | 427 | |
cd0b1709 | 428 | long GetOffset() const { return m_offset; } |
299fcbfe VZ |
429 | |
430 | private: | |
431 | // offset for this timezone from GMT in seconds | |
cd0b1709 | 432 | long m_offset; |
299fcbfe VZ |
433 | }; |
434 | ||
b76b015e VZ |
435 | // standard struct tm is limited to the years from 1900 (because |
436 | // tm_year field is the offset from 1900), so we use our own struct | |
437 | // instead to represent broken down time | |
fcc3d7cb VZ |
438 | // |
439 | // NB: this struct should always be kept normalized (i.e. mon should | |
440 | // be < 12, 1 <= day <= 31 &c), so use AddMonths(), AddDays() | |
441 | // instead of modifying the member fields directly! | |
bddd7a8d | 442 | struct WXDLLIMPEXP_BASE Tm |
b76b015e | 443 | { |
5ed8879e VZ |
444 | wxDateTime_t msec, sec, min, hour, |
445 | mday, // Day of the month in 1..31 range. | |
446 | yday; // Day of the year in 0..365 range. | |
fcc3d7cb VZ |
447 | Month mon; |
448 | int year; | |
b76b015e VZ |
449 | |
450 | // default ctor inits the object to an invalid value | |
451 | Tm(); | |
452 | ||
299fcbfe VZ |
453 | // ctor from struct tm and the timezone |
454 | Tm(const struct tm& tm, const TimeZone& tz); | |
b76b015e VZ |
455 | |
456 | // check that the given date/time is valid (in Gregorian calendar) | |
457 | bool IsValid() const; | |
458 | ||
459 | // get the week day | |
460 | WeekDay GetWeekDay() // not const because wday may be changed | |
461 | { | |
462 | if ( wday == Inv_WeekDay ) | |
463 | ComputeWeekDay(); | |
464 | ||
465 | return (WeekDay)wday; | |
466 | } | |
467 | ||
fcc3d7cb | 468 | // add the given number of months to the date keeping it normalized |
e6ec579c | 469 | void AddMonths(int monDiff); |
fcc3d7cb VZ |
470 | |
471 | // add the given number of months to the date keeping it normalized | |
e6ec579c | 472 | void AddDays(int dayDiff); |
fcc3d7cb | 473 | |
b76b015e VZ |
474 | private: |
475 | // compute the weekday from other fields | |
476 | void ComputeWeekDay(); | |
477 | ||
299fcbfe VZ |
478 | // the timezone we correspond to |
479 | TimeZone m_tz; | |
480 | ||
5ed8879e VZ |
481 | // This value can only be accessed via GetWeekDay() and not directly |
482 | // because it's not always computed when creating this object and may | |
483 | // need to be calculated on demand. | |
484 | wxDateTime_t wday; | |
b76b015e VZ |
485 | }; |
486 | ||
0979c962 VZ |
487 | // static methods |
488 | // ------------------------------------------------------------------------ | |
489 | ||
490 | // set the current country | |
491 | static void SetCountry(Country country); | |
492 | // get the current country | |
239446b4 VZ |
493 | static Country GetCountry(); |
494 | ||
68379eaf | 495 | // return true if the country is a West European one (in practice, |
239446b4 VZ |
496 | // this means that the same DST rules as for EEC apply) |
497 | static bool IsWestEuropeanCountry(Country country = Country_Default); | |
0979c962 VZ |
498 | |
499 | // return the current year | |
500 | static int GetCurrentYear(Calendar cal = Gregorian); | |
501 | ||
502 | // convert the year as returned by wxDateTime::GetYear() to a year | |
503 | // suitable for BC/AD notation. The difference is that BC year 1 | |
504 | // corresponds to the year 0 (while BC year 0 didn't exist) and AD | |
505 | // year N is just year N. | |
506 | static int ConvertYearToBC(int year); | |
507 | ||
508 | // return the current month | |
509 | static Month GetCurrentMonth(Calendar cal = Gregorian); | |
510 | ||
68379eaf | 511 | // returns true if the given year is a leap year in the given calendar |
2f02cb89 VZ |
512 | static bool IsLeapYear(int year = Inv_Year, Calendar cal = Gregorian); |
513 | ||
514 | // get the century (19 for 1999, 20 for 2000 and -5 for 492 BC) | |
a333edbd | 515 | static int GetCentury(int year); |
0979c962 | 516 | |
b76b015e VZ |
517 | // returns the number of days in this year (356 or 355 for Gregorian |
518 | // calendar usually :-) | |
0979c962 VZ |
519 | static wxDateTime_t GetNumberOfDays(int year, Calendar cal = Gregorian); |
520 | ||
521 | // get the number of the days in the given month (default value for | |
522 | // the year means the current one) | |
523 | static wxDateTime_t GetNumberOfDays(Month month, | |
524 | int year = Inv_Year, | |
525 | Calendar cal = Gregorian); | |
526 | ||
e538985e | 527 | |
b76b015e VZ |
528 | // get the full (default) or abbreviated month name in the current |
529 | // locale, returns empty string on error | |
f0f951fa VZ |
530 | static wxString GetMonthName(Month month, |
531 | NameFlags flags = Name_Full); | |
0979c962 | 532 | |
e538985e VZ |
533 | // get the standard English full (default) or abbreviated month name |
534 | static wxString GetEnglishMonthName(Month month, | |
535 | NameFlags flags = Name_Full); | |
536 | ||
b76b015e VZ |
537 | // get the full (default) or abbreviated weekday name in the current |
538 | // locale, returns empty string on error | |
f0f951fa VZ |
539 | static wxString GetWeekDayName(WeekDay weekday, |
540 | NameFlags flags = Name_Full); | |
541 | ||
e538985e VZ |
542 | // get the standard English full (default) or abbreviated weekday name |
543 | static wxString GetEnglishWeekDayName(WeekDay weekday, | |
544 | NameFlags flags = Name_Full); | |
545 | ||
f0f951fa VZ |
546 | // get the AM and PM strings in the current locale (may be empty) |
547 | static void GetAmPmStrings(wxString *am, wxString *pm); | |
0979c962 | 548 | |
68379eaf | 549 | // return true if the given country uses DST for this year |
239446b4 VZ |
550 | static bool IsDSTApplicable(int year = Inv_Year, |
551 | Country country = Country_Default); | |
552 | ||
0979c962 VZ |
553 | // get the beginning of DST for this year, will return invalid object |
554 | // if no DST applicable in this year. The default value of the | |
555 | // parameter means to take the current year. | |
239446b4 VZ |
556 | static wxDateTime GetBeginDST(int year = Inv_Year, |
557 | Country country = Country_Default); | |
0979c962 VZ |
558 | // get the end of DST for this year, will return invalid object |
559 | // if no DST applicable in this year. The default value of the | |
560 | // parameter means to take the current year. | |
239446b4 VZ |
561 | static wxDateTime GetEndDST(int year = Inv_Year, |
562 | Country country = Country_Default); | |
0979c962 | 563 | |
b76b015e VZ |
564 | // return the wxDateTime object for the current time |
565 | static inline wxDateTime Now(); | |
566 | ||
f6bcfd97 BP |
567 | // return the wxDateTime object for the current time with millisecond |
568 | // precision (if available on this platform) | |
569 | static wxDateTime UNow(); | |
570 | ||
cd0b1709 VZ |
571 | // return the wxDateTime object for today midnight: i.e. as Now() but |
572 | // with time set to 0 | |
573 | static inline wxDateTime Today(); | |
574 | ||
0979c962 VZ |
575 | // constructors: you should test whether the constructor succeeded with |
576 | // IsValid() function. The values Inv_Month and Inv_Year for the | |
577 | // parameters mean take current month and/or year values. | |
578 | // ------------------------------------------------------------------------ | |
579 | ||
580 | // default ctor does not initialize the object, use Set()! | |
4bd53224 | 581 | wxDateTime() { m_time = wxLongLong(wxINT32_MIN, 0); } |
0979c962 VZ |
582 | |
583 | // from time_t: seconds since the Epoch 00:00:00 UTC, Jan 1, 1970) | |
16ee521a DW |
584 | #if (!(defined(__VISAGECPP__) && __IBMCPP__ >= 400)) |
585 | // VA C++ confuses this with wxDateTime(double jdn) thinking it is a duplicate declaration | |
0979c962 | 586 | inline wxDateTime(time_t timet); |
16ee521a | 587 | #endif |
b76b015e | 588 | // from broken down time/date (only for standard Unix range) |
0979c962 | 589 | inline wxDateTime(const struct tm& tm); |
b76b015e VZ |
590 | // from broken down time/date (any range) |
591 | inline wxDateTime(const Tm& tm); | |
0979c962 | 592 | |
e6ec579c VZ |
593 | // from JDN (beware of rounding errors) |
594 | inline wxDateTime(double jdn); | |
595 | ||
0979c962 VZ |
596 | // from separate values for each component, date set to today |
597 | inline wxDateTime(wxDateTime_t hour, | |
598 | wxDateTime_t minute = 0, | |
599 | wxDateTime_t second = 0, | |
600 | wxDateTime_t millisec = 0); | |
601 | // from separate values for each component with explicit date | |
b76b015e | 602 | inline wxDateTime(wxDateTime_t day, // day of the month |
33ac7e6f | 603 | Month month, |
0979c962 VZ |
604 | int year = Inv_Year, // 1999, not 99 please! |
605 | wxDateTime_t hour = 0, | |
606 | wxDateTime_t minute = 0, | |
607 | wxDateTime_t second = 0, | |
608 | wxDateTime_t millisec = 0); | |
154014d6 VZ |
609 | #ifdef __WXMSW__ |
610 | wxDateTime(const struct _SYSTEMTIME& st) | |
611 | { | |
612 | SetFromMSWSysTime(st); | |
613 | } | |
614 | #endif | |
0979c962 VZ |
615 | |
616 | // default copy ctor ok | |
617 | ||
618 | // no dtor | |
619 | ||
620 | // assignment operators and Set() functions: all non const methods return | |
621 | // the reference to this object. IsValid() should be used to test whether | |
622 | // the function succeeded. | |
623 | // ------------------------------------------------------------------------ | |
624 | ||
625 | // set to the current time | |
626 | inline wxDateTime& SetToCurrent(); | |
627 | ||
16ee521a DW |
628 | #if (!(defined(__VISAGECPP__) && __IBMCPP__ >= 400)) |
629 | // VA C++ confuses this with wxDateTime(double jdn) thinking it is a duplicate declaration | |
0979c962 VZ |
630 | // set to given time_t value |
631 | inline wxDateTime& Set(time_t timet); | |
16ee521a | 632 | #endif |
0979c962 VZ |
633 | |
634 | // set to given broken down time/date | |
635 | wxDateTime& Set(const struct tm& tm); | |
636 | ||
b76b015e VZ |
637 | // set to given broken down time/date |
638 | inline wxDateTime& Set(const Tm& tm); | |
639 | ||
e6ec579c VZ |
640 | // set to given JDN (beware of rounding errors) |
641 | wxDateTime& Set(double jdn); | |
642 | ||
0979c962 VZ |
643 | // set to given time, date = today |
644 | wxDateTime& Set(wxDateTime_t hour, | |
645 | wxDateTime_t minute = 0, | |
646 | wxDateTime_t second = 0, | |
647 | wxDateTime_t millisec = 0); | |
648 | ||
649 | // from separate values for each component with explicit date | |
650 | // (defaults for month and year are the current values) | |
651 | wxDateTime& Set(wxDateTime_t day, | |
33ac7e6f | 652 | Month month, |
0979c962 VZ |
653 | int year = Inv_Year, // 1999, not 99 please! |
654 | wxDateTime_t hour = 0, | |
655 | wxDateTime_t minute = 0, | |
656 | wxDateTime_t second = 0, | |
657 | wxDateTime_t millisec = 0); | |
658 | ||
659 | // resets time to 00:00:00, doesn't change the date | |
660 | wxDateTime& ResetTime(); | |
661 | ||
fb96cf85 VZ |
662 | // get the date part of this object only, i.e. the object which has the |
663 | // same date as this one but time of 00:00:00 | |
664 | wxDateTime GetDateOnly() const; | |
fb96cf85 | 665 | |
0979c962 VZ |
666 | // the following functions don't change the values of the other |
667 | // fields, i.e. SetMinute() won't change either hour or seconds value | |
668 | ||
669 | // set the year | |
670 | wxDateTime& SetYear(int year); | |
671 | // set the month | |
672 | wxDateTime& SetMonth(Month month); | |
673 | // set the day of the month | |
674 | wxDateTime& SetDay(wxDateTime_t day); | |
675 | // set hour | |
676 | wxDateTime& SetHour(wxDateTime_t hour); | |
677 | // set minute | |
678 | wxDateTime& SetMinute(wxDateTime_t minute); | |
679 | // set second | |
680 | wxDateTime& SetSecond(wxDateTime_t second); | |
681 | // set millisecond | |
682 | wxDateTime& SetMillisecond(wxDateTime_t millisecond); | |
683 | ||
684 | // assignment operator from time_t | |
685 | wxDateTime& operator=(time_t timet) { return Set(timet); } | |
686 | ||
687 | // assignment operator from broken down time/date | |
688 | wxDateTime& operator=(const struct tm& tm) { return Set(tm); } | |
689 | ||
b76b015e VZ |
690 | // assignment operator from broken down time/date |
691 | wxDateTime& operator=(const Tm& tm) { return Set(tm); } | |
692 | ||
0979c962 VZ |
693 | // default assignment operator is ok |
694 | ||
695 | // calendar calculations (functions which set the date only leave the time | |
4f6aed9c VZ |
696 | // unchanged, e.g. don't explictly zero it): SetXXX() functions modify the |
697 | // object itself, GetXXX() ones return a new object. | |
0979c962 VZ |
698 | // ------------------------------------------------------------------------ |
699 | ||
cd0b1709 | 700 | // set to the given week day in the same week as this one |
2b5f62a0 VZ |
701 | wxDateTime& SetToWeekDayInSameWeek(WeekDay weekday, |
702 | WeekFlags flags = Monday_First); | |
703 | inline wxDateTime GetWeekDayInSameWeek(WeekDay weekday, | |
704 | WeekFlags flags = Monday_First) const; | |
cd0b1709 VZ |
705 | |
706 | // set to the next week day following this one | |
707 | wxDateTime& SetToNextWeekDay(WeekDay weekday); | |
4f6aed9c | 708 | inline wxDateTime GetNextWeekDay(WeekDay weekday) const; |
cd0b1709 | 709 | |
2ef31e80 | 710 | // set to the previous week day before this one |
cd0b1709 | 711 | wxDateTime& SetToPrevWeekDay(WeekDay weekday); |
4f6aed9c | 712 | inline wxDateTime GetPrevWeekDay(WeekDay weekday) const; |
cd0b1709 | 713 | |
7929902d | 714 | // set to Nth occurrence of given weekday in the given month of the |
68379eaf | 715 | // given year (time is set to 0), return true on success and false on |
0979c962 VZ |
716 | // failure. n may be positive (1..5) or negative to count from the end |
717 | // of the month (see helper function SetToLastWeekDay()) | |
718 | bool SetToWeekDay(WeekDay weekday, | |
719 | int n = 1, | |
2f02cb89 | 720 | Month month = Inv_Month, |
0979c962 | 721 | int year = Inv_Year); |
4f6aed9c VZ |
722 | inline wxDateTime GetWeekDay(WeekDay weekday, |
723 | int n = 1, | |
724 | Month month = Inv_Month, | |
725 | int year = Inv_Year) const; | |
0979c962 VZ |
726 | |
727 | // sets to the last weekday in the given month, year | |
728 | inline bool SetToLastWeekDay(WeekDay weekday, | |
2f02cb89 | 729 | Month month = Inv_Month, |
0979c962 | 730 | int year = Inv_Year); |
4f6aed9c VZ |
731 | inline wxDateTime GetLastWeekDay(WeekDay weekday, |
732 | Month month = Inv_Month, | |
733 | int year = Inv_Year); | |
0979c962 | 734 | |
ca3e85cf | 735 | #if WXWIN_COMPATIBILITY_2_6 |
0979c962 | 736 | // sets the date to the given day of the given week in the year, |
68379eaf | 737 | // returns true on success and false if given date doesn't exist (e.g. |
0979c962 | 738 | // numWeek is > 53) |
4c27e2fa VZ |
739 | // |
740 | // these functions are badly defined as they're not the reverse of | |
741 | // GetWeekOfYear(), use SetToTheWeekOfYear() instead | |
742 | wxDEPRECATED( bool SetToTheWeek(wxDateTime_t numWeek, | |
743 | WeekDay weekday = Mon, | |
744 | WeekFlags flags = Monday_First) ); | |
745 | wxDEPRECATED( wxDateTime GetWeek(wxDateTime_t numWeek, | |
746 | WeekDay weekday = Mon, | |
747 | WeekFlags flags = Monday_First) const ); | |
ca3e85cf | 748 | #endif // WXWIN_COMPATIBILITY_2_6 |
4c27e2fa VZ |
749 | |
750 | // returns the date corresponding to the given week day of the given | |
751 | // week (in ISO notation) of the specified year | |
752 | static wxDateTime SetToWeekOfYear(int year, | |
753 | wxDateTime_t numWeek, | |
754 | WeekDay weekday = Mon); | |
0979c962 | 755 | |
2f02cb89 VZ |
756 | // sets the date to the last day of the given (or current) month or the |
757 | // given (or current) year | |
758 | wxDateTime& SetToLastMonthDay(Month month = Inv_Month, | |
759 | int year = Inv_Year); | |
4f6aed9c VZ |
760 | inline wxDateTime GetLastMonthDay(Month month = Inv_Month, |
761 | int year = Inv_Year) const; | |
0979c962 | 762 | |
f0f951fa VZ |
763 | // sets to the given year day (1..365 or 366) |
764 | wxDateTime& SetToYearDay(wxDateTime_t yday); | |
4f6aed9c | 765 | inline wxDateTime GetYearDay(wxDateTime_t yday) const; |
f0f951fa | 766 | |
0979c962 VZ |
767 | // The definitions below were taken verbatim from |
768 | // | |
769 | // http://www.capecod.net/~pbaum/date/date0.htm | |
770 | // | |
771 | // (Peter Baum's home page) | |
772 | // | |
773 | // definition: The Julian Day Number, Julian Day, or JD of a | |
774 | // particular instant of time is the number of days and fractions of a | |
775 | // day since 12 hours Universal Time (Greenwich mean noon) on January | |
776 | // 1 of the year -4712, where the year is given in the Julian | |
777 | // proleptic calendar. The idea of using this reference date was | |
778 | // originally proposed by Joseph Scalizer in 1582 to count years but | |
779 | // it was modified by 19th century astronomers to count days. One | |
780 | // could have equivalently defined the reference time to be noon of | |
781 | // November 24, -4713 if were understood that Gregorian calendar rules | |
782 | // were applied. Julian days are Julian Day Numbers and are not to be | |
783 | // confused with Julian dates. | |
784 | // | |
785 | // definition: The Rata Die number is a date specified as the number | |
786 | // of days relative to a base date of December 31 of the year 0. Thus | |
787 | // January 1 of the year 1 is Rata Die day 1. | |
788 | ||
e6ec579c VZ |
789 | // get the Julian Day number (the fractional part specifies the time of |
790 | // the day, related to noon - beware of rounding errors!) | |
791 | double GetJulianDayNumber() const; | |
239446b4 VZ |
792 | double GetJDN() const { return GetJulianDayNumber(); } |
793 | ||
794 | // get the Modified Julian Day number: it is equal to JDN - 2400000.5 | |
795 | // and so integral MJDs correspond to the midnights (and not noons). | |
796 | // MJD 0 is Nov 17, 1858 | |
797 | double GetModifiedJulianDayNumber() const { return GetJDN() - 2400000.5; } | |
798 | double GetMJD() const { return GetModifiedJulianDayNumber(); } | |
0979c962 VZ |
799 | |
800 | // get the Rata Die number | |
e6ec579c | 801 | double GetRataDie() const; |
0979c962 VZ |
802 | |
803 | // TODO algorithms for calculating some important dates, such as | |
804 | // religious holidays (Easter...) or moon/solar eclipses? Some | |
805 | // algorithms can be found in the calendar FAQ | |
806 | ||
d26adb9d VZ |
807 | |
808 | // Timezone stuff: a wxDateTime object constructed using given | |
809 | // day/month/year/hour/min/sec values is interpreted as this moment in | |
810 | // local time. Using the functions below, it may be converted to another | |
811 | // time zone (e.g., the Unix epoch is wxDateTime(1, Jan, 1970).ToGMT()). | |
299fcbfe | 812 | // |
d26adb9d | 813 | // These functions try to handle DST internally, but there is no magical |
41acf5c0 VZ |
814 | // way to know all rules for it in all countries in the world, so if the |
815 | // program can handle it itself (or doesn't want to handle it at all for | |
816 | // whatever reason), the DST handling can be disabled with noDST. | |
b76b015e VZ |
817 | // ------------------------------------------------------------------------ |
818 | ||
299fcbfe | 819 | // transform to any given timezone |
68379eaf WS |
820 | inline wxDateTime ToTimezone(const TimeZone& tz, bool noDST = false) const; |
821 | wxDateTime& MakeTimezone(const TimeZone& tz, bool noDST = false); | |
b76b015e | 822 | |
d26adb9d VZ |
823 | // interpret current value as being in another timezone and transform |
824 | // it to local one | |
825 | inline wxDateTime FromTimezone(const TimeZone& tz, bool noDST = false) const; | |
826 | wxDateTime& MakeFromTimezone(const TimeZone& tz, bool noDST = false); | |
d26adb9d VZ |
827 | |
828 | // transform to/from GMT/UTC | |
829 | wxDateTime ToUTC(bool noDST = false) const { return ToTimezone(UTC, noDST); } | |
830 | wxDateTime& MakeUTC(bool noDST = false) { return MakeTimezone(UTC, noDST); } | |
831 | ||
832 | wxDateTime ToGMT(bool noDST = false) const { return ToUTC(noDST); } | |
833 | wxDateTime& MakeGMT(bool noDST = false) { return MakeUTC(noDST); } | |
834 | ||
d26adb9d VZ |
835 | wxDateTime FromUTC(bool noDST = false) const |
836 | { return FromTimezone(UTC, noDST); } | |
837 | wxDateTime& MakeFromUTC(bool noDST = false) | |
838 | { return MakeFromTimezone(UTC, noDST); } | |
fcc3d7cb | 839 | |
239446b4 VZ |
840 | // is daylight savings time in effect at this moment according to the |
841 | // rules of the specified country? | |
842 | // | |
843 | // Return value is > 0 if DST is in effect, 0 if it is not and -1 if | |
844 | // the information is not available (this is compatible with ANSI C) | |
845 | int IsDST(Country country = Country_Default) const; | |
846 | ||
d26adb9d | 847 | |
0979c962 VZ |
848 | // accessors: many of them take the timezone parameter which indicates the |
849 | // timezone for which to make the calculations and the default value means | |
850 | // to do it for the current timezone of this machine (even if the function | |
851 | // only operates with the date it's necessary because a date may wrap as | |
852 | // result of timezone shift) | |
853 | // ------------------------------------------------------------------------ | |
854 | ||
c3302e7e | 855 | // is the date valid? |
384223b3 | 856 | inline bool IsValid() const { return m_time != wxInvalidDateTime.m_time; } |
0979c962 | 857 | |
299fcbfe VZ |
858 | // get the broken down date/time representation in the given timezone |
859 | // | |
860 | // If you wish to get several time components (day, month and year), | |
861 | // consider getting the whole Tm strcuture first and retrieving the | |
862 | // value from it - this is much more efficient | |
863 | Tm GetTm(const TimeZone& tz = Local) const; | |
b76b015e VZ |
864 | |
865 | // get the number of seconds since the Unix epoch - returns (time_t)-1 | |
866 | // if the value is out of range | |
867 | inline time_t GetTicks() const; | |
868 | ||
a333edbd VZ |
869 | // get the century, same as GetCentury(GetYear()) |
870 | int GetCentury(const TimeZone& tz = Local) const | |
871 | { return GetCentury(GetYear(tz)); } | |
0979c962 | 872 | // get the year (returns Inv_Year if date is invalid) |
16ee521a | 873 | int GetYear(const TimeZone& tz = Local) const |
299fcbfe | 874 | { return GetTm(tz).year; } |
0979c962 | 875 | // get the month (Inv_Month if date is invalid) |
16ee521a | 876 | Month GetMonth(const TimeZone& tz = Local) const |
299fcbfe | 877 | { return (Month)GetTm(tz).mon; } |
0979c962 | 878 | // get the month day (in 1..31 range, 0 if date is invalid) |
16ee521a | 879 | wxDateTime_t GetDay(const TimeZone& tz = Local) const |
299fcbfe | 880 | { return GetTm(tz).mday; } |
0979c962 | 881 | // get the day of the week (Inv_WeekDay if date is invalid) |
16ee521a | 882 | WeekDay GetWeekDay(const TimeZone& tz = Local) const |
299fcbfe | 883 | { return GetTm(tz).GetWeekDay(); } |
0979c962 | 884 | // get the hour of the day |
16ee521a | 885 | wxDateTime_t GetHour(const TimeZone& tz = Local) const |
299fcbfe | 886 | { return GetTm(tz).hour; } |
0979c962 | 887 | // get the minute |
16ee521a | 888 | wxDateTime_t GetMinute(const TimeZone& tz = Local) const |
299fcbfe | 889 | { return GetTm(tz).min; } |
0979c962 | 890 | // get the second |
16ee521a | 891 | wxDateTime_t GetSecond(const TimeZone& tz = Local) const |
299fcbfe | 892 | { return GetTm(tz).sec; } |
0979c962 | 893 | // get milliseconds |
16ee521a | 894 | wxDateTime_t GetMillisecond(const TimeZone& tz = Local) const |
299fcbfe | 895 | { return GetTm(tz).msec; } |
0979c962 VZ |
896 | |
897 | // get the day since the year start (1..366, 0 if date is invalid) | |
299fcbfe | 898 | wxDateTime_t GetDayOfYear(const TimeZone& tz = Local) const; |
cd0b1709 | 899 | // get the week number since the year start (1..52 or 53, 0 if date is |
0979c962 | 900 | // invalid) |
9d9b7755 VZ |
901 | wxDateTime_t GetWeekOfYear(WeekFlags flags = Monday_First, |
902 | const TimeZone& tz = Local) const; | |
cd0b1709 VZ |
903 | // get the week number since the month start (1..5, 0 if date is |
904 | // invalid) | |
9d9b7755 VZ |
905 | wxDateTime_t GetWeekOfMonth(WeekFlags flags = Monday_First, |
906 | const TimeZone& tz = Local) const; | |
0979c962 VZ |
907 | |
908 | // is this date a work day? This depends on a country, of course, | |
909 | // because the holidays are different in different countries | |
4f6aed9c | 910 | bool IsWorkDay(Country country = Country_Default) const; |
0979c962 VZ |
911 | |
912 | // is this date later than Gregorian calendar introduction for the | |
913 | // given country (see enum GregorianAdoption)? | |
914 | // | |
4f6aed9c | 915 | // NB: this function shouldn't be considered as absolute authority in |
0979c962 VZ |
916 | // the matter. Besides, for some countries the exact date of |
917 | // adoption of the Gregorian calendar is simply unknown. | |
b76b015e | 918 | bool IsGregorianDate(GregorianAdoption country = Gr_Standard) const; |
0979c962 | 919 | |
2b5f62a0 VZ |
920 | // dos date and time format |
921 | // ------------------------------------------------------------------------ | |
922 | ||
923 | // set from the DOS packed format | |
924 | wxDateTime& SetFromDOS(unsigned long ddt); | |
925 | ||
926 | // pack the date in DOS format | |
927 | unsigned long GetAsDOS() const; | |
928 | ||
154014d6 VZ |
929 | // SYSTEMTIME format |
930 | // ------------------------------------------------------------------------ | |
931 | #ifdef __WXMSW__ | |
154014d6 | 932 | // convert SYSTEMTIME to wxDateTime |
10acc3ef | 933 | wxDateTime& SetFromMSWSysTime(const struct _SYSTEMTIME& st); |
154014d6 VZ |
934 | |
935 | // convert wxDateTime to SYSTEMTIME | |
10acc3ef VZ |
936 | void GetAsMSWSysTime(struct _SYSTEMTIME* st) const; |
937 | ||
938 | // same as above but only take date part into account, time is always zero | |
939 | wxDateTime& SetFromMSWSysDate(const struct _SYSTEMTIME& st); | |
940 | void GetAsMSWSysDate(struct _SYSTEMTIME* st) const; | |
154014d6 VZ |
941 | #endif // __WXMSW__ |
942 | ||
0979c962 VZ |
943 | // comparison (see also functions below for operator versions) |
944 | // ------------------------------------------------------------------------ | |
945 | ||
68379eaf | 946 | // returns true if the two moments are strictly identical |
b76b015e VZ |
947 | inline bool IsEqualTo(const wxDateTime& datetime) const; |
948 | ||
68379eaf | 949 | // returns true if the date is strictly earlier than the given one |
b76b015e | 950 | inline bool IsEarlierThan(const wxDateTime& datetime) const; |
0979c962 | 951 | |
68379eaf | 952 | // returns true if the date is strictly later than the given one |
b76b015e | 953 | inline bool IsLaterThan(const wxDateTime& datetime) const; |
0979c962 | 954 | |
68379eaf | 955 | // returns true if the date is strictly in the given range |
b76b015e VZ |
956 | inline bool IsStrictlyBetween(const wxDateTime& t1, |
957 | const wxDateTime& t2) const; | |
958 | ||
68379eaf | 959 | // returns true if the date is in the given range |
b76b015e | 960 | inline bool IsBetween(const wxDateTime& t1, const wxDateTime& t2) const; |
0979c962 | 961 | |
be4017f8 VZ |
962 | // do these two objects refer to the same date? |
963 | inline bool IsSameDate(const wxDateTime& dt) const; | |
964 | ||
965 | // do these two objects have the same time? | |
966 | inline bool IsSameTime(const wxDateTime& dt) const; | |
967 | ||
968 | // are these two objects equal up to given timespan? | |
969 | inline bool IsEqualUpTo(const wxDateTime& dt, const wxTimeSpan& ts) const; | |
970 | ||
26364344 WS |
971 | inline bool operator<(const wxDateTime& dt) const |
972 | { | |
9a83f860 | 973 | wxASSERT_MSG( IsValid() && dt.IsValid(), wxT("invalid wxDateTime") ); |
26364344 WS |
974 | return GetValue() < dt.GetValue(); |
975 | } | |
976 | ||
977 | inline bool operator<=(const wxDateTime& dt) const | |
978 | { | |
9a83f860 | 979 | wxASSERT_MSG( IsValid() && dt.IsValid(), wxT("invalid wxDateTime") ); |
26364344 WS |
980 | return GetValue() <= dt.GetValue(); |
981 | } | |
982 | ||
983 | inline bool operator>(const wxDateTime& dt) const | |
984 | { | |
9a83f860 | 985 | wxASSERT_MSG( IsValid() && dt.IsValid(), wxT("invalid wxDateTime") ); |
26364344 WS |
986 | return GetValue() > dt.GetValue(); |
987 | } | |
988 | ||
989 | inline bool operator>=(const wxDateTime& dt) const | |
990 | { | |
9a83f860 | 991 | wxASSERT_MSG( IsValid() && dt.IsValid(), wxT("invalid wxDateTime") ); |
26364344 WS |
992 | return GetValue() >= dt.GetValue(); |
993 | } | |
994 | ||
995 | inline bool operator==(const wxDateTime& dt) const | |
996 | { | |
9a83f860 | 997 | wxASSERT_MSG( IsValid() && dt.IsValid(), wxT("invalid wxDateTime") ); |
26364344 WS |
998 | return GetValue() == dt.GetValue(); |
999 | } | |
1000 | ||
1001 | inline bool operator!=(const wxDateTime& dt) const | |
1002 | { | |
9a83f860 | 1003 | wxASSERT_MSG( IsValid() && dt.IsValid(), wxT("invalid wxDateTime") ); |
26364344 WS |
1004 | return GetValue() != dt.GetValue(); |
1005 | } | |
1006 | ||
cd0b1709 | 1007 | // arithmetics with dates (see also below for more operators) |
0979c962 VZ |
1008 | // ------------------------------------------------------------------------ |
1009 | ||
cd0b1709 VZ |
1010 | // return the sum of the date with a time span (positive or negative) |
1011 | inline wxDateTime Add(const wxTimeSpan& diff) const; | |
0979c962 | 1012 | // add a time span (positive or negative) |
b76b015e | 1013 | inline wxDateTime& Add(const wxTimeSpan& diff); |
0979c962 | 1014 | // add a time span (positive or negative) |
b76b015e | 1015 | inline wxDateTime& operator+=(const wxTimeSpan& diff); |
26364344 WS |
1016 | inline wxDateTime operator+(const wxTimeSpan& ts) const |
1017 | { | |
1018 | wxDateTime dt(*this); | |
1019 | dt.Add(ts); | |
1020 | return dt; | |
1021 | } | |
0979c962 | 1022 | |
cd0b1709 | 1023 | // return the difference of the date with a time span |
f6bcfd97 BP |
1024 | inline wxDateTime Subtract(const wxTimeSpan& diff) const; |
1025 | // subtract a time span (positive or negative) | |
1026 | inline wxDateTime& Subtract(const wxTimeSpan& diff); | |
1027 | // subtract a time span (positive or negative) | |
0979c962 | 1028 | inline wxDateTime& operator-=(const wxTimeSpan& diff); |
26364344 WS |
1029 | inline wxDateTime operator-(const wxTimeSpan& ts) const |
1030 | { | |
1031 | wxDateTime dt(*this); | |
1032 | dt.Subtract(ts); | |
1033 | return dt; | |
1034 | } | |
0979c962 | 1035 | |
cd0b1709 VZ |
1036 | // return the sum of the date with a date span |
1037 | inline wxDateTime Add(const wxDateSpan& diff) const; | |
0979c962 VZ |
1038 | // add a date span (positive or negative) |
1039 | wxDateTime& Add(const wxDateSpan& diff); | |
1040 | // add a date span (positive or negative) | |
b76b015e | 1041 | inline wxDateTime& operator+=(const wxDateSpan& diff); |
26364344 WS |
1042 | inline wxDateTime operator+(const wxDateSpan& ds) const |
1043 | { | |
1044 | wxDateTime dt(*this); | |
1045 | dt.Add(ds); | |
1046 | return dt; | |
1047 | } | |
0979c962 | 1048 | |
cd0b1709 | 1049 | // return the difference of the date with a date span |
f6bcfd97 BP |
1050 | inline wxDateTime Subtract(const wxDateSpan& diff) const; |
1051 | // subtract a date span (positive or negative) | |
1052 | inline wxDateTime& Subtract(const wxDateSpan& diff); | |
1053 | // subtract a date span (positive or negative) | |
0979c962 | 1054 | inline wxDateTime& operator-=(const wxDateSpan& diff); |
26364344 WS |
1055 | inline wxDateTime operator-(const wxDateSpan& ds) const |
1056 | { | |
1057 | wxDateTime dt(*this); | |
1058 | dt.Subtract(ds); | |
1059 | return dt; | |
1060 | } | |
0979c962 | 1061 | |
cd0b1709 | 1062 | // return the difference between two dates |
f6bcfd97 | 1063 | inline wxTimeSpan Subtract(const wxDateTime& dt) const; |
26364344 | 1064 | inline wxTimeSpan operator-(const wxDateTime& dt2) const; |
0979c962 | 1065 | |
c398434d | 1066 | // conversion to/from text |
0979c962 VZ |
1067 | // ------------------------------------------------------------------------ |
1068 | ||
c398434d VZ |
1069 | // all conversions functions return true to indicate whether parsing |
1070 | // succeeded or failed and fill in the provided end iterator, which must | |
1071 | // not be NULL, with the location of the character where the parsing | |
1072 | // stopped (this will be end() of the passed string if everything was | |
1073 | // parsed) | |
1074 | ||
0979c962 VZ |
1075 | // parse a string in RFC 822 format (found e.g. in mail headers and |
1076 | // having the form "Wed, 10 Feb 1999 19:07:07 +0100") | |
c398434d VZ |
1077 | bool ParseRfc822Date(const wxString& date, |
1078 | wxString::const_iterator *end); | |
75a29ef1 | 1079 | |
f0f951fa VZ |
1080 | // parse a date/time in the given format (see strptime(3)), fill in |
1081 | // the missing (in the string) fields with the values of dateDef (by | |
1082 | // default, they will not change if they had valid values or will | |
1083 | // default to Today() otherwise) | |
c398434d VZ |
1084 | bool ParseFormat(const wxString& date, |
1085 | const wxString& format, | |
1086 | const wxDateTime& dateDef, | |
1087 | wxString::const_iterator *end); | |
1088 | ||
1089 | bool ParseFormat(const wxString& date, | |
1090 | const wxString& format, | |
1091 | wxString::const_iterator *end) | |
71ebd60b VZ |
1092 | { |
1093 | return ParseFormat(date, format, wxDefaultDateTime, end); | |
1094 | } | |
1095 | ||
c398434d VZ |
1096 | bool ParseFormat(const wxString& date, |
1097 | wxString::const_iterator *end) | |
1098 | { | |
1099 | return ParseFormat(date, wxDefaultDateTimeFormat, wxDefaultDateTime, end); | |
1100 | } | |
71ebd60b | 1101 | |
f3f2e255 VZ |
1102 | // parse a string containing date, time or both in ISO 8601 format |
1103 | // | |
1104 | // notice that these functions are new in wx 3.0 and so we don't | |
1105 | // provide compatibility overloads for them | |
1106 | bool ParseISODate(const wxString& date) | |
1107 | { | |
a0bcd61b | 1108 | wxString::const_iterator end; |
c398434d | 1109 | return ParseFormat(date, wxS("%Y-%m-%d"), &end) && end == date.end(); |
f3f2e255 VZ |
1110 | } |
1111 | ||
a0bcd61b | 1112 | bool ParseISOTime(const wxString& time) |
f3f2e255 | 1113 | { |
a0bcd61b | 1114 | wxString::const_iterator end; |
c398434d | 1115 | return ParseFormat(time, wxS("%H:%M:%S"), &end) && end == time.end(); |
f3f2e255 VZ |
1116 | } |
1117 | ||
a0bcd61b | 1118 | bool ParseISOCombined(const wxString& datetime, char sep = 'T') |
f3f2e255 | 1119 | { |
a0bcd61b | 1120 | wxString::const_iterator end; |
f3f2e255 | 1121 | const wxString fmt = wxS("%Y-%m-%d") + wxString(sep) + wxS("%H:%M:%S"); |
c398434d | 1122 | return ParseFormat(datetime, fmt, &end) && end == datetime.end(); |
f3f2e255 VZ |
1123 | } |
1124 | ||
0979c962 VZ |
1125 | // parse a string containing the date/time in "free" format, this |
1126 | // function will try to make an educated guess at the string contents | |
c398434d VZ |
1127 | bool ParseDateTime(const wxString& datetime, |
1128 | wxString::const_iterator *end); | |
71ebd60b | 1129 | |
cd0b1709 VZ |
1130 | // parse a string containing the date only in "free" format (less |
1131 | // flexible than ParseDateTime) | |
c398434d VZ |
1132 | bool ParseDate(const wxString& date, |
1133 | wxString::const_iterator *end); | |
71ebd60b | 1134 | |
cd0b1709 | 1135 | // parse a string containing the time only in "free" format |
c398434d VZ |
1136 | bool ParseTime(const wxString& time, |
1137 | wxString::const_iterator *end); | |
71ebd60b | 1138 | |
0979c962 VZ |
1139 | |
1140 | // this function accepts strftime()-like format string (default | |
1141 | // argument corresponds to the preferred date and time representation | |
1142 | // for the current locale) and returns the string containing the | |
1143 | // resulting text representation | |
12e82477 | 1144 | wxString Format(const wxString& format = wxDefaultDateTimeFormat, |
299fcbfe | 1145 | const TimeZone& tz = Local) const; |
0979c962 | 1146 | // preferred date representation for the current locale |
f3f2e255 | 1147 | wxString FormatDate() const { return Format(wxS("%x")); } |
0979c962 | 1148 | // preferred time representation for the current locale |
f3f2e255 | 1149 | wxString FormatTime() const { return Format(wxS("%X")); } |
4f6aed9c | 1150 | // returns the string representing the date in ISO 8601 format |
9d9b7755 | 1151 | // (YYYY-MM-DD) |
f3f2e255 | 1152 | wxString FormatISODate() const { return Format(wxS("%Y-%m-%d")); } |
4f6aed9c VZ |
1153 | // returns the string representing the time in ISO 8601 format |
1154 | // (HH:MM:SS) | |
f3f2e255 VZ |
1155 | wxString FormatISOTime() const { return Format(wxS("%H:%M:%S")); } |
1156 | // return the combined date time representation in ISO 8601 format; the | |
1157 | // separator character should be 'T' according to the standard but it | |
1158 | // can also be useful to set it to ' ' | |
1159 | wxString FormatISOCombined(char sep = 'T') const | |
1160 | { return FormatISODate() + sep + FormatISOTime(); } | |
0979c962 | 1161 | |
c398434d VZ |
1162 | |
1163 | // backwards compatible versions of the parsing functions: they return an | |
1164 | // object representing the next character following the date specification | |
1165 | // (i.e. the one where the scan had to stop) or a special NULL-like object | |
1166 | // on failure | |
1167 | // | |
1168 | // they're not deprecated because a lot of existing code uses them and | |
1169 | // there is no particular harm in keeping them but you should still prefer | |
1170 | // the versions above in the new code | |
1171 | wxAnyStrPtr ParseRfc822Date(const wxString& date) | |
1172 | { | |
1173 | wxString::const_iterator end; | |
1174 | return ParseRfc822Date(date, &end) ? wxAnyStrPtr(date, end) | |
1175 | : wxAnyStrPtr(); | |
1176 | } | |
1177 | ||
1178 | wxAnyStrPtr ParseFormat(const wxString& date, | |
1179 | const wxString& format = wxDefaultDateTimeFormat, | |
1180 | const wxDateTime& dateDef = wxDefaultDateTime) | |
1181 | { | |
1182 | wxString::const_iterator end; | |
1183 | return ParseFormat(date, format, dateDef, &end) ? wxAnyStrPtr(date, end) | |
1184 | : wxAnyStrPtr(); | |
1185 | } | |
1186 | ||
1187 | wxAnyStrPtr ParseDateTime(const wxString& datetime) | |
1188 | { | |
1189 | wxString::const_iterator end; | |
1190 | return ParseDateTime(datetime, &end) ? wxAnyStrPtr(datetime, end) | |
1191 | : wxAnyStrPtr(); | |
1192 | } | |
1193 | ||
1194 | wxAnyStrPtr ParseDate(const wxString& date) | |
1195 | { | |
1196 | wxString::const_iterator end; | |
1197 | return ParseDate(date, &end) ? wxAnyStrPtr(date, end) | |
1198 | : wxAnyStrPtr(); | |
1199 | } | |
1200 | ||
1201 | wxAnyStrPtr ParseTime(const wxString& time) | |
1202 | { | |
1203 | wxString::const_iterator end; | |
1204 | return ParseTime(time, &end) ? wxAnyStrPtr(time, end) | |
1205 | : wxAnyStrPtr(); | |
1206 | } | |
1207 | ||
0979c962 VZ |
1208 | // implementation |
1209 | // ------------------------------------------------------------------------ | |
1210 | ||
cd0b1709 VZ |
1211 | // construct from internal representation |
1212 | wxDateTime(const wxLongLong& time) { m_time = time; } | |
1213 | ||
0979c962 VZ |
1214 | // get the internal representation |
1215 | inline wxLongLong GetValue() const; | |
1216 | ||
0979c962 | 1217 | // a helper function to get the current time_t |
d3b9f782 | 1218 | static time_t GetTimeNow() { return time(NULL); } |
0979c962 | 1219 | |
2f02cb89 VZ |
1220 | // another one to get the current time broken down |
1221 | static struct tm *GetTmNow() | |
1222 | { | |
135d1ad0 JS |
1223 | static struct tm l_CurrentTime; |
1224 | return GetTmNow(&l_CurrentTime); | |
2f02cb89 VZ |
1225 | } |
1226 | ||
a452689b SN |
1227 | // get current time using thread-safe function |
1228 | static struct tm *GetTmNow(struct tm *tmstruct); | |
1229 | ||
2f02cb89 | 1230 | private: |
0979c962 | 1231 | // the current country - as it's the same for all program objects (unless |
b76b015e VZ |
1232 | // it runs on a _really_ big cluster system :-), this is a static member: |
1233 | // see SetCountry() and GetCountry() | |
0979c962 VZ |
1234 | static Country ms_country; |
1235 | ||
0979c962 VZ |
1236 | // this constant is used to transform a time_t value to the internal |
1237 | // representation, as time_t is in seconds and we use milliseconds it's | |
1238 | // fixed to 1000 | |
cd0b1709 | 1239 | static const long TIME_T_FACTOR; |
0979c962 | 1240 | |
68379eaf | 1241 | // returns true if we fall in range in which we can use standard ANSI C |
b76b015e | 1242 | // functions |
fcc3d7cb | 1243 | inline bool IsInStdRange() const; |
b76b015e VZ |
1244 | |
1245 | // the internal representation of the time is the amount of milliseconds | |
1246 | // elapsed since the origin which is set by convention to the UNIX/C epoch | |
1247 | // value: the midnight of January 1, 1970 (UTC) | |
1248 | wxLongLong m_time; | |
0979c962 VZ |
1249 | }; |
1250 | ||
1251 | // ---------------------------------------------------------------------------- | |
1252 | // This class contains a difference between 2 wxDateTime values, so it makes | |
f6bcfd97 | 1253 | // sense to add it to wxDateTime and it is the result of subtraction of 2 |
0979c962 VZ |
1254 | // objects of that class. See also wxDateSpan. |
1255 | // ---------------------------------------------------------------------------- | |
b76b015e | 1256 | |
bddd7a8d | 1257 | class WXDLLIMPEXP_BASE wxTimeSpan |
0979c962 VZ |
1258 | { |
1259 | public: | |
1260 | // constructors | |
1261 | // ------------------------------------------------------------------------ | |
1262 | ||
bd35ed32 VZ |
1263 | // return the timespan for the given number of milliseconds |
1264 | static wxTimeSpan Milliseconds(wxLongLong ms) { return wxTimeSpan(0, 0, 0, ms); } | |
1265 | static wxTimeSpan Millisecond() { return Milliseconds(1); } | |
1266 | ||
fcc3d7cb | 1267 | // return the timespan for the given number of seconds |
9c21e80b | 1268 | static wxTimeSpan Seconds(wxLongLong sec) { return wxTimeSpan(0, 0, sec); } |
68ee7c47 | 1269 | static wxTimeSpan Second() { return Seconds(1); } |
fcc3d7cb VZ |
1270 | |
1271 | // return the timespan for the given number of minutes | |
6f2a55e3 | 1272 | static wxTimeSpan Minutes(long min) { return wxTimeSpan(0, min, 0 ); } |
68ee7c47 | 1273 | static wxTimeSpan Minute() { return Minutes(1); } |
fcc3d7cb VZ |
1274 | |
1275 | // return the timespan for the given number of hours | |
6f2a55e3 | 1276 | static wxTimeSpan Hours(long hours) { return wxTimeSpan(hours, 0, 0); } |
68ee7c47 | 1277 | static wxTimeSpan Hour() { return Hours(1); } |
fcc3d7cb | 1278 | |
cd0b1709 | 1279 | // return the timespan for the given number of days |
6f2a55e3 | 1280 | static wxTimeSpan Days(long days) { return Hours(24 * days); } |
68ee7c47 | 1281 | static wxTimeSpan Day() { return Days(1); } |
cd0b1709 VZ |
1282 | |
1283 | // return the timespan for the given number of weeks | |
6f2a55e3 | 1284 | static wxTimeSpan Weeks(long days) { return Days(7 * days); } |
68ee7c47 | 1285 | static wxTimeSpan Week() { return Weeks(1); } |
cd0b1709 | 1286 | |
0979c962 VZ |
1287 | // default ctor constructs the 0 time span |
1288 | wxTimeSpan() { } | |
1289 | ||
1290 | // from separate values for each component, date set to 0 (hours are | |
1291 | // not restricted to 0..24 range, neither are minutes, seconds or | |
1292 | // milliseconds) | |
6f2a55e3 VZ |
1293 | inline wxTimeSpan(long hours, |
1294 | long minutes = 0, | |
9c21e80b VZ |
1295 | wxLongLong seconds = 0, |
1296 | wxLongLong milliseconds = 0); | |
0979c962 | 1297 | |
0979c962 VZ |
1298 | // default copy ctor is ok |
1299 | ||
1300 | // no dtor | |
1301 | ||
cd0b1709 | 1302 | // arithmetics with time spans (see also below for more operators) |
0979c962 VZ |
1303 | // ------------------------------------------------------------------------ |
1304 | ||
cd0b1709 VZ |
1305 | // return the sum of two timespans |
1306 | inline wxTimeSpan Add(const wxTimeSpan& diff) const; | |
0979c962 VZ |
1307 | // add two timespans together |
1308 | inline wxTimeSpan& Add(const wxTimeSpan& diff); | |
1309 | // add two timespans together | |
1310 | wxTimeSpan& operator+=(const wxTimeSpan& diff) { return Add(diff); } | |
26364344 WS |
1311 | inline wxTimeSpan operator+(const wxTimeSpan& ts) const |
1312 | { | |
1313 | return wxTimeSpan(GetValue() + ts.GetValue()); | |
1314 | } | |
0979c962 | 1315 | |
cd0b1709 | 1316 | // return the difference of two timespans |
f6bcfd97 BP |
1317 | inline wxTimeSpan Subtract(const wxTimeSpan& diff) const; |
1318 | // subtract another timespan | |
1319 | inline wxTimeSpan& Subtract(const wxTimeSpan& diff); | |
1320 | // subtract another timespan | |
1321 | wxTimeSpan& operator-=(const wxTimeSpan& diff) { return Subtract(diff); } | |
26364344 WS |
1322 | inline wxTimeSpan operator-(const wxTimeSpan& ts) |
1323 | { | |
1324 | return wxTimeSpan(GetValue() - ts.GetValue()); | |
1325 | } | |
0979c962 | 1326 | |
cd0b1709 VZ |
1327 | // multiply timespan by a scalar |
1328 | inline wxTimeSpan Multiply(int n) const; | |
0979c962 VZ |
1329 | // multiply timespan by a scalar |
1330 | inline wxTimeSpan& Multiply(int n); | |
1331 | // multiply timespan by a scalar | |
1332 | wxTimeSpan& operator*=(int n) { return Multiply(n); } | |
26364344 WS |
1333 | inline wxTimeSpan operator*(int n) const |
1334 | { | |
1335 | return wxTimeSpan(*this).Multiply(n); | |
1336 | } | |
0979c962 | 1337 | |
3103e8a9 | 1338 | // return this timespan with opposite sign |
b76b015e | 1339 | wxTimeSpan Negate() const { return wxTimeSpan(-GetValue()); } |
0979c962 VZ |
1340 | // negate the value of the timespan |
1341 | wxTimeSpan& Neg() { m_diff = -GetValue(); return *this; } | |
1342 | // negate the value of the timespan | |
1343 | wxTimeSpan& operator-() { return Neg(); } | |
1344 | ||
1345 | // return the absolute value of the timespan: does _not_ modify the | |
1346 | // object | |
1347 | inline wxTimeSpan Abs() const; | |
1348 | ||
1349 | // there is intentionally no division because we don't want to | |
1350 | // introduce rounding errors in time calculations | |
1351 | ||
1352 | // comparaison (see also operator versions below) | |
1353 | // ------------------------------------------------------------------------ | |
1354 | ||
1355 | // is the timespan null? | |
b76b015e | 1356 | bool IsNull() const { return m_diff == 0l; } |
0979c962 VZ |
1357 | // returns true if the timespan is null |
1358 | bool operator!() const { return !IsNull(); } | |
1359 | ||
1360 | // is the timespan positive? | |
b76b015e | 1361 | bool IsPositive() const { return m_diff > 0l; } |
0979c962 VZ |
1362 | |
1363 | // is the timespan negative? | |
b76b015e | 1364 | bool IsNegative() const { return m_diff < 0l; } |
0979c962 VZ |
1365 | |
1366 | // are two timespans equal? | |
1367 | inline bool IsEqualTo(const wxTimeSpan& ts) const; | |
1368 | // compare two timestamps: works with the absolute values, i.e. -2 | |
68379eaf | 1369 | // hours is longer than 1 hour. Also, it will return false if the |
0979c962 VZ |
1370 | // timespans are equal in absolute value. |
1371 | inline bool IsLongerThan(const wxTimeSpan& ts) const; | |
1372 | // compare two timestamps: works with the absolute values, i.e. 1 | |
68379eaf | 1373 | // hour is shorter than -2 hours. Also, it will return false if the |
0979c962 | 1374 | // timespans are equal in absolute value. |
f7541d48 | 1375 | bool IsShorterThan(const wxTimeSpan& t) const; |
0979c962 | 1376 | |
26364344 WS |
1377 | inline bool operator<(const wxTimeSpan &ts) const |
1378 | { | |
1379 | return GetValue() < ts.GetValue(); | |
1380 | } | |
1381 | ||
1382 | inline bool operator<=(const wxTimeSpan &ts) const | |
1383 | { | |
1384 | return GetValue() <= ts.GetValue(); | |
1385 | } | |
1386 | ||
1387 | inline bool operator>(const wxTimeSpan &ts) const | |
1388 | { | |
1389 | return GetValue() > ts.GetValue(); | |
1390 | } | |
1391 | ||
1392 | inline bool operator>=(const wxTimeSpan &ts) const | |
1393 | { | |
1394 | return GetValue() >= ts.GetValue(); | |
1395 | } | |
1396 | ||
1397 | inline bool operator==(const wxTimeSpan &ts) const | |
1398 | { | |
1399 | return GetValue() == ts.GetValue(); | |
1400 | } | |
1401 | ||
1402 | inline bool operator!=(const wxTimeSpan &ts) const | |
1403 | { | |
1404 | return GetValue() != ts.GetValue(); | |
1405 | } | |
1406 | ||
e6ec579c | 1407 | // breaking into days, hours, minutes and seconds |
0979c962 VZ |
1408 | // ------------------------------------------------------------------------ |
1409 | ||
0979c962 VZ |
1410 | // get the max number of weeks in this timespan |
1411 | inline int GetWeeks() const; | |
1412 | // get the max number of days in this timespan | |
1413 | inline int GetDays() const; | |
1414 | // get the max number of hours in this timespan | |
1415 | inline int GetHours() const; | |
1416 | // get the max number of minutes in this timespan | |
1417 | inline int GetMinutes() const; | |
1418 | // get the max number of seconds in this timespan | |
e6ec579c | 1419 | inline wxLongLong GetSeconds() const; |
0979c962 | 1420 | // get the number of milliseconds in this timespan |
b76b015e | 1421 | wxLongLong GetMilliseconds() const { return m_diff; } |
0979c962 VZ |
1422 | |
1423 | // conversion to text | |
1424 | // ------------------------------------------------------------------------ | |
1425 | ||
1426 | // this function accepts strftime()-like format string (default | |
1427 | // argument corresponds to the preferred date and time representation | |
1428 | // for the current locale) and returns the string containing the | |
1429 | // resulting text representation. Notice that only some of format | |
1430 | // specifiers valid for wxDateTime are valid for wxTimeSpan: hours, | |
1431 | // minutes and seconds make sense, but not "PM/AM" string for example. | |
12e82477 | 1432 | wxString Format(const wxString& format = wxDefaultTimeSpanFormat) const; |
0979c962 VZ |
1433 | |
1434 | // implementation | |
1435 | // ------------------------------------------------------------------------ | |
1436 | ||
cd0b1709 VZ |
1437 | // construct from internal representation |
1438 | wxTimeSpan(const wxLongLong& diff) { m_diff = diff; } | |
1439 | ||
0979c962 VZ |
1440 | // get the internal representation |
1441 | wxLongLong GetValue() const { return m_diff; } | |
1442 | ||
1443 | private: | |
1444 | // the (signed) time span in milliseconds | |
1445 | wxLongLong m_diff; | |
1446 | }; | |
1447 | ||
1448 | // ---------------------------------------------------------------------------- | |
1449 | // This class is a "logical time span" and is useful for implementing program | |
1450 | // logic for such things as "add one month to the date" which, in general, | |
1451 | // doesn't mean to add 60*60*24*31 seconds to it, but to take the same date | |
1452 | // the next month (to understand that this is indeed different consider adding | |
1453 | // one month to Feb, 15 - we want to get Mar, 15, of course). | |
1454 | // | |
1455 | // When adding a month to the date, all lesser components (days, hours, ...) | |
4f6aed9c VZ |
1456 | // won't be changed unless the resulting date would be invalid: for example, |
1457 | // Jan 31 + 1 month will be Feb 28, not (non existing) Feb 31. | |
1458 | // | |
f6bcfd97 | 1459 | // Because of this feature, adding and subtracting back again the same |
4f6aed9c VZ |
1460 | // wxDateSpan will *not*, in general give back the original date: Feb 28 - 1 |
1461 | // month will be Jan 28, not Jan 31! | |
0979c962 VZ |
1462 | // |
1463 | // wxDateSpan can be either positive or negative. They may be | |
1464 | // multiplied by scalars which multiply all deltas by the scalar: i.e. 2*(1 | |
1465 | // month and 1 day) is 2 months and 2 days. They can be added together and | |
1466 | // with wxDateTime or wxTimeSpan, but the type of result is different for each | |
1467 | // case. | |
1468 | // | |
1469 | // Beware about weeks: if you specify both weeks and days, the total number of | |
1470 | // days added will be 7*weeks + days! See also GetTotalDays() function. | |
1471 | // | |
93401be9 VZ |
1472 | // Equality operators are defined for wxDateSpans. Two datespans are equal if |
1473 | // they both give the same target date when added to *every* source date. | |
1474 | // Thus wxDateSpan::Months(1) is not equal to wxDateSpan::Days(30), because | |
1475 | // they not give the same date when added to 1 Feb. But wxDateSpan::Days(14) is | |
1476 | // equal to wxDateSpan::Weeks(2) | |
1477 | // | |
0979c962 VZ |
1478 | // Finally, notice that for adding hours, minutes &c you don't need this |
1479 | // class: wxTimeSpan will do the job because there are no subtleties | |
1480 | // associated with those. | |
1481 | // ---------------------------------------------------------------------------- | |
b76b015e | 1482 | |
bddd7a8d | 1483 | class WXDLLIMPEXP_BASE wxDateSpan |
0979c962 VZ |
1484 | { |
1485 | public: | |
1486 | // constructors | |
1487 | // ------------------------------------------------------------------------ | |
1488 | ||
1489 | // this many years/months/weeks/days | |
2f02cb89 VZ |
1490 | wxDateSpan(int years = 0, int months = 0, int weeks = 0, int days = 0) |
1491 | { | |
1492 | m_years = years; | |
1493 | m_months = months; | |
1494 | m_weeks = weeks; | |
1495 | m_days = days; | |
1496 | } | |
1497 | ||
1498 | // get an object for the given number of days | |
1499 | static wxDateSpan Days(int days) { return wxDateSpan(0, 0, 0, days); } | |
68ee7c47 | 1500 | static wxDateSpan Day() { return Days(1); } |
2f02cb89 VZ |
1501 | |
1502 | // get an object for the given number of weeks | |
1503 | static wxDateSpan Weeks(int weeks) { return wxDateSpan(0, 0, weeks, 0); } | |
68ee7c47 | 1504 | static wxDateSpan Week() { return Weeks(1); } |
2f02cb89 VZ |
1505 | |
1506 | // get an object for the given number of months | |
1507 | static wxDateSpan Months(int mon) { return wxDateSpan(0, mon, 0, 0); } | |
68ee7c47 | 1508 | static wxDateSpan Month() { return Months(1); } |
2f02cb89 VZ |
1509 | |
1510 | // get an object for the given number of years | |
1511 | static wxDateSpan Years(int years) { return wxDateSpan(years, 0, 0, 0); } | |
68ee7c47 | 1512 | static wxDateSpan Year() { return Years(1); } |
0979c962 VZ |
1513 | |
1514 | // default copy ctor is ok | |
1515 | ||
1516 | // no dtor | |
1517 | ||
1518 | // accessors (all SetXXX() return the (modified) wxDateSpan object) | |
1519 | // ------------------------------------------------------------------------ | |
1520 | ||
1521 | // set number of years | |
b76b015e | 1522 | wxDateSpan& SetYears(int n) { m_years = n; return *this; } |
0979c962 | 1523 | // set number of months |
b76b015e | 1524 | wxDateSpan& SetMonths(int n) { m_months = n; return *this; } |
0979c962 | 1525 | // set number of weeks |
b76b015e | 1526 | wxDateSpan& SetWeeks(int n) { m_weeks = n; return *this; } |
0979c962 | 1527 | // set number of days |
b76b015e | 1528 | wxDateSpan& SetDays(int n) { m_days = n; return *this; } |
0979c962 VZ |
1529 | |
1530 | // get number of years | |
1531 | int GetYears() const { return m_years; } | |
1532 | // get number of months | |
1533 | int GetMonths() const { return m_months; } | |
1534 | // get number of weeks | |
1535 | int GetWeeks() const { return m_weeks; } | |
1536 | // get number of days | |
1537 | int GetDays() const { return m_days; } | |
1538 | // returns 7*GetWeeks() + GetDays() | |
1539 | int GetTotalDays() const { return 7*m_weeks + m_days; } | |
1540 | ||
cd0b1709 | 1541 | // arithmetics with date spans (see also below for more operators) |
0979c962 VZ |
1542 | // ------------------------------------------------------------------------ |
1543 | ||
cd0b1709 VZ |
1544 | // return sum of two date spans |
1545 | inline wxDateSpan Add(const wxDateSpan& other) const; | |
0979c962 VZ |
1546 | // add another wxDateSpan to us |
1547 | inline wxDateSpan& Add(const wxDateSpan& other); | |
1548 | // add another wxDateSpan to us | |
1549 | inline wxDateSpan& operator+=(const wxDateSpan& other); | |
26364344 WS |
1550 | inline wxDateSpan operator+(const wxDateSpan& ds) const |
1551 | { | |
1552 | return wxDateSpan(GetYears() + ds.GetYears(), | |
1553 | GetMonths() + ds.GetMonths(), | |
1554 | GetWeeks() + ds.GetWeeks(), | |
1555 | GetDays() + ds.GetDays()); | |
1556 | } | |
0979c962 | 1557 | |
cd0b1709 | 1558 | // return difference of two date spans |
f6bcfd97 BP |
1559 | inline wxDateSpan Subtract(const wxDateSpan& other) const; |
1560 | // subtract another wxDateSpan from us | |
1561 | inline wxDateSpan& Subtract(const wxDateSpan& other); | |
1562 | // subtract another wxDateSpan from us | |
0979c962 | 1563 | inline wxDateSpan& operator-=(const wxDateSpan& other); |
26364344 WS |
1564 | inline wxDateSpan operator-(const wxDateSpan& ds) const |
1565 | { | |
1566 | return wxDateSpan(GetYears() - ds.GetYears(), | |
1567 | GetMonths() - ds.GetMonths(), | |
1568 | GetWeeks() - ds.GetWeeks(), | |
1569 | GetDays() - ds.GetDays()); | |
1570 | } | |
0979c962 VZ |
1571 | |
1572 | // return a copy of this time span with changed sign | |
1573 | inline wxDateSpan Negate() const; | |
1574 | // inverse the sign of this timespan | |
1575 | inline wxDateSpan& Neg(); | |
1576 | // inverse the sign of this timespan | |
1577 | wxDateSpan& operator-() { return Neg(); } | |
1578 | ||
cd0b1709 VZ |
1579 | // return the date span proportional to this one with given factor |
1580 | inline wxDateSpan Multiply(int factor) const; | |
0979c962 | 1581 | // multiply all components by a (signed) number |
cd0b1709 VZ |
1582 | inline wxDateSpan& Multiply(int factor); |
1583 | // multiply all components by a (signed) number | |
1584 | inline wxDateSpan& operator*=(int factor) { return Multiply(factor); } | |
26364344 WS |
1585 | inline wxDateSpan operator*(int n) const |
1586 | { | |
1587 | return wxDateSpan(*this).Multiply(n); | |
1588 | } | |
1589 | ||
1590 | // ds1 == d2 if and only if for every wxDateTime t t + ds1 == t + ds2 | |
1591 | inline bool operator==(const wxDateSpan& ds) const | |
1592 | { | |
1593 | return GetYears() == ds.GetYears() && | |
1594 | GetMonths() == ds.GetMonths() && | |
1595 | GetTotalDays() == ds.GetTotalDays(); | |
1596 | } | |
1597 | ||
1598 | inline bool operator!=(const wxDateSpan& ds) const | |
1599 | { | |
1600 | return !(*this == ds); | |
1601 | } | |
0979c962 VZ |
1602 | |
1603 | private: | |
1604 | int m_years, | |
1605 | m_months, | |
1606 | m_weeks, | |
1607 | m_days; | |
1608 | }; | |
1609 | ||
4f6aed9c VZ |
1610 | // ---------------------------------------------------------------------------- |
1611 | // wxDateTimeArray: array of dates. | |
1612 | // ---------------------------------------------------------------------------- | |
1613 | ||
bb24c68f | 1614 | WX_DECLARE_USER_EXPORTED_OBJARRAY(wxDateTime, wxDateTimeArray, WXDLLIMPEXP_BASE); |
4f6aed9c VZ |
1615 | |
1616 | // ---------------------------------------------------------------------------- | |
1617 | // wxDateTimeHolidayAuthority: an object of this class will decide whether a | |
1618 | // given date is a holiday and is used by all functions working with "work | |
1619 | // days". | |
1620 | // | |
1621 | // NB: the base class is an ABC, derived classes must implement the pure | |
1622 | // virtual methods to work with the holidays they correspond to. | |
1623 | // ---------------------------------------------------------------------------- | |
1624 | ||
b5dbe15d | 1625 | class WXDLLIMPEXP_FWD_BASE wxDateTimeHolidayAuthority; |
d5d29b8a | 1626 | WX_DEFINE_USER_EXPORTED_ARRAY_PTR(wxDateTimeHolidayAuthority *, |
bb24c68f | 1627 | wxHolidayAuthoritiesArray, |
fd497ede | 1628 | class WXDLLIMPEXP_BASE); |
4f6aed9c | 1629 | |
f6081a04 | 1630 | class wxDateTimeHolidaysModule; |
bddd7a8d | 1631 | class WXDLLIMPEXP_BASE wxDateTimeHolidayAuthority |
4f6aed9c | 1632 | { |
f6bcfd97 | 1633 | friend class wxDateTimeHolidaysModule; |
4f6aed9c | 1634 | public: |
68379eaf | 1635 | // returns true if the given date is a holiday |
4f6aed9c VZ |
1636 | static bool IsHoliday(const wxDateTime& dt); |
1637 | ||
1638 | // fills the provided array with all holidays in the given range, returns | |
1639 | // the number of them | |
1640 | static size_t GetHolidaysInRange(const wxDateTime& dtStart, | |
1641 | const wxDateTime& dtEnd, | |
1642 | wxDateTimeArray& holidays); | |
1643 | ||
1644 | // clear the list of holiday authorities | |
1645 | static void ClearAllAuthorities(); | |
1646 | ||
1647 | // add a new holiday authority (the pointer will be deleted by | |
1648 | // wxDateTimeHolidayAuthority) | |
1649 | static void AddAuthority(wxDateTimeHolidayAuthority *auth); | |
1650 | ||
30e671a5 | 1651 | // the base class must have a virtual dtor |
5e233068 | 1652 | virtual ~wxDateTimeHolidayAuthority(); |
30e671a5 | 1653 | |
4f6aed9c VZ |
1654 | protected: |
1655 | // this function is called to determine whether a given day is a holiday | |
1656 | virtual bool DoIsHoliday(const wxDateTime& dt) const = 0; | |
1657 | ||
1658 | // this function should fill the array with all holidays between the two | |
1659 | // given dates - it is implemented in the base class, but in a very | |
1660 | // inefficient way (it just iterates over all days and uses IsHoliday() for | |
1661 | // each of them), so it must be overridden in the derived class where the | |
1662 | // base class version may be explicitly used if needed | |
1663 | // | |
1664 | // returns the number of holidays in the given range and fills holidays | |
1665 | // array | |
1666 | virtual size_t DoGetHolidaysInRange(const wxDateTime& dtStart, | |
1667 | const wxDateTime& dtEnd, | |
1668 | wxDateTimeArray& holidays) const = 0; | |
1669 | ||
1670 | private: | |
1671 | // all holiday authorities | |
1672 | static wxHolidayAuthoritiesArray ms_authorities; | |
1673 | }; | |
1674 | ||
1675 | // the holidays for this class are all Saturdays and Sundays | |
bddd7a8d | 1676 | class WXDLLIMPEXP_BASE wxDateTimeWorkDays : public wxDateTimeHolidayAuthority |
4f6aed9c VZ |
1677 | { |
1678 | protected: | |
1679 | virtual bool DoIsHoliday(const wxDateTime& dt) const; | |
1680 | virtual size_t DoGetHolidaysInRange(const wxDateTime& dtStart, | |
1681 | const wxDateTime& dtEnd, | |
1682 | wxDateTimeArray& holidays) const; | |
1683 | }; | |
0979c962 | 1684 | |
2f02cb89 VZ |
1685 | // ============================================================================ |
1686 | // inline functions implementation | |
1687 | // ============================================================================ | |
1688 | ||
df5168c4 MB |
1689 | // ---------------------------------------------------------------------------- |
1690 | // private macros | |
1691 | // ---------------------------------------------------------------------------- | |
1692 | ||
1693 | #define MILLISECONDS_PER_DAY 86400000l | |
1694 | ||
1695 | // some broken compilers (HP-UX CC) refuse to compile the "normal" version, but | |
1696 | // using a temp variable always might prevent other compilers from optimising | |
1697 | // it away - hence use of this ugly macro | |
1698 | #ifndef __HPUX__ | |
1699 | #define MODIFY_AND_RETURN(op) return wxDateTime(*this).op | |
1700 | #else | |
1701 | #define MODIFY_AND_RETURN(op) wxDateTime dt(*this); dt.op; return dt | |
1702 | #endif | |
1703 | ||
1704 | // ---------------------------------------------------------------------------- | |
1705 | // wxDateTime construction | |
1706 | // ---------------------------------------------------------------------------- | |
1707 | ||
1708 | inline bool wxDateTime::IsInStdRange() const | |
1709 | { | |
57563c71 VZ |
1710 | // currently we don't know what is the real type of time_t so prefer to err |
1711 | // on the safe side and limit it to 32 bit values which is safe everywhere | |
1712 | return m_time >= 0l && (m_time / TIME_T_FACTOR) < wxINT32_MAX; | |
df5168c4 | 1713 | } |
2f02cb89 | 1714 | |
df5168c4 MB |
1715 | /* static */ |
1716 | inline wxDateTime wxDateTime::Now() | |
1717 | { | |
a452689b SN |
1718 | struct tm tmstruct; |
1719 | return wxDateTime(*GetTmNow(&tmstruct)); | |
df5168c4 MB |
1720 | } |
1721 | ||
1722 | /* static */ | |
1723 | inline wxDateTime wxDateTime::Today() | |
1724 | { | |
cb1ef833 VZ |
1725 | wxDateTime dt(Now()); |
1726 | dt.ResetTime(); | |
df5168c4 | 1727 | |
cb1ef833 | 1728 | return dt; |
df5168c4 MB |
1729 | } |
1730 | ||
1731 | #if (!(defined(__VISAGECPP__) && __IBMCPP__ >= 400)) | |
1732 | inline wxDateTime& wxDateTime::Set(time_t timet) | |
1733 | { | |
1734 | // assign first to avoid long multiplication overflow! | |
1735 | m_time = timet - WX_TIME_BASE_OFFSET ; | |
1736 | m_time *= TIME_T_FACTOR; | |
1737 | ||
1738 | return *this; | |
1739 | } | |
2f02cb89 VZ |
1740 | #endif |
1741 | ||
df5168c4 MB |
1742 | inline wxDateTime& wxDateTime::SetToCurrent() |
1743 | { | |
1744 | *this = Now(); | |
1745 | return *this; | |
1746 | } | |
1747 | ||
1748 | #if (!(defined(__VISAGECPP__) && __IBMCPP__ >= 400)) | |
1749 | inline wxDateTime::wxDateTime(time_t timet) | |
1750 | { | |
1751 | Set(timet); | |
1752 | } | |
dc84437e | 1753 | #endif |
2f02cb89 | 1754 | |
df5168c4 MB |
1755 | inline wxDateTime::wxDateTime(const struct tm& tm) |
1756 | { | |
1757 | Set(tm); | |
1758 | } | |
1759 | ||
1760 | inline wxDateTime::wxDateTime(const Tm& tm) | |
1761 | { | |
1762 | Set(tm); | |
1763 | } | |
1764 | ||
1765 | inline wxDateTime::wxDateTime(double jdn) | |
1766 | { | |
1767 | Set(jdn); | |
1768 | } | |
1769 | ||
1770 | inline wxDateTime& wxDateTime::Set(const Tm& tm) | |
1771 | { | |
9a83f860 | 1772 | wxASSERT_MSG( tm.IsValid(), wxT("invalid broken down date/time") ); |
df5168c4 | 1773 | |
271f6072 VZ |
1774 | return Set(tm.mday, (Month)tm.mon, tm.year, |
1775 | tm.hour, tm.min, tm.sec, tm.msec); | |
df5168c4 MB |
1776 | } |
1777 | ||
1778 | inline wxDateTime::wxDateTime(wxDateTime_t hour, | |
1779 | wxDateTime_t minute, | |
1780 | wxDateTime_t second, | |
1781 | wxDateTime_t millisec) | |
1782 | { | |
1783 | Set(hour, minute, second, millisec); | |
1784 | } | |
1785 | ||
1786 | inline wxDateTime::wxDateTime(wxDateTime_t day, | |
1787 | Month month, | |
1788 | int year, | |
1789 | wxDateTime_t hour, | |
1790 | wxDateTime_t minute, | |
1791 | wxDateTime_t second, | |
1792 | wxDateTime_t millisec) | |
1793 | { | |
1794 | Set(day, month, year, hour, minute, second, millisec); | |
1795 | } | |
1796 | ||
1797 | // ---------------------------------------------------------------------------- | |
1798 | // wxDateTime accessors | |
1799 | // ---------------------------------------------------------------------------- | |
1800 | ||
1801 | inline wxLongLong wxDateTime::GetValue() const | |
1802 | { | |
9a83f860 | 1803 | wxASSERT_MSG( IsValid(), wxT("invalid wxDateTime")); |
df5168c4 MB |
1804 | |
1805 | return m_time; | |
1806 | } | |
1807 | ||
1808 | inline time_t wxDateTime::GetTicks() const | |
1809 | { | |
9a83f860 | 1810 | wxASSERT_MSG( IsValid(), wxT("invalid wxDateTime")); |
df5168c4 MB |
1811 | if ( !IsInStdRange() ) |
1812 | { | |
1813 | return (time_t)-1; | |
1814 | } | |
1815 | ||
d3c58c7e | 1816 | return (time_t)((m_time / (long)TIME_T_FACTOR).ToLong()) + WX_TIME_BASE_OFFSET; |
df5168c4 MB |
1817 | } |
1818 | ||
1819 | inline bool wxDateTime::SetToLastWeekDay(WeekDay weekday, | |
1820 | Month month, | |
1821 | int year) | |
1822 | { | |
1823 | return SetToWeekDay(weekday, -1, month, year); | |
1824 | } | |
1825 | ||
fc7a2a60 VZ |
1826 | inline wxDateTime |
1827 | wxDateTime::GetWeekDayInSameWeek(WeekDay weekday, | |
1828 | WeekFlags WXUNUSED(flags)) const | |
df5168c4 MB |
1829 | { |
1830 | MODIFY_AND_RETURN( SetToWeekDayInSameWeek(weekday) ); | |
1831 | } | |
1832 | ||
1833 | inline wxDateTime wxDateTime::GetNextWeekDay(WeekDay weekday) const | |
1834 | { | |
1835 | MODIFY_AND_RETURN( SetToNextWeekDay(weekday) ); | |
1836 | } | |
1837 | ||
1838 | inline wxDateTime wxDateTime::GetPrevWeekDay(WeekDay weekday) const | |
1839 | { | |
1840 | MODIFY_AND_RETURN( SetToPrevWeekDay(weekday) ); | |
1841 | } | |
1842 | ||
1843 | inline wxDateTime wxDateTime::GetWeekDay(WeekDay weekday, | |
1844 | int n, | |
1845 | Month month, | |
1846 | int year) const | |
1847 | { | |
1848 | wxDateTime dt(*this); | |
1849 | ||
1850 | return dt.SetToWeekDay(weekday, n, month, year) ? dt : wxInvalidDateTime; | |
1851 | } | |
1852 | ||
1853 | inline wxDateTime wxDateTime::GetLastWeekDay(WeekDay weekday, | |
1854 | Month month, | |
1855 | int year) | |
1856 | { | |
1857 | wxDateTime dt(*this); | |
1858 | ||
1859 | return dt.SetToLastWeekDay(weekday, month, year) ? dt : wxInvalidDateTime; | |
1860 | } | |
1861 | ||
df5168c4 MB |
1862 | inline wxDateTime wxDateTime::GetLastMonthDay(Month month, int year) const |
1863 | { | |
1864 | MODIFY_AND_RETURN( SetToLastMonthDay(month, year) ); | |
1865 | } | |
1866 | ||
1867 | inline wxDateTime wxDateTime::GetYearDay(wxDateTime_t yday) const | |
1868 | { | |
1869 | MODIFY_AND_RETURN( SetToYearDay(yday) ); | |
1870 | } | |
1871 | ||
1872 | // ---------------------------------------------------------------------------- | |
1873 | // wxDateTime comparison | |
1874 | // ---------------------------------------------------------------------------- | |
1875 | ||
1876 | inline bool wxDateTime::IsEqualTo(const wxDateTime& datetime) const | |
1877 | { | |
9a83f860 | 1878 | wxASSERT_MSG( IsValid() && datetime.IsValid(), wxT("invalid wxDateTime")); |
df5168c4 MB |
1879 | |
1880 | return m_time == datetime.m_time; | |
1881 | } | |
1882 | ||
1883 | inline bool wxDateTime::IsEarlierThan(const wxDateTime& datetime) const | |
1884 | { | |
9a83f860 | 1885 | wxASSERT_MSG( IsValid() && datetime.IsValid(), wxT("invalid wxDateTime")); |
df5168c4 MB |
1886 | |
1887 | return m_time < datetime.m_time; | |
1888 | } | |
1889 | ||
1890 | inline bool wxDateTime::IsLaterThan(const wxDateTime& datetime) const | |
1891 | { | |
9a83f860 | 1892 | wxASSERT_MSG( IsValid() && datetime.IsValid(), wxT("invalid wxDateTime")); |
df5168c4 MB |
1893 | |
1894 | return m_time > datetime.m_time; | |
1895 | } | |
1896 | ||
1897 | inline bool wxDateTime::IsStrictlyBetween(const wxDateTime& t1, | |
1898 | const wxDateTime& t2) const | |
1899 | { | |
1900 | // no need for assert, will be checked by the functions we call | |
1901 | return IsLaterThan(t1) && IsEarlierThan(t2); | |
1902 | } | |
1903 | ||
1904 | inline bool wxDateTime::IsBetween(const wxDateTime& t1, | |
1905 | const wxDateTime& t2) const | |
1906 | { | |
1907 | // no need for assert, will be checked by the functions we call | |
1908 | return IsEqualTo(t1) || IsEqualTo(t2) || IsStrictlyBetween(t1, t2); | |
1909 | } | |
1910 | ||
1911 | inline bool wxDateTime::IsSameDate(const wxDateTime& dt) const | |
1912 | { | |
1913 | Tm tm1 = GetTm(), | |
1914 | tm2 = dt.GetTm(); | |
1915 | ||
1916 | return tm1.year == tm2.year && | |
1917 | tm1.mon == tm2.mon && | |
1918 | tm1.mday == tm2.mday; | |
1919 | } | |
1920 | ||
1921 | inline bool wxDateTime::IsSameTime(const wxDateTime& dt) const | |
1922 | { | |
1923 | // notice that we can't do something like this: | |
1924 | // | |
1925 | // m_time % MILLISECONDS_PER_DAY == dt.m_time % MILLISECONDS_PER_DAY | |
1926 | // | |
1927 | // because we have also to deal with (possibly) different DST settings! | |
1928 | Tm tm1 = GetTm(), | |
1929 | tm2 = dt.GetTm(); | |
1930 | ||
1931 | return tm1.hour == tm2.hour && | |
1932 | tm1.min == tm2.min && | |
1933 | tm1.sec == tm2.sec && | |
1934 | tm1.msec == tm2.msec; | |
1935 | } | |
1936 | ||
1937 | inline bool wxDateTime::IsEqualUpTo(const wxDateTime& dt, | |
1938 | const wxTimeSpan& ts) const | |
1939 | { | |
1940 | return IsBetween(dt.Subtract(ts), dt.Add(ts)); | |
1941 | } | |
1942 | ||
1943 | // ---------------------------------------------------------------------------- | |
1944 | // wxDateTime arithmetics | |
1945 | // ---------------------------------------------------------------------------- | |
1946 | ||
1947 | inline wxDateTime wxDateTime::Add(const wxTimeSpan& diff) const | |
1948 | { | |
9a83f860 | 1949 | wxASSERT_MSG( IsValid(), wxT("invalid wxDateTime")); |
df5168c4 MB |
1950 | |
1951 | return wxDateTime(m_time + diff.GetValue()); | |
1952 | } | |
1953 | ||
1954 | inline wxDateTime& wxDateTime::Add(const wxTimeSpan& diff) | |
1955 | { | |
9a83f860 | 1956 | wxASSERT_MSG( IsValid(), wxT("invalid wxDateTime")); |
df5168c4 MB |
1957 | |
1958 | m_time += diff.GetValue(); | |
1959 | ||
1960 | return *this; | |
1961 | } | |
1962 | ||
1963 | inline wxDateTime& wxDateTime::operator+=(const wxTimeSpan& diff) | |
1964 | { | |
1965 | return Add(diff); | |
1966 | } | |
1967 | ||
1968 | inline wxDateTime wxDateTime::Subtract(const wxTimeSpan& diff) const | |
1969 | { | |
9a83f860 | 1970 | wxASSERT_MSG( IsValid(), wxT("invalid wxDateTime")); |
df5168c4 MB |
1971 | |
1972 | return wxDateTime(m_time - diff.GetValue()); | |
1973 | } | |
1974 | ||
1975 | inline wxDateTime& wxDateTime::Subtract(const wxTimeSpan& diff) | |
1976 | { | |
9a83f860 | 1977 | wxASSERT_MSG( IsValid(), wxT("invalid wxDateTime")); |
df5168c4 MB |
1978 | |
1979 | m_time -= diff.GetValue(); | |
1980 | ||
1981 | return *this; | |
1982 | } | |
1983 | ||
1984 | inline wxDateTime& wxDateTime::operator-=(const wxTimeSpan& diff) | |
1985 | { | |
1986 | return Subtract(diff); | |
1987 | } | |
1988 | ||
1989 | inline wxTimeSpan wxDateTime::Subtract(const wxDateTime& datetime) const | |
1990 | { | |
9a83f860 | 1991 | wxASSERT_MSG( IsValid() && datetime.IsValid(), wxT("invalid wxDateTime")); |
df5168c4 MB |
1992 | |
1993 | return wxTimeSpan(GetValue() - datetime.GetValue()); | |
1994 | } | |
1995 | ||
26364344 WS |
1996 | inline wxTimeSpan wxDateTime::operator-(const wxDateTime& dt2) const |
1997 | { | |
1998 | return this->Subtract(dt2); | |
1999 | } | |
2000 | ||
df5168c4 MB |
2001 | inline wxDateTime wxDateTime::Add(const wxDateSpan& diff) const |
2002 | { | |
2003 | return wxDateTime(*this).Add(diff); | |
2004 | } | |
2005 | ||
2006 | inline wxDateTime& wxDateTime::Subtract(const wxDateSpan& diff) | |
2007 | { | |
2008 | return Add(diff.Negate()); | |
2009 | } | |
2010 | ||
2011 | inline wxDateTime wxDateTime::Subtract(const wxDateSpan& diff) const | |
2012 | { | |
2013 | return wxDateTime(*this).Subtract(diff); | |
2014 | } | |
2015 | ||
2016 | inline wxDateTime& wxDateTime::operator-=(const wxDateSpan& diff) | |
2017 | { | |
2018 | return Subtract(diff); | |
2019 | } | |
2020 | ||
2021 | inline wxDateTime& wxDateTime::operator+=(const wxDateSpan& diff) | |
2022 | { | |
2023 | return Add(diff); | |
2024 | } | |
2025 | ||
2026 | // ---------------------------------------------------------------------------- | |
2027 | // wxDateTime and timezones | |
2028 | // ---------------------------------------------------------------------------- | |
2029 | ||
d26adb9d VZ |
2030 | inline wxDateTime |
2031 | wxDateTime::ToTimezone(const wxDateTime::TimeZone& tz, bool noDST) const | |
df5168c4 MB |
2032 | { |
2033 | MODIFY_AND_RETURN( MakeTimezone(tz, noDST) ); | |
2034 | } | |
2035 | ||
d26adb9d VZ |
2036 | inline wxDateTime |
2037 | wxDateTime::FromTimezone(const wxDateTime::TimeZone& tz, bool noDST) const | |
2038 | { | |
2039 | MODIFY_AND_RETURN( MakeFromTimezone(tz, noDST) ); | |
2040 | } | |
2041 | ||
df5168c4 MB |
2042 | // ---------------------------------------------------------------------------- |
2043 | // wxTimeSpan construction | |
2044 | // ---------------------------------------------------------------------------- | |
2045 | ||
2046 | inline wxTimeSpan::wxTimeSpan(long hours, | |
2047 | long minutes, | |
9c21e80b VZ |
2048 | wxLongLong seconds, |
2049 | wxLongLong milliseconds) | |
df5168c4 MB |
2050 | { |
2051 | // assign first to avoid precision loss | |
2052 | m_diff = hours; | |
2053 | m_diff *= 60l; | |
2054 | m_diff += minutes; | |
2055 | m_diff *= 60l; | |
2056 | m_diff += seconds; | |
2057 | m_diff *= 1000l; | |
2058 | m_diff += milliseconds; | |
2059 | } | |
2060 | ||
2061 | // ---------------------------------------------------------------------------- | |
2062 | // wxTimeSpan accessors | |
2063 | // ---------------------------------------------------------------------------- | |
2064 | ||
2065 | inline wxLongLong wxTimeSpan::GetSeconds() const | |
2066 | { | |
2067 | return m_diff / 1000l; | |
2068 | } | |
2069 | ||
2070 | inline int wxTimeSpan::GetMinutes() const | |
2071 | { | |
18c7af7e VZ |
2072 | // explicit cast to int suppresses a warning with CodeWarrior and possibly |
2073 | // others (changing the return type to long from int is impossible in 2.8) | |
2074 | return (int)((GetSeconds() / 60l).GetLo()); | |
df5168c4 MB |
2075 | } |
2076 | ||
2077 | inline int wxTimeSpan::GetHours() const | |
2078 | { | |
2079 | return GetMinutes() / 60; | |
2080 | } | |
2081 | ||
2082 | inline int wxTimeSpan::GetDays() const | |
2083 | { | |
2084 | return GetHours() / 24; | |
2085 | } | |
2086 | ||
2087 | inline int wxTimeSpan::GetWeeks() const | |
2088 | { | |
2089 | return GetDays() / 7; | |
2090 | } | |
2091 | ||
2092 | // ---------------------------------------------------------------------------- | |
2093 | // wxTimeSpan arithmetics | |
2094 | // ---------------------------------------------------------------------------- | |
2095 | ||
2096 | inline wxTimeSpan wxTimeSpan::Add(const wxTimeSpan& diff) const | |
2097 | { | |
2098 | return wxTimeSpan(m_diff + diff.GetValue()); | |
2099 | } | |
2100 | ||
2101 | inline wxTimeSpan& wxTimeSpan::Add(const wxTimeSpan& diff) | |
2102 | { | |
2103 | m_diff += diff.GetValue(); | |
2104 | ||
2105 | return *this; | |
2106 | } | |
2107 | ||
2108 | inline wxTimeSpan wxTimeSpan::Subtract(const wxTimeSpan& diff) const | |
2109 | { | |
2110 | return wxTimeSpan(m_diff - diff.GetValue()); | |
2111 | } | |
2112 | ||
2113 | inline wxTimeSpan& wxTimeSpan::Subtract(const wxTimeSpan& diff) | |
2114 | { | |
2115 | m_diff -= diff.GetValue(); | |
2116 | ||
2117 | return *this; | |
2118 | } | |
2119 | ||
2120 | inline wxTimeSpan& wxTimeSpan::Multiply(int n) | |
2121 | { | |
2122 | m_diff *= (long)n; | |
2123 | ||
2124 | return *this; | |
2125 | } | |
2126 | ||
2127 | inline wxTimeSpan wxTimeSpan::Multiply(int n) const | |
2128 | { | |
2129 | return wxTimeSpan(m_diff * (long)n); | |
2130 | } | |
2131 | ||
2132 | inline wxTimeSpan wxTimeSpan::Abs() const | |
2133 | { | |
2134 | return wxTimeSpan(GetValue().Abs()); | |
2135 | } | |
2136 | ||
2137 | inline bool wxTimeSpan::IsEqualTo(const wxTimeSpan& ts) const | |
2138 | { | |
2139 | return GetValue() == ts.GetValue(); | |
2140 | } | |
2141 | ||
2142 | inline bool wxTimeSpan::IsLongerThan(const wxTimeSpan& ts) const | |
2143 | { | |
2144 | return GetValue().Abs() > ts.GetValue().Abs(); | |
f7541d48 VZ |
2145 | } |
2146 | ||
2147 | inline bool wxTimeSpan::IsShorterThan(const wxTimeSpan& ts) const | |
2148 | { | |
2149 | return GetValue().Abs() < ts.GetValue().Abs(); | |
df5168c4 MB |
2150 | } |
2151 | ||
2152 | // ---------------------------------------------------------------------------- | |
2153 | // wxDateSpan | |
2154 | // ---------------------------------------------------------------------------- | |
2155 | ||
2156 | inline wxDateSpan& wxDateSpan::operator+=(const wxDateSpan& other) | |
2157 | { | |
2158 | m_years += other.m_years; | |
2159 | m_months += other.m_months; | |
2160 | m_weeks += other.m_weeks; | |
2161 | m_days += other.m_days; | |
2162 | ||
2163 | return *this; | |
2164 | } | |
2165 | ||
2166 | inline wxDateSpan& wxDateSpan::Add(const wxDateSpan& other) | |
2167 | { | |
2168 | return *this += other; | |
2169 | } | |
2170 | ||
2171 | inline wxDateSpan wxDateSpan::Add(const wxDateSpan& other) const | |
2172 | { | |
2173 | wxDateSpan ds(*this); | |
2174 | ds.Add(other); | |
2175 | return ds; | |
2176 | } | |
2177 | ||
2178 | inline wxDateSpan& wxDateSpan::Multiply(int factor) | |
2179 | { | |
2180 | m_years *= factor; | |
2181 | m_months *= factor; | |
2182 | m_weeks *= factor; | |
2183 | m_days *= factor; | |
2184 | ||
2185 | return *this; | |
2186 | } | |
2187 | ||
2188 | inline wxDateSpan wxDateSpan::Multiply(int factor) const | |
2189 | { | |
2190 | wxDateSpan ds(*this); | |
2191 | ds.Multiply(factor); | |
2192 | return ds; | |
2193 | } | |
2194 | ||
2195 | inline wxDateSpan wxDateSpan::Negate() const | |
2196 | { | |
2197 | return wxDateSpan(-m_years, -m_months, -m_weeks, -m_days); | |
2198 | } | |
2199 | ||
2200 | inline wxDateSpan& wxDateSpan::Neg() | |
2201 | { | |
2202 | m_years = -m_years; | |
2203 | m_months = -m_months; | |
2204 | m_weeks = -m_weeks; | |
2205 | m_days = -m_days; | |
2206 | ||
2207 | return *this; | |
2208 | } | |
2209 | ||
2210 | inline wxDateSpan& wxDateSpan::operator-=(const wxDateSpan& other) | |
2211 | { | |
2212 | return *this += other.Negate(); | |
2213 | } | |
2214 | ||
2215 | inline wxDateSpan& wxDateSpan::Subtract(const wxDateSpan& other) | |
2216 | { | |
2217 | return *this -= other; | |
2218 | } | |
2219 | ||
2220 | inline wxDateSpan wxDateSpan::Subtract(const wxDateSpan& other) const | |
2221 | { | |
2222 | wxDateSpan ds(*this); | |
2223 | ds.Subtract(other); | |
2224 | return ds; | |
2225 | } | |
2226 | ||
2227 | #undef MILLISECONDS_PER_DAY | |
2228 | ||
2229 | #undef MODIFY_AND_RETURN | |
2230 | ||
0979c962 VZ |
2231 | // ============================================================================ |
2232 | // binary operators | |
2233 | // ============================================================================ | |
2234 | ||
0979c962 VZ |
2235 | // ---------------------------------------------------------------------------- |
2236 | // wxTimeSpan operators | |
2237 | // ---------------------------------------------------------------------------- | |
2238 | ||
26364344 | 2239 | wxTimeSpan WXDLLIMPEXP_BASE operator*(int n, const wxTimeSpan& ts); |
0979c962 VZ |
2240 | |
2241 | // ---------------------------------------------------------------------------- | |
2242 | // wxDateSpan | |
2243 | // ---------------------------------------------------------------------------- | |
2244 | ||
26364344 | 2245 | wxDateSpan WXDLLIMPEXP_BASE operator*(int n, const wxDateSpan& ds); |
cd0b1709 VZ |
2246 | |
2247 | // ============================================================================ | |
2248 | // other helper functions | |
2249 | // ============================================================================ | |
2250 | ||
2251 | // ---------------------------------------------------------------------------- | |
2252 | // iteration helpers: can be used to write a for loop over enum variable like | |
2253 | // this: | |
2254 | // for ( m = wxDateTime::Jan; m < wxDateTime::Inv_Month; wxNextMonth(m) ) | |
2255 | // ---------------------------------------------------------------------------- | |
2256 | ||
26364344 WS |
2257 | WXDLLIMPEXP_BASE void wxNextMonth(wxDateTime::Month& m); |
2258 | WXDLLIMPEXP_BASE void wxPrevMonth(wxDateTime::Month& m); | |
2259 | WXDLLIMPEXP_BASE void wxNextWDay(wxDateTime::WeekDay& wd); | |
2260 | WXDLLIMPEXP_BASE void wxPrevWDay(wxDateTime::WeekDay& wd); | |
0979c962 | 2261 | |
e421922f VZ |
2262 | #endif // wxUSE_DATETIME |
2263 | ||
2f02cb89 | 2264 | #endif // _WX_DATETIME_H |