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