dep/ACE_wrappers/ace/Time_Value.h

   1 // -*- C++ -*-
   2
   3 //=============================================================================
   4 /**
   5  *  @file    Time_Value.h
   6  *
   7  *  $Id: Time_Value.h 81914 2008-06-11 13:56:11Z sma $
   8  *
   9  *  @author Douglas C. Schmidt <schmidt@cs.wustl.edu>
  10  */
  11 //=============================================================================
  12
  13 #ifndef ACE_TIME_VALUE_H
  14 #define ACE_TIME_VALUE_H
  15
  16 #include /**/ "ace/pre.h"
  17
  18 #include /**/ "ace/ACE_export.h"
  19
  20 #if !defined (ACE_LACKS_PRAGMA_ONCE)
  21 # pragma once
  22 #endif /* ACE_LACKS_PRAGMA_ONCE */
  23
  24 # include "ace/os_include/os_time.h"
  25
  26 // Define some helpful constants.
  27 // Not type-safe, and signed.  For backward compatibility.
  28 #define ACE_ONE_SECOND_IN_MSECS 1000L
  29 suseconds_t const ACE_ONE_SECOND_IN_USECS = 1000000;
  30 #define ACE_ONE_SECOND_IN_NSECS 1000000000L
  31
  32 // needed for ACE_UINT64
  33 #include "ace/Basic_Types.h"
  34
  35 // This forward declaration is needed by the set() and FILETIME() functions
  36 #if defined (ACE_LACKS_LONGLONG_T)
  37 ACE_BEGIN_VERSIONED_NAMESPACE_DECL
  38 class ACE_Export ACE_U_LongLong;
  39 ACE_END_VERSIONED_NAMESPACE_DECL
  40 #endif  /* ACE_LACKS_LONGLONG_T */
  41
  42 // -------------------------------------------------------------------
  43
  44 /**
  45  * @class ACE_Time_Value
  46  *
  47  * @brief Operations on "timeval" structures, which express time in
  48  * seconds (secs) and microseconds (usecs).
  49  *
  50  * This class centralizes all the time related processing in
  51  * ACE.  These time values are typically used in conjunction with OS
  52  * mechanisms like <select>, <poll>, or <cond_timedwait>.
  53  */
  54 #if defined (ACE_WIN32) && defined (_WIN32_WCE)
  55 // Something is a bit brain-damaged here and I'm not sure what... this code
  56 // compiled before the OS reorg for ACE 5.4. Since then it hasn't - eVC
  57 // complains that the operators that return ACE_Time_Value are C-linkage
  58 // functions that can't return a C++ class. The only way I've found to
  59 // defeat this is to wrap the whole class in extern "C++".
  60 //    - Steve Huston, 23-Aug-2004
  61 extern "C++" {
  62 #endif
  63
  64 ACE_BEGIN_VERSIONED_NAMESPACE_DECL
  65
  66 class ACE_Export ACE_Time_Value
  67 {
  68 public:
  69
  70   /// Constant "0".
  71   static const ACE_Time_Value zero;
  72
  73   /**
  74    * Constant for maximum time representable.  Note that this time is
  75    * not intended for use with <select> or other calls that may have
  76    * *their own* implementation-specific maximum time representations.
  77    * Its primary use is in time computations such as those used by the
  78    * dynamic subpriority strategies in the ACE_Dynamic_Message_Queue
  79    * class.
  80    */
  81   static const ACE_Time_Value max_time;
  82
  83   // = Initialization methods.
  84
  85   /// Default Constructor.
  86   ACE_Time_Value (void);
  87
  88   /// Constructor.
  89   explicit ACE_Time_Value (time_t sec, suseconds_t usec = 0);
  90
  91   // = Methods for converting to/from various time formats.
  92
  93   /// Construct the ACE_Time_Value from a timeval.
  94   explicit ACE_Time_Value (const struct timeval &t);
  95
  96   /// Construct the ACE_Time_Value object from a timespec_t.
  97   explicit ACE_Time_Value (const timespec_t &t);
  98
  99 # if defined (ACE_WIN32)
 100   /// Construct the ACE_Time_Value object from a Win32 FILETIME
 101   explicit ACE_Time_Value (const FILETIME &ft);
 102 # endif /* ACE_WIN32 */
 103
 104   /// Initializes the ACE_Time_Value from seconds and useconds.
 105   void set (time_t sec, suseconds_t usec);
 106
 107   /// Initializes the ACE_Time_Value from a double, which is assumed to be
 108   /// in second format, with any remainder treated as microseconds.
 109   void set (double d);
 110
 111   /// Initializes the ACE_Time_Value from a timeval.
 112   void set (const timeval &t);
 113
 114   /// Initializes the ACE_Time_Value object from a timespec_t.
 115   void set (const timespec_t &t);
 116
 117 # if defined (ACE_WIN32)
 118   ///  Initializes the ACE_Time_Value object from a Win32 FILETIME.
 119   void set (const FILETIME &ft);
 120 # endif /* ACE_WIN32 */
 121
 122   /// Converts from ACE_Time_Value format into milliseconds format.
 123   /**
 124    * @return Sum of second field (in milliseconds) and microsecond field
 125    *         (in milliseconds).  Note that this method can overflow if
 126    *         the second and microsecond field values are large, so use
 127    *         the msec (ACE_UINT64 &ms) method instead.
 128    *
 129    * @note The semantics of this method differs from the sec() and
 130    *       usec() methods.  There is no analogous "millisecond"
 131    *       component in an ACE_Time_Value.
 132    */
 133   unsigned long msec (void) const;
 134
 135   /// Converts from ACE_Time_Value format into milliseconds format.
 136   /**
 137    * @return Sum of second field (in milliseconds) and microsecond field
 138    *         (in milliseconds) and return them via the @param ms parameter.
 139    *
 140    * @note The semantics of this method differs from the sec() and
 141    *       usec() methods.  There is no analogous "millisecond"
 142    *       component in an ACE_Time_Value.
 143    */
 144   void msec (ACE_UINT64 &ms) const;
 145
 146   /// Converts from ACE_Time_Value format into milliseconds format.
 147   /**
 148    * @return Sum of second field (in milliseconds) and microsecond field
 149    *         (in milliseconds) and return them via the @param ms parameter.
 150    *
 151    * @note The semantics of this method differs from the sec() and
 152    *       usec() methods.  There is no analogous "millisecond"
 153    *       component in an ACE_Time_Value.
 154    */
 155   void msec (ACE_UINT64 &ms) /* const */;
 156
 157   /// Converts from milli-seconds format into ACE_Time_Value format.
 158   /**
 159    * @note The semantics of this method differs from the sec() and
 160    *       usec() methods.  There is no analogous "millisecond"
 161    *       component in an ACE_Time_Value.
 162    */
 163   void msec (long);
 164
 165   /// Converts from milli-seconds format into ACE_Time_Value format.
 166   /**
 167    * @note The semantics of this method differs from the sec() and
 168    *       usec() methods.  There is no analogous "millisecond"
 169    *       component in an ACE_Time_Value.
 170    */
 171   void msec (int);  // converted to long then calls above.
 172
 173   /// Returns the value of the object as a timespec_t.
 174   operator timespec_t () const;
 175
 176   /// Returns the value of the object as a timeval.
 177   operator timeval () const;
 178
 179   /// Returns a pointer to the object as a timeval.
 180   operator const timeval *() const;
 181
 182 # if defined (ACE_WIN32)
 183   /// Returns the value of the object as a Win32 FILETIME.
 184   operator FILETIME () const;
 185 # endif /* ACE_WIN32 */
 186
 187   // = The following are accessor/mutator methods.
 188
 189   /// Get seconds.
 190   /**
 191    * @return The second field/component of this ACE_Time_Value.
 192    *
 193    * @note The semantics of this method differs from the msec()
 194    *       method.
 195    */
 196   time_t sec (void) const;
 197
 198   /// Set seconds.
 199   void sec (time_t sec);
 200
 201   /// Get microseconds.
 202   /**
 203    * @return The microsecond field/component of this ACE_Time_Value.
 204    *
 205    * @note The semantics of this method differs from the msec()
 206    *       method.
 207    */
 208   suseconds_t usec (void) const;
 209
 210   /// Set microseconds.
 211   void usec (suseconds_t usec);
 212
 213   /**
 214    * @return Sum of second field (in microseconds) and microsecond field
 215    *         and return them via the @param usec parameter.
 216    */
 217   void to_usec (ACE_UINT64 &usec) const;
 218
 219   // = The following arithmetic methods operate on ACE_Time_Value's.
 220
 221   /// Add @a tv to this.
 222   ACE_Time_Value &operator += (const ACE_Time_Value &tv);
 223
 224   /// Add @a tv to this.
 225   ACE_Time_Value &operator += (time_t tv);
 226
 227   /// Assign @ tv to this
 228   ACE_Time_Value &operator = (const ACE_Time_Value &tv);
 229
 230   /// Assign @ tv to this
 231   ACE_Time_Value &operator = (time_t tv);
 232
 233   /// Subtract @a tv to this.
 234   ACE_Time_Value &operator -= (const ACE_Time_Value &tv);
 235
 236   /// Substract @a tv to this.
 237   ACE_Time_Value &operator -= (time_t tv);
 238
 239   /**
 240     \brief Multiply the time value by the @a d factor.
 241     \note The result of the operator is valid for results from range
 242     < (ACE_INT32_MIN, -999999), (ACE_INT32_MAX, 999999) >. Result
 243     outside this range are saturated to a limit.
 244      */
 245   ACE_Time_Value &operator *= (double d);
 246
 247   /// Increment microseconds as postfix.
 248   /**
 249    * @note The only reason this is here is to allow the use of ACE_Atomic_Op
 250    * with ACE_Time_Value.
 251    */
 252   ACE_Time_Value operator++ (int);
 253
 254   /// Increment microseconds as prefix.
 255   /**
 256    * @note The only reason this is here is to allow the use of ACE_Atomic_Op
 257    * with ACE_Time_Value.
 258    */
 259   ACE_Time_Value &operator++ (void);
 260
 261   /// Decrement microseconds as postfix.
 262   /**
 263    * @note The only reason this is here is to allow the use of ACE_Atomic_Op
 264    * with ACE_Time_Value.
 265    */
 266   ACE_Time_Value operator-- (int);
 267
 268   /// Decrement microseconds as prefix.
 269   /**
 270    * @note The only reason this is here is to allow the use of ACE_Atomic_Op
 271    * with ACE_Time_Value.
 272    */
 273   ACE_Time_Value &operator-- (void);
 274
 275   /// Adds two ACE_Time_Value objects together, returns the sum.
 276   friend ACE_Export ACE_Time_Value operator + (const ACE_Time_Value &tv1,
 277                                                const ACE_Time_Value &tv2);
 278
 279   /// Subtracts two ACE_Time_Value objects, returns the difference.
 280   friend ACE_Export ACE_Time_Value operator - (const ACE_Time_Value &tv1,
 281                                                const ACE_Time_Value &tv2);
 282
 283   /// True if @a tv1 < @a tv2.
 284   friend ACE_Export bool operator < (const ACE_Time_Value &tv1,
 285                                      const ACE_Time_Value &tv2);
 286
 287   /// True if @a tv1 > @a tv2.
 288   friend ACE_Export bool operator > (const ACE_Time_Value &tv1,
 289                                      const ACE_Time_Value &tv2);
 290
 291   /// True if @a tv1 <= @a tv2.
 292   friend ACE_Export bool operator <= (const ACE_Time_Value &tv1,
 293                                       const ACE_Time_Value &tv2);
 294
 295   /// True if @a tv1 >= @a tv2.
 296   friend ACE_Export bool operator >= (const ACE_Time_Value &tv1,
 297                                       const ACE_Time_Value &tv2);
 298
 299   /// True if @a tv1 == @a tv2.
 300   friend ACE_Export bool operator == (const ACE_Time_Value &tv1,
 301                                       const ACE_Time_Value &tv2);
 302
 303   /// True if @a tv1 != @a tv2.
 304   friend ACE_Export bool operator != (const ACE_Time_Value &tv1,
 305                                       const ACE_Time_Value &tv2);
 306
 307   //@{
 308   /// Multiplies the time value by @a d
 309   friend ACE_Export ACE_Time_Value operator * (double d,
 310                                                const ACE_Time_Value &tv);
 311
 312   friend ACE_Export ACE_Time_Value operator * (const ACE_Time_Value &tv,
 313                                                double d);
 314   //@}
 315
 316   /// Dump is a no-op.
 317   /**
 318    * The dump() method is a no-op.  It's here for backwards compatibility
 319    * only, but does not dump anything. Invoking logging methods here
 320    * violates layering restrictions in ACE because this class is part
 321    * of the OS layer and @c ACE_Log_Msg is at a higher level.
 322    */
 323   void dump (void) const;
 324
 325 # if defined (ACE_WIN32)
 326   /// Const time difference between FILETIME and POSIX time.
 327 #  if defined (ACE_LACKS_LONGLONG_T)
 328   static const ACE_U_LongLong FILETIME_to_timval_skew;
 329 #  else
 330   static const DWORDLONG FILETIME_to_timval_skew;
 331 #  endif // ACE_LACKS_LONGLONG_T
 332 # endif /* ACE_WIN32 */
 333
 334 private:
 335   /// Put the timevalue into a canonical form.
 336   void normalize (void);
 337
 338   /// Store the values as a timeval.
 339 #if defined (ACE_HAS_TIME_T_LONG_MISMATCH)
 340   // Windows' timeval is non-conformant, so swap in a struct that conforms
 341   // to the proper data types to represent the entire time range that this
 342   // class's API can accept.
 343   // Also, since this class can supply a pointer to a timeval that things
 344   // like select() expect, we need the OS-defined one as well. To make this
 345   // available, use a real timeval called ext_tv_ and set it up when needed.
 346   // Since this is most often for relative times that don't approach 32 bits
 347   // in size, reducing a time_t to fit should be no problem.
 348   struct {
 349     time_t tv_sec;
 350     suseconds_t tv_usec;
 351   } tv_;
 352   timeval ext_tv_;
 353 #else
 354   timeval tv_;
 355 #endif /* ACE_HAS_TIME_T_LONG_MISMATCH */
 356 };
 357
 358 ACE_END_VERSIONED_NAMESPACE_DECL
 359
 360 #if defined (__ACE_INLINE__)
 361 #include "ace/Time_Value.inl"
 362 #endif /* __ACE_INLINE__ */
 363
 364 #if defined (ACE_WIN32) && defined (_WIN32_WCE)
 365 }
 366 #endif
 367
 368 #if defined (__MINGW32__)
 369 ACE_BEGIN_VERSIONED_NAMESPACE_DECL
 370 // The MingW linker has problems with the exported statics
 371 // zero and max_time with these two statics the linker will be able to
 372 // resolve the static exported symbols.
 373 static const ACE_Time_Value& __zero_time = ACE_Time_Value::zero;
 374 static const ACE_Time_Value& __max_time = ACE_Time_Value::max_time;
 375 ACE_END_VERSIONED_NAMESPACE_DECL
 376 #endif /* __MINGW32__ */
 377
 378 #include /**/ "ace/post.h"
 379
 380 #endif /* ACE_TIME_VALUE_H */