globus_time.h

Go to the documentation of this file.
00001 /*
00002  * Copyright 1999-2006 University of Chicago
00003  * 
00004  * Licensed under the Apache License, Version 2.0 (the "License");
00005  * you may not use this file except in compliance with the License.
00006  * You may obtain a copy of the License at
00007  * 
00008  * http://www.apache.org/licenses/LICENSE-2.0
00009  * 
00010  * Unless required by applicable law or agreed to in writing, software
00011  * distributed under the License is distributed on an "AS IS" BASIS,
00012  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
00013  * See the License for the specific language governing permissions and
00014  * limitations under the License.
00015  */
00016 
00022 #if !defined(GLOBUS_TIME_H)
00023 #define      GLOBUS_TIME_H
00024 
00025 #include "globus_types.h"
00026 #include <time.h>
00027 
00028 #ifdef __cplusplus
00029 extern "C" {
00030 #endif
00031 
00032 #define GLOBUS_I_TIME_INFINITY_SEC   INT_MAX
00033 #define GLOBUS_I_TIME_INFINITY_NSEC  INT_MAX
00034 #define GLOBUS_I_TIME_INFINITY_USEC  INT_MAX
00035 
00036 #if defined(_WIN32) && !defined(_POSIX)
00037 typedef struct globus_abstime_s
00038 {
00039    time_t  tv_sec;
00040    long    tv_nsec;
00041 } globus_abstime_t;
00042 #else
00043 typedef struct timespec      globus_abstime_t;
00044 #endif
00045 
00046 typedef struct timeval  globus_reltime_t;
00047 
00051 #define  GlobusTimeAbstimeSet(Abstime, Sec, USec)         \
00052 {                                                         \
00053     GlobusTimeAbstimeGetCurrent(Abstime);                 \
00054     (Abstime).tv_nsec += (USec * 1000);                   \
00055     if((Abstime).tv_nsec >= 1000000000)                    \
00056     {                                                     \
00057         (Abstime).tv_sec += ((Abstime).tv_nsec / 1000000000);\
00058         (Abstime).tv_nsec = (Abstime).tv_nsec  % 1000000000; \
00059     }                                                     \
00060     (Abstime).tv_sec += Sec;                              \
00061 }
00062 
00065 #define  GlobusTimeAbstimeGet(Abstime, Sec, USec)         \
00066 {                                                         \
00067     Sec = (Abstime).tv_sec;                               \
00068     USec = ((Abstime).tv_nsec / 1000);                    \
00069 }
00070 
00074 #define  GlobusTimeReltimeSet(Reltime, Sec, USec)         \
00075 {                                                         \
00076     (Reltime).tv_usec = (USec);                           \
00077     (Reltime).tv_sec = Sec;                               \
00078     if((Reltime).tv_usec >= 1000000)                      \
00079     {                                                     \
00080         (Reltime).tv_sec += ((Reltime).tv_usec / 1000000);\
00081         (Reltime).tv_usec = (Reltime).tv_usec  % 1000000; \
00082     }                                                     \
00083 }
00084 
00085 #define  GlobusTimeReltimeGet(Reltime, Sec, USec)         \
00086 {                                                         \
00087     (USec) = (Reltime).tv_usec;                           \
00088     (Sec) = (Reltime).tv_sec;                             \
00089 }
00090 
00091 #define  GlobusTimeAbstimePrintf(Abstime)                 \
00092 {                                                         \
00093     printf("sec  -->%lu\n", (unsigned long) (Abstime).tv_sec);            \
00094     printf("nsec -->%lu\n", (unsigned long) (Abstime).tv_nsec);           \
00095 }
00096 
00097 #define  GlobusTimeReltimePrintf(Reltime)                 \
00098 {                                                         \
00099     printf("sec  -->%lu\n", (unsigned long) (Reltime).tv_sec);            \
00100     printf("usec -->%lu\n", (unsigned long) (Reltime).tv_usec);           \
00101 }
00102 
00106 #define  GlobusTimeAbstimeDiff(Reltime, T1, T2)           \
00107 {                                                         \
00108     int __res = globus_abstime_cmp(&(T1), &(T2));         \
00109     if(__res < 0)                                         \
00110     {                                                     \
00111         (Reltime).tv_sec = (T2).tv_sec - (T1).tv_sec;     \
00112         (Reltime).tv_usec =                               \
00113                 (((T2).tv_nsec - (T1).tv_nsec) / 1000);   \
00114         if((Reltime).tv_usec < 0)                         \
00115         {                                                 \
00116             (Reltime).tv_sec--;                           \
00117             (Reltime).tv_usec += 1000000;                 \
00118         }                                                 \
00119     }                                                     \
00120     else if(__res > 0)                                    \
00121     {                                                     \
00122         (Reltime).tv_sec = (T1).tv_sec - (T2).tv_sec;     \
00123         (Reltime).tv_usec =                               \
00124                 (((T1).tv_nsec - (T2).tv_nsec) / 1000);   \
00125         if((Reltime).tv_usec < 0)                         \
00126         {                                                 \
00127             (Reltime).tv_sec--;                           \
00128             (Reltime).tv_usec += 1000000;                 \
00129         }                                                 \
00130     }                                                     \
00131     else                                                  \
00132     {                                                     \
00133         (Reltime).tv_sec = 0;                             \
00134         (Reltime).tv_usec = 0;                            \
00135     }                                                     \
00136 }
00137 
00138 #define  GlobusTimeReltimeDiff(Reltime, T1, T2)           \
00139 {                                                         \
00140     int __res = globus_reltime_cmp(&(T1), &(T2));         \
00141     if(__res < 0)                                         \
00142     {                                                     \
00143         (Reltime).tv_sec = (T2).tv_sec - (T1).tv_sec;     \
00144         (Reltime).tv_usec =                               \
00145                 ((T2).tv_usec - (T1).tv_usec);            \
00146         if((Reltime).tv_usec < 0)                         \
00147         {                                                 \
00148             (Reltime).tv_sec--;                           \
00149             (Reltime).tv_usec += 1000000;                 \
00150         }                                                 \
00151     }                                                     \
00152     else if(__res > 0)                                    \
00153     {                                                     \
00154         (Reltime).tv_sec = (T1).tv_sec - (T2).tv_sec;     \
00155         (Reltime).tv_usec =                               \
00156                 ((T1).tv_usec - (T2).tv_usec);            \
00157         if((Reltime).tv_usec < 0)                         \
00158         {                                                 \
00159             (Reltime).tv_sec--;                           \
00160             (Reltime).tv_usec += 1000000;                 \
00161         }                                                 \
00162     }                                                     \
00163     else                                                  \
00164     {                                                     \
00165         (Reltime).tv_sec = 0;                             \
00166         (Reltime).tv_usec = 0;                            \
00167     }                                                     \
00168 }
00169 
00173 #define  GlobusTimeReltimeToUSec(SlpInt, Reltime)         \
00174 {                                                         \
00175     SlpInt = ((Reltime).tv_sec * 1000000) +               \
00176                                      ((Reltime).tv_usec); \
00177 }
00178 
00182 #define  GlobusTimeReltimeToMilliSec( Milliseconds, Reltime)  \
00183 {                                                         \
00184     Milliseconds = ((Reltime).tv_sec * 1000) +            \
00185                               ((Reltime).tv_usec)/ 1000;   \
00186 }
00187 
00191 #define  GlobusTimeAbstimeInc(Abstime, Reltime)           \
00192 {                                                         \
00193     (Abstime).tv_nsec += ((Reltime).tv_usec * 1000);      \
00194     if((Abstime).tv_nsec >= 1000000000)                    \
00195     {                                                     \
00196         (Abstime).tv_sec++;                               \
00197         (Abstime).tv_nsec -= 1000000000;                  \
00198     }                                                     \
00199     (Abstime).tv_sec += (Reltime).tv_sec;                 \
00200 }
00201 
00202 #define  GlobusTimeAbstimeDec(Abstime, Reltime)           \
00203 {                                                         \
00204     (Abstime).tv_nsec -= ((Reltime).tv_usec * 1000);      \
00205     if((Abstime).tv_nsec < 0)                             \
00206     {                                                     \
00207         (Abstime).tv_sec--;                               \
00208         (Abstime).tv_nsec += 1000000000;                  \
00209     }                                                     \
00210     (Abstime).tv_sec -= (Reltime).tv_sec;                 \
00211 }
00212 
00213 
00217 #if defined(_WIN32)
00218 #   define GlobusTimeAbstimeGetCurrent(Abstime)           \
00219     {                                                     \
00220         struct _timeb timebuffer;                      \
00221                                                           \
00222         _ftime(&timebuffer);                            \
00223         (Abstime).tv_sec = timebuffer.time;               \
00224         (Abstime).tv_nsec = (timebuffer.millitm * 1000000);  \
00225     }
00226 #else
00227 #   define  GlobusTimeAbstimeGetCurrent(Abstime)          \
00228     {                                                     \
00229         struct timeval __time;                            \
00230                                                           \
00231         gettimeofday(&__time, GLOBUS_NULL);               \
00232         (Abstime).tv_sec = __time.tv_sec;                 \
00233         (Abstime).tv_nsec = (__time.tv_usec * 1000);      \
00234     }
00235 #endif
00236 
00240 #define  GlobusTimeAbstimeCopy(Dest, Src)                 \
00241 {                                                         \
00242    (Dest).tv_sec = (Src).tv_sec;                          \
00243    (Dest).tv_nsec = (Src).tv_nsec;                        \
00244 }
00245 
00249 #define  GlobusTimeReltimeCopy(Dest, Src)                 \
00250 {                                                         \
00251    (Dest).tv_sec = (Src).tv_sec;                          \
00252    (Dest).tv_usec = (Src).tv_usec;                        \
00253 }
00254 
00258 #define  GlobusTimeReltimeMultiply(Reltime, Factor)       \
00259 {                                                         \
00260    (Reltime).tv_usec *= Factor;                           \
00261    (Reltime).tv_sec *= Factor;                            \
00262                                                           \
00263     if((Reltime).tv_usec >= 1000000)                      \
00264     {                                                     \
00265         (Reltime).tv_sec += ((Reltime).tv_usec / 1000000);\
00266         (Reltime).tv_usec = (Reltime).tv_usec  % 1000000; \
00267     }                                                     \
00268 }
00269 
00273 #define  GlobusTimeReltimeDivide(Reltime, Factor)         \
00274 {                                                         \
00275    (Reltime).tv_usec /= Factor;                           \
00276    (Reltime).tv_sec /= Factor;                            \
00277 }
00278 
00279 extern const globus_abstime_t         globus_i_abstime_infinity;
00280 extern const globus_abstime_t         globus_i_abstime_zero;
00281 extern const globus_reltime_t         globus_i_reltime_infinity;
00282 extern const globus_reltime_t         globus_i_reltime_zero;
00283 
00290 globus_bool_t
00291 globus_time_has_expired(
00292     const globus_abstime_t *                     abstime);
00293 
00297 globus_bool_t
00298 globus_time_abstime_is_infinity(
00299     const globus_abstime_t *                     abstime);
00300 
00304 globus_bool_t
00305 globus_time_reltime_is_infinity(
00306     const globus_reltime_t *                     reltime);
00307 
00318 int
00319 globus_abstime_cmp(
00320     const globus_abstime_t *                     abstime_1,
00321     const globus_abstime_t *                     abstime_2);
00322 
00333 int
00334 globus_reltime_cmp(
00335     const globus_reltime_t *                     reltime_1,
00336     const globus_reltime_t *                     reltime_2);
00337 
00338 
00339 #ifdef __cplusplus
00340 }
00341 #endif
00342 #endif /* GLOBUS_TIME_H */

Generated on 17 Mar 2017 for globus_common by  doxygen 1.4.7