ACE/ace/Time_Value.inl

   1 // -*- C++ -*-
   2 #include "ace/Truncate.h"
   3
   4 ACE_BEGIN_VERSIONED_NAMESPACE_DECL
   5
   6 /// Returns the value of the object as a timeval.
   7 ACE_INLINE
   8 ACE_Time_Value::operator timeval () const
   9 {
  10   // ACE_OS_TRACE ("ACE_Time_Value::operator timeval");
  11 #if defined (ACE_HAS_TIME_T_LONG_MISMATCH)
  12   // Recall that on some Windows we substitute another type for timeval in tv_
  13   ACE_Time_Value *me = const_cast<ACE_Time_Value*> (this);
  14   me->ext_tv_.tv_sec = ACE_Utils::truncate_cast<long> (this->tv_.tv_sec);
  15   me->ext_tv_.tv_usec = ACE_Utils::truncate_cast<long> (this->tv_.tv_usec);
  16   return this->ext_tv_;
  17 #else
  18   return this->tv_;
  19 #endif /* ACE_HAS_TIME_T_LONG_MISMATCH */
  20 }
  21
  22 ACE_INLINE void
  23 ACE_Time_Value::set (const timeval &tv)
  24 {
  25   // ACE_OS_TRACE ("ACE_Time_Value::set");
  26   this->tv_.tv_sec = tv.tv_sec;
  27   this->tv_.tv_usec = tv.tv_usec;
  28
  29   this->normalize ();
  30 }
  31
  32 ACE_INLINE
  33 ACE_Time_Value::ACE_Time_Value (const struct timeval &tv)
  34 {
  35   // ACE_OS_TRACE ("ACE_Time_Value::ACE_Time_Value");
  36   this->set (tv);
  37 }
  38
  39 ACE_INLINE
  40 ACE_Time_Value::operator const timeval * () const
  41 {
  42   // ACE_OS_TRACE ("ACE_Time_Value::operator const timeval *");
  43 #if defined (ACE_HAS_TIME_T_LONG_MISMATCH)
  44   // Recall that on some Windows we substitute another type for timeval in tv_
  45   ACE_Time_Value *me = const_cast<ACE_Time_Value*> (this);
  46   me->ext_tv_.tv_sec = ACE_Utils::truncate_cast<long> (this->tv_.tv_sec);
  47   me->ext_tv_.tv_usec = ACE_Utils::truncate_cast<long> (this->tv_.tv_usec);
  48   return (const timeval *) &this->ext_tv_;
  49 #else
  50   return (const timeval *) &this->tv_;
  51 #endif /* ACE_HAS_TIME_T_LONG_MISMATCH */
  52 }
  53
  54 ACE_INLINE void
  55 ACE_Time_Value::set (time_t sec, suseconds_t usec)
  56 {
  57   // ACE_OS_TRACE ("ACE_Time_Value::set");
  58   this->tv_.tv_sec = sec;
  59   this->tv_.tv_usec = usec;
  60 #ifdef __GNUC__
  61   if ((__builtin_constant_p(sec) &
  62        __builtin_constant_p(usec)) &&
  63       (sec >= 0 && usec >= 0 && usec < ACE_ONE_SECOND_IN_USECS))
  64     return;
  65 #endif
  66   this->normalize ();
  67 }
  68
  69 ACE_INLINE void
  70 ACE_Time_Value::set (double d)
  71 {
  72   // ACE_OS_TRACE ("ACE_Time_Value::set");
  73   if (d < ACE_Numeric_Limits<time_t>::min())
  74     {
  75       this->tv_.tv_sec = ACE_Numeric_Limits<time_t>::min();
  76       this->tv_.tv_usec = -ACE_ONE_SECOND_IN_USECS + 1;
  77     }
  78   else if (d > ACE_Numeric_Limits<time_t>::max())
  79     {
  80       this->tv_.tv_sec = ACE_Numeric_Limits<time_t>::max();
  81       this->tv_.tv_usec = ACE_ONE_SECOND_IN_USECS - 1;
  82     }
  83   else
  84     {
  85       time_t l = (time_t) d;
  86       this->tv_.tv_sec = l;
  87       this->tv_.tv_usec = (suseconds_t) ((d - (double) l) * ACE_ONE_SECOND_IN_USECS + (d < 0 ? -0.5 : 0.5));
  88     }
  89 }
  90
  91 /// Initializes a timespec_t.  Note that this approach loses precision
  92 /// since it converts the nano-seconds into micro-seconds.  But then
  93 /// again, do any real systems have nano-second timer precision?!
  94 ACE_INLINE void
  95 ACE_Time_Value::set (const timespec_t &tv)
  96 {
  97   // ACE_OS_TRACE ("ACE_Time_Value::set");
  98
  99   this->set (tv.tv_sec,
 100              tv.tv_nsec / 1000); // Convert nanoseconds into microseconds.
 101 }
 102
 103 ACE_INLINE
 104 ACE_Time_Value::ACE_Time_Value ()
 105   // : tv_ ()
 106 {
 107   // ACE_OS_TRACE ("ACE_Time_Value::ACE_Time_Value");
 108   this->set (0, 0);
 109 }
 110
 111 ACE_INLINE
 112 ACE_Time_Value::ACE_Time_Value (time_t sec, suseconds_t usec)
 113 {
 114   // ACE_OS_TRACE ("ACE_Time_Value::ACE_Time_Value");
 115   this->set (sec, usec);
 116 }
 117
 118 /// Returns number of seconds.
 119 ACE_INLINE time_t
 120 ACE_Time_Value::sec () const
 121 {
 122   // ACE_OS_TRACE ("ACE_Time_Value::sec");
 123   return this->tv_.tv_sec;
 124 }
 125
 126 /// Sets the number of seconds.
 127 ACE_INLINE void
 128 ACE_Time_Value::sec (time_t sec)
 129 {
 130   // ACE_OS_TRACE ("ACE_Time_Value::sec");
 131   this->tv_.tv_sec = sec;
 132 }
 133
 134 /// Converts from Time_Value format into milli-seconds format.
 135 ACE_INLINE unsigned long
 136 ACE_Time_Value::msec () const
 137 {
 138   // ACE_OS_TRACE ("ACE_Time_Value::msec");
 139
 140   // Note - we're truncating a value here, which can lose data. This is
 141   // called out in the user documentation for this with a recommendation to
 142   // use msec(ACE_UINT64&) instead, so just go ahead and truncate.
 143   time_t secs = this->tv_.tv_sec * 1000 + this->tv_.tv_usec / 1000;
 144   return ACE_Utils::truncate_cast<unsigned long> (secs);
 145 }
 146
 147 ACE_INLINE ACE_UINT64
 148 ACE_Time_Value::get_msec () const
 149 {
 150   // ACE_OS_TRACE ("ACE_Time_Value::get_msec");
 151   ACE_UINT64 ms = ACE_Utils::truncate_cast<ACE_UINT64> (this->tv_.tv_sec);
 152   ms *= 1000;
 153   ms += (this->tv_.tv_usec / 1000);
 154   return ms;
 155 }
 156
 157 ACE_INLINE void
 158 ACE_Time_Value::msec (ACE_UINT64 &ms) const
 159 {
 160   // ACE_OS_TRACE ("ACE_Time_Value::msec");
 161   ms = this->get_msec ();
 162 }
 163
 164 ACE_INLINE void
 165 ACE_Time_Value::msec (ACE_UINT64 &ms) /*const*/
 166 {
 167   // ACE_OS_TRACE ("ACE_Time_Value::msec");
 168   const ACE_Time_Value *tv = this;
 169   tv->msec (ms);
 170 }
 171
 172 ACE_INLINE void
 173 ACE_Time_Value::set_msec (const ACE_UINT64 &ms)
 174 {
 175   // ACE_OS_TRACE ("ACE_Time_Value::set_msec");
 176   // Convert millisecond units to seconds;
 177   ACE_UINT64 secs = ms / 1000;
 178   this->tv_.tv_sec = static_cast<long> (secs);
 179   // Convert remainder to microseconds;
 180   this->tv_.tv_usec = static_cast<long>((ms - (secs * 1000)) * 1000);
 181 }
 182
 183 /// Converts from milli-seconds format into Time_Value format.
 184 ACE_INLINE void
 185 ACE_Time_Value::msec (long milliseconds)
 186 {
 187   // ACE_OS_TRACE ("ACE_Time_Value::msec");
 188   // Convert millisecond units to seconds;
 189   long secs = milliseconds / 1000;
 190   this->tv_.tv_sec = secs;
 191   // Convert remainder to microseconds;
 192   this->tv_.tv_usec = (milliseconds - (secs * 1000)) * 1000;
 193 }
 194
 195 /// Converts from milli-seconds format into Time_Value format.
 196 ACE_INLINE void
 197 ACE_Time_Value::msec (int milliseconds)
 198 {
 199   ACE_Time_Value::msec (static_cast<long> (milliseconds));
 200 }
 201
 202 /// Returns number of micro-seconds.
 203 ACE_INLINE suseconds_t
 204 ACE_Time_Value::usec () const
 205 {
 206   // ACE_OS_TRACE ("ACE_Time_Value::usec");
 207   return this->tv_.tv_usec;
 208 }
 209
 210 /// Sets the number of micro-seconds.
 211 ACE_INLINE void
 212 ACE_Time_Value::usec (suseconds_t usec)
 213 {
 214   // ACE_OS_TRACE ("ACE_Time_Value::usec");
 215   this->tv_.tv_usec = usec;
 216 }
 217
 218 ACE_INLINE void
 219 ACE_Time_Value::to_usec (ACE_UINT64 & usec) const
 220 {
 221   // ACE_OS_TRACE ("ACE_Time_Value::to_usec");
 222   usec = static_cast<ACE_UINT64> (this->tv_.tv_sec);
 223   usec *= 1000000;
 224   usec += this->tv_.tv_usec;
 225 }
 226
 227 ACE_INLINE ACE_Time_Value
 228 operator * (double d, const ACE_Time_Value &tv)
 229 {
 230   return ACE_Time_Value (tv) *= d;
 231 }
 232
 233 ACE_INLINE ACE_Time_Value
 234 operator * (const ACE_Time_Value &tv, double d)
 235 {
 236   return ACE_Time_Value (tv) *= d;
 237 }
 238
 239 /// True if tv1 > tv2.
 240 ACE_INLINE bool
 241 operator > (const ACE_Time_Value &tv1,
 242             const ACE_Time_Value &tv2)
 243 {
 244   // ACE_OS_TRACE ("operator >");
 245   if (tv1.sec () > tv2.sec ())
 246     return 1;
 247   else if (tv1.sec () == tv2.sec ()
 248            && tv1.usec () > tv2.usec ())
 249     return 1;
 250   else
 251     return 0;
 252 }
 253
 254 /// True if tv1 >= tv2.
 255 ACE_INLINE bool
 256 operator >= (const ACE_Time_Value &tv1,
 257              const ACE_Time_Value &tv2)
 258 {
 259   // ACE_OS_TRACE ("operator >=");
 260   if (tv1.sec () > tv2.sec ())
 261     return 1;
 262   else if (tv1.sec () == tv2.sec ()
 263            && tv1.usec () >= tv2.usec ())
 264     return 1;
 265   else
 266     return 0;
 267 }
 268
 269 /// Returns the value of the object as a timespec_t.
 270 ACE_INLINE
 271 ACE_Time_Value::operator timespec_t () const
 272 {
 273   // ACE_OS_TRACE ("ACE_Time_Value::operator timespec_t");
 274   timespec_t tv;
 275   tv.tv_sec = this->sec ();
 276   // Convert microseconds into nanoseconds.
 277   tv.tv_nsec = this->tv_.tv_usec * 1000;
 278   return tv;
 279 }
 280
 281 /// Initializes the ACE_Time_Value object from a timespec_t.
 282 ACE_INLINE
 283 ACE_Time_Value::ACE_Time_Value (const timespec_t &tv)
 284   // : tv_ ()
 285 {
 286   // ACE_OS_TRACE ("ACE_Time_Value::ACE_Time_Value");
 287   this->set (tv);
 288 }
 289
 290 /// True if tv1 < tv2.
 291 ACE_INLINE bool
 292 operator < (const ACE_Time_Value &tv1,
 293             const ACE_Time_Value &tv2)
 294 {
 295   // ACE_OS_TRACE ("operator <");
 296   return tv2 > tv1;
 297 }
 298
 299 /// True if tv1 >= tv2.
 300 ACE_INLINE bool
 301 operator <= (const ACE_Time_Value &tv1,
 302              const ACE_Time_Value &tv2)
 303 {
 304   // ACE_OS_TRACE ("operator <=");
 305   return tv2 >= tv1;
 306 }
 307
 308 /// True if tv1 == tv2.
 309 ACE_INLINE bool
 310 operator == (const ACE_Time_Value &tv1,
 311              const ACE_Time_Value &tv2)
 312 {
 313   // ACE_OS_TRACE ("operator ==");
 314   return tv1.sec () == tv2.sec ()
 315     && tv1.usec () == tv2.usec ();
 316 }
 317
 318 /// True if tv1 != tv2.
 319 ACE_INLINE bool
 320 operator != (const ACE_Time_Value &tv1,
 321              const ACE_Time_Value &tv2)
 322 {
 323   // ACE_OS_TRACE ("operator !=");
 324   return !(tv1 == tv2);
 325 }
 326
 327 /// Add TV to this.
 328 ACE_INLINE ACE_Time_Value &
 329 ACE_Time_Value::operator+= (const ACE_Time_Value &tv)
 330 {
 331   // ACE_OS_TRACE ("ACE_Time_Value::operator+=");
 332   this->sec (this->sec () + tv.sec ());
 333   this->usec (this->usec () + tv.usec ());
 334   this->normalize ();
 335   return *this;
 336 }
 337
 338 ACE_INLINE ACE_Time_Value &
 339 ACE_Time_Value::operator+= (time_t tv)
 340 {
 341   // ACE_OS_TRACE ("ACE_Time_Value::operator+=");
 342   this->sec (this->sec () + tv);
 343   return *this;
 344 }
 345
 346 ACE_INLINE ACE_Time_Value &
 347 ACE_Time_Value::operator= (time_t tv)
 348 {
 349   // ACE_OS_TRACE ("ACE_Time_Value::operator=");
 350   this->sec (tv);
 351   this->usec (0);
 352   return *this;
 353 }
 354
 355 /// Subtract TV to this.
 356 ACE_INLINE ACE_Time_Value &
 357 ACE_Time_Value::operator-= (const ACE_Time_Value &tv)
 358 {
 359   // ACE_OS_TRACE ("ACE_Time_Value::operator-=");
 360   this->sec (this->sec () - tv.sec ());
 361   this->usec (this->usec () - tv.usec ());
 362   this->normalize ();
 363   return *this;
 364 }
 365
 366 ACE_INLINE ACE_Time_Value &
 367 ACE_Time_Value::operator-= (time_t tv)
 368 {
 369   // ACE_OS_TRACE ("ACE_Time_Value::operator-=");
 370   this->sec (this->sec () - tv);
 371   return *this;
 372 }
 373
 374 /// Adds two ACE_Time_Value objects together, returns the sum.
 375 ACE_INLINE ACE_Time_Value
 376 operator + (const ACE_Time_Value &tv1,
 377             const ACE_Time_Value &tv2)
 378 {
 379   // ACE_OS_TRACE ("operator +");
 380   ACE_Time_Value sum (tv1);
 381   sum += tv2;
 382
 383   return sum;
 384 }
 385
 386 /// Subtracts two ACE_Time_Value objects, returns the difference.
 387 ACE_INLINE ACE_Time_Value
 388 operator - (const ACE_Time_Value &tv1,
 389             const ACE_Time_Value &tv2)
 390 {
 391   // ACE_OS_TRACE ("operator -");
 392   ACE_Time_Value delta (tv1);
 393   delta -= tv2;
 394
 395   return delta;
 396 }
 397
 398 ACE_END_VERSIONED_NAMESPACE_DECL
 399
 400 // Additional chrono streaming operators.
 401 namespace std
 402 {
 403   namespace chrono
 404   {
 405     ACE_INLINE nanoseconds&
 406     operator <<(nanoseconds &ns, ACE_Time_Value const &tv)
 407     {
 408       ns = duration_cast<nanoseconds>(seconds{tv.sec ()}) +
 409         duration_cast<nanoseconds>(microseconds{tv.usec()});
 410       return ns;
 411     }
 412
 413     ACE_INLINE microseconds&
 414     operator <<(microseconds &us, ACE_Time_Value const &tv)
 415     {
 416       us= duration_cast<microseconds>(seconds{tv.sec ()}) +
 417         microseconds{tv.usec()};
 418       return us;
 419     }
 420
 421     ACE_INLINE milliseconds&
 422     operator <<(milliseconds &ms, ACE_Time_Value const &tv)
 423     {
 424       ms = duration_cast<milliseconds>(seconds{tv.sec ()}) +
 425         duration_cast<milliseconds>(microseconds{tv.usec()});
 426       return ms;
 427     }
 428
 429     ACE_INLINE seconds&
 430     operator <<(seconds &s, ACE_Time_Value const &tv)
 431     {
 432       s = seconds{tv.sec ()} +
 433         duration_cast<seconds>(microseconds{tv.usec()});
 434       return s;
 435     }
 436
 437     ACE_INLINE minutes&
 438     operator <<(minutes &m, ACE_Time_Value const &tv)
 439     {
 440       m = duration_cast<minutes>(seconds{tv.sec ()}) +
 441         duration_cast<minutes>(microseconds{tv.usec()});
 442       return m;
 443     }
 444
 445     ACE_INLINE hours&
 446     operator <<(hours &h, ACE_Time_Value const &tv)
 447     {
 448       h = duration_cast<hours>(seconds{tv.sec ()}) +
 449         duration_cast<hours>(microseconds{tv.usec()});
 450       return h;
 451     }
 452
 453
 454     ACE_INLINE nanoseconds&
 455     operator +=(nanoseconds &ns, ACE_Time_Value const &tv)
 456     {
 457       ns += duration_cast<nanoseconds>(seconds{tv.sec ()}) +
 458         duration_cast<nanoseconds>(microseconds{tv.usec()});
 459       return ns;
 460     }
 461
 462     ACE_INLINE microseconds&
 463     operator +=(microseconds &us, ACE_Time_Value const &tv)
 464     {
 465       us += duration_cast<microseconds>(seconds{tv.sec ()}) +
 466         microseconds{tv.usec()};
 467       return us;
 468     }
 469
 470     ACE_INLINE milliseconds&
 471     operator +=(milliseconds &ms, ACE_Time_Value const &tv)
 472     {
 473       ms += duration_cast<milliseconds>(seconds{tv.sec ()}) +
 474         duration_cast<milliseconds>(microseconds{tv.usec()});
 475       return ms;
 476     }
 477
 478     ACE_INLINE seconds&
 479     operator +=(seconds &s, ACE_Time_Value const &tv)
 480     {
 481       s += seconds{tv.sec ()} +
 482         duration_cast<seconds>(microseconds{tv.usec()});
 483       return s;
 484     }
 485
 486     ACE_INLINE minutes&
 487     operator +=(minutes &m, ACE_Time_Value const &tv)
 488     {
 489       m += duration_cast<minutes>(seconds{tv.sec ()}) +
 490         duration_cast<minutes>(microseconds{tv.usec()});
 491       return m;
 492     }
 493
 494     ACE_INLINE hours&
 495     operator +=(hours &h, ACE_Time_Value const &tv)
 496     {
 497       h += duration_cast<hours>(seconds{tv.sec ()}) +
 498         duration_cast<hours>(microseconds{tv.usec()});
 499       return h;
 500     }
 501
 502
 503     ACE_INLINE nanoseconds&
 504     operator -=(nanoseconds &ns, ACE_Time_Value const &tv)
 505     {
 506       ns -= duration_cast<nanoseconds>(seconds{tv.sec ()}) +
 507         duration_cast<nanoseconds>(microseconds{tv.usec()});
 508       return ns;
 509     }
 510
 511     ACE_INLINE microseconds&
 512     operator -=(microseconds &us, ACE_Time_Value const &tv)
 513     {
 514       us -= duration_cast<microseconds>(seconds{tv.sec ()}) +
 515         microseconds{tv.usec()};
 516       return us;
 517     }
 518
 519     ACE_INLINE milliseconds&
 520     operator -=(milliseconds &ms, ACE_Time_Value const &tv)
 521     {
 522       ms -= duration_cast<milliseconds>(seconds{tv.sec ()}) +
 523         duration_cast<milliseconds>(microseconds{tv.usec()});
 524       return ms;
 525     }
 526
 527     ACE_INLINE seconds&
 528     operator -=(seconds &s, ACE_Time_Value const &tv)
 529     {
 530       s -= seconds{tv.sec ()} +
 531         duration_cast<seconds>(microseconds{tv.usec()});
 532       return s;
 533     }
 534
 535     ACE_INLINE minutes&
 536     operator -=(minutes &m, ACE_Time_Value const &tv)
 537     {
 538       m -= duration_cast<minutes>(seconds{tv.sec ()}) +
 539         duration_cast<minutes>(microseconds{tv.usec()});
 540       return m;
 541     }
 542
 543     ACE_INLINE hours&
 544     operator -=(hours &h, ACE_Time_Value const &tv)
 545     {
 546       h -= duration_cast<hours>(seconds{tv.sec ()}) +
 547         duration_cast<hours>(microseconds{tv.usec()});
 548       return h;
 549     }
 550   }
 551 }