Main Page   Namespace List   Class Hierarchy   Alphabetical List   Compound List   File List   Compound Members   File Members   Related Pages  

TimeValue.cpp

Go to the documentation of this file.
00001 #include "headers.h"
00002 
00008 
00012 TimeValue::TimeValue() {
00013     m_timeValue.tv_sec = 0;
00014     m_timeValue.tv_usec = 0;
00015 } // ctor
00016 
00017 
00018 TimeValue::TimeValue(const TimeValue& value) {
00019     m_timeValue.tv_sec = value.m_timeValue.tv_sec;
00020     m_timeValue.tv_usec = value.m_timeValue.tv_usec;
00021 } // ctor
00022 
00023 
00029 TimeValue::TimeValue(int seconds, int microseconds) {
00030     m_timeValue.tv_sec = seconds;
00031     m_timeValue.tv_usec = microseconds;
00032     doCarry();
00033 } // ctor
00034 
00035 
00040 TimeValue 
00041 TimeValue::operator-(const TimeValue& value) {
00042     TimeValue tmp;
00043     tmp.m_timeValue.tv_sec = m_timeValue.tv_sec - value.m_timeValue.tv_sec;
00044     tmp.m_timeValue.tv_usec = m_timeValue.tv_usec - value.m_timeValue.tv_usec;
00045     if (tmp.m_timeValue.tv_usec < 0) {
00046         tmp.m_timeValue.tv_sec--;
00047         tmp.m_timeValue.tv_usec = 1000000 - tmp.m_timeValue.tv_usec;
00048     }
00049     return tmp;
00050 } // fn operator-
00051     
00052    
00056 TimeValue
00057 TimeValue::operator+(const TimeValue& value) {
00058     TimeValue tmp;
00059     tmp.m_timeValue.tv_sec = m_timeValue.tv_sec + value.m_timeValue.tv_sec;
00060     tmp.m_timeValue.tv_usec = m_timeValue.tv_usec + value.m_timeValue.tv_usec;
00061     tmp.doCarry();
00062     return tmp;
00063 } // fn operator+
00064 
00065 
00069 TimeValue
00070 TimeValue::operator*(double value) {
00071     TimeValue tmp;
00072     // multiply seconds
00073     tmp.m_timeValue.tv_sec = (long)(m_timeValue.tv_sec * value);
00074 
00075     // we get a remainder since we are multiplying integer times a double
00076     double remainder = fmod(m_timeValue.tv_sec, value);
00077 
00078     // multiply the microseconds
00079     tmp.m_timeValue.tv_usec = (long)(m_timeValue.tv_usec * value);
00080 
00081     // added remainder from seconds multiplication to microseconds
00082     tmp.m_timeValue.tv_usec += (long)(remainder * 1000000);
00083 
00084     tmp.doCarry();
00085 
00086     return tmp;
00087 } // fn operator*
00088 
00089 
00094 void 
00095 TimeValue::setToCurrentTime() {
00096 #ifdef WIN32
00097         struct _timeb timePtr;
00098         _ftime(&timePtr);
00099         m_timeValue.tv_sec = timePtr.time;
00100         m_timeValue.tv_usec = timePtr.millitm*1000;
00101 #endif
00102 
00103 #ifdef LINUX
00104         gettimeofday(&m_timeValue, NULL);
00105 #endif
00106 } // fn setToCurrentTime
00107 
00108 
00112 TimeValue
00113 TimeValue::getCurrentTime() {
00114     TimeValue value;
00115     value.setToCurrentTime();
00116     return value;
00117 } // fn getCurrentTime
00118 
00119 
00124 timeval 
00125 TimeValue::getTimevalStruct() {
00126     return m_timeValue;
00127 } // fn getTimevalStruct
00128 
00129 
00134 timespec
00135 TimeValue::getTimespecStruct() {
00136         m_timeSpec.tv_sec = m_timeValue.tv_sec;
00137         m_timeSpec.tv_nsec = m_timeValue.tv_usec * 1000;
00138     return m_timeSpec;
00139 } // fn getTimespecStruct
00140 
00141 
00145 bool
00146 TimeValue::isZero() {
00147     return ((m_timeValue.tv_sec == 0) && (m_timeValue.tv_usec == 0));
00148 } // fn isZero
00149 
00150 
00154 long
00155 TimeValue::getSeconds() {
00156     return m_timeValue.tv_sec;
00157 } // fn getSeconds
00158 
00159 
00163 long
00164 TimeValue::getMilliseconds() {
00165     return (m_timeValue.tv_usec / 1000);
00166 } // fn getMilliseconds
00167 
00168 
00173 long
00174 TimeValue::getTotalMilliseconds() {
00175     return (getSeconds() * 1000 + getMilliseconds());
00176 }
00177 
00178 
00182 long
00183 TimeValue::getMicroseconds() {
00184     return m_timeValue.tv_usec;
00185 } // fn getMicroseconds
00186 
00187 
00191 void
00192 TimeValue::setSeconds(long value) {
00193     m_timeValue.tv_sec = value;
00194 } // fn setSeconds
00195 
00196 
00197 void 
00198 TimeValue::doCarry() {
00199     m_timeValue.tv_sec += m_timeValue.tv_usec / 1000000;
00200     m_timeValue.tv_usec = m_timeValue.tv_usec % 1000000;
00201 } // fn doCarry
00202 
00203 
00207 void
00208 TimeValue::setMilliseconds(long value) {
00209     m_timeValue.tv_usec = value * 1000;
00210     doCarry();
00211 } // fn setMilliseconds
00212 
00213 
00214 void
00215 TimeValue::setMicroseconds(long value) {
00216     m_timeValue.tv_usec = value;
00217     doCarry();
00218 } // fn setMicroseconds
00219 
00220 
00221 void
00222 TimeValue::toStream(std::ostream& out) {
00223     out << m_timeValue.tv_sec << " seconds, " 
00224         << m_timeValue.tv_usec << " microseconds.";
00225 } // fn toStream
00226 
00227 
00228 bool 
00229 operator<(const TimeValue& value1, const TimeValue& value2) {
00230     if (value1.m_timeValue.tv_sec < value2.m_timeValue.tv_sec) {
00231         return true;
00232         }
00233         else if ((value1.m_timeValue.tv_sec == value2.m_timeValue.tv_sec) 
00234              && (value1.m_timeValue.tv_usec < value2.m_timeValue.tv_usec)) {
00235         return true;
00236     }
00237     else {
00238                 return false;
00239         }
00240 } // operator<
00241 
00242 
00246 bool 
00247 operator<(const timespec& time1, const timespec& time2) {
00248     if (time1.tv_sec < time2.tv_sec) {
00249         return true;
00250         }
00251         else if ((time1.tv_sec == time2.tv_sec) && (time1.tv_nsec < time2.tv_nsec)) {
00252         return true;
00253     }
00254     else {
00255                 return false;   }
00256 } // operator <
00257 
00258 

Generated at Thu Jul 11 13:31:52 2002 for Peekabooty by doxygen1.2.9 written by Dimitri van Heesch, © 1997-2001