Time.h

Go to the documentation of this file.

#ifndef GAUDIKERNEL_TIME_H
#define GAUDIKERNEL_TIME_H 1

// Include files
//   for the architecture independent int64 definition (long long)
#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;
#ifdef WIN32
typedef struct _FILETIME FILETIME;
#endif

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();
#ifdef WIN32
    static Time from( const FILETIME* systime );
#endif
    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().

    inline void TimeAssert( bool cond, const std::string& msg = "time assertion failed" ) const {
      if ( !cond ) throw TimeException( msg );
    }
  };
} // namespace Gaudi

#include "GaudiKernel/Time.icpp"

#endif // GAUDIKERNEL_TIME_H