Time.icpp

Go to the documentation of this file.

/***********************************************************************************\
* (c) Copyright 1998-2019 CERN for the benefit of the LHCb and ATLAS collaborations *
*                                                                                   *
* This software is distributed under the terms of the Apache version 2 licence,     *
* copied verbatim in the file "LICENSE".                                            *
*                                                                                   *
* In applying this licence, CERN does not waive the privileges and immunities       *
* granted to it by virtue of its status as an Intergovernmental Organization        *
* or submit itself to any jurisdiction.                                             *
\***********************************************************************************/
#pragma once
 
// 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();
  }
} // namespace Gaudi
 
//<<<<<< 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;
}