TVldTimeStamp Class Reference

Encapsulate the seconds and ns since EPOCH. More...

#include <TVldTimeStamp.hxx>

Collaboration diagram for TVldTimeStamp:

[legend]

List of all members.

Public Member Functions
	TVldTimeStamp ()
	Empty ctor (builds current time with nsec field filled as best possible).
	TVldTimeStamp (const TVldTimeStamp &source)
	Copy.
TVldTimeStamp &	operator= (const TVldTimeStamp &source)
	Assignment.
	TVldTimeStamp (const timespec_t &ts)
	Construction from timespec struct.
	TVldTimeStamp (const time_t &t, const Int_t nsec)
	Construction from time_t and separate nsec.
	TVldTimeStamp (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)
	TVldTimeStamp (UInt_t date, UInt_t time, UInt_t nsec, Bool_t isUTC=kTRUE, Int_t secOffset=0)
	TVldTimeStamp (Double_t seconds)
virtual	~TVldTimeStamp ()
	operator double () const
timespec_t	GetTimeSpec () const
	Get timestamp as a timespec_t.
time_t	GetSec (void) const
	Get (integral) seconds after the EPOCH.
Int_t	GetNanoSec (void) const
	Get nanoseconds after the second.
Double_t	GetSeconds (void) const
	Get time from the epoch in seconds.
const char *	AsString (Option_t *option="") const
void	Copy (TVldTimeStamp &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 TVldTimeStamp &offset)
void	Add (Double_t seconds)
void	Print (Option_t *option="") const
Static Public Member Functions
static TVldTimeStamp	GetBOT ()
	Static method to return the "beginning of time" (start of Unix EPOCH).
static TVldTimeStamp	GetEOT ()
static TVldTimeStamp	GetNBOT ()
static Int_t	GetZoneOffset ()
static time_t	MktimeFromUTC (tm_t *tmstruct)
static Bool_t	IsLeapYear (Int_t year)
	Is the given year a leap year.
static void	DumpTMStruct (const tm_t &tmstruct)
	Print out the "tm" structure:.
Private Member Functions
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 ()
Private Attributes
Int_t	fSec
Int_t	fNanoSec
Friends
Bool_t	operator== (const TVldTimeStamp &lhs, const TVldTimeStamp &rhs)
Bool_t	operator!= (const TVldTimeStamp &lhs, const TVldTimeStamp &rhs)
Bool_t	operator< (const TVldTimeStamp &lhs, const TVldTimeStamp &rhs)
Bool_t	operator<= (const TVldTimeStamp &lhs, const TVldTimeStamp &rhs)
Bool_t	operator> (const TVldTimeStamp &lhs, const TVldTimeStamp &rhs)
Bool_t	operator>= (const TVldTimeStamp &lhs, const TVldTimeStamp &rhs)
TVldTimeStamp	operator- (const TVldTimeStamp &lhs, const TVldTimeStamp &rhs)

---

Detailed Description

Encapsulate the seconds and ns since EPOCH.

This extends (and isolates) struct timespec

struct timespec { time_t tv_sec; // seconds long tv_nsec; // nanoseconds } time_t seconds is relative to Jan 1, 1970 00:00:00 UTC

Due to ROOT/CINT limitations TVldTimeStamp does not explicitly hold a timespec struct; attempting to do so means the Streamer must be hand written. Instead we have chosen to simply contain similar fields within the private area of this class.

Note:

the use of time_t (and its default implementation as a 32 int) implies overflow conditions occurs somewhere around Jan 18, 19:14:07, 2038. If this experiment is still going when it becomes significant someone will have to deal with it.

Author:

(last to touch it)

Author

finch

Version:

Revision

1.2

Date:

Date

2011/06/09 14:44:29

Contact: R. Hatcher

Created on: Wed Apr 13 17:53:23 2005

Author: R. Hatcher 2000.04.19 R. Hatcher 2000.12.20 -- convert from TDatime to struct timespec

Id

TVldTimeStamp.hxx,v 1.2 2011/06/09 14:44:29 finch Exp

Definition at line 62 of file TVldTimeStamp.hxx.

---

Constructor & Destructor Documentation

TVldTimeStamp::TVldTimeStamp

(

)

Empty ctor (builds current time with nsec field filled as best possible).

Definition at line 85 of file TVldTimeStamp.cxx.

References Set().

Referenced by GetBOT(), GetEOT(), and GetNBOT().

: fSec(0), fNanoSec(0) { Set(); }

Here is the call graph for this function:

Here is the caller graph for this function:

TVldTimeStamp::TVldTimeStamp

(

const TVldTimeStamp &

source

)

[inline]

Copy.

Definition at line 91 of file TVldTimeStamp.hxx.

     : fSec(source.fSec), 
     fNanoSec(source.fNanoSec) { }

TVldTimeStamp::TVldTimeStamp

(

const timespec_t &

ts

)

[inline]

Construction from timespec struct.

Definition at line 101 of file TVldTimeStamp.hxx.

References NormalizeNanoSec().

     : fSec(ts.tv_sec), fNanoSec(ts.tv_nsec)
      { NormalizeNanoSec(); }

Here is the call graph for this function:

TVldTimeStamp::TVldTimeStamp	(	const time_t &	t,
		const Int_t	nsec
	)			[inline]

Construction from time_t and separate nsec.

Definition at line 106 of file TVldTimeStamp.hxx.

References NormalizeNanoSec().

     : fSec(t), fNanoSec(nsec)
      { NormalizeNanoSec(); }

Here is the call graph for this function:

TVldTimeStamp::TVldTimeStamp	(	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
	)

Create a TVldTimeStamp and set it to the specified year, month, day, time, hour, minute, second and nanosec. If !isUTC then it is assumed to be the standard local time zone.

If local time is PST then one can use

TVldTimeStamp(year,month,day,hour,min,sec,nsec,kFALSE,0);

or

Int_t secOffset = 8*60*60; TVldTimeStamp(year,month,day,hour,min,sec,nsec,kTRUE,8*60*60);

Definition at line 89 of file TVldTimeStamp.cxx.

References Set().

  : fSec(0), fNanoSec(0)
{
   // Create a TVldTimeStamp and set it to the specified year, month,
   // day, time, hour, minute, second and nanosec.
   // If !isUTC then it is assumed to be the standard local time zone.
   //
   // If local time is PST then one can use
   //    TVldTimeStamp(year,month,day,hour,min,sec,nsec,kFALSE,0);
   // or
   //    Int_t secOffset = 8*60*60;
   //    TVldTimeStamp(year,month,day,hour,min,sec,nsec,kTRUE,8*60*60);

   Set(year, month, day, hour, min, sec, nsec, isUTC, secOffset);
}

Here is the call graph for this function:

TVldTimeStamp::TVldTimeStamp	(	UInt_t	date,
		UInt_t	time,
		UInt_t	nsec,
		Bool_t	isUTC = kTRUE,
		Int_t	secOffset = 0
	)

Create a TVldTimeStamp and set it to the specified date, time, nanosec. If !isUTC then it is assumed to be the standard local time zone.

Definition at line 110 of file TVldTimeStamp.cxx.

References Set().

  : fSec(0), fNanoSec(0)
{
   // Create a TVldTimeStamp and set it to the specified date, time, nanosec.
   // If !isUTC then it is assumed to be the standard local time zone.

   Set(date, time, nsec, isUTC, secOffset);
}

Here is the call graph for this function:

TVldTimeStamp::TVldTimeStamp

(

Double_t

seconds

)

[inline]

Create a TVldTimeStamp 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!

Definition at line 140 of file TVldTimeStamp.hxx.

References NormalizeNanoSec().

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

Here is the call graph for this function:

TVldTimeStamp::~TVldTimeStamp

(

)

[virtual]

Definition at line 86 of file TVldTimeStamp.cxx.

{ ; }

---

Member Function Documentation

void TVldTimeStamp::Add

(

Double_t

seconds

)

Definition at line 296 of file TVldTimeStamp.cxx.

References fNanoSec, fSec, NormalizeNanoSec(), and SK_DBI_Warn.

{
  // Add 'seconds' as a delta time

  fSec += (Int_t) seconds;
  fNanoSec += (Int_t) (fmod(seconds,1.0) * 1e9);
  NormalizeNanoSec();
  if(seconds > 1e6)
    SK_DBI_Warn( "VldTimeStamp moved by offset " << seconds <<" which is too large to maintain ns accuracy." << "  ");
}

Here is the call graph for this function:

void TVldTimeStamp::Add

(

const TVldTimeStamp &

offset

)

Definition at line 286 of file TVldTimeStamp.cxx.

References fNanoSec, fSec, and NormalizeNanoSec().

{
   // Add "offset" as a delta time.

   fSec     += offset.fSec;
   fNanoSec += offset.fNanoSec;
   NormalizeNanoSec();

}

Here is the call graph for this function:

const char * TVldTimeStamp::AsString

(

Option_t *

option = ""

)

const

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.

Definition at line 121 of file TVldTimeStamp.cxx.

References fNanoSec, and fSec.

Referenced by TVldRange::AsString(), TVldContext::AsString(), TDbiResultKey::AsString(), TVldValidate::CompareTimeStamps(), TDbiValidityRec::GetL2CacheName(), TDbi::MakeDateTimeString(), operator<<(), Print(), TDbiDBProxy::ReplaceInsertDate(), TDbiSqlValPacket::SetCreationDate(), TDbiSqlContext::TDbiSqlContext(), and TVldValidate::TestTimeStamp().

{
   // 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 int nbuffers = 8;     // # of buffers

   static char formatted[nbuffers][64];  // strftime fields substituted
   static char formatted2[nbuffers][64]; // nanosec field substituted
   static int ibuffer = nbuffers;
   ibuffer = (ibuffer+1)%nbuffers; // each call moves to next buffer

   TString opt = option;
   opt.ToLower();

   if (opt.Contains("2")) {
      // return string formatted as integer {sec,nsec}
      sprintf(formatted[ibuffer], "{%d,%d}", fSec, fNanoSec);
      return formatted[ibuffer];
   }

#ifdef linux
   // under linux %z is the hour offset and %Z is the timezone name
   const char *RFC822   = "%a, %d %b %Y %H:%M:%S %z (%Z) +#9ld nsec";
   const char *ISO8601  = "%Y-%m-%d %H:%M:%S.#9.9ld%z";
   const char *ISO8601Z = "%Y-%m-%d %H:%M:%S.#9.9ldZ";
#else
   // otherwise only %Z is guarenteed to be defind
   const char *RFC822   = "%a, %d %b %Y %H:%M:%S %Z +#9ld nsec";
   const char *ISO8601  = "%Y-%m-%d %H:%M:%S.#9.9ld%Z";
   const char *ISO8601Z = "%Y-%m-%d %H:%M:%S.#9.9ldZ";
#endif
   const char *SQL = "%Y-%m-%d %H:%M:%S";

   Bool_t asLocal = opt.Contains("l");
   Bool_t asSQL   = opt.Contains("s");
   if (asSQL) asLocal = kFALSE;

   const char *format = RFC822;
   if (opt.Contains("c")) {
      format = ISO8601;
      if (!asLocal) format = ISO8601Z;
   }
   if (asSQL) format = SQL;

   struct tm *ptm;
   time_t seconds = (time_t) fSec;   // deal with possible mismatch of types
                                     // of fSec and the time_t required
                                     // by functions

   // get the components into a tm struct
   ptm = (asLocal) ? localtime(&seconds) : gmtime(&seconds);

   // format all but the nsec field
   // size_t length =
   strftime(formatted[ibuffer], sizeof(formatted[ibuffer]), format, ptm);

   if (asSQL) return formatted[ibuffer];

   // hack in the nsec part
   char *ptr = strrchr(formatted[ibuffer], '#');
   if (ptr) *ptr = '%';    // substitute % for #
   sprintf(formatted2[ibuffer], formatted[ibuffer], fNanoSec);

   return formatted2[ibuffer];
}

Here is the caller graph for this function:

void TVldTimeStamp::Copy

(

TVldTimeStamp &

vldts

)

const

Definition at line 218 of file TVldTimeStamp.cxx.

References fNanoSec, and fSec.

{
   // Copy this to ts.

   ts.fSec     = fSec;
   ts.fNanoSec = fNanoSec;

}

void TVldTimeStamp::DumpTMStruct

(

const tm_t &

tmstruct

)

[static]

Print out the "tm" structure:.

Definition at line 568 of file TVldTimeStamp.cxx.

{
   // Print out the "tm" structure:
   // tmstruct.tm_year = year;    // years since 1900
   // tmstruct.tm_mon  = month-1; // months since Jan [0,11]
   // tmstruct.tm_mday = day;     // day of the month [1,31]
   // tmstruct.tm_hour = hour;    // hours since midnight [0,23]
   // tmstruct.tm_min  = min;     // minutes after the hour [0,59]
   // tmstruct.tm_sec  = sec;     // seconds after the minute [0,59]
   // tmstruct.tm_wday            // day of week [0,6]
   // tmstruct.tm_yday            // days in year [0,365]
   // tmstruct.tm_isdst           // DST [-1/0/1]  (unknown,false,true)

   printf(" tm { year %4d, mon   %2d, day   %2d,\n",
          tmstruct.tm_year,
          tmstruct.tm_mon,
          tmstruct.tm_mday);
   printf("      hour   %2d, min   %2d, sec   %2d,\n",
          tmstruct.tm_hour,
          tmstruct.tm_min,
          tmstruct.tm_sec);
   printf("      wday   %2d, yday %3d, isdst %2d",
          tmstruct.tm_wday,
          tmstruct.tm_yday,
          tmstruct.tm_isdst);
#ifdef linux
//#ifdef __GNUC__
// special GCC extras
   printf(",\n      tm_gmtoff %7ld,  tm_zone \"%s\"",
#ifdef __USE_BSD
          tmstruct.tm_gmtoff,tmstruct.tm_zone);
#else
          tmstruct.__tm_gmtoff,tmstruct.__tm_zone);
#endif
#endif
   printf("}\n");
}

TVldTimeStamp TVldTimeStamp::GetBOT

(

)

[static]

Static method to return the "beginning of time" (start of Unix EPOCH).

Definition at line 64 of file TVldTimeStamp.cxx.

References TVldTimeStamp().

{
    return TVldTimeStamp((time_t)0,0);
}

Here is the call graph for this function:

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

Return date in form of 19971224 (i.e. 24/12/1997), if non-zero pointers supplied for year, month, day fill those as well

Definition at line 228 of file TVldTimeStamp.cxx.

References fSec.

Referenced by TDbi::MakeTimeStamp(), and TVldValidate::TestTimeStamp().

{
   // Return date in form of 19971224 (i.e. 24/12/1997),
   // if non-zero pointers supplied for year, month, day fill those as well

   time_t atime = fSec + secOffset;
   struct tm *ptm = (inUTC) ? gmtime(&atime) : localtime(&atime);

   if (year)  *year  = ptm->tm_year + 1900;
   if (month) *month = ptm->tm_mon + 1;
   if (day)   *day   = ptm->tm_mday;

   return (1900+ptm->tm_year)*10000 + (1+ptm->tm_mon)*100 + ptm->tm_mday;

}

Here is the caller graph for this function:

TVldTimeStamp TVldTimeStamp::GetEOT

(

)

[static]

Static method to return the "end of time" which is sometime in the future and near or at the limit of TVldTimeStamp's ability to hold large times.

Definition at line 69 of file TVldTimeStamp.cxx.

References TVldTimeStamp().

{
    return TVldTimeStamp((time_t)INT_MAX,0);
}

Here is the call graph for this function:

Int_t TVldTimeStamp::GetNanoSec

(

void

)

const [inline]

Get nanoseconds after the second.

Definition at line 164 of file TVldTimeStamp.hxx.

References fNanoSec.

Referenced by operator-().

{ return fNanoSec; }

Here is the caller graph for this function:

TVldTimeStamp TVldTimeStamp::GetNBOT

(

)

[static]

Static method to return the "negative beginning of time", i.e. the earliest time prior to start of Unix EPOCH which is negative seconds.

Definition at line 74 of file TVldTimeStamp.cxx.

References TVldTimeStamp().

{
    return TVldTimeStamp((time_t)INT_MIN,0);
}

Here is the call graph for this function:

time_t TVldTimeStamp::GetSec

(

void

)

const [inline]

Get (integral) seconds after the EPOCH.

Definition at line 162 of file TVldTimeStamp.hxx.

References fSec.

Referenced by ClassImp(), DateTimeToUnixTime(), TDbiDBProxy::FindTimeBoundaries(), TDbiValidityRecBuilder::MakeGapRec(), operator-(), and TDbiDBProxy::QueryValidity().

{ return fSec;}

Here is the caller graph for this function:

Double_t TVldTimeStamp::GetSeconds

(

void

)

const [inline]

Get time from the epoch in seconds.

Definition at line 167 of file TVldTimeStamp.hxx.

References fNanoSec, and fSec.

{ return fSec+(fNanoSec/1.0e9); }

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

Return time in form of 123623 (i.e. 12:36:23), if non-zero pointers supplied for hour, min, sec fill those as well

Definition at line 246 of file TVldTimeStamp.cxx.

References fSec.

Referenced by TVldValidate::TestTimeStamp().

{
   // Return time in form of 123623 (i.e. 12:36:23),
   // if non-zero pointers supplied for hour, min, sec fill those as well

   time_t atime = fSec + secOffset;
   struct tm *ptm = (inUTC) ? gmtime(&atime) : localtime(&atime);

   if (hour) *hour = ptm->tm_hour;
   if (min)  *min  = ptm->tm_min;
   if (sec)  *sec  = ptm->tm_sec;

   return ptm->tm_hour*10000 + ptm->tm_min*100 + ptm->tm_sec;

}

Here is the caller graph for this function:

timespec_t TVldTimeStamp::GetTimeSpec

(

)

const [inline]

Get timestamp as a timespec_t.

Definition at line 158 of file TVldTimeStamp.hxx.

References fNanoSec, and fSec.

Referenced by TVldValidate::TestTimeStamp().

      { timespec_t value = {fSec,fNanoSec}; return value; }

Here is the caller graph for this function:

Int_t TVldTimeStamp::GetZoneOffset

(

)

[static]

Static method returning local (current) time zone offset from UTC. This is the difference in seconds between UTC and local standard time.

Definition at line 264 of file TVldTimeStamp.cxx.

Referenced by TVldValidate::TestTimeStamp().

{
   // Static method returning local (current) time zone offset from UTC.
   // This is the difference in seconds between UTC and local standard time.

   // ?? should tzset (_tzset) be called?
#ifndef R__WIN32
   tzset();
#if !defined(R__MACOSX) && !defined(R__FBSD)
   return  timezone;   /* unix has extern long int */
#else
   time_t *tp = 0;
   time(tp);
   return localtime(tp)->tm_gmtoff;
#endif
#else
   _tzset();
   return _timezone;   /* Win32 prepends "_" */
#endif
}

Here is the caller graph for this function:

Bool_t TVldTimeStamp::IsLeapYear

(

Int_t

year

)

[static]

Is the given year a leap year.

Definition at line 534 of file TVldTimeStamp.cxx.

Referenced by MktimeFromUTC().

{
   // Is the given year a leap year.


   // The calendar year is 365 days long, unless the year is exactly divisible
   // by 4, in which case an extra day is added to February to make the year
   // 366 days long. If the year is the last year of a century, eg. 1700, 1800,
   // 1900, 2000, then it is only a leap year if it is exactly divisible by
   // 400. Therefore, 1900 wasn't a leap year but 2000 was. The reason for
   // these rules is to bring the average length of the calendar year into
   // line with the length of the Earth's orbit around the Sun, so that the
   // seasons always occur during the same months each year.

   if (year%4 != 0) {
      return false;
   }
   else {
      if (year%400 == 0) {
         return true;
      }
      else {
         if (year%100 == 0) {
            return false;
         }
         else {
            return true;
         }
      }
   }

}

Here is the caller graph for this function:

time_t TVldTimeStamp::MktimeFromUTC

(

tm_t *

tmstruct

)

[static]

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).

Definition at line 476 of file TVldTimeStamp.cxx.

References IsLeapYear().

Referenced by Set().

{
   // 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).

   const Int_t days[]     = {31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
   const Int_t daysLeap[] = {31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};

   Int_t year = tmstruct->tm_year + 1900;
   Bool_t isleap = TVldTimeStamp::IsLeapYear(year);

   const Int_t *daysInMonth = days;
   if (isleap) daysInMonth = daysLeap;

   // fill in tmstruct->tm_yday

   int &ref_tm_mon = tmstruct->tm_mon;
   int &ref_tm_mday = tmstruct->tm_mday;
   // count days in months past
   tmstruct->tm_yday = 0;
   for (Int_t imonth = 0; imonth < ref_tm_mon; imonth++) {
      tmstruct->tm_yday += daysInMonth[imonth];
   }
   tmstruct->tm_yday += ref_tm_mday - 1;  // day [1-31] but yday [0-365]

   // adjust if day in this month is more than the month has
   while (ref_tm_mday > daysInMonth[ref_tm_mon]) {
      ref_tm_mday -= daysInMonth[ref_tm_mon];
      ref_tm_mon++;
   }

   // *should* calculate tm_wday (0-6) here ...

   // UTC is never DST
   tmstruct->tm_isdst = 0;

   // Calculate seconds since the Epoch based on formula in
   // POSIX  IEEEE Std 1003.1b-1993 pg 22

   Int_t utc_sec = tmstruct->tm_sec +
                   tmstruct->tm_min*60 +
                   tmstruct->tm_hour*3600 +
                   tmstruct->tm_yday*86400 +
                   (tmstruct->tm_year-70)*31536000 +
                   ((tmstruct->tm_year-69)/4)*86400;

   return utc_sec;
}

Here is the call graph for this function:

Here is the caller graph for this function:

void TVldTimeStamp::NormalizeNanoSec

(

)

[private]

Definition at line 460 of file TVldTimeStamp.cxx.

References fNanoSec, and fSec.

Referenced by Add(), Set(), and TVldTimeStamp().

{
   // Ensure that the fNanoSec field is in range [0,99999999].

   // deal with negative values
   while (fNanoSec < 0) {
      fNanoSec += kNsPerSec;
      fSec -= 1;
   }
   // deal with values inf fNanoSec greater than one sec
   while (fNanoSec >= kNsPerSec) {
      fNanoSec -= kNsPerSec;
      fSec += 1;
   }
}

Here is the caller graph for this function:

TVldTimeStamp::operator double

(

)

const [inline]

Implicitly convert a TVldTimeStamp to a double.

Warning:

This will truncate precision to no better than about 1 microsecond. Do not compare/subtract TVldTimeStamps that have been converted to doubles if you require the full nanosecond precision!

Definition at line 154 of file TVldTimeStamp.hxx.

References fNanoSec, and fSec.

{ return fSec + 1.0e-9 * fNanoSec; }

TVldTimeStamp& TVldTimeStamp::operator=

(

const TVldTimeStamp &

source

)

[inline]

Assignment.

Definition at line 96 of file TVldTimeStamp.hxx.

References fNanoSec, and fSec.

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

void TVldTimeStamp::Print

(

Option_t *

option = ""

)

const

Definition at line 308 of file TVldTimeStamp.cxx.

References AsString().

Referenced by TVldValidate::TestTimeStamp().

{
   // Print date and time.

   printf("Date/Time = %s\n", AsString(option));

}

Here is the call graph for this function:

Here is the caller graph for this function:

void TVldTimeStamp::Set	(	Int_t	date,
		Int_t	time,
		Int_t	nsec,
		Bool_t	isUTC,
		Int_t	secOffset
	)			[private]

Definition at line 419 of file TVldTimeStamp.cxx.

References Set().

{
   // Set date/time from integers of the form [yy]YYMMDD and HHMMSS,
   // assume UTC (UTC) components:
   //
   //  MM: 01=January .. 12=December
   //  DD: 01 .. 31
   //
   //  HH: 00=midnight .. 23
   //  MM: 00 .. 59
   //  SS: 00 .. 69
   //
   // Date must be in format 980418 or 19980418
   //                       1001127 or 20001127  (i.e. year 100 = 2000).
   // Time must be in format 224512 (second precision).
   // Date must be >= 700101.

   Int_t year  = date/10000;
   Int_t month = (date-year*10000)/100;
   Int_t day   = date%100;

   // protect against odd attempts at time offsets
   const Int_t oneday = 240000;
   while (time < 0) {
      time += oneday;
      day  -= 1;
   }
   while (time > oneday) {
      time -= oneday;
      day  += 1;
   }
   Int_t hour  = time/10000;
   Int_t min   = (time-hour*10000)/100;
   Int_t sec   = time%100;

   Set(year, month, day, hour, min, sec, nsec, isUTC, secOffset);

}

Here is the call graph for this function:

void TVldTimeStamp::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
	)			[private]

Definition at line 367 of file TVldTimeStamp.cxx.

References fNanoSec, fSec, MktimeFromUTC(), NormalizeNanoSec(), and SK_DBI_Info.

{
   // Set Date/Time from components.
   //
   // month & day both use normal 1..12 and 1..31 counting
   // hours, min, sec run from 0 to 23, 59, 59 respectively;
   // secOffset provides method for adjusting for alternative timezones
   //
   // "year"  |    0    1 ... 37 | 38...69   |   70 .. 100  101 ..  137
   // true    | 2000 2001   2037 | undefined | 1970   2000 2001 .. 2037
   //
   // "year"  | 138...1969 | 1970 .. 2037 | ...
   // true    | undefined  | 1970 .. 2037 | undefined
   //


   // deal with special formats of year
   if (year <= 37)                year += 2000;
   if (year >= 70 && year <= 137) year += 1900;
   // tm.tm_year is years since 1900
   if (year >= 1900)              year -= 1900;

   struct tm tmstruct;
   tmstruct.tm_year  = year;    // years since 1900
   tmstruct.tm_mon   = month-1; // months since Jan [0,11]
   tmstruct.tm_mday  = day;     // day of the month [1,31]
   tmstruct.tm_hour  = hour;    // hours since midnight [0,23]
   tmstruct.tm_min   = min;     // minutes after the hour [0,59]
   tmstruct.tm_sec   = sec + secOffset;  // seconds after the minute [0,59]
   tmstruct.tm_isdst = -1;     // let "mktime" determine DST setting

   const time_t bad_time_t = (time_t) -1;
   // convert tm struct to time_t, if values are given in UTC then
   // no standard routine exists and we'll have to use our homegrown routine,
   // if values are given in local time then use "mktime"
   // which also normalizes the tm struct as a byproduct
   time_t utc_sec = (isUTC) ? MktimeFromUTC(&tmstruct) : mktime(&tmstruct);

   //   TVldTimeStamp::Dump_tm_struct(tmstruct);

   if (utc_sec == bad_time_t)
      SK_DBI_Info(  "VldTimeStamp::Set mktime returned -1" << "  ");

   fSec  = utc_sec;
   fNanoSec = nsec;

   NormalizeNanoSec();
}

Here is the call graph for this function:

void TVldTimeStamp::Set

(

)

[private]

Definition at line 317 of file TVldTimeStamp.cxx.

References fNanoSec, and fSec.

Referenced by Set(), and TVldTimeStamp().

{
   // Set Date/Time to current time as reported by the system.
   // no accounting for nanoseconds with std ANSI functions,
   // ns part faked so that subsequent calls simply add 1 to it
   // this ensures that calls within the same second come back
   // distinct (and sortable).

#ifdef R__WIN32
   ULARGE_INTEGER time;
   GetSystemTimeAsFileTime((FILETIME *)&time);
   // NT keeps time in FILETIME format which is 100ns ticks since
   // Jan 1, 1601. TTimeStamps use time in 100ns ticks since Jan 1, 1970.
   // The difference is 134774 days.
   fNanoSec = Int_t((time.QuadPart * (unsigned __int64) 100) %
                    (unsigned __int64) 1000000000);
   time.QuadPart -=
            (unsigned __int64) (1000*1000*10)       // seconds
          * (unsigned __int64) (60 * 60 * 24)       // days
          * (unsigned __int64) (134774);            // # of days

   fSec     = Int_t(time.QuadPart/(unsigned __int64) (1000*1000*10));
#else
   // this should work on UNIX to get microsec precision
   // we'll stick to a ns hack to make calls unique
   struct timeval now;
   if (!gettimeofday(&now,0)) {
      fSec     = now.tv_sec;
      fNanoSec = now.tv_usec * 1000;
   }
   else {
      time_t nowtime;
      time(&nowtime);
      fSec     = nowtime;
      fNanoSec = 0;
   }
#endif
   static Int_t sec = 0, nsec = 0, fake_ns = 0;

   if (fSec == sec && fNanoSec == nsec)
      fNanoSec += ++fake_ns;
   else {
      fake_ns = 0;
      sec     = fSec;
      nsec    = fNanoSec;
   }

}

Here is the caller graph for this function:

---

Friends And Related Function Documentation

Bool_t operator!=	(	const TVldTimeStamp &	lhs,
		const TVldTimeStamp &	rhs
	)			[friend]

TVldTimeStamp operator-	(	const TVldTimeStamp &	lhs,
		const TVldTimeStamp &	rhs
	)			[friend]

Bool_t operator<	(	const TVldTimeStamp &	lhs,
		const TVldTimeStamp &	rhs
	)			[friend]

Bool_t operator<=	(	const TVldTimeStamp &	lhs,
		const TVldTimeStamp &	rhs
	)			[friend]

Bool_t operator==	(	const TVldTimeStamp &	lhs,
		const TVldTimeStamp &	rhs
	)			[friend]

Bool_t operator>	(	const TVldTimeStamp &	lhs,
		const TVldTimeStamp &	rhs
	)			[friend]

Bool_t operator>=	(	const TVldTimeStamp &	lhs,
		const TVldTimeStamp &	rhs
	)			[friend]

---

Member Data Documentation

Int_t TVldTimeStamp::fNanoSec [private]

Definition at line 258 of file TVldTimeStamp.hxx.

Referenced by Add(), AsString(), Copy(), GetNanoSec(), GetSeconds(), GetTimeSpec(), NormalizeNanoSec(), operator double(), operator!=(), operator<(), operator<=(), operator=(), operator==(), operator>(), operator>=(), and Set().

Int_t TVldTimeStamp::fSec [private]

Definition at line 257 of file TVldTimeStamp.hxx.

Referenced by Add(), AsString(), Copy(), GetDate(), GetSec(), GetSeconds(), GetTime(), GetTimeSpec(), NormalizeNanoSec(), operator double(), operator!=(), operator<(), operator<=(), operator=(), operator==(), operator>(), operator>=(), and Set().

---

The documentation for this class was generated from the following files:

• src/TVldTimeStamp.hxx
• src/TVldTimeStamp.cxx