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/StreamBuffer.h>

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:
    typedef long long ValueType;

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

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

    static const int SECS_PER_DAY = 86400;

    static const int SECS_PER_HOUR = 3600;

    static const 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( size_t minwidth = 1, size_t maxwidth = 9 ) const;
 
    static bool isLeap( int year );
 
    // Conversion helpers
    static unsigned toDosDate( Time time );
    static Time     fromDosDate( unsigned dosDate );
 
    friend bool operator==( const Gaudi::Time& t1, const Gaudi::Time& t2 ) { return t1.ns() == t2.ns(); }
 
    friend bool operator!=( const Gaudi::Time& t1, const Gaudi::Time& t2 ) { return t1.ns() != t2.ns(); }
 
    friend bool operator<( const Gaudi::Time& t1, const Gaudi::Time& t2 ) { return t1.ns() < t2.ns(); }
 
    friend bool operator<=( const Gaudi::Time& t1, const Gaudi::Time& t2 ) { return t1.ns() <= t2.ns(); }
 
    friend bool operator>( const Gaudi::Time& t1, const Gaudi::Time& t2 ) { return t1.ns() > t2.ns(); }
 
    friend bool operator>=( const Gaudi::Time& t1, const Gaudi::Time& t2 ) { return t1.ns() >= t2.ns(); }
 
  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 } );
    }
  };
} // namespace Gaudi
 
#include <GaudiKernel/Time.icpp>