Update copyright to LGPL on all files
[dyninst.git] / common / h / Time.h
1 /*
2  * Copyright (c) 1996-2009 Barton P. Miller
3  * 
4  * We provide the Paradyn Parallel Performance Tools (below
5  * described as "Paradyn") on an AS IS basis, and do not warrant its
6  * validity or performance.  We reserve the right to update, modify,
7  * or discontinue this software at any time.  We shall have no
8  * obligation to supply such updates or modifications or any other
9  * form of support to you.
10  * 
11  * By your use of Paradyn, you understand and agree that we (or any
12  * other person or entity with proprietary rights in Paradyn) are
13  * under no obligation to provide either maintenance services,
14  * update services, notices of latent defects, or correction of
15  * defects for Paradyn.
16  * 
17  * This library is free software; you can redistribute it and/or
18  * modify it under the terms of the GNU Lesser General Public
19  * License as published by the Free Software Foundation; either
20  * version 2.1 of the License, or (at your option) any later version.
21  * 
22  * This library is distributed in the hope that it will be useful,
23  * but WITHOUT ANY WARRANTY; without even the implied warranty of
24  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
25  * Lesser General Public License for more details.
26  * 
27  * You should have received a copy of the GNU Lesser General Public
28  * License along with this library; if not, write to the Free Software
29  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
30  */
31
32 #ifndef __TIME_H
33 #define __TIME_H
34
35 #include <assert.h>
36 #include "common/h/Types.h"
37 #include "common/h/fraction.h"
38
39 /* These user classes that are defined:
40    timeUnit  - eg. microsecond, minute, year
41                size: 32 bytes
42    timeBase  - represents the time that a timeStamp is based from  (eg. 1970)
43                size: 8 bytes
44    timeStamp - represents a point in time, ie. a length of time from a timeBase
45                size: 8 bytes
46    timeLength- represents a length of time
47                size: 8 bytes
48 */
49
50 // timeUnit ---------------------------------------------------
51
52 // A timeUnit represents a unit of time and thus consists of a ratio of how
53 // many nanoseconds (the standard unit decided upon) per unit of the
54 // represented time unit.  The timeUnit class is used by the timeStamp and
55 // timeLength classes for converting the represented base to (via
56 // ns_per_unit) and from (via units_per_ns) nanoseconds.
57
58 class timeUnit {
59  private:
60   // logically const
61    COMMON_EXPORT static const timeUnit *_leapYear;
62    COMMON_EXPORT static const timeUnit *_year;
63    COMMON_EXPORT static const timeUnit *_day;
64    COMMON_EXPORT static const timeUnit *_hour;
65    COMMON_EXPORT static const timeUnit *_minute;
66    COMMON_EXPORT static const timeUnit *_sec;
67    COMMON_EXPORT static const timeUnit *_ms;
68    COMMON_EXPORT static const timeUnit *_us;
69    COMMON_EXPORT static const timeUnit *_ns;
70    COMMON_EXPORT static const timeUnit *nsHelp();
71    COMMON_EXPORT static const timeUnit *usHelp();
72    COMMON_EXPORT static const timeUnit *msHelp();
73    COMMON_EXPORT static const timeUnit *secHelp();
74    COMMON_EXPORT static const timeUnit *minHelp();
75    COMMON_EXPORT static const timeUnit *hourHelp();
76    COMMON_EXPORT static const timeUnit *dayHelp();
77    COMMON_EXPORT static const timeUnit *yearHelp();
78    COMMON_EXPORT static const timeUnit *leapYearHelp();
79  public:
80    COMMON_EXPORT static const timeUnit &ns();
81    COMMON_EXPORT static const timeUnit &us();
82    COMMON_EXPORT static const timeUnit &ms();
83    COMMON_EXPORT static const timeUnit &sec();
84    COMMON_EXPORT static const timeUnit &minute();
85    COMMON_EXPORT static const timeUnit &hour();
86    COMMON_EXPORT static const timeUnit &day();
87    COMMON_EXPORT static const timeUnit &year();
88    COMMON_EXPORT static const timeUnit &leapYear();
89
90  public:
91   typedef enum { sparse, verbose } ostream_fmt; 
92    static ostream_fmt curFmt;
93
94  private:
95   fraction ns_per_unit;
96   fraction units_per_ns;
97
98  public:
99    COMMON_EXPORT timeUnit(fraction _ns_per_unit);
100   // default copy constructor
101
102   // Selectors
103    COMMON_EXPORT fraction get_ns_per_unit()  const;
104    COMMON_EXPORT fraction get_units_per_ns() const;
105
106   // Mutators
107    COMMON_EXPORT void set_ns_per_unit(const fraction &nspu);
108    COMMON_EXPORT int64_t cvtTo_ns(double  units) const;
109    COMMON_EXPORT int64_t cvtTo_ns(int64_t units) const;
110    COMMON_EXPORT double  cvtFrom_nsD(int64_t ns) const;
111    COMMON_EXPORT int64_t cvtFrom_nsI(int64_t ns) const;
112 };
113
114 COMMON_EXPORT ostream& operator<<(ostream&s, const timeUnit::ostream_fmt &u);
115 COMMON_EXPORT ostream& operator<<(ostream&s, const timeUnit &u);
116
117 class timeStamp;
118
119 // timeBase ---------------------------------------------------
120
121 // Represents the starting time that a timeStamp time is from.  For example
122 // time from gettimeofday has a time base of 1970.  I have set up these
123 // constant time bases:
124 // b1970: represents Jan 1, 12:00:00am 1970
125 // bStd:  represents Jan 1, 12:00:00am 2000
126 // bNone: no base, sometimes want timeStamp that has no time base as in
127 //        process times.  eg. for process time we care only about the length
128 //        of the time not so much the start time (ie. base)
129
130 // A timeBase is stored as number of nanoseconds from the represented (start)
131 // time to bStd (ie. Jan 1, 12:00:00am 2000).  This class also provides
132 // functions that convert nanoseconds to and from the represented time base
133 // and the standard time base (bStd).  No this is not the base class of any
134 // of timeParent, timeStamp, timeLength.  Sorry for any confusion.
135
136 class timeBase {
137  private:
138   // change internal time base to 2100 in the year 2050
139   COMMON_EXPORT static const timeBase *_b1970;  // logically const
140   COMMON_EXPORT static const timeBase *_bStd;
141   COMMON_EXPORT static const timeBase *bStdHelp();
142   COMMON_EXPORT static const timeBase *b1970Help();
143  public:
144   // ie. the year for the internal time base, if changed check to make
145   // sure timeBase::b1970Help() is still accurate
146   enum { StdBaseMark = 2000 };  
147   COMMON_EXPORT static const timeBase &bStd();
148   COMMON_EXPORT static const timeBase &b1970();
149   // bNone is for times like process time, time is counted since the
150   // start of the process representing the process time in regards to
151   // a real time base (not unit) as in b1970 doesn't make sense
152   COMMON_EXPORT static const timeBase &bNone();
153
154  private:
155   int64_t ns2StdBaseMark;  
156
157  public:
158   //Paradyn default base: from nearest century turnover
159
160   COMMON_EXPORT timeBase(int64_t ns2stdMark);
161   COMMON_EXPORT timeBase(timeStamp mark);  // defined inline below
162   COMMON_EXPORT int64_t get_ns2StdBaseMark() const;
163   COMMON_EXPORT int64_t cvtTo_bStd(int64_t ns) const;
164   COMMON_EXPORT double  cvtFrom_bStd(double ns) const;
165   COMMON_EXPORT int64_t cvtFrom_bStd(int64_t ns) const;
166 };
167
168 COMMON_EXPORT ostream& operator<<(ostream&s, timeBase b);
169
170 // Responsibilities:
171 //   - store time in a standard unit and time base, currently this is:
172 //        * standard unit:      nanoseconds
173 //        * standard time base: Jan 1, 12:00:00am 2000
174
175 // an abstract class
176 class timeParent {
177  private:
178   COMMON_EXPORT static const int64_t uninitializedValue;
179   int64_t ns;
180
181   // Constructors
182  public:
183   // Selectors
184   COMMON_EXPORT int64_t get_ns() const;
185
186   // returns true if the timeStamp is uninitialized
187   COMMON_EXPORT bool isInitialized() const;
188
189   // the disadvantage of having a timeParent operator<< via the help
190   // of this virtual put function is that it causes a pointer to the vtable
191   // to be carried around with all of our timeLengths and timeStamps
192   // and they become less lightweight
193   //  virtual ostream& put(ostream& s) const = 0;  // write *this to s
194
195  protected:
196   COMMON_EXPORT timeParent();
197   COMMON_EXPORT timeParent(int64_t _ns);
198   // Mutators
199   COMMON_EXPORT void assign(const int64_t v);
200   COMMON_EXPORT int64_t getRolloverTime(double t);
201 };
202
203 //ostream& operator<<(ostream& s, const timeParent &tp);
204
205 class timeLength;
206
207 // timeStamp ---------------------------------------------------
208
209 // A timeStamp represents a point in time.  To do this it stores the number
210 // of nanoseconds since the standard time base (Jan 1, 2000).  It provides a
211 // generic method of storing time.  It is based on a 64bit signed integer so
212 // it can represent any time at nanosecond granularity between year 2000 +-
213 // 292 years (ie. 1708-2292).
214
215 class timeStamp : public timeParent {
216  private:
217   COMMON_EXPORT static const timeStamp *_ts1800;
218   COMMON_EXPORT static const timeStamp *_ts1970;
219   COMMON_EXPORT static const timeStamp *_tsStd;  // ie. timeBase::InternalTimeBase (2000)
220   COMMON_EXPORT static const timeStamp *_ts2200;
221   COMMON_EXPORT static const timeStamp *ts1800Help();
222   COMMON_EXPORT static const timeStamp *ts1970Help();
223   COMMON_EXPORT static const timeStamp *tsStdHelp();
224   COMMON_EXPORT static const timeStamp *ts2200Help();
225  public:
226   COMMON_EXPORT static const timeStamp &ts1800();
227   COMMON_EXPORT static const timeStamp &ts1970();
228   COMMON_EXPORT static const timeStamp &tsStd();
229   COMMON_EXPORT static const timeStamp &ts2200();
230   COMMON_EXPORT static const timeStamp &tsLongAgoTime();
231   COMMON_EXPORT static const timeStamp &tsFarOffTime();
232
233   // need this constructor to use in vector container class
234   // value set to a "weird" value to represent uninitialized
235   COMMON_EXPORT timeStamp();
236   // eg. to create the time Jan 1, 1995 12:00am you could do this:
237   //    timeStamp myTime(25, timeUnit::year(), timeBase::b1970());
238   // one way to create July 20, 1976 8:35am:
239   //    timeStamp myBirthDay = timeStamp::b1970() + 4*timeLength::year() +
240   //                           2*timeStamp::leapYear() +
241   //                           202*timeLength::day() + 8*timeLength::hour() +
242   //                           35*timeLength::min();  
243   COMMON_EXPORT timeStamp(int64_t iTime, const timeUnit &u, timeBase b);
244   COMMON_EXPORT timeStamp(int iTime, const timeUnit &u, timeBase b);
245   COMMON_EXPORT timeStamp(const timeLength &tl, timeBase b);
246   COMMON_EXPORT timeStamp(double dTime, const timeUnit &u, timeBase b);
247
248   // Selectors
249   COMMON_EXPORT double getD(const timeUnit &u, timeBase b) const;
250   // eg. to get the number of seconds since 1970 do this: 
251   //        ts.getI(timeUnit::sec(), timeBase::b1970()) 
252   COMMON_EXPORT int64_t getI(const timeUnit &u, timeBase b) const;
253
254   // ostream& put(ostream& s) const { return s << *this; }
255
256   friend COMMON_EXPORT const timeStamp operator+=(timeStamp &ts, timeLength tl);
257   friend COMMON_EXPORT const timeStamp operator-=(timeStamp &ts, timeLength tl);
258   friend COMMON_EXPORT const timeLength operator-(const timeStamp a, const timeStamp b);
259   friend COMMON_EXPORT const timeStamp operator+(const timeStamp a, const timeLength b);
260   friend COMMON_EXPORT const timeStamp operator-(const timeStamp a, const timeLength b);
261   friend COMMON_EXPORT const timeStamp operator+(const timeLength a, const timeStamp b);
262   // non-member ==, !=, >, <, >=, <=  operators also defined for timeStamp
263
264  private:
265   COMMON_EXPORT void initI(int64_t iTime, const timeUnit &u, timeBase b);
266   COMMON_EXPORT timeStamp(int64_t ns_);
267 };
268
269 COMMON_EXPORT ostream& operator<<(ostream&s, timeStamp z);
270
271 // relTimeStamp ---------------------------------------------------
272 // A timeStamp that proceeds on a timeline based at "zero"
273 // It has no relation to time on the "date" timeline.  There is no
274 // map from the "zero" based timeline for the relTimeStamp to the timeline
275 // based on "human time" for the timeStamp class.
276
277 class relTimeStamp : public timeParent {
278  private:
279   COMMON_EXPORT static const relTimeStamp *_Zero;
280   COMMON_EXPORT static const relTimeStamp *ZeroHelp();
281  public:
282   COMMON_EXPORT static const relTimeStamp &Zero();
283
284   // need this constructor to use in vector container class
285   COMMON_EXPORT relTimeStamp();
286   COMMON_EXPORT relTimeStamp(int64_t iTime, const timeUnit &u);
287   COMMON_EXPORT relTimeStamp(int iTime, const timeUnit &u);
288   COMMON_EXPORT relTimeStamp(const timeLength &tl);
289   COMMON_EXPORT relTimeStamp(double dTime, const timeUnit &u);
290
291   // Selectors
292   COMMON_EXPORT double getD(const timeUnit &u) const;
293   COMMON_EXPORT int64_t getI(const timeUnit &u) const;
294   // ostream& put(ostream& s) const { return s << *this; }
295
296   friend COMMON_EXPORT const relTimeStamp operator+=(relTimeStamp &ts, timeLength tl);
297   friend COMMON_EXPORT const relTimeStamp operator-=(relTimeStamp &ts, timeLength tl);
298   friend COMMON_EXPORT const timeLength operator-(const relTimeStamp a,const relTimeStamp b);
299   friend COMMON_EXPORT const relTimeStamp operator+(const relTimeStamp a, const timeLength b);
300   friend COMMON_EXPORT const relTimeStamp operator-(const relTimeStamp a, const timeLength b);
301   friend COMMON_EXPORT const relTimeStamp operator+(const timeLength a, const relTimeStamp b);
302   // non-member ==, !=, >, <, >=, <=  operators also defined for relTimeStamp
303
304  private:
305   COMMON_EXPORT void initI(int64_t iTime, const timeUnit &u);
306   COMMON_EXPORT relTimeStamp(int64_t ns_);
307 };
308
309 COMMON_EXPORT ostream& operator<<(ostream&s, relTimeStamp z);
310
311 // timeLength ---------------------------------------------------
312
313 // A timeLength represents a length of time and has no notion of a start or
314 // base time.  It has a range of signed 64bit integer or about 292 years
315 // since we're counting nanoseconds.
316
317 class timeLength : public timeParent {
318  private:
319   // logically const
320   COMMON_EXPORT static const timeLength *_zero;
321   COMMON_EXPORT static const timeLength *_ns;
322   COMMON_EXPORT static const timeLength *_us;
323   COMMON_EXPORT static const timeLength *_ms;
324   COMMON_EXPORT static const timeLength *_sec;
325   COMMON_EXPORT static const timeLength *_minute;
326   COMMON_EXPORT static const timeLength *_hour;
327   COMMON_EXPORT static const timeLength *_day;
328   COMMON_EXPORT static const timeLength *_year;
329   COMMON_EXPORT static const timeLength *_leapYear;
330   COMMON_EXPORT static const timeLength *ZeroHelp();
331   COMMON_EXPORT static const timeLength *nsHelp();
332   COMMON_EXPORT static const timeLength *usHelp();
333   COMMON_EXPORT static const timeLength *msHelp();
334   COMMON_EXPORT static const timeLength *secHelp();
335   COMMON_EXPORT static const timeLength *minHelp();
336   COMMON_EXPORT static const timeLength *hourHelp();
337   COMMON_EXPORT static const timeLength *dayHelp();
338   COMMON_EXPORT static const timeLength *yearHelp();
339   COMMON_EXPORT static const timeLength *leapYearHelp();
340  public:
341   COMMON_EXPORT static const timeLength &Zero();
342   COMMON_EXPORT static const timeLength &ns();
343   COMMON_EXPORT static const timeLength &us();
344   COMMON_EXPORT static const timeLength &ms();
345   COMMON_EXPORT static const timeLength &sec();
346   COMMON_EXPORT static const timeLength &minute();
347   COMMON_EXPORT static const timeLength &hour();
348   COMMON_EXPORT static const timeLength &day();
349   COMMON_EXPORT static const timeLength &year();
350   COMMON_EXPORT static const timeLength &leapYear();
351
352   // need this constructor to use in vector container class
353   COMMON_EXPORT timeLength();
354   COMMON_EXPORT timeLength(int64_t iTime, const timeUnit &u);
355   COMMON_EXPORT timeLength(int iTime, const timeUnit &u);
356   COMMON_EXPORT timeLength(double dTime, const timeUnit &u);
357
358   // Selectors
359   COMMON_EXPORT double getD(const timeUnit &u) const;
360   COMMON_EXPORT int64_t getI(const timeUnit &u) const;
361
362   //ostream& put(ostream& s) const { return s << *this; }
363
364   friend COMMON_EXPORT const timeLength operator+=(timeLength &t, timeLength tl);
365   friend COMMON_EXPORT const timeLength operator-=(timeLength &t, timeLength tl);
366   friend COMMON_EXPORT const timeLength operator*=(timeLength &t, double d);
367   friend COMMON_EXPORT const timeLength operator/=(timeLength &t, double d);
368   friend COMMON_EXPORT const timeLength operator-(const timeLength &t);
369   friend COMMON_EXPORT const timeLength operator-(const timeStamp a, const timeStamp b);
370   friend COMMON_EXPORT const timeLength operator-(const relTimeStamp a,const relTimeStamp b);
371   friend COMMON_EXPORT const timeStamp operator+(const timeStamp a, const timeLength b);
372   friend COMMON_EXPORT const timeStamp operator-(const timeStamp a, const timeLength b);
373   friend COMMON_EXPORT const timeStamp operator+(const timeLength a, const timeStamp b);
374   friend COMMON_EXPORT const timeLength operator+(const timeLength a, const timeLength b);
375   friend COMMON_EXPORT const timeLength operator-(const timeLength a, const timeLength b);
376   friend COMMON_EXPORT const timeLength operator*(const timeLength a, const double b);
377   friend COMMON_EXPORT const timeLength operator/(const timeLength a, const double b);
378   friend COMMON_EXPORT const timeLength operator*(const double a, const timeLength b);
379   friend COMMON_EXPORT const timeLength operator/(const double a, const timeLength b);
380   friend COMMON_EXPORT double operator/(const timeLength a, const timeLength b);
381   // non-member ==, !=, >, <, >=, <=  operators also defined for timeLength
382
383  private:
384   COMMON_EXPORT void initI(int64_t iTime, const timeUnit &u);
385   // a fast constructor just for timeLength operators
386   COMMON_EXPORT timeLength(int64_t ns_);
387 };
388
389 COMMON_EXPORT ostream& operator<<(ostream&s, timeLength z);
390
391 // timeStamp +=/-= timeLength
392 COMMON_EXPORT const timeStamp operator+=(timeStamp &ts, timeLength tl);
393 COMMON_EXPORT const timeStamp operator-=(timeStamp &ts, timeLength tl);
394
395 // timeLength +=/-= timeLength
396 COMMON_EXPORT const timeLength operator+=(timeLength &t, timeLength tl);
397 COMMON_EXPORT const timeLength operator-=(timeLength &t, timeLength tl);
398
399 // timeLength *=, /= double
400 COMMON_EXPORT const timeLength operator*=(timeLength &t, double d);
401 COMMON_EXPORT const timeLength operator/=(timeLength &t, double d);
402
403 // - timeLength
404 COMMON_EXPORT const timeLength operator-(const timeLength &t);
405
406 // timeStamp - timeStamp = timeLength  ;  the length of time between time stamps
407 COMMON_EXPORT const timeLength operator-(const timeStamp a, const timeStamp b);
408
409 // timeStamp +/- timeLength = timeStamp
410 COMMON_EXPORT const timeStamp operator+(const timeStamp a, const timeLength b);
411 COMMON_EXPORT const timeStamp operator-(const timeStamp a, const timeLength b);
412
413 // timeLength + timeStamp = timeStamp
414 COMMON_EXPORT const timeStamp operator+(const timeLength a, const timeStamp b);
415 // timeLength - timeStamp doesn't make sense, ie. 3 days - Mar 9 = ?
416
417 // timeLength +/- timeLength = timeLength
418 COMMON_EXPORT const timeLength operator+(const timeLength a, const timeLength b);
419 COMMON_EXPORT const timeLength operator-(const timeLength a, const timeLength b);
420
421 // timeLength */ double = timeLength
422 COMMON_EXPORT const timeLength operator*(const timeLength a, const double b);
423 COMMON_EXPORT const timeLength operator/(const timeLength a, const double b);
424
425 // double */ timeLength = timeLength
426 COMMON_EXPORT const timeLength operator*(const double a, const timeLength b);
427 COMMON_EXPORT const timeLength operator/(const double a, const timeLength b);
428
429 // Be careful if writing * operators because Time is based at nanosecond
430 // level, which can overflow when multiplying times that seem small
431 // eg. Time(1,timeUnit::day) * Time(2,timeUnit::day) will overflow
432
433 // timeStamp @ timeStamp = bool
434 COMMON_EXPORT bool operator==(const timeStamp a, const timeStamp b);
435 COMMON_EXPORT bool operator!=(const timeStamp a, const timeStamp b);
436 COMMON_EXPORT bool operator>(const timeStamp a, const timeStamp b);
437 COMMON_EXPORT bool operator>=(const timeStamp a, const timeStamp b);
438 COMMON_EXPORT bool operator<(const timeStamp a, const timeStamp b);
439 COMMON_EXPORT bool operator<=(const timeStamp a, const timeStamp b);
440
441 COMMON_EXPORT timeStamp earlier(const timeStamp a, const timeStamp b);
442 COMMON_EXPORT timeStamp later(const timeStamp a, const timeStamp b);
443 // timeLength @ timeLength = bool
444 COMMON_EXPORT bool operator==(const timeLength a, const timeLength b);
445 COMMON_EXPORT bool operator!=(const timeLength a, const timeLength b);
446 COMMON_EXPORT bool operator>(const timeLength a, const timeLength b);
447 COMMON_EXPORT bool operator>=(const timeLength a, const timeLength b);
448 COMMON_EXPORT bool operator<(const timeLength a, const timeLength b);
449 COMMON_EXPORT bool operator<=(const timeLength a, const timeLength b);
450
451
452 COMMON_EXPORT timeLength minimum(const timeLength a, const timeLength b);
453
454 COMMON_EXPORT timeLength maximum(const timeLength a, const timeLength b);
455 COMMON_EXPORT const timeLength abs(const timeLength a);
456
457 // relTimeStamp +=/-= timeLength
458 COMMON_EXPORT const relTimeStamp operator+=(relTimeStamp &ts, timeLength tl);
459 COMMON_EXPORT const relTimeStamp operator-=(relTimeStamp &ts, timeLength tl);
460
461 // relTimeStamp - relTimeStamp = timeLength  ;  the length of time between time stamps
462 COMMON_EXPORT const timeLength operator-(const relTimeStamp a, const relTimeStamp b);
463
464 // relTimeStamp +/- relTimeLength = relTimeStamp
465 COMMON_EXPORT const relTimeStamp operator+(const relTimeStamp a, const timeLength b);
466 COMMON_EXPORT const relTimeStamp operator-(const relTimeStamp a, const timeLength b);
467
468 // timeLength + relTimeStamp = relTimeStamp
469 COMMON_EXPORT const relTimeStamp operator+(const timeLength a, const relTimeStamp b);
470 // timeLength - timeStamp doesn't make sense, ie. 3 days - Mar 9 = ?
471
472
473 // Be careful if writing * operators because Time is based at nanosecond
474 // level, which can overflow when multiplying times that seem small
475 // eg. Time(1,timeUnit::day) * Time(2,timeUnit::day) will overflow
476
477 // relTimeStamp @ relTimeStamp = bool
478 COMMON_EXPORT bool operator==(const relTimeStamp a, const relTimeStamp b);
479 COMMON_EXPORT bool operator!=(const relTimeStamp a, const relTimeStamp b);
480 COMMON_EXPORT bool operator>(const relTimeStamp a, const relTimeStamp b);
481 COMMON_EXPORT bool operator>=(const relTimeStamp a, const relTimeStamp b);
482 COMMON_EXPORT bool operator<(const relTimeStamp a, const relTimeStamp b);
483 COMMON_EXPORT bool operator<=(const relTimeStamp a, const relTimeStamp b);
484
485 COMMON_EXPORT relTimeStamp earlier(const relTimeStamp a, const relTimeStamp b);
486
487 COMMON_EXPORT relTimeStamp later(const relTimeStamp a, const relTimeStamp b);
488
489
490
491 #endif
492