In This Package:

TimeStamp.h

Go to the documentation of this file.

#ifndef TIMESTAMP_HH
#define TIMESTAMP_HH


#include <ctime>

// make the TimeStamp cout'able
#include <iosfwd>


class TimeStamp;
std::ostream& operator<<(std::ostream& os, const TimeStamp& vldts);

class TimeStamp {

    friend bool operator==(const TimeStamp &lhs, const TimeStamp &rhs);
    friend bool operator!=(const TimeStamp &lhs, const TimeStamp &rhs);
    friend bool operator< (const TimeStamp &lhs, const TimeStamp &rhs);
    friend bool operator<=(const TimeStamp &lhs, const TimeStamp &rhs);
    friend bool operator> (const TimeStamp &lhs, const TimeStamp &rhs);
    friend bool operator>=(const TimeStamp &lhs, const TimeStamp &rhs);

    friend TimeStamp operator- (const TimeStamp &lhs, const TimeStamp &rhs);

public:

    static TimeStamp GetBOT();

    static TimeStamp GetEOT();

    static TimeStamp GetNBOT();

    TimeStamp();

    TimeStamp(const TimeStamp &source)
        { mSec = source.mSec; mNanoSec = source.mNanoSec; }
    TimeStamp& operator=(const TimeStamp &source)
        { if (this != &source) {mSec = source.mSec; mNanoSec = source.mNanoSec;}
            return *this; }

    TimeStamp(const timespec &ts)
        { mSec = ts.tv_sec; mNanoSec = ts.tv_nsec; NormalizeNanoSec(); }

    TimeStamp(const time_t &t, const int nsec)
        { mSec = t; mNanoSec = 0; mNanoSec = nsec; NormalizeNanoSec(); }

    TimeStamp(unsigned int year, unsigned int month,
              unsigned int day,  unsigned int hour,
              unsigned int min,  unsigned int sec,
              unsigned int nsec=0, 
              bool isUTC=true, int secOffset=0);

    TimeStamp(unsigned int date, unsigned int time, unsigned int nsec, 
              bool isUTC=true, int secOffset=0);

    // Create a TimeStamp using double precision floating point
    // seconds from the EPOCH.
    //
    // \warning This will truncate precision to no better than about 1
    // microsecond.  Do not use this constructor for timestamps that
    // are expected to be more precise!
    //
    TimeStamp(double seconds)
        { mSec = (int)seconds; mNanoSec = (int)((seconds-mSec)*1.0e9); 
            NormalizeNanoSec();}
  

    virtual ~TimeStamp();

    // Implicitly convert a TimeStamp to a double.
    //
    // \warning This will truncate precision to no better than about 1
    // microsecond.  Do not compare/subtract TimeStamps that have
    // been converted to doubles if you require the full nanosecond
    // precision!
  
    operator double() const { return mSec + 1.0e-9 * mNanoSec; }
  
  
    timespec     GetTimeSpec() const { timespec value = {mSec,mNanoSec}; return value; }
  
    time_t         GetSec(void) const { return mSec;}
    int          GetNanoSec(void) const { return mNanoSec; }
  
    double GetSeconds(void) const { return mSec+(mNanoSec/1.0e9); }
  
    //    Return the date & time as a string.
    //   
    //    Result is pointer to a statically allocated string.
    //    User should copy this into their own buffer before calling
    //    this method again.  This is somewhat mitigated
    //    by use of a circular buffer of strings.
    //   
    //    Option "l" returns it in local zone format
    //    (can be applied to default or compact format).
    //   
    //    Default format is RFC822 compliant:
    //      "Mon, 02 Jan 2001 18:11:12 +0000 (GMT) +999999999 nsec"
    //      "Mon, 02 Jan 2001 10:11:12 -0800 (PST) +999999999 nsec"
    //   
    //    Option "c" compact is (almost) ISO 8601 compliant:
    //      "2001-01-02 18:11:12.9999999999Z"
    //      "2001-01-02 10:11:12.9999999999-0800"  if PST
    //         * uses "-" as date separator as specified in ISO 8601
    //         * uses "." rather than preferred "," for decimal separator
    //         * -HHMM is the difference between local and UTC (if behind, + if ahead).
    //      The "-HHMM" is replaced with "Z" if given as UTC.
    //      To be strictly conforming it should use "T" instead of the
    //      blank separating the date and time.
    //   
    //    Option "2" returns as {sec,nsec} integers.
    //   
    //    Option "s" returns "2001-01-02 18:11:12" with an implied UTC,
    //    overrides "l" option.
    //   
    //    Internally uses a circular list of buffers to avoid problems
    //    using AsString multiple times in a single statement.
    //    
    const char    *AsString(const char* option="") const;
    void           Copy(TimeStamp &vldts) const;

    int          GetDate(bool inUTC=true, int secOffset=0,
                         unsigned int *year=0, unsigned int *month=0,
                         unsigned int *day=0) const;

    int          GetTime(bool inUTC=true, int secOffset=0,
                         unsigned int* hour=0, unsigned int* min=0, 
                         unsigned int* sec=0) const;

    void           Add(const TimeStamp& offset);
    void           Add(double seconds);
    void           Subtract(const TimeStamp& offset);
    void           Subtract(double seconds);

    void           Print(const char* option="") const;
  
    bool          IsNull() const { return (mSec==0)&&(mNanoSec==0); };
  
    // Utility functions
  
    static int   GetZoneOffset();
 
    // Equivalent of standard routine "mktime" but
    // using the assumption that tm struct is filled with UTC, not local, time.
    //
    // This version *ISN'T* configured to handle every possible
    // weirdness of out-of-range values in the case of normalizing
    // the tm struct.
    //
    // This version *DOESN'T* correctly handle values that can't be
    // fit into a time_t (i.e. beyond year 2038-01-18 19:14:07, or
    // before the start of Epoch). */
  
    static time_t  MktimeFromUTC(tm* tmstruct);
  
    static bool  IsLeapYear(int year);
  
    static void    DumpTMStruct(const tm& tmstruct);

private:

    void           Set();
    void           Set(int year, int month, int day,
                       int hour, int min, int sec, 
                       int nsec, bool isUTC, int secOffset);
    void           Set(int date, int time, int nsec,
                       bool isUTC, int secOffset);
    void           NormalizeNanoSec();

    // Data members:
    // similar fields to struct timespec
    // use ROOT versions to "know" that they are platform consistent
    // 32-bit integers to avoid IO confusion.
    int  mSec;
    int  mNanoSec;

};


//=============================================================================
// Implementation details -- inlines need to be hidden from CINT
//=============================================================================

inline bool operator==(const TimeStamp &lhs, const TimeStamp &rhs)
{ return lhs.mSec  == rhs.mSec && 
        lhs.mNanoSec == rhs.mNanoSec; }

inline bool operator!=(const TimeStamp &lhs, const TimeStamp &rhs)
{ return lhs.mSec  != rhs.mSec ||
        lhs.mNanoSec != rhs.mNanoSec; }

inline bool operator<(const TimeStamp &lhs, const TimeStamp &rhs)
{ return lhs.mSec  < rhs.mSec ||
        ( lhs.mSec  == rhs.mSec &&
          lhs.mNanoSec <  rhs.mNanoSec   ); }

inline bool operator<=(const TimeStamp &lhs, const TimeStamp &rhs)
{ return lhs.mSec  < rhs.mSec ||
        ( lhs.mSec  == rhs.mSec &&
          lhs.mNanoSec <= rhs.mNanoSec   ); }

inline bool operator>(const TimeStamp &lhs, const TimeStamp &rhs)
{ return lhs.mSec  > rhs.mSec ||
        ( lhs.mSec  == rhs.mSec &&
          lhs.mNanoSec >  rhs.mNanoSec   ); }

inline bool operator>=(const TimeStamp &lhs, const TimeStamp &rhs)
{ return lhs.mSec  > rhs.mSec ||
        ( lhs.mSec  == rhs.mSec &&
          lhs.mNanoSec >= rhs.mNanoSec   ); }

inline TimeStamp operator-(const TimeStamp& lhs, const TimeStamp& rhs)
{
    return TimeStamp(lhs.GetSec()     - rhs.GetSec(),
                     lhs.GetNanoSec() - rhs.GetNanoSec());
}

#endif // TIMESTAMP_HH

---