| The Gaudi Framework v32r1 (f65d50dc)

Public Types | Public Member Functions | Static Public Member Functions | Static Public Attributes | Private Member Functions | Private Attributes | Friends | List of all members
Gaudi::Time Class Reference

Based on seal::Time. More...

`#include <GaudiKernel/Time.h>`

## Public Types
enum | Months { January = 0, February = 1, March = 2, April = 3, May = 4, June = 5, July = 6, August = 7, September = 8, October = 9, November = 10, December = 11 }
| Symbolic names for months. More...
typedef long long | ValueType

## Public Member Functions
| Time ()=default
| Initialize an empty (zero) time value. More...
| Time (TimeSpan ts)
| Initialize time to ts nanoseconds since 00:00:00 on January 1, 1970 in UTC. More...
| Time (ValueType nsecs)
| Initialize time to nsecs nanoseconds since 00:00:00 on January 1, 1970 in UTC. More...
| Time (ValueType secs, int nsecs)
| Initialize time to secs (seconds) and nsecs (nanoseconds) summed since 00:00:00 on January 1, 1970 in UTC. More...
| Time (int year, int month, int day, int hour, int min, int sec, ValueType nsecs, bool local=true)
tm | split (bool local, int *nsecpart=0) const
| Break up the time to the standard representation, either in UTC (if local is `false`) or local time (if local is `true`). More...
tm | utc (int *nsecpart=0) const
| Break up the time to the standard library representation, keeping it in UTC. More...
tm | local (int *nsecpart=0) const
| Break up the time to the standard library representation, converting it first to local time. More...
int | year (bool local) const
| Get the year. More...
int | month (bool local) const
| Get the month, numbered [0,11]. More...
int | day (bool local) const
| Get the day of month, numbered [1,31]. More...
int | hour (bool local) const
| Get the hour, numbered [0, 23]. More...
int | minute (bool local) const
| Get the minute, numbered [0, 59]. More...
int | second (bool local) const
| Get the seconds, numbered [0,61] (allowing one or two leap seconds, years with leap seconds can have the time Dec 31, 23:59:60 (or :61).) More...
int | nsecond () const
| Get the nanoseconds. More...
int | weekday (bool local) const
| Get the day of week, numbered [0,6] and starting from Sunday. More...
bool | isdst (bool local) const
| Check whether daylight savings is in effect. More...
ValueType | utcoffset (int *daylight=0) const
| Return the number of nanoseconds that needs to be added to UTC to translate this time to the local time (= nanoseconds east of UTC). More...
const char * | timezone (int *daylight=0) const
| Return the local timezone name that applies at this time value. More...
Time & | operator+= (const TimeSpan &x)
| Add the specified amount to the time. More...
Time & | operator-= (const TimeSpan &x)
| Subtract the specified amount from the time. More...
ValueType | ns () const
| Return the time as nanoseconds since 00:00:00 on January 1, 1970 in UTC. More...
std::string | format (bool local, std::string spec="%c") const
| Format the time using `strftime`. More...
std::string | nanoformat (size_t minwidth=1, size_t maxwidth=9) const
| Format the nanosecond fractional part of the time as a string. More...

## Static Public Member Functions
static Time | epoch ()
| Returns the minimum time. More...
static Time | max ()
| Returns the maximum time. More...
static Time | current ()
| Returns the current time. More...
static Time | build (bool local, const tm &base, TimeSpan diff=0)
| Construct a time from local time base and a delta diff. More...
static bool | isLeap (int year)
| Check if the year is a leap-year. More...
static unsigned | toDosDate (Time time)
| Convert the Time t into a MS-DOS date format. More...
static Time | fromDosDate (unsigned dosDate)
| Convert the MS-DOS date dosDate into a Time. More...

## Static Public Attributes
static const int | SECS_PER_DAY = 86400
| Seconds in 24 hours. More...
static const int | SECS_PER_HOUR = 3600
| Seconds in one hour hour. More...
static const ValueType | SEC_NSECS = 1000000000
| Nanoseconds in one second. More...

## Private Member Functions
void | TimeAssert (bool cond, const std::string &msg="time assertion failed") const

## Private Attributes
ValueType | m_nsecs = 0

## Friends
class | TimeSpan
bool | operator== (const Gaudi::Time &t1, const Gaudi::Time &t2)
bool | operator!= (const Gaudi::Time &t1, const Gaudi::Time &t2)
bool | operator< (const Gaudi::Time &t1, const Gaudi::Time &t2)
bool | operator<= (const Gaudi::Time &t1, const Gaudi::Time &t2)
bool | operator> (const Gaudi::Time &t1, const Gaudi::Time &t2)
bool | operator>= (const Gaudi::Time &t1, const Gaudi::Time &t2)

## Detailed Description

Based on seal::Time.

Calendar time in nanoseconds since 00:00:00 on January 1, 1970, Coordinated Universal Time (UTC).

Time is represented internally as UTC time, but it can also be converted to the local time as necessary. Most methods take an argument flag `local` to indicate which time interpretation is desired by the client, and automatically perform the necessary adjustments. The client can also find out about the difference between UTC time and local time using the utcoffset() method, and the time zone name with timezone() method. Both allow the client to discover whether daylight savings is in effect.

The native representation of Time is not well suited for human handling of time. Time provides access in more convenient terms such as year(), month() and day(); more are available through conversion into a TimeSpan. Time can also be converted to and from ISO C standard `tm` structure. Note however that unlike C's `mktime()` which always assumes `tm` in local time, Time fully supports all conversions between local and universal time. Thus it is possible for example to build() a UTC time directly from a `tm`.

Time behaves as an integral type. Differences in time values are represented as a TimeSpan. Usual integral arithmetic works with both types. Output works in general as any other integral type, however since the ValueType can be a wide type, it may be poorly supported by the `iostream`; if so, including the `LongLong.h` header will help. Note that the output value will usually be very large as Time is represented in nanoseconds, not seconds! When constructing Time values in seconds, such as when reading in, do remember to use the two-argument constructor taking seconds and nanoseconds instead of the default single-argument one.

Time can be formatted into a string using the format() method, which uses the versatile `strftime()` function. Since the latter works on seconds at best (through a struct `tm`), the subsecond part cannot be formatted; the nanoformat() method is provided to overcome this limitation. To combine format() and nanoformat() output use a suitable #StringFormat pattern.

Time is linked to the system's concept of calendar time and is therefore may not be linear nor monotonic. System time can jump arbitrarily in either direction as real time clock is corrected or the system is suspended. The local time may also jump due to daylight savings. The process' ability to sample system time can be limited for reasons such as getting swapped out. #TimeInfo provides an alternative time measurement facility not linked to calendar and guaranteed to grow monotonically – though not always linearly. Note that few systems actually provide wall-clock time in nanosecond resolution. Not all system provide an interface to get time at that resolution, let alone track it so precisely.

Because of the time warp issues, scheduling events using Time is not straightforward. Application code should understand whether it is dealing with concrete or abstract calendar calculations, and how the events it schedules are linked to wall clock time.

For calculations on concrete calendar as perceived by people use local() after plain Time and TimeSpan integer arithmetic. The method accounts for timezone and daylight savings definitions. To schedule events use build() to derive times from local() time to get values comparable to the system time returned by current(). The applications should know whether events are scheduled in UTC or local time—"meeting at 9:00 on Wednesday morning" when the device switches timezones may be known to be at 9:00 in the new timezone (= locked to local time), or in the timezone where the event was created (= locked to UTC). The build() and split() methods allow either format to be used, the application just needs to know which one to use. It is also easy to convert between the two using utcoffset().

For calculations using an abstract calendar, without timezone or daylight savings, use Time in its native UTC representation and integer arithmetic with Time and TimeSpan. Do note however that "T + 24 hours" may not be the same hour the next day in the local calendar time – timezone changes and daylight savings make a difference. This may require the application to accept as user input exception rules to its usual calendar calculations.

To schedule events, one should choose between three choices: UTC time, local time, or delta time. For the first two cases system time should be polled regularly to see if any of the recorded events have expired. It is not a good idea to sleep until the next scheduled event, as the system time may jump during the nap; instead sleep small increments, recheck the current time after each nap and trigger the events that have expired. A policy must be applied when the system time warps; this can happen both forwards and backwards with both local and UTC time (daylight savings or timezone changes for mobile devices are common local time change reasons, but the system time can be updated for any reason, e.g. when the real time clock is wrong, or if the system is suspended for a long time). Some events should be executed only once in case of time warps backwards. If the time jumps forwards, several events may need to be dealt with in one go. In either case the application should guard against major time changes: long system suspends, moving mobile devices and major time updates may result in a large number of "missed" events. One possibility is to provide a user-configurable "excessive time drift limit" (e.g. N hours): if time changes by more than that, missed events are not triggered.

For the final case of using delta times, sort upcoming events by their deltas from the previous event—not by the time they are anticipated to occur. Capture current time before and after the sleep and pull events off the queue based on the difference (the sleep time may exceed the requested time). Either guard against long time warps like suspends or schedule timer events cautiously. Using #TimeInfo as schedule base solves such issues simply. To cope with backward system time jumps when using Time as schedule base, assume that sleeps always last at least the requested time; if the time delta over the nap is less than the requested, assume time warp (this is not foolproof against interrupted system calls but works for many event scheduling situations).

See also
  #TimeInfo for monotonic time not related to the calendar. (Documentation taken from original SEAL class)

Author
  Marco Clemencic

Date
  2005-12-15

Definition at line 231 of file Time.h.

## Member Typedef Documentation

## ◆ ValueType

typedef long long Gaudi::Time::ValueType

Definition at line 235 of file Time.h.

## Member Enumeration Documentation

## ◆ Months

enum Gaudi::Time::Months

Symbolic names for months.

Enumerator
January |
February |
March |
April |
May |
June |
July |
August |
September |
October |
November |
December |

Definition at line 238 of file Time.h.

238 {
239 January = 0,
240 February = 1,
241 March = 2,
242 April = 3,
243 May = 4,
244 June = 5,
245 July = 6,
246 August = 7,
247 September = 8,
248 October = 9,
249 November = 10,
250 December = 11
251 };
Gaudi::Time::May
Definition: Time.h:243
Gaudi::Time::February
Definition: Time.h:240
Gaudi::Time::October
Definition: Time.h:248
Gaudi::Time::September
Definition: Time.h:247
Gaudi::Time::April
Definition: Time.h:242
Gaudi::Time::June
Definition: Time.h:244
Gaudi::Time::December
Definition: Time.h:250
Gaudi::Time::November
Definition: Time.h:249
Gaudi::Time::July
Definition: Time.h:245
Gaudi::Time::March
Definition: Time.h:241
Gaudi::Time::January
Definition: Time.h:239
Gaudi::Time::August
Definition: Time.h:246

## Constructor & Destructor Documentation

## ◆ Time() [1/5]

Gaudi::Time::Time | ( |  | ) |
| default

Initialize an empty (zero) time value.

## ◆ Time() [2/5]

Gaudi::Time::Time | ( | TimeSpan | ts | ) |
| inline

Initialize time to ts nanoseconds since 00:00:00 on January 1, 1970 in UTC.

Definition at line 16 of file Time.icpp.

16 : m_nsecs( ts.m_nsecs ) {
17 TimeAssert( m_nsecs >= 0, "cannot create a negative time" );
18 }
compareRootHistos.ts
tuple ts
Definition: compareRootHistos.py:447
Gaudi::Time::m_nsecs
ValueType m_nsecs
Definition: Time.h:328
Gaudi::Time::TimeAssert
void TimeAssert(bool cond, const std::string &msg="time assertion failed") const
Definition: Time.h:330

## ◆ Time() [3/5]

Gaudi::Time::Time | ( | ValueType | nsecs | ) |
| inline

Initialize time to nsecs nanoseconds since 00:00:00 on January 1, 1970 in UTC.

Definition at line 10 of file Time.icpp.

10 : m_nsecs( nsecs ) {
11 TimeAssert( m_nsecs >= 0, "cannot create a negative time" );
12 }
Gaudi::Time::m_nsecs
ValueType m_nsecs
Definition: Time.h:328
Gaudi::Time::TimeAssert
void TimeAssert(bool cond, const std::string &msg="time assertion failed") const
Definition: Time.h:330

## ◆ Time() [4/5]

Gaudi::Time::Time | ( | ValueType | secs,
|  | int | nsecs
| ) |  |
| inline

Initialize time to secs (seconds) and nsecs (nanoseconds) summed since 00:00:00 on January 1, 1970 in UTC.

Definition at line 22 of file Time.icpp.

22 : m_nsecs( secs * Time::SEC_NSECS + nsecs ) {
23 TimeAssert( m_nsecs >= 0, "cannot create a negative time" );
24 }
Gaudi::Time::SEC_NSECS
static const ValueType SEC_NSECS
Nanoseconds in one second.
Definition: Time.h:260
Gaudi::Time::m_nsecs
ValueType m_nsecs
Definition: Time.h:328
Gaudi::Time::TimeAssert
void TimeAssert(bool cond, const std::string &msg="time assertion failed") const
Definition: Time.h:330

## ◆ Time() [5/5]

Time::Time | ( | int | year,
|  | int | month,
|  | int | day,
|  | int | hour,
|  | int | min,
|  | int | sec,
|  | ValueType | nsecs,
|  | bool | local = `true`
| ) |  |

Definition at line 80 of file Time.cpp.

80 {
81 tm val;
82 memset( &val, 0, sizeof( val ) );
83 val.tm_sec = sec;
84 val.tm_min = min;
85 val.tm_hour = hour;
86 val.tm_mday = day;
87 val.tm_mon = month;
88 val.tm_year = year > 1900 ? year - 1900 : year;
89 val.tm_isdst = -1; // FIXME?
90
91 m_nsecs = build( local, val, nsecs ).m_nsecs;
92 }
Gaudi::Time::year
int year(bool local) const
Get the year.
Definition: Time.cpp:166
Gaudi::Time::build
static Time build(bool local, const tm &base, TimeSpan diff=0)
Construct a time from local time base and a delta diff.
Definition: Time.cpp:132
Gaudi::Time::day
int day(bool local) const
Get the day of month, numbered [1,31].
Definition: Time.cpp:172
min
EventIDBase min(const EventIDBase &lhs, const EventIDBase &rhs)
Definition: EventIDBase.h:202
std::memset
T memset(T... args)
Gaudi::Time::hour
int hour(bool local) const
Get the hour, numbered [0, 23].
Definition: Time.cpp:175
Gaudi::Time::month
int month(bool local) const
Get the month, numbered [0,11].
Definition: Time.cpp:169
Gaudi::Time::m_nsecs
ValueType m_nsecs
Definition: Time.h:328
Gaudi::Time::local
tm local(int *nsecpart=0) const
Break up the time to the standard library representation, converting it first to local time.
Definition: Time.cpp:163

## Member Function Documentation

## ◆ build()

Time Time::build | ( | bool | local,
|  | const tm & | base,
|  | TimeSpan | diff = `0`
| ) |  |
| static

Construct a time from local time base and a delta diff.

Definition at line 132 of file Time.cpp.

132 {
133 tm tmp( base );
134 return Time( local ? mktime( &tmp ) : timegm( &tmp ), 0 ) + diff;
135 }
Gaudi::Time::Time
Time()=default
Initialize an empty (zero) time value.
std::mktime
T mktime(T... args)
Gaudi::Time::local
tm local(int *nsecpart=0) const
Break up the time to the standard library representation, converting it first to local time.
Definition: Time.cpp:163

## ◆ current()

Time Time::current | ( | void |  | ) |
| static

Returns the current time.

Return the current system time.

Definition at line 109 of file Time.cpp.

109 {
110 #ifdef WIN32
111 FILETIME ftime;
112 GetSystemTimeAsFileTime( &ftime );
113 return from( &ftime );
114 #else
115 timeval tv;
116 if ( gettimeofday( &tv, nullptr ) != 0 ) {
117 char buf[256];
118 std::ostringstream tag, msg;
119 tag << "errno=" << errno;
120 if ( strerror_r( errno, buf, 256 ) == 0 ) {
121 msg << buf;
122 } else {
123 msg << "Unknown error retrieving current time";
124 }
125 throw GaudiException( msg.str(), tag.str(), StatusCode::FAILURE );
126 }
127 return Time( tv.tv_sec, tv.tv_usec * 1000 );
128 #endif
129 }
Gaudi::Time::Time
Time()=default
Initialize an empty (zero) time value.
GaudiException
Define general base for Gaudi exception.
Definition: GaudiException.h:21
std::ostringstream
STL class.
std::ostringstream::str
T str(T... args)
GaudiMP.FdsRegistry.msg
msg
Definition: FdsRegistry.py:8
StatusCode::FAILURE
constexpr static const auto FAILURE
Definition: StatusCode.h:86

## ◆ day()

int Time::day | ( | bool | local | ) | const

Get the day of month, numbered [1,31].

Definition at line 172 of file Time.cpp.

172 { return split( local ).tm_mday; }
Gaudi::Time::split
tm split(bool local, int *nsecpart=0) const
Break up the time to the standard representation, either in UTC (if local is false) or local time (if...
Definition: Time.cpp:141
Gaudi::Time::local
tm local(int *nsecpart=0) const
Break up the time to the standard library representation, converting it first to local time.
Definition: Time.cpp:163

## ◆ epoch()

Time Gaudi::Time::epoch | ( |  | ) |
| inline static

Returns the minimum time.

Return the time for the epoch (= zero time).

Definition at line 47 of file Time.icpp.

47 { return 0LL; }

## ◆ format()

std::string Time::format | ( | bool | local,
|  | std::string | spec = `"%c"`
| ) |  | const

Format the time using `strftime`.

The additional conversion specifier f can be used to display milliseconds (extension for compatibility with MessageSvc time format).

Fix-Me:
  : This doesn't account for nsecs part!

Definition at line 252 of file Time.cpp.

252 {
254 std::string result;
255 tm time = split( local );
256 std::string::size_type length = 0;
257
258 // handle the special case of "%f"
259 std::string::size_type pos = spec.find( "%f" );
260 if ( std::string::npos != pos ) {
261 // Get the milliseconds string
262 std::string ms = nanoformat( 3, 3 );
263 // Replace all the occurrences of '%f' (if not preceded by '%')
264 while ( std::string::npos != pos ) {
265 if ( pos != 0 && spec[pos - 1] != '%' ) { spec.replace( pos, 2, ms ); }
266 pos = spec.find( "%f", pos + 1 ); // search for the next occurrence
267 }
268 }
269 const int MIN_BUF_SIZE = 128;
270 do {
271 // Guess how much we'll expand. If we go wrong, we'll expand again. (with a minimum)
272 result.resize( std::max<std::string::size_type>(
273 result.size() * 2, std::max<std::string::size_type>( spec.size() * 2, MIN_BUF_SIZE ) ),
274 0 );
275 length = ::strftime( &result[0], result.size(), spec.c_str(), &time );
276 } while ( !length );
277
278 result.resize( length );
279 return result;
280 }
plotSpeedupsPyRoot.time
def time
Definition: plotSpeedupsPyRoot.py:152
std::string::resize
T resize(T... args)
std::string
STL class.
std::string::replace
T replace(T... args)
Gaudi::Time::split
tm split(bool local, int *nsecpart=0) const
Break up the time to the standard representation, either in UTC (if local is false) or local time (if...
Definition: Time.cpp:141
std::string::find
T find(T... args)
std::string::size
T size(T... args)
std::string::c_str
T c_str(T... args)
Gaudi::Time::local
tm local(int *nsecpart=0) const
Break up the time to the standard library representation, converting it first to local time.
Definition: Time.cpp:163
Gaudi::Units::ms
constexpr double ms
Definition: SystemOfUnits.h:134
Gaudi::Time::nanoformat
std::string nanoformat(size_t minwidth=1, size_t maxwidth=9) const
Format the nanosecond fractional part of the time as a string.
Definition: Time.cpp:292

## ◆ fromDosDate()

Time Time::fromDosDate | ( | unsigned | dosDate | ) |
| static

Convert the MS-DOS date dosDate into a Time.

Definition at line 329 of file Time.cpp.

329 {
330 // DOS times are generally local; treat it as UTC. This avoids
331 // any round-trip conversion and leaves only a presentation as an
332 // issue. Since not much can be known about the origin of the DOS
333 // times, it's generally best to present them as such (= in UTC).
334 struct tm localtm;
335 memset( &localtm, 0, sizeof( localtm ) );
336 localtm.tm_mday = ( dosDate >> 16 ) & 0x1f;
337 localtm.tm_mon = ( ( dosDate >> 21 ) & 0xf ) - 1;
338 localtm.tm_year = ( ( dosDate >> 25 ) & 0x7f ) + 80;
339 localtm.tm_hour = ( dosDate >> 11 ) & 0x1f;
340 localtm.tm_min = ( dosDate >> 5 ) & 0x3f;
341 localtm.tm_sec = ( dosDate & 0x1f ) * 2;
342 localtm.tm_isdst = -1;
343
344 return Time( mktime( &localtm ), 0 );
345 }
Gaudi::Time::Time
Time()=default
Initialize an empty (zero) time value.
std::memset
T memset(T... args)
std::mktime
T mktime(T... args)

## ◆ hour()

int Time::hour | ( | bool | local | ) | const

Get the hour, numbered [0, 23].

Definition at line 175 of file Time.cpp.

175 { return split( local ).tm_hour; }
Gaudi::Time::split
tm split(bool local, int *nsecpart=0) const
Break up the time to the standard representation, either in UTC (if local is false) or local time (if...
Definition: Time.cpp:141
Gaudi::Time::local
tm local(int *nsecpart=0) const
Break up the time to the standard library representation, converting it first to local time.
Definition: Time.cpp:163

## ◆ isdst()

bool Time::isdst | ( | bool | local | ) | const

Check whether daylight savings is in effect.

This really only makes sense if local is true since daylight savings is never in effect for UTC time.

Definition at line 196 of file Time.cpp.

196 { return split( local ).tm_isdst > 0; }
Gaudi::Time::split
tm split(bool local, int *nsecpart=0) const
Break up the time to the standard representation, either in UTC (if local is false) or local time (if...
Definition: Time.cpp:141
Gaudi::Time::local
tm local(int *nsecpart=0) const
Break up the time to the standard library representation, converting it first to local time.
Definition: Time.cpp:163

## ◆ isLeap()

bool Gaudi::Time::isLeap | ( | int | year | ) |
| inline static

Check if the year is a leap-year.

Definition at line 53 of file Time.icpp.

53 {
54 return ( ( year % 4 ) == 0 && ( ( year % 100 ) != 0 || ( year % 400 ) == 0 ) );
55 }
Gaudi::Time::year
int year(bool local) const
Get the year.
Definition: Time.cpp:166

## ◆ local()

tm Time::local | ( | int * | nsecpart = `0` | ) | const

Break up the time to the standard library representation, converting it first to local time.

If nsecpart is non-null, it is set to the nanosecond part that cannot be stored into `tm`.

Definition at line 163 of file Time.cpp.

163 { return split( true, nsecpart ); }
Gaudi::Time::split
tm split(bool local, int *nsecpart=0) const
Break up the time to the standard representation, either in UTC (if local is false) or local time (if...
Definition: Time.cpp:141

## ◆ max()

Time Gaudi::Time::max | ( |  | ) |
| inline static

Returns the maximum time.

Return the maximum time.

Definition at line 50 of file Time.icpp.

50 { return 0x7fffffffffffffffLL; }

## ◆ minute()

int Time::minute | ( | bool | local | ) | const

Get the minute, numbered [0, 59].

Definition at line 178 of file Time.cpp.

178 { return split( local ).tm_min; }
Gaudi::Time::split
tm split(bool local, int *nsecpart=0) const
Break up the time to the standard representation, either in UTC (if local is false) or local time (if...
Definition: Time.cpp:141
Gaudi::Time::local
tm local(int *nsecpart=0) const
Break up the time to the standard library representation, converting it first to local time.
Definition: Time.cpp:163

## ◆ month()

int Time::month | ( | bool | local | ) | const

Get the month, numbered [0,11].

Definition at line 169 of file Time.cpp.

169 { return split( local ).tm_mon; }
Gaudi::Time::split
tm split(bool local, int *nsecpart=0) const
Break up the time to the standard representation, either in UTC (if local is false) or local time (if...
Definition: Time.cpp:141
Gaudi::Time::local
tm local(int *nsecpart=0) const
Break up the time to the standard library representation, converting it first to local time.
Definition: Time.cpp:163

## ◆ nanoformat()

std::string Time::nanoformat | ( | size_t | minwidth = `1`,
|  | size_t | maxwidth = `9`
| ) |  | const

Format the nanosecond fractional part of the time as a string.

The arguments control the representation of the resulting value. The nanosecond part is printed as fixed nine-character-wide number and then excess zeroes are stripped off at the right end. Use minwidth to force a specific number number of them to be left intact: the resulting number will have at least that many digits. Use maxwidth to truncate the value: the resulting number will have at most that many digits. Both minwidth and maxwidth must be between one and nine inclusive and minwidth must be less or equal to maxwidth.

Definition at line 292 of file Time.cpp.

292 {
293 TimeAssert( ( minwidth >= 1 ) && ( minwidth <= maxwidth ) && ( maxwidth <= 9 ),
294 "nanoformat options do not satisfy: 1 <= minwidth <= maxwidth <= 9" );
295
296 // Calculate the nanosecond fraction. This will be < 1000000000.
297 int value = (int)( m_nsecs % SEC_NSECS );
298
299 std::ostringstream buf;
300 buf.fill( '0' );
301 buf.width( 9 );
302 buf << value;
303 std::string out = buf.str();
304 // Find the last non-0 char before maxwidth, but after minwidth
305 // (Note: -1 and +1 are to account for difference between position and size.
306 // moreover, npos + 1 == 0, so it is correct to say that 'not found' means size of 0)
307 size_t len = out.find_last_not_of( '0', maxwidth - 1 ) + 1;
308 // Truncate the output string to at least minwidth chars
309 out.resize( std::max( len, minwidth ) );
310 return out;
311 }
std::string::resize
T resize(T... args)
Gaudi::Time::SEC_NSECS
static const ValueType SEC_NSECS
Nanoseconds in one second.
Definition: Time.h:260
std::string
STL class.
std::ostringstream
STL class.
std::ostringstream::width
T width(T... args)
std::ostringstream::str
T str(T... args)
std::max
T max(T... args)
std::string::find_last_not_of
T find_last_not_of(T... args)
Gaudi::Time::m_nsecs
ValueType m_nsecs
Definition: Time.h:328
std::ostringstream::fill
T fill(T... args)
Gaudi::Time::TimeAssert
void TimeAssert(bool cond, const std::string &msg="time assertion failed") const
Definition: Time.h:330

## ◆ ns()

Time::ValueType Gaudi::Time::ns | ( |  | ) | const
| inline

Return the time as nanoseconds since 00:00:00 on January 1, 1970 in UTC.

Definition at line 28 of file Time.icpp.

28 { return m_nsecs; }
Gaudi::Time::m_nsecs
ValueType m_nsecs
Definition: Time.h:328

## ◆ nsecond()

int Time::nsecond | ( | void |  | ) | const

Get the nanoseconds.

There is no `local` argument since time zone and daylight savings never affects the value at the subsecond granularity.

Definition at line 188 of file Time.cpp.

188 { return (int)( m_nsecs % SEC_NSECS ); }
Gaudi::Time::SEC_NSECS
static const ValueType SEC_NSECS
Nanoseconds in one second.
Definition: Time.h:260
Gaudi::Time::m_nsecs
ValueType m_nsecs
Definition: Time.h:328

## ◆ operator+=()

Time & Gaudi::Time::operator+= | ( | const TimeSpan & | x | ) |
| inline

Add the specified amount to the time.

Note that Time is always expressed in UTC.

Definition at line 32 of file Time.icpp.

32 {
33 TimeAssert( m_nsecs >= -x.m_nsecs, "time operation lead to negative time" );
34 m_nsecs += x.m_nsecs;
35 return *this;
36 }
Gaudi::Time::m_nsecs
ValueType m_nsecs
Definition: Time.h:328
Gaudi::Time::TimeAssert
void TimeAssert(bool cond, const std::string &msg="time assertion failed") const
Definition: Time.h:330

## ◆ operator-=()

Time & Gaudi::Time::operator-= | ( | const TimeSpan & | x | ) |
| inline

Subtract the specified amount from the time.

Note that Time is always expressed in UTC.

Definition at line 40 of file Time.icpp.

40 {
41 TimeAssert( m_nsecs >= x.m_nsecs, "time operation lead to negative time" );
42 m_nsecs -= x.m_nsecs;
43 return *this;
44 }
Gaudi::Time::m_nsecs
ValueType m_nsecs
Definition: Time.h:328
Gaudi::Time::TimeAssert
void TimeAssert(bool cond, const std::string &msg="time assertion failed") const
Definition: Time.h:330

## ◆ second()

int Time::second | ( | bool | local | ) | const

Get the seconds, numbered [0,61] (allowing one or two leap seconds, years with leap seconds can have the time Dec 31, 23:59:60 (or :61).)

Definition at line 183 of file Time.cpp.

183 { return split( local ).tm_sec; }
Gaudi::Time::split
tm split(bool local, int *nsecpart=0) const
Break up the time to the standard representation, either in UTC (if local is false) or local time (if...
Definition: Time.cpp:141
Gaudi::Time::local
tm local(int *nsecpart=0) const
Break up the time to the standard library representation, converting it first to local time.
Definition: Time.cpp:163

## ◆ split()

tm Time::split | ( | bool | local,
|  | int * | nsecpart = `0`
| ) |  | const

Break up the time to the standard representation, either in UTC (if local is `false`) or local time (if local is `true`).

If nsecpart is non-null, it is set to the nanosecond part that cannot be stored into `tm`.

Definition at line 141 of file Time.cpp.

141 {
142 if ( nsecpart ) *nsecpart = (int)( m_nsecs % SEC_NSECS );
143
144 time_t val = ( time_t )( m_nsecs / SEC_NSECS );
145
146 tm retval;
147 if ( local )
148 localtime_r( &val, &retval );
149 else
150 gmtime_r( &val, &retval );
151
152 return retval;
153 }
compareRootHistos.retval
def retval
Definition: compareRootHistos.py:458
Gaudi::Time::SEC_NSECS
static const ValueType SEC_NSECS
Nanoseconds in one second.
Definition: Time.h:260
Gaudi::Time::m_nsecs
ValueType m_nsecs
Definition: Time.h:328
Gaudi::Time::local
tm local(int *nsecpart=0) const
Break up the time to the standard library representation, converting it first to local time.
Definition: Time.cpp:163

## ◆ TimeAssert()

void Gaudi::Time::TimeAssert | ( | bool | cond,
|  | const std::string & | msg = `"time assertion failed"`
| ) |  | const
| inline private

Definition at line 330 of file Time.h.

330 {
331 if ( !cond ) throw TimeException( msg );
332 }
TimeException
Exception thrown by Gaudi::Time.
Definition: Time.h:20
GaudiMP.FdsRegistry.msg
msg
Definition: FdsRegistry.py:8

## ◆ timezone()

const char * Time::timezone | ( | int * | daylight = `0` | ) | const

Return the local timezone name that applies at this time value.

On some platforms returns the most recent timezone name (dst or non-dst one depending on the time value), not the one that applies at the time value.

Definition at line 238 of file Time.cpp.

238 {
239 tm localtm = local();
240 if ( daylight ) *daylight = localtm.tm_isdst;
241 // extern "C" { extern char *tzname [2]; }
242 return tzname[localtm.tm_isdst > 0 ? 1 : 0];
243 }
Gaudi::Time::local
tm local(int *nsecpart=0) const
Break up the time to the standard library representation, converting it first to local time.
Definition: Time.cpp:163

## ◆ toDosDate()

unsigned Time::toDosDate | ( | Time | time | ) |
| static

Convert the Time t into a MS-DOS date format.

Definition at line 315 of file Time.cpp.

315 {
316 // Use local time since DOS does too.
317 struct tm localtm = time.local();
318
319 unsigned mday = localtm.tm_mday;
320 unsigned mon = localtm.tm_mon + 1;
321 unsigned year = ( localtm.tm_year > 80 ? localtm.tm_year - 80 : 0 );
322 unsigned sec = localtm.tm_sec / 2;
323 unsigned min = localtm.tm_min;
324 unsigned hour = localtm.tm_hour;
325 return ( mday << 16 | mon << 21 | year << 25 | sec | min << 5 | hour << 11 );
326 }
plotSpeedupsPyRoot.time
def time
Definition: plotSpeedupsPyRoot.py:152
Gaudi::Time::year
int year(bool local) const
Get the year.
Definition: Time.cpp:166
min
EventIDBase min(const EventIDBase &lhs, const EventIDBase &rhs)
Definition: EventIDBase.h:202
Gaudi::Time::hour
int hour(bool local) const
Get the hour, numbered [0, 23].
Definition: Time.cpp:175

## ◆ utc()

tm Time::utc | ( | int * | nsecpart = `0` | ) | const

Break up the time to the standard library representation, keeping it in UTC.

If nsecpart is non-null, it is set to the nanosecond part that cannot be stored into `tm`.

Definition at line 158 of file Time.cpp.

158 { return split( false, nsecpart ); }
Gaudi::Time::split
tm split(bool local, int *nsecpart=0) const
Break up the time to the standard representation, either in UTC (if local is false) or local time (if...
Definition: Time.cpp:141

## ◆ utcoffset()

Time::ValueType Time::utcoffset | ( | int * | daylight = `0` | ) | const

Return the number of nanoseconds that needs to be added to UTC to translate this time to the local time (= nanoseconds east of UTC).

This accounts for the time zone and daylight savings settings of the local time as of the current value. If daylight is non-null, it is set to indicate daylight savings status (that is, tm.tm_isdst for the effective local time).

Definition at line 204 of file Time.cpp.

204 {
205 ValueType n = 0;
206
207 #ifndef WIN32
208 tm localtm = local();
209 n = localtm.tm_gmtoff;
210 if ( daylight ) *daylight = localtm.tm_isdst;
211 #else
212 // Adapted from WINE.
213 time_t utctime = ( time_t )( m_nsecs / SEC_NSECS );
214 tm localtm;
215 localtime_s( &localtm, &utctime );
216 int savedaylight = localtm.tm_isdst;
217 tm gmt;
218 gmtime_s( &gmt, &utctime );
219
220 gmt.tm_isdst = savedaylight;
221 n = utctime - mktime( &gmt );
222
223 if ( daylight ) *daylight = savedaylight;
224 #endif
225 return n * SEC_NSECS;
226 }
Gaudi::Time::SEC_NSECS
static const ValueType SEC_NSECS
Nanoseconds in one second.
Definition: Time.h:260
GaudiPluginService.cpluginsvc.n
n
Definition: cpluginsvc.py:210
std::mktime
T mktime(T... args)
Gaudi::Time::m_nsecs
ValueType m_nsecs
Definition: Time.h:328
Gaudi::Time::local
tm local(int *nsecpart=0) const
Break up the time to the standard library representation, converting it first to local time.
Definition: Time.cpp:163
Gaudi::Time::ValueType
long long ValueType
Definition: Time.h:235

## ◆ weekday()

int Time::weekday | ( | bool | local | ) | const

Get the day of week, numbered [0,6] and starting from Sunday.

Definition at line 191 of file Time.cpp.

191 { return split( local ).tm_wday; }
Gaudi::Time::split
tm split(bool local, int *nsecpart=0) const
Break up the time to the standard representation, either in UTC (if local is false) or local time (if...
Definition: Time.cpp:141
Gaudi::Time::local
tm local(int *nsecpart=0) const
Break up the time to the standard library representation, converting it first to local time.
Definition: Time.cpp:163

## ◆ year()

int Time::year | ( | bool | local | ) | const

Get the year.

Definition at line 166 of file Time.cpp.

166 { return split( local ).tm_year + 1900; }
Gaudi::Time::split
tm split(bool local, int *nsecpart=0) const
Break up the time to the standard representation, either in UTC (if local is false) or local time (if...
Definition: Time.cpp:141
Gaudi::Time::local
tm local(int *nsecpart=0) const
Break up the time to the standard library representation, converting it first to local time.
Definition: Time.cpp:163

## Friends And Related Function Documentation

## ◆ operator!=

bool operator!= | ( | const Gaudi::Time & | t1,
|  | const Gaudi::Time & | t2
| ) |  |
| friend

Definition at line 317 of file Time.h.

317 { return t1.ns() != t2.ns(); }
Gaudi::Time::ns
ValueType ns() const
Return the time as nanoseconds since 00:00:00 on January 1, 1970 in UTC.
Definition: Time.icpp:28

## ◆ operator<

bool operator< | ( | const Gaudi::Time & | t1,
|  | const Gaudi::Time & | t2
| ) |  |
| friend

Definition at line 319 of file Time.h.

319 { return t1.ns() < t2.ns(); }
Gaudi::Time::ns
ValueType ns() const
Return the time as nanoseconds since 00:00:00 on January 1, 1970 in UTC.
Definition: Time.icpp:28

## ◆ operator<=

bool operator<= | ( | const Gaudi::Time & | t1,
|  | const Gaudi::Time & | t2
| ) |  |
| friend

Definition at line 321 of file Time.h.

321 { return t1.ns() <= t2.ns(); }
Gaudi::Time::ns
ValueType ns() const
Return the time as nanoseconds since 00:00:00 on January 1, 1970 in UTC.
Definition: Time.icpp:28

## ◆ operator==

bool operator== | ( | const Gaudi::Time & | t1,
|  | const Gaudi::Time & | t2
| ) |  |
| friend

Definition at line 315 of file Time.h.

315 { return t1.ns() == t2.ns(); }
Gaudi::Time::ns
ValueType ns() const
Return the time as nanoseconds since 00:00:00 on January 1, 1970 in UTC.
Definition: Time.icpp:28

## ◆ operator>

bool operator> | ( | const Gaudi::Time & | t1,
|  | const Gaudi::Time & | t2
| ) |  |
| friend

Definition at line 323 of file Time.h.

323 { return t1.ns() > t2.ns(); }
Gaudi::Time::ns
ValueType ns() const
Return the time as nanoseconds since 00:00:00 on January 1, 1970 in UTC.
Definition: Time.icpp:28

## ◆ operator>=

bool operator>= | ( | const Gaudi::Time & | t1,
|  | const Gaudi::Time & | t2
| ) |  |
| friend

Definition at line 325 of file Time.h.

325 { return t1.ns() >= t2.ns(); }
Gaudi::Time::ns
ValueType ns() const
Return the time as nanoseconds since 00:00:00 on January 1, 1970 in UTC.
Definition: Time.icpp:28

## ◆ TimeSpan

friend class TimeSpan
| friend

Definition at line 232 of file Time.h.

## Member Data Documentation

## ◆ m_nsecs

ValueType Gaudi::Time::m_nsecs = 0
| private

Definition at line 328 of file Time.h.

## ◆ SEC_NSECS

const ValueType Gaudi::Time::SEC_NSECS = 1000000000
| static

Nanoseconds in one second.

Definition at line 260 of file Time.h.

## ◆ SECS_PER_DAY

const int Gaudi::Time::SECS_PER_DAY = 86400
| static

Seconds in 24 hours.

Definition at line 254 of file Time.h.

## ◆ SECS_PER_HOUR

const int Gaudi::Time::SECS_PER_HOUR = 3600
| static

Seconds in one hour hour.

Definition at line 257 of file Time.h.

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

- GaudiKernel/GaudiKernel/Time.h
- GaudiKernel/GaudiKernel/Time.icpp
- GaudiKernel/src/Lib/Time.cpp