Time.h

Go to the documentation of this file.

/***********************************************************************************\
* (c) Copyright 1998-2025 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
 
#include <GaudiKernel/GaudiException.h>
#include <GaudiKernel/Kernel.h>
#include <GaudiKernel/StatusCode.h>
#include <GaudiKernel/StreamBuffer.h>
#include <cstdint>
#include <iostream>
#include <limits>
#include <string>
#include <string_view>
#include <utility>

struct GAUDI_API TimeException : GaudiException {
  // Standard constructor
  TimeException( std::string Message = "unspecified exception", std::string Tag = "*Gaudi::Time*",
                 StatusCode Code = StatusCode::FAILURE )
      : GaudiException( std::move( Message ), std::move( Tag ), std::move( Code ) ) {}
};
 
struct tm;
 
namespace Gaudi {
 
  class Time;
  class TimeSpan;

  class GAUDI_API TimeSpan {
    friend class Time;
 
  public:
    using ValueType = std::int64_t;

    TimeSpan() = default;
 
    TimeSpan( Time t );
    TimeSpan( ValueType nsecs );
    TimeSpan( ValueType secs, int nsecs );
    TimeSpan( int days, int hours, int mins, int secs, int nsecs );
 
    int       days() const;
    int       hours() const;
    int       minutes() const;
    ValueType seconds() const;
 
    int lastHours() const;
    int lastMinutes() const;
    int lastSeconds() const;
    int lastNSeconds() const;
 
    TimeSpan& operator+=( const TimeSpan& x );
    TimeSpan& operator-=( const TimeSpan& x );
    TimeSpan& operator*=( const TimeSpan& n );
    TimeSpan& operator/=( const TimeSpan& n );
    TimeSpan& operator%=( const TimeSpan& n );
 
    ValueType ns() const;
 
    friend auto operator<=>( const Gaudi::TimeSpan& t1, const Gaudi::TimeSpan& t2 ) = default;
 
    friend Gaudi::TimeSpan operator+( const Gaudi::TimeSpan& ts1, const Gaudi::TimeSpan& ts2 ) {
      return Gaudi::TimeSpan( ts1.ns() + ts2.ns() );
    }
 
    friend Gaudi::TimeSpan operator-( const Gaudi::TimeSpan& ts1, const Gaudi::TimeSpan& ts2 ) {
      return Gaudi::TimeSpan( ts1.ns() - ts2.ns() );
    }
 
  private:
    ValueType m_nsecs = 0; //< The span length.
  };

  class GAUDI_API Time {
    friend class TimeSpan;
 
  public:
    using ValueType = std::int64_t;

    enum Months {
      January   = 0,
      February  = 1,
      March     = 2,
      April     = 3,
      May       = 4,
      June      = 5,
      July      = 6,
      August    = 7,
      September = 8,
      October   = 9,
      November  = 10,
      December  = 11
    };

    inline static constexpr int SECS_PER_DAY = 86400;

    inline static constexpr int SECS_PER_HOUR = 3600;

    inline static constexpr ValueType SEC_NSECS = 1000000000;

    Time() = default;
 
    Time( TimeSpan ts );
    Time( ValueType nsecs );
    Time( ValueType secs, int nsecs );
    Time( int year, int month, int day, int hour, int min, int sec, ValueType nsecs, bool local = true );
    // implicit copy constructor
    // implicit assignment operator
    // implicit destructor

    static Time epoch();
    static Time max();
    static Time current();
 
    static Time build( bool local, const tm& base, TimeSpan diff = 0 );
 
    tm split( bool local, int* nsecpart = 0 ) const;
    tm utc( int* nsecpart = 0 ) const;
    tm local( int* nsecpart = 0 ) const;
 
    int  year( bool local ) const;
    int  month( bool local ) const;
    int  day( bool local ) const;
    int  hour( bool local ) const;
    int  minute( bool local ) const;
    int  second( bool local ) const;
    int  nsecond() const;
    int  weekday( bool local ) const;
    bool isdst( bool local ) const;
 
    ValueType   utcoffset( int* daylight = 0 ) const;
    const char* timezone( int* daylight = 0 ) const;
 
    Time& operator+=( const TimeSpan& x );
    Time& operator-=( const TimeSpan& x );
 
    ValueType ns() const;
 
    std::string format( bool local, std::string spec = "%c" ) const;
    std::string nanoformat( std::size_t minwidth = 1, std::size_t maxwidth = 9 ) const;
 
    static bool isLeap( int year );
 
    // Conversion helpers
    static unsigned toDosDate( Time time );
    static Time     fromDosDate( unsigned dosDate );
 
    friend auto operator<=>( const Gaudi::Time& t1, const Gaudi::Time& t2 ) = default;
 
  private:
    ValueType m_nsecs = 0; //< Time value as nsecs from #epoch().
 
    // Taking string_view means there will never be any dynamic allocation if cond == true
    inline void TimeAssert( bool cond, std::string_view msg = "time assertion failed" ) const {
      if ( !cond ) throw TimeException( std::string{ msg } );
    }
  };

  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 std::numeric_limits<ValueType>::max(); }

  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 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;
}