1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
|
#ifndef _sys_Time_h
#define _sys_Time_h
/*
*
* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. The ASF licenses this file
* to you under the Apache License, Version 2.0 (the
* "License"); you may not use this file except in compliance
* with the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing,
* software distributed under the License is distributed on an
* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
* KIND, either express or implied. See the License for the
* specific language governing permissions and limitations
* under the License.
*
*/
#include "qpid/sys/IntegerTypes.h"
/*
* The platform defines its notion of time as a TimePrivate type. The
* platform's implementation knows how to handle this type.
*/
#if defined (_WIN32)
# include "windows/Time.h"
#else
# include "posix/Time.h"
#endif
#include <limits>
#include <iosfwd>
namespace qpid {
namespace sys {
class Duration;
/**
* @class AbsTime
*
* Class to represent an instant in time.
*
* The time resolution is in nanosecs, and this is held with 64 bits
* giving a total time span from about 25 million years ago to 25 million
* years hence. As an aside the internal time can sensibly be negative
* meaning before the epoch (probably 1/1/1970 although this class doesn't
* care).
*
* The AbsTime class is a value class and so you don't need to add any
* accessors to its internal state. If you think you want to replace its value,
* you need to construct a new AbsTime and assign it, viz:
*
* AbsTime when = AbsTime::now();
* ...
* when = AbsTime(when, 2*TIME_SEC); // Advance timer 2 secs
*
* If for some reason you need access to the internal nanosec value you need
* to convert the AbsTime to a Duration and use its conversion to int64_t, viz:
*
* AbsTime now = AbsTime::now();
*
* int64_t ns = Duration(now);
*
* However note that the nanosecond value that is returned here is not
* defined to be anything in particular and could vary from platform to
* platform.
*
* There are some sensible operations that are currently missing from
* AbsTime, but nearly all that's needed can be done with a mixture of
* AbsTimes and Durations.
*
* For example, convenience operators to add a Duration and AbsTime returning
* an AbsTime would fit here (although you can already perform the operation
* with one of the AbsTime constructors). However trying to add 2 AbsTimes
* doesn't make sense.
*/
class AbsTime {
friend class Duration;
TimePrivate timepoint;
public:
inline AbsTime() {}
AbsTime(const AbsTime& time0, const Duration& duration);
// Default assignment operation fine
// Default copy constructor fine
static AbsTime now();
static AbsTime FarFuture();
const TimePrivate& getPrivate(void) const { return timepoint; }
bool operator==(const AbsTime& t) const { return t.timepoint == timepoint; }
template <class S> void serialize(S& s) { s(timepoint); }
friend bool operator<(const AbsTime& a, const AbsTime& b);
friend bool operator>(const AbsTime& a, const AbsTime& b);
friend std::ostream& operator << (std::ostream&, const AbsTime&);
};
std::ostream& operator << (std::ostream&, const AbsTime&);
/**
* @class Duration
* Class to represent the duration between instants of time.
*
* As AbsTime, this class also uses nanosecs for its time
* resolution where possible. For the most part a duration can be dealt
* with like a 64 bit integer, and indeed there is an implicit conversion which
* makes this quite convenient.
*/
class Duration {
static int64_t max() { return std::numeric_limits<int64_t>::max(); }
int64_t nanosecs;
friend class AbsTime;
public:
inline Duration(int64_t time0);
explicit Duration(const AbsTime& time0);
explicit Duration(const AbsTime& start, const AbsTime& finish);
inline operator int64_t() const;
};
std::ostream& operator << (std::ostream&, const Duration&);
inline AbsTime now() { return AbsTime::now(); }
inline bool operator<(const AbsTime& a, const AbsTime& b)
{ return a.timepoint < b.timepoint; }
inline bool operator>(const AbsTime& a, const AbsTime& b)
{ return a.timepoint > b.timepoint; }
Duration::Duration(int64_t time0) :
nanosecs(time0)
{}
Duration::operator int64_t() const
{ return nanosecs; }
/** Nanoseconds per second. */
const Duration TIME_SEC = 1000*1000*1000;
/** Nanoseconds per millisecond */
const Duration TIME_MSEC = 1000*1000;
/** Nanoseconds per microseconds. */
const Duration TIME_USEC = 1000;
/** Nanoseconds per nanosecond. */
const Duration TIME_NSEC = 1;
/** Value to represent an infinite timeout */
const Duration TIME_INFINITE = std::numeric_limits<int64_t>::max();
/** Time greater than any other time */
const AbsTime FAR_FUTURE = AbsTime::FarFuture();
/** Portable sleep for a number of seconds */
void sleep(int secs);
/** Portable sleep for a number of microseconds */
void usleep(uint64_t usecs);
}}
#endif /*!_sys_Time_h*/
|
