VldTimeStamp.h

Go to the documentation of this file.

#ifndef VLDTIMESTAMP_H
#define VLDTIMESTAMP_H

// TTimeStamp is the ROOT adopted version of this class
// so it has all the necessary includes
#include "TTimeStamp.h"

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

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

class VldTimeStamp {

   friend Bool_t operator==(const VldTimeStamp &lhs, const VldTimeStamp &rhs);
   friend Bool_t operator!=(const VldTimeStamp &lhs, const VldTimeStamp &rhs);
   friend Bool_t operator< (const VldTimeStamp &lhs, const VldTimeStamp &rhs);
   friend Bool_t operator<=(const VldTimeStamp &lhs, const VldTimeStamp &rhs);
   friend Bool_t operator> (const VldTimeStamp &lhs, const VldTimeStamp &rhs);
   friend Bool_t operator>=(const VldTimeStamp &lhs, const VldTimeStamp &rhs);

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

 public:

   static VldTimeStamp GetBOT();

   static VldTimeStamp GetEOT();

   static VldTimeStamp GetNBOT();

   VldTimeStamp();

   VldTimeStamp(const VldTimeStamp &source)
     : fSec(source.fSec), fNanoSec(source.fNanoSec) { }

   VldTimeStamp& operator=(const VldTimeStamp &source)
      { if (this != &source) {fSec = source.fSec; fNanoSec = source.fNanoSec;}
      return *this; }

   VldTimeStamp(const timespec_t &ts)
     : fSec(ts.tv_sec), fNanoSec(ts.tv_nsec)
      { NormalizeNanoSec(); }

   VldTimeStamp(const time_t &t, const Int_t nsec)
     : fSec(t), fNanoSec(nsec)
      { NormalizeNanoSec(); }

   VldTimeStamp(UInt_t year, UInt_t month,
                UInt_t day,  UInt_t hour,
                UInt_t min,  UInt_t sec,
                UInt_t nsec=0, 
                Bool_t isUTC=kTRUE, Int_t secOffset=0);

   VldTimeStamp(UInt_t date, UInt_t time, UInt_t nsec, 
                Bool_t isUTC=kTRUE, Int_t secOffset=0);

   VldTimeStamp(Double_t seconds)
     : fSec((Int_t)seconds), fNanoSec((Int_t)((seconds-fSec)*1.0e9))
     { NormalizeNanoSec(); }


   virtual ~VldTimeStamp();

   operator double() const { return fSec + 1.0e-9 * fNanoSec; }


   timespec_t     GetTimeSpec() const
      { timespec_t value = {fSec,fNanoSec}; return value; }

   time_t         GetSec(void) const { return fSec;}
   Int_t          GetNanoSec(void) const { return fNanoSec; }
   
   Double_t GetSeconds(void) const { return fSec+(fNanoSec/1.0e9); }
    
   const char    *AsString(Option_t *option="") const;
   void           Copy(VldTimeStamp &vldts) const;

   Int_t          GetDate(Bool_t inUTC=kTRUE, Int_t secOffset=0,
                          UInt_t *year=0, UInt_t *month=0,
                          UInt_t *day=0) const;

   Int_t          GetTime(Bool_t inUTC=kTRUE, Int_t secOffset=0,
                          UInt_t* hour=0, UInt_t* min=0, 
                          UInt_t* sec=0) const;

   void           Add(const VldTimeStamp& offset);
   void           Add(Double_t seconds);

   void           Print(Option_t *option="") const;

   // Utility functions

   static Int_t   GetZoneOffset();
   static time_t  MktimeFromUTC(tm_t* tmstruct);
   static Bool_t  IsLeapYear(Int_t year);
   static void    DumpTMStruct(const tm_t& tmstruct);

 private:

   void           Set();
   void           Set(Int_t year, Int_t month, Int_t day,
                      Int_t hour, Int_t min, Int_t sec, 
                      Int_t nsec, Bool_t isUTC, Int_t secOffset);
   void           Set(Int_t date, Int_t time, Int_t nsec,
                      Bool_t isUTC, Int_t 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_t  fSec;
   Int_t  fNanoSec;

   ClassDef(VldTimeStamp,2)
};

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

inline Bool_t operator==(const VldTimeStamp &lhs, const VldTimeStamp &rhs)
   { return lhs.fSec  == rhs.fSec && 
            lhs.fNanoSec == rhs.fNanoSec; }

inline Bool_t operator!=(const VldTimeStamp &lhs, const VldTimeStamp &rhs)
   { return lhs.fSec  != rhs.fSec ||
            lhs.fNanoSec != rhs.fNanoSec; }

inline Bool_t operator<(const VldTimeStamp &lhs, const VldTimeStamp &rhs)
   { return lhs.fSec  < rhs.fSec ||
             ( lhs.fSec  == rhs.fSec &&
               lhs.fNanoSec <  rhs.fNanoSec   ); }

inline Bool_t operator<=(const VldTimeStamp &lhs, const VldTimeStamp &rhs)
   { return lhs.fSec  < rhs.fSec ||
             ( lhs.fSec  == rhs.fSec &&
               lhs.fNanoSec <= rhs.fNanoSec   ); }

inline Bool_t operator>(const VldTimeStamp &lhs, const VldTimeStamp &rhs)
   { return lhs.fSec  > rhs.fSec ||
             ( lhs.fSec  == rhs.fSec &&
               lhs.fNanoSec >  rhs.fNanoSec   ); }

inline Bool_t operator>=(const VldTimeStamp &lhs, const VldTimeStamp &rhs)
   { return lhs.fSec  > rhs.fSec ||
             ( lhs.fSec  == rhs.fSec &&
               lhs.fNanoSec >= rhs.fNanoSec   ); }

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

#endif /* __CINT__ */
#endif // VLDTIMESTAMP_H

---