VldTimeStamp.h

Go to the documentation of this file.

#ifndef VLDTIMESTAMP_H
#define VLDTIMESTAMP_H

#ifndef ROOT_Rtypes
#if !defined(__CINT__) || defined(__MAKECINT__)
#include "Rtypes.h"
#endif
#endif
#ifndef ROOT_Riosfwd
#include "Riosfwd.h"
#endif

#include <time.h>
#if !defined(__CINT__) && defined(R__MACOSX)
#include <sys/time.h>
#endif
#if defined(MACOSX)
 #include "TTimeStamp.h"
#else                                        // start of MACOSX opt-out section
 #if defined(__CINT__) || defined(R__WIN32) || \
    (defined(R__LINUX) && defined(R__KCC) && !defined(__timespec_defined))
// explicit definition of timespec  'cause "rootcint" won't look in 
// appropriate <time.h>. time_t appears to be defined as "typedef long time_t;"
// in CINT version of <time.h>.  This isn't required by the standard:
// to be compatible w/ std functions it must be at least 32-bits long,
// but it might be longer to avoid the year-2037 cutoff.
struct timespec 
{
   time_t   tv_sec;   /* seconds */
   long     tv_nsec;  /* nanoseconds */
};
 #endif
 #if defined(__CINT__)
struct tm
{
  int tm_sec;                   /* Seconds.     [0-60] (1 leap second) */
  int tm_min;                   /* Minutes.     [0-59]   */
  int tm_hour;                  /* Hours.       [0-23]   */
  int tm_mday;                  /* Day.         [1-31]   */
  int tm_mon;                   /* Month.       [0-11]   */
  int tm_year;                  /* Year - 1900.          */
  int tm_wday;                  /* Day of week. [0-6]    */
  int tm_yday;                  /* Days in year.[0-365]  */
  int tm_isdst;                 /* DST.         [-1/0/1] */
};
 #endif

// define this typedef so that CINT doesn't barf at using these
// for function return values
typedef struct timespec timespec_t;
typedef struct tm       tm_t;
#endif                                         // end of MACOSX opt-out section

// 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();

   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 = 0; 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

---