| # Gaudi Framework, version v20r3
Generated: 24 Nov 2008

# Time.icpp

Go to the documentation of this file.

    00001 // $Id: Time.icpp,v 1.1 2006/01/25 16:02:48 hmd Exp $
    00002 #ifndef GAUDIKERNEL_TIME_ICPP
    00003 #define GAUDIKERNEL_TIME_ICPP 1
    00004
    00005 // Implementation of inline function for classes Gaudi::Time and Gaudi::TimeSpan
    00006
    00007 namespace Gaudi {
    00008
    00010   inline Time::Time (void): m_nsecs(0) {}
    00011
    00014   inline Time::Time (ValueType nsecs): m_nsecs(nsecs) {
    00015     TimeAssert( m_nsecs >= 0, "cannot create a negative time");
    00016   }
    00017
    00020   inline Time::Time (TimeSpan ts) : m_nsecs(ts.m_nsecs) {
    00021     TimeAssert( m_nsecs >= 0, "cannot create a negative time");
    00022   }
    00023
    00026   inline Time::Time (ValueType secs, int nsecs)
    00027     : m_nsecs(secs * Time::SEC_NSECS + nsecs) {
    00028     TimeAssert( m_nsecs >= 0, "cannot create a negative time");
    00029   }
    00030
    00033   inline Time::ValueType Time::ns (void) const {
    00034     return m_nsecs;
    00035   }
    00036
    00039   inline Time &Time::operator+= (const TimeSpan &x) {
    00040     TimeAssert( m_nsecs >= -x.m_nsecs, "time operation lead to negative time");
    00041     m_nsecs += x.m_nsecs;
    00042     return *this;
    00043   }
    00044
    00047   inline Time &Time::operator-= (const TimeSpan &x) {
    00048     TimeAssert( m_nsecs >= x.m_nsecs, "time operation lead to negative time");
    00049     m_nsecs -= x.m_nsecs;
    00050     return *this;
    00051   }
    00052
    00054   inline Time Time::epoch (void) {
    00055     return 0LL;
    00056   }
    00057
    00059   inline Time Time::max (void) {
    00060     return 0x7fffffffffffffffLL;
    00061   }
    00062
    00064   inline bool Time::isLeap (int year) {
    00065     return ((year % 4) == 0
    00066             && ((year % 100) != 0
    00067                 || (year % 400) == 0));
    00068   }
    00069
    00073
    00074   inline TimeSpan::TimeSpan (void): m_nsecs(0) {}
    00075
    00077   inline TimeSpan::TimeSpan (Time t): m_nsecs (t.m_nsecs) {}
    00078
    00080   inline TimeSpan::TimeSpan (ValueType nsecs): m_nsecs (nsecs) {}
    00081
    00090   inline TimeSpan::TimeSpan (ValueType secs, int nsecs)
    00091     : m_nsecs(secs * Time::SEC_NSECS + nsecs) {}
    00092
    00104   inline TimeSpan::TimeSpan (int days, int hours, int mins, int secs, int nsecs) {
    00105     m_nsecs = (secs + 60 * (mins + 60 * (hours + 24*days)))*Time::SEC_NSECS + nsecs;
    00106   }
    00107
    00109   inline int TimeSpan::days (void) const {
    00110     return int(m_nsecs / Time::SEC_NSECS / Time::SECS_PER_DAY);
    00111   }
    00112
    00114   inline int TimeSpan::hours (void) const {
    00115     return int(m_nsecs / Time::SEC_NSECS / Time::SECS_PER_HOUR);
    00116   }
    00117
    00119   inline int TimeSpan::minutes (void) const {
    00120     return int(m_nsecs / Time::SEC_NSECS / 60);
    00121   }
    00122
    00124   inline TimeSpan::ValueType TimeSpan::seconds (void) const {
    00125     return m_nsecs / Time::SEC_NSECS;
    00126   }
    00127
    00129   inline TimeSpan::ValueType TimeSpan::ns (void) const {
    00130     return m_nsecs;
    00131   }
    00132
    00135   inline int TimeSpan::lastHours (void) const {
    00136     return hours () - days () * 24;
    00137   }
    00138
    00141   inline int TimeSpan::lastMinutes (void) const {
    00142     return minutes () - hours () * 60;
    00143   }
    00144
    00147   inline int TimeSpan::lastSeconds (void) const {
    00148     return int(seconds() - ( (ValueType)minutes() * (ValueType)60 ));
    00149   }
    00150
    00153   inline int TimeSpan::lastNSeconds (void) const {
    00154     return int(m_nsecs % Time::SEC_NSECS);
    00155   }
    00156
    00158   inline TimeSpan &TimeSpan::operator+= (const TimeSpan &x) {
    00159     m_nsecs += x.m_nsecs;
    00160     return *this;
    00161   }
    00162
    00164   inline TimeSpan & TimeSpan::operator-= (const TimeSpan &x) {
    00165     m_nsecs -= x.m_nsecs;
    00166     return *this;
    00167   }
    00168
    00170   inline TimeSpan & TimeSpan::operator*= (const TimeSpan &x) {
    00171     m_nsecs *= x.m_nsecs;
    00172     return *this;
    00173   }
    00174
    00176   inline TimeSpan & TimeSpan::operator/= (const TimeSpan &x) {
    00177     m_nsecs /= x.m_nsecs; return *this;
    00178   }
    00179
    00181   inline TimeSpan & TimeSpan::operator%= (const TimeSpan &x) {
    00182     m_nsecs %= x.m_nsecs; return *this;
    00183   }
    00184 }
    00185
    00186 //<<<<<< INLINE PUBLIC FUNCTIONS                                        >>>>>>
    00187
    00188 inline std::ostream& operator<< (std::ostream &out, const Gaudi::Time &time) {
    00189   return out << Gaudi::TimeSpan(time).seconds() << '.' << time.nanoformat();
    00190 }
    00191
    00192 inline std::ostream& operator<< (std::ostream &out, const Gaudi::TimeSpan &time) {
    00193   return out << time.seconds() << '.' << Gaudi::Time(time).nanoformat();
    00194 }
    00195
    00196 inline Gaudi::Time operator+ (const Gaudi::Time &t, const Gaudi::TimeSpan &ts) {
    00197   return Gaudi::Time (t.ns() + ts.ns());
    00198 }
    00199
    00200 inline Gaudi::Time operator+ (const Gaudi::TimeSpan &ts, const Gaudi::Time &t) {
    00201   return Gaudi::Time (t.ns() + ts.ns());
    00202 }
    00203
    00204 inline Gaudi::TimeSpan operator- (const Gaudi::Time &t1, const Gaudi::Time &t2) {
    00205   return Gaudi::TimeSpan (t1.ns() - t2.ns());
    00206 }
    00207
    00208 inline Gaudi::Time operator- (const Gaudi::Time &t, const Gaudi::TimeSpan &ts) {
    00209   return Gaudi::Time (t.ns() - ts.ns());
    00210 }
    00211
    00212 //inline Gaudi::TimeSpan operator* (const Gaudi::Time &t, const Gaudi::TimeSpan &ts) {
    00213 //  return Gaudi::TimeSpan (t.ns() * ts.ns());
    00214 //}
    00215
    00216 //inline Gaudi::TimeSpan operator/ (const Gaudi::Time &t, const Gaudi::TimeSpan &ts) {
    00217 //  return Gaudi::TimeSpan (t.ns() / ts.ns());
    00218 //}
    00219
    00220 //inline Gaudi::TimeSpan operator% (const Gaudi::Time &t, const Gaudi::TimeSpan &ts) {
    00221 //  return Gaudi::TimeSpan (t.ns() % ts.ns());
    00222 //}
    00223
    00224 inline bool operator== (const Gaudi::Time &t1, const Gaudi::Time &t2) {
    00225   return t1.ns() == t2.ns();
    00226 }
    00227
    00228 inline bool operator!= (const Gaudi::Time &t1, const Gaudi::Time &t2) {
    00229   return t1.ns() != t2.ns();
    00230 }
    00231
    00232 inline bool operator< (const Gaudi::Time &t1, const Gaudi::Time &t2) {
    00233   return t1.ns() < t2.ns();
    00234 }
    00235
    00236 inline bool operator<= (const Gaudi::Time &t1, const Gaudi::Time &t2) {
    00237   return t1.ns() <= t2.ns();
    00238 }
    00239
    00240 inline bool operator> (const Gaudi::Time &t1, const Gaudi::Time &t2) {
    00241   return t1.ns() > t2.ns();
    00242 }
    00243
    00244 inline bool operator>= (const Gaudi::Time &t1, const Gaudi::Time &t2) {
    00245   return t1.ns() >= t2.ns();
    00246 }
    00247
    00248 inline bool operator! (const Gaudi::Time &t) {
    00249   return ! t.ns();
    00250 }
    00251
    00255
    00256 inline Gaudi::TimeSpan operator+ (const Gaudi::TimeSpan &ts) {
    00257   return ts;
    00258 }
    00259
    00260 inline Gaudi::TimeSpan operator- (const Gaudi::TimeSpan &ts) {
    00261   return Gaudi::TimeSpan (-ts.ns());
    00262 }
    00263
    00264 inline Gaudi::TimeSpan operator+ (const Gaudi::TimeSpan &ts1, const Gaudi::TimeSpan &ts2) {
    00265   return Gaudi::TimeSpan (ts1.ns() + ts2.ns());
    00266 }
    00267
    00268 inline Gaudi::TimeSpan operator- (const Gaudi::TimeSpan &ts1, const Gaudi::TimeSpan &ts2) {
    00269   return Gaudi::TimeSpan (ts1.ns() - ts2.ns());
    00270 }
    00271
    00272 //inline Gaudi::TimeSpan operator* (const Gaudi::TimeSpan &ts1, const Gaudi::TimeSpan &ts2) {
    00273 //  return Gaudi::TimeSpan (ts1.ns() * ts2.ns());
    00274 //}
    00275
    00276 //inline Gaudi::TimeSpan operator/ (const Gaudi::TimeSpan &ts1, const Gaudi::TimeSpan &ts2) {
    00277 //  return Gaudi::TimeSpan (ts1.ns() / ts2.ns());
    00278 //}
    00279
    00280 //inline Gaudi::TimeSpan operator% (const Gaudi::TimeSpan &ts1, const Gaudi::TimeSpan &ts2) {
    00281 //  return Gaudi::TimeSpan (ts1.ns() % ts2.ns());
    00282 //}
    00283
    00284 inline bool operator== (const Gaudi::TimeSpan &t1, const Gaudi::TimeSpan &t2) {
    00285   return t1.ns() == t2.ns();
    00286 }
    00287
    00288 inline bool operator!= (const Gaudi::TimeSpan &t1, const Gaudi::TimeSpan &t2) {
    00289   return t1.ns() != t2.ns();
    00290 }
    00291
    00292 inline bool operator< (const Gaudi::TimeSpan &t1, const Gaudi::TimeSpan &t2) {
    00293   return t1.ns() < t2.ns();
    00294 }
    00295
    00296 inline bool operator<= (const Gaudi::TimeSpan &t1, const Gaudi::TimeSpan &t2) {
    00297   return t1.ns() <= t2.ns();
    00298 }
    00299
    00300 inline bool operator> (const Gaudi::TimeSpan &t1, const Gaudi::TimeSpan &t2) {
    00301   return t1.ns() > t2.ns();
    00302 }
    00303
    00304 inline bool operator>= (const Gaudi::TimeSpan &t1, const Gaudi::TimeSpan &t2) {
    00305   return t1.ns() >= t2.ns();
    00306 }
    00307
    00308 inline bool operator! (const Gaudi::TimeSpan &ts) {
    00309   return ! ts.ns();
    00310 }
    00311
    00312 // --- operators for serialization ---
    00313
    00314 // Output serialization
    00315 inline StreamBuffer& operator<<(StreamBuffer &s, const Gaudi::Time &t)  {
    00316   return s << t.ns();
    00317 }
    00318 // Input serialization
    00319 inline StreamBuffer& operator>>(StreamBuffer &s, Gaudi::Time &t)  {
    00320   Gaudi::Time::ValueType tmp;
    00321   s >> tmp;
    00322   t = Gaudi::Time(tmp);
    00323   return s;
    00324 }
    00325
    00326 #endif