Time.icpp

Go to the documentation of this file.

#ifndef GAUDIKERNEL_TIME_ICPP
#define GAUDIKERNEL_TIME_ICPP 1

// Implementation of inline function for classes Gaudi::Time and Gaudi::TimeSpan

namespace Gaudi {

  inline Time::Time (ValueType nsecs): m_nsecs(nsecs) {
    TimeAssert( m_nsecs >= 0, "cannot create a negative time");
  }

  inline Time::Time (TimeSpan ts) : m_nsecs(ts.m_nsecs) {
    TimeAssert( m_nsecs >= 0, "cannot create a negative time");
  }

  inline Time::Time (ValueType secs, int nsecs)
    : m_nsecs(secs * Time::SEC_NSECS + nsecs) {
    TimeAssert( m_nsecs >= 0, "cannot create a negative time");
  }

  inline Time::ValueType Time::ns() const {
    return m_nsecs;
  }

  inline Time &Time::operator+= (const TimeSpan &x) {
    TimeAssert( m_nsecs >= -x.m_nsecs, "time operation lead to negative time");
    m_nsecs += x.m_nsecs;
    return *this;
  }

  inline Time &Time::operator-= (const TimeSpan &x) {
    TimeAssert( m_nsecs >= x.m_nsecs, "time operation lead to negative time");
    m_nsecs -= x.m_nsecs;
    return *this;
  }

  inline Time Time::epoch() {
    return 0LL;
  }

  inline Time Time::max() {
    return 0x7fffffffffffffffLL;
  }

  inline bool Time::isLeap (int year) {
    return ((year % 4) == 0
            && ((year % 100) != 0
                || (year % 400) == 0));
  }


  inline TimeSpan::TimeSpan (Time t): m_nsecs (t.m_nsecs) {}

  inline TimeSpan::TimeSpan (ValueType nsecs): m_nsecs (nsecs) {}

  inline TimeSpan::TimeSpan (ValueType secs, int nsecs)
    : m_nsecs(secs * Time::SEC_NSECS + nsecs) {}

  inline TimeSpan::TimeSpan (int days, int hours, int mins, int secs, int nsecs) {
    m_nsecs = (secs + 60 * (mins + 60 * (hours + 24*days)))*Time::SEC_NSECS + nsecs;
  }

  inline int TimeSpan::days() const {
    return int(m_nsecs / Time::SEC_NSECS / Time::SECS_PER_DAY);
  }

  inline int TimeSpan::hours() const {
    return int(m_nsecs / Time::SEC_NSECS / Time::SECS_PER_HOUR);
  }

  inline int TimeSpan::minutes() const {
    return int(m_nsecs / Time::SEC_NSECS / 60);
  }

  inline TimeSpan::ValueType TimeSpan::seconds() const {
    return m_nsecs / Time::SEC_NSECS;
  }

  inline TimeSpan::ValueType TimeSpan::ns() const {
    return m_nsecs;
  }

  inline int TimeSpan::lastHours() const {
    return hours () - days () * 24;
  }

  inline int TimeSpan::lastMinutes() const {
    return minutes () - hours () * 60;
  }

  inline int TimeSpan::lastSeconds() const {
    return int(seconds() - ( (ValueType)minutes() * (ValueType)60 ));
  }

  inline int TimeSpan::lastNSeconds() const {
    return int(m_nsecs % Time::SEC_NSECS);
  }

  inline TimeSpan &TimeSpan::operator+= (const TimeSpan &x) {
    m_nsecs += x.m_nsecs;
    return *this;
  }

  inline TimeSpan & TimeSpan::operator-= (const TimeSpan &x) {
    m_nsecs -= x.m_nsecs;
    return *this;
  }

  inline TimeSpan & TimeSpan::operator*= (const TimeSpan &x) {
    m_nsecs *= x.m_nsecs;
    return *this;
  }

  inline TimeSpan & TimeSpan::operator/= (const TimeSpan &x) {
    m_nsecs /= x.m_nsecs; return *this;
  }

  inline TimeSpan & TimeSpan::operator%= (const TimeSpan &x) {
    m_nsecs %= x.m_nsecs; return *this;
  }

  inline std::ostream& operator<< (std::ostream &out, const Gaudi::Time &time) {
    return out << Gaudi::TimeSpan(time).seconds() << '.' << time.nanoformat();
  }

  inline std::ostream& operator<< (std::ostream &out, const Gaudi::TimeSpan &time) {
    return out << time.seconds() << '.' << Gaudi::Time(time).nanoformat();
  }
}

//<<<<<< INLINE PUBLIC FUNCTIONS                                        >>>>>>
inline Gaudi::Time operator+ (const Gaudi::Time &t, const Gaudi::TimeSpan &ts) {
  return Gaudi::Time (t.ns() + ts.ns());
}

inline Gaudi::Time operator+ (const Gaudi::TimeSpan &ts, const Gaudi::Time &t) {
  return Gaudi::Time (t.ns() + ts.ns());
}

inline Gaudi::TimeSpan operator- (const Gaudi::Time &t1, const Gaudi::Time &t2) {
  return Gaudi::TimeSpan (t1.ns() - t2.ns());
}

inline Gaudi::Time operator- (const Gaudi::Time &t, const Gaudi::TimeSpan &ts) {
  return Gaudi::Time (t.ns() - ts.ns());
}


inline bool operator! (const Gaudi::Time &t) {
  return ! t.ns();
}


inline Gaudi::TimeSpan operator+ (const Gaudi::TimeSpan &ts) {
  return ts;
}

inline Gaudi::TimeSpan operator- (const Gaudi::TimeSpan &ts) {
  return Gaudi::TimeSpan (-ts.ns());
}

inline bool operator! (const Gaudi::TimeSpan &ts) {
  return ! ts.ns();
}

// --- operators for serialization ---

// Output serialization
inline StreamBuffer& operator<<(StreamBuffer &s, const Gaudi::Time &t)  {
  return s << t.ns();
}
// Input serialization
inline StreamBuffer& operator>>(StreamBuffer &s, Gaudi::Time &t)  {
  Gaudi::Time::ValueType tmp;
  s >> tmp;
  t = Gaudi::Time(tmp);
  return s;
}

// make sure that "namespace  Gaudi { using ::operator<; }" continues to compile...
// to be removed once all instances of the above have been removed from user code...
class backwards_compatibility_hack_time_timespan {backwards_compatibility_hack_time_timespan()=delete; };
inline bool operator<(backwards_compatibility_hack_time_timespan,backwards_compatibility_hack_time_timespan) {
    return false;
}

#endif