timeval.h
上传用户:zhongxx05
上传日期:2007-06-06
资源大小:33641k
文件大小:7k
源码类别:

Symbian

开发平台:

C/C++

  1. /* ***** BEGIN LICENSE BLOCK ***** 
  2.  * Version: RCSL 1.0/RPSL 1.0 
  3.  *  
  4.  * Portions Copyright (c) 1995-2002 RealNetworks, Inc. All Rights Reserved. 
  5.  *      
  6.  * The contents of this file, and the files included with this file, are 
  7.  * subject to the current version of the RealNetworks Public Source License 
  8.  * Version 1.0 (the "RPSL") available at 
  9.  * http://www.helixcommunity.org/content/rpsl unless you have licensed 
  10.  * the file under the RealNetworks Community Source License Version 1.0 
  11.  * (the "RCSL") available at http://www.helixcommunity.org/content/rcsl, 
  12.  * in which case the RCSL will apply. You may also obtain the license terms 
  13.  * directly from RealNetworks.  You may not use this file except in 
  14.  * compliance with the RPSL or, if you have a valid RCSL with RealNetworks 
  15.  * applicable to this file, the RCSL.  Please see the applicable RPSL or 
  16.  * RCSL for the rights, obligations and limitations governing use of the 
  17.  * contents of the file.  
  18.  *  
  19.  * This file is part of the Helix DNA Technology. RealNetworks is the 
  20.  * developer of the Original Code and owns the copyrights in the portions 
  21.  * it created. 
  22.  *  
  23.  * This file, and the files included with this file, is distributed and made 
  24.  * available on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER 
  25.  * EXPRESS OR IMPLIED, AND REALNETWORKS HEREBY DISCLAIMS ALL SUCH WARRANTIES, 
  26.  * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY, FITNESS 
  27.  * FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT. 
  28.  * 
  29.  * Technology Compatibility Kit Test Suite(s) Location: 
  30.  *    http://www.helixcommunity.org/content/tck 
  31.  * 
  32.  * Contributor(s): 
  33.  *  
  34.  * ***** END LICENSE BLOCK ***** */ 
  35. #ifndef _TIMEVAL_H_
  36. #define _TIMEVAL_H_
  37. #include "hxtime.h"
  38. #define MILLISECOND                     1000
  39. #define SECOND                          1000000
  40. /*
  41.  * Because of conflicts between the use of winsock.h and winsock2.h
  42.  * we cannot derive the struct Timeval from struct timeval on WINDOWS
  43.  * platforms
  44.  */
  45. class Timeval: public HXTime {
  46. static void i2t(tv_sec_t& sec, tv_usec_t& usec, 
  47. long32 s, long32 us);
  48. public:
  49. Timeval(){}
  50. Timeval(long32 sec, long32 usec);
  51. Timeval(long32 usec);
  52. #if __MWERKS__ && !defined(_CARBON)
  53. // I added this to make Timeval t = sendperiod compile
  54. Timeval(time_t sec);
  55. #endif
  56. #if !(defined _UNIX && (defined _LONG_IS_64 || defined _VXWORKS))
  57. Timeval(int sec, int usec);
  58. Timeval(int usec);
  59. #endif
  60. Timeval(float t);
  61. Timeval(double t);
  62. Timeval& operator +=(const int b);
  63. Timeval& operator -=(const int b);
  64. Timeval& operator +=(const Timeval& b);
  65. Timeval& operator -=(const Timeval& b);
  66. };
  67. #if __MWERKS__ && !defined(_CARBON)
  68. // I added this to make Timeval t = sendperiod compile
  69. inline Timeval::Timeval(time_t t) {
  70. tv_sec = (tv_sec_t)t;
  71. tv_usec = (tv_usec_t)0;
  72. }
  73. #endif
  74. inline Timeval::Timeval(float t) {
  75. tv_sec = (tv_sec_t)t;
  76. tv_usec = (tv_usec_t)((t-tv_sec)*SECOND);
  77. }
  78. inline Timeval::Timeval(double t) {
  79. tv_sec = (tv_sec_t)t;
  80. tv_usec = (tv_usec_t)((t-tv_sec)*SECOND);
  81. }
  82. inline void Timeval::i2t(tv_sec_t& sec, tv_usec_t& usec,
  83.                          long32 s, long32 us) {
  84. sec = s;
  85. if (us >= SECOND) {
  86. sec +=  us / SECOND;
  87. usec = us % SECOND;
  88. } else {
  89. usec = us;
  90. }
  91. }
  92. inline Timeval::Timeval(long32 s, long32 us) {
  93. Timeval::i2t((tv_sec_t&)tv_sec, (tv_usec_t&)tv_usec, s, us);
  94. }
  95. inline Timeval::Timeval(long32 us) {
  96. Timeval::i2t((tv_sec_t&)tv_sec, (tv_usec_t&)tv_usec, 0L, us);
  97. }
  98. #if !(defined _UNIX && (defined _LONG_IS_64 || defined _VXWORKS))
  99. inline Timeval::Timeval(int s, int us) {
  100. Timeval::i2t((tv_sec_t&)tv_sec, (tv_usec_t&)tv_usec, s, us);
  101. }
  102. inline Timeval::Timeval(int us) {
  103. Timeval::i2t((tv_sec_t&)tv_sec, (tv_usec_t&)tv_usec, 0L, us);
  104. }
  105. #endif
  106. inline Timeval& Timeval::operator +=(const int b) {
  107. tv_usec += b;
  108. if (tv_usec >= SECOND) {
  109. tv_sec += tv_usec / SECOND;
  110. tv_usec %= SECOND;
  111. }
  112. return *this;
  113. }
  114. inline Timeval& Timeval::operator -=(const int b) {
  115. tv_usec -= b;
  116. if (tv_usec < 0) {
  117. tv_sec += tv_usec / SECOND;
  118. tv_usec %= SECOND;
  119. if (tv_usec < 0) {
  120. tv_sec--;
  121. tv_usec += SECOND;
  122. }
  123. }
  124. return *this;
  125. }
  126. /*
  127.  * The following functions don't always work for negative 'a' or 'b'
  128.  */
  129. inline Timeval& Timeval::operator +=(const Timeval& b) {
  130. tv_sec += b.tv_sec;
  131. tv_usec += b.tv_usec;
  132. while (tv_usec >= SECOND) {
  133. tv_sec++;
  134. tv_usec -= SECOND;
  135. }
  136. return *this;
  137. }
  138. inline Timeval& Timeval::operator -=(const Timeval& b) {
  139. #ifdef __hpux
  140. // tv_sec is u_long on HPUX
  141. // HP just has to do everything different doesn't it? :-(
  142. if (tv_sec < b.tv_sec)
  143. {
  144.     tv_sec = 0;
  145.     tv_usec = 0;
  146.     return *this;
  147. }
  148. if ((tv_sec == b.tv_sec) && (tv_usec < b.tv_usec))
  149. {
  150.     tv_sec = 0;
  151.     tv_usec = 0;
  152.     return *this;
  153. }
  154. #endif
  155. tv_sec -= b.tv_sec;
  156. tv_usec -= b.tv_usec;
  157. while (tv_usec < 0) {
  158. tv_sec--;
  159. tv_usec += SECOND;
  160. }
  161. return *this;
  162. }
  163. inline Timeval operator +(const Timeval& a, const Timeval& b) {
  164. Timeval c;
  165. c.tv_sec = a.tv_sec + b.tv_sec;
  166. c.tv_usec = a.tv_usec + b.tv_usec;
  167. while (c.tv_usec >= SECOND) {
  168. c.tv_sec++;
  169. c.tv_usec -= SECOND;
  170. }
  171. return c;
  172. }
  173. inline Timeval operator -(const Timeval& a, const Timeval& b) {
  174. Timeval c;
  175. #ifdef __hpux
  176. // tv_sec is u_long on HPUX
  177. // HP just has to do everything different doesn't it? :-(
  178. if (a.tv_sec < b.tv_sec)
  179. return (Timeval(0,0));
  180. if ((a.tv_sec == b.tv_sec) && (a.tv_usec < b.tv_usec))
  181. return (Timeval(0,0));
  182. #endif
  183. c.tv_sec = a.tv_sec - b.tv_sec;
  184. c.tv_usec = a.tv_usec - b.tv_usec;
  185. while (c.tv_usec < 0) {
  186. c.tv_sec--;
  187. c.tv_usec += SECOND;
  188. }
  189. return c;
  190. }
  191. inline int operator ==(const Timeval& a, const Timeval& b) {
  192. return a.tv_usec == b.tv_usec && a.tv_sec == b.tv_sec;
  193. }
  194. inline int operator !=(const Timeval& a, const Timeval& b) {
  195. return a.tv_usec != b.tv_usec || a.tv_sec != b.tv_sec;
  196. }
  197. inline int operator <=(const Timeval& a, const Timeval& b) {
  198. return a.tv_sec < b.tv_sec ||
  199.        (a.tv_sec == b.tv_sec && a.tv_usec <= b.tv_usec);
  200. }
  201. inline int operator >=(const Timeval& a, const Timeval& b) {
  202. return a.tv_sec > b.tv_sec ||
  203.        (a.tv_sec == b.tv_sec && a.tv_usec >= b.tv_usec);
  204. }
  205. inline int operator <(const Timeval& a, const Timeval& b) {
  206. return a.tv_sec < b.tv_sec ||
  207.        (a.tv_sec == b.tv_sec && a.tv_usec < b.tv_usec);
  208. }
  209. inline int operator >(const Timeval& a, const Timeval& b) {
  210. return a.tv_sec > b.tv_sec ||
  211.        (a.tv_sec == b.tv_sec && a.tv_usec > b.tv_usec);
  212. }
  213. #endif/*_TIMEVAL_H_*/