private:

void NormalizeNanoSec() 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)public:

TTimeStamp TTimeStamp() TTimeStamp TTimeStamp(const timespec_t& ts) TTimeStamp TTimeStamp(time_t t, Int_t nsec) TTimeStamp TTimeStamp(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) TTimeStamp TTimeStamp(UInt_t date, UInt_t time, UInt_t nsec, Bool_t isUTC = kTRUE, Int_t secOffset = 0) TTimeStamp TTimeStamp(const TTimeStamp&) virtual void ~TTimeStamp() void Add(const TTimeStamp& offset) const char* AsString(const Option_t* option) const static TClass* Class() void Copy(TTimeStamp& ts) static void DumpTMStruct(const tm_t& tmstruct) UInt_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 GetNanoSec() const time_t GetSec() const UInt_t GetTime(Bool_t inUTC = kTRUE, Int_t secOffset = 0, UInt_t* hour = 0, UInt_t* min = 0, UInt_t* sec = 0) const timespec_t GetTimeSpec() const static Int_t GetZoneOffset() virtual TClass* IsA() const static Bool_t IsLeapYear(Int_t year) static time_t MktimeFromUTC(tm_t* tmstruct) void Print(const Option_t* option) const virtual void ShowMembers(TMemberInspector& insp, char* parent) virtual void Streamer(TBuffer& b) void StreamerNVirtual(TBuffer& b)

private:

Int_t fSecsecondsInt_t fNanoSecnanoseconds

The TTimeStamp encapsulates 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 No accounting of leap seconds is made. Due to ROOT/CINT limitations TTimeStamp 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.

TTimeStamp()

Default ctor. Create a TTimeStamp and set it to the current time (as best possible). The nanosecond part is faked so that subsequenct calls simply add 1 to ensure that sequential calls are distinct (and sortable).

TTimeStamp(UInt_t year, UInt_t month, UInt_t day, UInt_t hour, UInt_t min, UInt_t sec, UInt_t nsec, Bool_t isUTC, Int_t secOffset)

Create a TTimeStamp 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 TTimeStamp(year,month,day,hour,min,sec,nsec,kFALSE,0); or Int_t secOffset = 8*60*60; TTimeStamp(year,month,day,hour,min,sec,nsec,kTRUE,8*60*60);

TTimeStamp(UInt_t date, UInt_t time, UInt_t nsec, Bool_t isUTC, Int_t secOffset)

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

const char* 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. 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.

void Copy(TTimeStamp &ts)

Copy this to ts.

UInt_t GetDate(Bool_t inUTC, Int_t secOffset, UInt_t *year, UInt_t *month, UInt_t *day) 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.

UInt_t GetTime(Bool_t inUTC, Int_t secOffset, UInt_t *hour, UInt_t *min, UInt_t *sec) 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.

Int_t GetZoneOffset()

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

void Add(const TTimeStamp &offset)

Add "offset" as a delta time.

void Print(Option_t *option) const

Print date and time.

void Set()

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). Time is since Jan 1, 1970.

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)

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

void Set(Int_t date, Int_t time, Int_t nsec, Bool_t isUTC, Int_t secOffset)

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.

void NormalizeNanoSec()

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

time_t MktimeFromUTC(tm_t *tmstruct)

Equivalent of standard routine "mktime" but using the assumption that tm struct is filled with UTC, not local, time.

Bool_t IsLeapYear(Int_t year)

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

void DumpTMStruct(const tm_t &tmstruct)

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)

TTimeStamp TTimeStamp(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) TTimeStamp TTimeStamp(UInt_t date, UInt_t time, UInt_t nsec, Bool_t isUTC = kTRUE, Int_t secOffset = 0) timespec_t GetTimeSpec() const time_t GetSec() const Int_t GetNanoSec() const TClass* Class() TClass* IsA() const void ShowMembers(TMemberInspector& insp, char* parent) void Streamer(TBuffer& b) void StreamerNVirtual(TBuffer& b) TTimeStamp TTimeStamp(const TTimeStamp&) void ~TTimeStamp()

This page has been automatically generated. If you have any comments or suggestions about the page layout send a mail to ROOT support, or contact the developers with any questions or problems regarding ROOT.