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