Branch data     Line data    Source code

       1                 :            : 
       2                 :            : #include "gwrl/time.h"
       3                 :            : 
       4                 :            : #ifdef __cplusplus
       5                 :            : extern "C" {
       6                 :            : #endif
       7                 :            : 
       8                 :        384 : void gwtm_gettimeofday_timespec(struct timespec * ts) {
       9                 :        384 :         struct timeval tv;
      10                 :        384 :         gettimeofday(&tv,NULL);
      11                 :        384 :         gwtm_timeval_to_timespec(&tv,ts);
      12                 :        384 : }
      13                 :            : 
      14                 :          1 : void gwtm_ms_to_timeval(int64_t ms, struct timeval * tv) {
      15                 :          1 :         tv->tv_sec = (long)(ms/1000);
      16                 :          1 :         tv->tv_usec = 1000*(ms%1000);
      17                 :          1 :         if(tv->tv_usec >= _MICROSECONDS_WC) {
      18                 :          0 :                 tv->tv_sec += 1;
      19                 :          0 :                 tv->tv_usec -= _MICROSECONDS_WC;
      20                 :          0 :         }
      21                 :          1 : }
      22                 :            : 
      23                 :          2 : void gwtm_ms_to_timespec(int64_t ms, struct timespec * ts) {
      24                 :          2 :         ts->tv_sec = (long)(ms/1000);
      25                 :          2 :         ts->tv_nsec = 1000000 * (ms%1000);
      26                 :          2 :         if(ts->tv_nsec >= _NANOSECONDS_WC) {
      27                 :          0 :                 ts->tv_sec += 1;
      28                 :          0 :                 ts->tv_nsec -= _NANOSECONDS_WC;
      29                 :          0 :         }
      30                 :          2 : }
      31                 :            : 
      32                 :          3 : void gwtm_timeval_to_ms(struct timeval * tv, int64_t * ms) {
      33         [ +  - ]:          1 :         if(tv->tv_sec == 0 && tv->tv_usec == 0) {
      34                 :          1 :                 *ms = 0;
      35                 :          1 :                 return;
      36                 :            :         }
      37                 :          2 :         *ms = ((int64_t)tv->tv_sec)*1000;
      38                 :          2 :         *ms += tv->tv_usec/1000;
      39                 :          3 : }
      40                 :            : 
      41                 :          2 : void gwtm_timespec_to_ms(struct timespec * ts, int64_t * ms) {
      42         [ +  - ]:          1 :         if(ts->tv_sec == 0 && ts->tv_nsec == 0) {
      43                 :          1 :                 *ms = 0;
      44                 :          1 :                 return;
      45                 :            :         }
      46                 :          1 :         *ms = ((int64_t)ts->tv_sec)*1000;
      47                 :          1 :         *ms += ts->tv_nsec/1000000;
      48                 :          2 : }
      49                 :            : 
      50                 :          3 : void gwtm_add_ms_to_timeval(int64_t ms, struct timeval * tv) {
      51                 :          1 :         if(ms == 0) return;
      52                 :          2 :         tv->tv_sec += (long)(ms/1000);
      53                 :          2 :         tv->tv_usec += 1000*(ms%1000);
      54         [ -  + ]:          2 :         while(tv->tv_usec >= _MICROSECONDS_WC) {
      55                 :          0 :                 tv->tv_sec += 1;
      56                 :          0 :                 tv->tv_usec -= _MICROSECONDS_WC;
      57                 :          0 :         }
      58                 :          3 : }
      59                 :            : 
      60                 :        148 : void gwtm_add_ms_to_timespec(int64_t ms, struct timespec * ts) {
      61                 :        102 :         if(ms == 0) return;
      62                 :         46 :         ts->tv_sec += (long)(ms/1000);
      63                 :         46 :         ts->tv_nsec += 1000000*(ms%1000);
      64         [ +  + ]:         48 :         while(ts->tv_nsec >= _NANOSECONDS_WC) {
      65                 :          2 :                 ts->tv_sec += 1;
      66                 :          2 :                 ts->tv_nsec -= _NANOSECONDS_WC;
      67                 :          2 :         }
      68                 :        148 : }
      69                 :            : 
      70                 :        158 : struct timespec * gwtm_timespec_cmp(struct timespec * ts1, struct timespec * ts2) {
      71                 :        124 :         if(ts1->tv_sec < ts2->tv_sec) return ts1;
      72         [ +  + ]:         34 :         if(ts1->tv_sec == ts2->tv_sec) {
      73         [ +  + ]:         13 :                 if(ts1->tv_nsec < ts2->tv_nsec) return ts1;
      74         [ -  + ]:          5 :                 else if(ts1->tv_nsec == ts2->tv_nsec) return NULL;
      75                 :          5 :         }
      76                 :         26 :         return ts2;
      77                 :        158 : }
      78                 :            : 
      79                 :        157 : bool gwtm_timespec_copy_if_smaller(struct timespec * source, struct timespec * update) {
      80                 :        157 :         struct timespec * smaller = gwtm_timespec_cmp(source,update);
      81                 :        157 :         if(smaller == source) {
      82         [ -  + ]:        131 :                 memcpy(update,smaller,sizeof(struct timespec));
      83                 :        131 :                 return true;
      84                 :            :         }
      85                 :         26 :         return false;
      86                 :        157 : }
      87                 :            : 
      88                 :        465 : void gwtm_timespec_sub_into(struct timespec * ts1, struct timespec * ts2, struct timespec * into) {
      89                 :        465 :         into->tv_sec = ts1->tv_sec - ts2->tv_sec;
      90                 :        465 :         into->tv_nsec = ts1->tv_nsec - ts2->tv_nsec;
      91         [ +  + ]:        859 :         while(into->tv_nsec < 0) {
      92                 :        394 :                 into->tv_sec -= 1;
      93                 :        394 :                 into->tv_nsec += _NANOSECONDS_WC;
      94                 :        394 :         }
      95                 :        465 : }
      96                 :            : 
      97                 :        347 : bool gwtm_timespec_is_expired(struct timespec * ts1) {
      98                 :        143 :         if(ts1->tv_sec < 0) return true;
      99 [ +  + ][ +  + ]:        204 :         if(ts1->tv_sec <= 0 && ts1->tv_nsec <= 0) return true;
     100                 :        203 :         return false;
     101                 :        347 : }
     102                 :            : 
     103                 :        385 : void gwtm_timeval_to_timespec(struct timeval * tv, struct timespec * ts) {
     104                 :        385 :         ts->tv_sec = tv->tv_sec;
     105                 :        385 :         ts->tv_nsec = ((int64_t)tv->tv_usec)*1000;
     106                 :        385 : }
     107                 :            : 
     108                 :          1 : void gwtm_timespec_to_timeval(struct timespec * ts, struct timeval * tv) {
     109                 :          1 :         tv->tv_sec = ts->tv_sec;
     110                 :          1 :         tv->tv_usec = ((long)ts->tv_nsec)/1000;
     111                 :          1 : }
     112                 :            : 
     113                 :            : #ifdef __cplusplus
     114                 :            : }
     115                 :            : #endif