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 (void): m_nsecs(0) {}

  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 (void) 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 (void) {
    return 0LL;
  }

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

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


  inline TimeSpan::TimeSpan (void): m_nsecs(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 (void) const {
    return int(m_nsecs / Time::SEC_NSECS / Time::SECS_PER_DAY);
  }

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

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

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

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

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

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

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

  inline int TimeSpan::lastNSeconds (void) 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 Gaudi::TimeSpan operator* (const Gaudi::Time &t, const Gaudi::TimeSpan &ts) {
//  return Gaudi::TimeSpan (t.ns() * ts.ns());
//}

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

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

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

inline bool operator!= (const Gaudi::Time &t1, const Gaudi::Time &t2) {
  return t1.ns() != t2.ns();
}

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

inline bool operator<= (const Gaudi::Time &t1, const Gaudi::Time &t2) {
  return t1.ns() <= t2.ns();
}

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

inline bool operator>= (const Gaudi::Time &t1, const Gaudi::Time &t2) {
  return t1.ns() >= t2.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 Gaudi::TimeSpan operator+ (const Gaudi::TimeSpan &ts1, const Gaudi::TimeSpan &ts2) {
  return Gaudi::TimeSpan (ts1.ns() + ts2.ns());
}

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

//inline Gaudi::TimeSpan operator* (const Gaudi::TimeSpan &ts1, const Gaudi::TimeSpan &ts2) {
//  return Gaudi::TimeSpan (ts1.ns() * ts2.ns());
//}

//inline Gaudi::TimeSpan operator/ (const Gaudi::TimeSpan &ts1, const Gaudi::TimeSpan &ts2) {
//  return Gaudi::TimeSpan (ts1.ns() / ts2.ns());
//}

//inline Gaudi::TimeSpan operator% (const Gaudi::TimeSpan &ts1, const Gaudi::TimeSpan &ts2) {
//  return Gaudi::TimeSpan (ts1.ns() % ts2.ns());
//}

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

inline bool operator!= (const Gaudi::TimeSpan &t1, const Gaudi::TimeSpan &t2) {
  return t1.ns() != t2.ns();
}

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

inline bool operator<= (const Gaudi::TimeSpan &t1, const Gaudi::TimeSpan &t2) {
  return t1.ns() <= t2.ns();
}

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

inline bool operator>= (const Gaudi::TimeSpan &t1, const Gaudi::TimeSpan &t2) {
  return t1.ns() >= t2.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;
}

#endif