globus_common  17.10
globus_time.h
Go to the documentation of this file.
1 
7 #if !defined(GLOBUS_TIME_H)
8 #define GLOBUS_TIME_H
9 
10 #include "globus_types.h"
11 #include <time.h>
12 
13 #ifdef __cplusplus
14 extern "C" {
15 #endif
16 
17 #define GLOBUS_I_TIME_INFINITY_SEC INT_MAX
18 #define GLOBUS_I_TIME_INFINITY_NSEC INT_MAX
19 #define GLOBUS_I_TIME_INFINITY_USEC INT_MAX
20 
21 #if defined(_WIN32) && !defined(_POSIX)
22 typedef struct globus_abstime_s
23 {
24  time_t tv_sec;
25  long tv_nsec;
26 } globus_abstime_t;
27 #else
28 typedef struct timespec globus_abstime_t;
29 #endif
30 
31 typedef struct timeval globus_reltime_t;
32 
36 #define GlobusTimeAbstimeSet(Abstime, Sec, USec) \
37 { \
38  GlobusTimeAbstimeGetCurrent(Abstime); \
39  (Abstime).tv_nsec += (USec * 1000); \
40  if((Abstime).tv_nsec >= 1000000000) \
41  { \
42  (Abstime).tv_sec += ((Abstime).tv_nsec / 1000000000);\
43  (Abstime).tv_nsec = (Abstime).tv_nsec % 1000000000; \
44  } \
45  (Abstime).tv_sec += Sec; \
46 }
50 #define GlobusTimeAbstimeGet(Abstime, Sec, USec) \
51 { \
52  Sec = (Abstime).tv_sec; \
53  USec = ((Abstime).tv_nsec / 1000); \
54 }
55 
59 #define GlobusTimeReltimeSet(Reltime, Sec, USec) \
60 { \
61  (Reltime).tv_usec = (USec); \
62  (Reltime).tv_sec = Sec; \
63  if((Reltime).tv_usec >= 1000000) \
64  { \
65  (Reltime).tv_sec += ((Reltime).tv_usec / 1000000);\
66  (Reltime).tv_usec = (Reltime).tv_usec % 1000000; \
67  } \
68 }
69 
70 #define GlobusTimeReltimeGet(Reltime, Sec, USec) \
71 { \
72  (USec) = (Reltime).tv_usec; \
73  (Sec) = (Reltime).tv_sec; \
74 }
75 
76 #define GlobusTimeAbstimePrintf(Abstime) \
77 { \
78  printf("sec -->%lu\n", (unsigned long) (Abstime).tv_sec); \
79  printf("nsec -->%lu\n", (unsigned long) (Abstime).tv_nsec); \
80 }
81 
82 #define GlobusTimeReltimePrintf(Reltime) \
83 { \
84  printf("sec -->%lu\n", (unsigned long) (Reltime).tv_sec); \
85  printf("usec -->%lu\n", (unsigned long) (Reltime).tv_usec); \
86 }
87 
91 #define GlobusTimeAbstimeDiff(Reltime, T1, T2) \
92 { \
93  int __res = globus_abstime_cmp(&(T1), &(T2)); \
94  if(__res < 0) \
95  { \
96  (Reltime).tv_sec = (T2).tv_sec - (T1).tv_sec; \
97  (Reltime).tv_usec = \
98  (((T2).tv_nsec - (T1).tv_nsec) / 1000); \
99  if((Reltime).tv_usec < 0) \
100  { \
101  (Reltime).tv_sec--; \
102  (Reltime).tv_usec += 1000000; \
103  } \
104  } \
105  else if(__res > 0) \
106  { \
107  (Reltime).tv_sec = (T1).tv_sec - (T2).tv_sec; \
108  (Reltime).tv_usec = \
109  (((T1).tv_nsec - (T2).tv_nsec) / 1000); \
110  if((Reltime).tv_usec < 0) \
111  { \
112  (Reltime).tv_sec--; \
113  (Reltime).tv_usec += 1000000; \
114  } \
115  } \
116  else \
117  { \
118  (Reltime).tv_sec = 0; \
119  (Reltime).tv_usec = 0; \
120  } \
121 }
122 
123 #define GlobusTimeReltimeDiff(Reltime, T1, T2) \
124 { \
125  int __res = globus_reltime_cmp(&(T1), &(T2)); \
126  if(__res < 0) \
127  { \
128  (Reltime).tv_sec = (T2).tv_sec - (T1).tv_sec; \
129  (Reltime).tv_usec = \
130  ((T2).tv_usec - (T1).tv_usec); \
131  if((Reltime).tv_usec < 0) \
132  { \
133  (Reltime).tv_sec--; \
134  (Reltime).tv_usec += 1000000; \
135  } \
136  } \
137  else if(__res > 0) \
138  { \
139  (Reltime).tv_sec = (T1).tv_sec - (T2).tv_sec; \
140  (Reltime).tv_usec = \
141  ((T1).tv_usec - (T2).tv_usec); \
142  if((Reltime).tv_usec < 0) \
143  { \
144  (Reltime).tv_sec--; \
145  (Reltime).tv_usec += 1000000; \
146  } \
147  } \
148  else \
149  { \
150  (Reltime).tv_sec = 0; \
151  (Reltime).tv_usec = 0; \
152  } \
153 }
154 
158 #define GlobusTimeReltimeToUSec(SlpInt, Reltime) \
159 { \
160  SlpInt = ((Reltime).tv_sec * 1000000) + \
161  ((Reltime).tv_usec); \
162 }
163 
167 #define GlobusTimeReltimeToMilliSec( Milliseconds, Reltime) \
168 { \
169  Milliseconds = ((Reltime).tv_sec * 1000) + \
170  ((Reltime).tv_usec)/ 1000; \
171 }
172 
176 #define GlobusTimeAbstimeInc(Abstime, Reltime) \
177 { \
178  (Abstime).tv_nsec += ((Reltime).tv_usec * 1000); \
179  if((Abstime).tv_nsec >= 1000000000) \
180  { \
181  (Abstime).tv_sec++; \
182  (Abstime).tv_nsec -= 1000000000; \
183  } \
184  (Abstime).tv_sec += (Reltime).tv_sec; \
185 }
186 
187 #define GlobusTimeAbstimeDec(Abstime, Reltime) \
188 { \
189  (Abstime).tv_nsec -= ((Reltime).tv_usec * 1000); \
190  if((Abstime).tv_nsec < 0) \
191  { \
192  (Abstime).tv_sec--; \
193  (Abstime).tv_nsec += 1000000000; \
194  } \
195  (Abstime).tv_sec -= (Reltime).tv_sec; \
196 }
197 
198 
202 #if defined(_WIN32)
203 # define GlobusTimeAbstimeGetCurrent(Abstime) \
204  { \
205  struct _timeb timebuffer; \
206  \
207  _ftime(&timebuffer); \
208  (Abstime).tv_sec = timebuffer.time; \
209  (Abstime).tv_nsec = (timebuffer.millitm * 1000000); \
210  }
211 #else
212 # define GlobusTimeAbstimeGetCurrent(Abstime) \
213  { \
214  struct timeval __time; \
215  \
216  gettimeofday(&__time, GLOBUS_NULL); \
217  (Abstime).tv_sec = __time.tv_sec; \
218  (Abstime).tv_nsec = (__time.tv_usec * 1000); \
219  }
220 #endif
221 
225 #define GlobusTimeAbstimeCopy(Dest, Src) \
226 { \
227  (Dest).tv_sec = (Src).tv_sec; \
228  (Dest).tv_nsec = (Src).tv_nsec; \
229 }
230 
234 #define GlobusTimeReltimeCopy(Dest, Src) \
235 { \
236  (Dest).tv_sec = (Src).tv_sec; \
237  (Dest).tv_usec = (Src).tv_usec; \
238 }
239 
243 #define GlobusTimeReltimeMultiply(Reltime, Factor) \
244 { \
245  (Reltime).tv_usec *= Factor; \
246  (Reltime).tv_sec *= Factor; \
247  \
248  if((Reltime).tv_usec >= 1000000) \
249  { \
250  (Reltime).tv_sec += ((Reltime).tv_usec / 1000000);\
251  (Reltime).tv_usec = (Reltime).tv_usec % 1000000; \
252  } \
253 }
254 
258 #define GlobusTimeReltimeDivide(Reltime, Factor) \
259 { \
260  (Reltime).tv_usec /= Factor; \
261  (Reltime).tv_sec /= Factor; \
262 }
263 
264 extern const globus_abstime_t globus_i_abstime_infinity;
265 extern const globus_abstime_t globus_i_abstime_zero;
266 extern const globus_reltime_t globus_i_reltime_infinity;
267 extern const globus_reltime_t globus_i_reltime_zero;
268 
277  const globus_abstime_t * abstime);
278 
284  const globus_abstime_t * abstime);
285 
291  const globus_reltime_t * reltime);
292 
303 int
305  const globus_abstime_t * abstime_1,
306  const globus_abstime_t * abstime_2);
307 
318 int
320  const globus_reltime_t * reltime_1,
321  const globus_reltime_t * reltime_2);
322 
323 
324 #ifdef __cplusplus
325 }
326 #endif
327 #endif /* GLOBUS_TIME_H */
int globus_reltime_cmp(const globus_reltime_t *reltime_1, const globus_reltime_t *reltime_2)
Definition: globus_time.c:116
globus_bool_t globus_time_abstime_is_infinity(const globus_abstime_t *abstime)
Definition: globus_time.c:47
globus_bool_t globus_time_reltime_is_infinity(const globus_reltime_t *reltime)
Definition: globus_time.c:60
int globus_abstime_cmp(const globus_abstime_t *abstime_1, const globus_abstime_t *abstime_2)
Definition: globus_time.c:73
globus_bool_t globus_time_has_expired(const globus_abstime_t *abstime)
Definition: globus_time.c:31
Common Primitive Types.
int globus_bool_t
Boolean type.
Definition: globus_types.h:78