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
169
170
171
172
173
174
175
|
#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 "qpid/CommonImportExport.h"
#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 = now();
* ...
* when = AbsTime(when, 2*TIME_SEC); // Advance timer 2 secs
*
* AbsTime is not intended to be used to represent calendar dates/times
* but you can construct a Duration since the Unix Epoch, 1970-1-1-00:00,
* so that you can convert to a date/time if needed:
*
* int64_t nanosec_since_epoch = Duration(EPOCH, now());
*
* 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;
friend class Condition;
TimePrivate timepoint;
public:
inline AbsTime() : timepoint() {}
QPID_COMMON_EXTERN AbsTime(const AbsTime& time0, const Duration& duration);
// Default assignment operation fine
// Default copy constructor fine
QPID_COMMON_EXTERN static AbsTime now();
QPID_COMMON_EXTERN static AbsTime FarFuture();
QPID_COMMON_EXTERN static AbsTime Epoch();
bool operator==(const AbsTime& t) const { return t.timepoint == timepoint; }
friend bool operator<(const AbsTime& a, const AbsTime& b);
friend bool operator>(const AbsTime& a, const AbsTime& b);
QPID_COMMON_EXTERN friend std::ostream& operator << (std::ostream&, const AbsTime&);
};
QPID_COMMON_EXTERN 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:
QPID_COMMON_INLINE_EXTERN inline Duration(int64_t time0 = 0);
QPID_COMMON_EXTERN 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();
/** Absolute time point for the Unix epoch: 1970-01-01T00:00:00 */
const AbsTime EPOCH = AbsTime::Epoch();
/** Time greater than any other time */
const AbsTime FAR_FUTURE = AbsTime::FarFuture();
/** Portable sleep for a number of seconds */
QPID_COMMON_EXTERN void sleep(int secs);
/** Portable sleep for a number of microseconds */
QPID_COMMON_EXTERN void usleep(uint64_t usecs);
/** Output formatted date/time for now*/
void outputFormattedNow(std::ostream&);
/** Output unformatted nanosecond-resolution time for now */
void outputHiresNow(std::ostream&);
}}
#endif /*!_sys_Time_h*/
|
