Time.cpp

Go to the documentation of this file.

/***********************************************************************************\
* (c) Copyright 1998-2025 CERN for the benefit of the LHCb and ATLAS collaborations *
*                                                                                   *
* This software is distributed under the terms of the Apache version 2 licence,     *
* copied verbatim in the file "LICENSE".                                            *
*                                                                                   *
* In applying this licence, CERN does not waive the privileges and immunities       *
* granted to it by virtue of its status as an Intergovernmental Organization        *
* or submit itself to any jurisdiction.                                             *
\***********************************************************************************/
#include <GaudiKernel/Time.h>
#include <GaudiKernel/time_r.h>
#include <cerrno>
#include <cstdio>
#include <cstring>
#include <ctime>
#include <iostream>
 
using namespace Gaudi;
 
// architecture dependent includes
#ifdef WIN32
 
// this turns off a lot of useless Win stuff which conflicts with Gaudi. (found empirically)
#  define NOATOM
#  define NOGDI
#  define NOGDICAPMASKS
#  define NOMETAFILE
#  define NOMINMAX
#  define NOMSG
#  define NOOPENFILE
#  define NORASTEROPS
#  define NOSCROLL
#  define NOSOUND
#  define NOSYSMETRICS
#  define NOTEXTMETRIC
#  define NOWH
#  define NOCOMM
#  define NOKANJI
#  define NOCRYPT
#  define NOMCX
 
#  include <windows.h>
 
#else
// Linux
 
#  include <sys/time.h>
 
#endif
 
//-----------------------------------------------------------------------------
// Implementation file for class : Gaudi::Time
// Based on seal::Time
// 2005-12-15 : Marco Clemencic
//-----------------------------------------------------------------------------
 
#ifdef WIN32
 
// # define SECS_1601_TO_1970   ((369 * 365 + 89) * SECS_PER_DAY)
#  define SECS_1601_TO_1970 ( ( 369 * 365 + 89 ) * 86400ui64 )
#endif
 
#ifdef WIN32
static time_t timegm( struct tm* t ) {
  // This code is adapted from wine, samba
  time_t    t1 = mktime( t );
  struct tm gmt;
  gmtime_s( &gmt, &t1 );
  time_t t2 = mktime( &gmt );
  return t1 + ( t1 - t2 );
}
#endif
 
Time::Time( int year, int month, int day, int hour, int min, int sec, ValueType nsecs, bool local /* = true */ ) {
  tm val;
  memset( &val, 0, sizeof( val ) );
  val.tm_sec   = sec;
  val.tm_min   = min;
  val.tm_hour  = hour;
  val.tm_mday  = day;
  val.tm_mon   = month;
  val.tm_year  = year > 1900 ? year - 1900 : year;
  val.tm_isdst = -1; // FIXME?
 
  m_nsecs = build( local, val, nsecs ).m_nsecs;
}
 
#ifdef WIN32
 
Time Time::from( const FILETIME* systime ) {
  ValueType t = ( (ValueType)systime->dwHighDateTime << 32 ) + (ValueType)systime->dwLowDateTime;
 
  if ( t )
    // Subtract bias (1970--1601 in 100ns), then convert to nanoseconds.
    t = ( t - SECS_1601_TO_1970 * ( SEC_NSECS / 100 ) ) * 100;
 
  return Time( t );
}
#endif
 
Time Time::current( void ) {
#ifdef WIN32
  FILETIME ftime;
  GetSystemTimeAsFileTime( &ftime );
  return from( &ftime );
#else
  timeval tv;
  if ( gettimeofday( &tv, nullptr ) != 0 ) {
    char               buf[256];
    std::ostringstream tag, msg;
    tag << "errno=" << errno;
    if ( strerror_r( errno, buf, 256 ) == 0 ) {
      msg << buf;
    } else {
      msg << "Unknown error retrieving current time";
    }
    throw GaudiException( msg.str(), tag.str(), StatusCode::FAILURE );
  }
  return Time( tv.tv_sec, tv.tv_usec * 1000 );
#endif
}
 
Time Time::build( bool local, const tm& base, TimeSpan diff /* = 0 */ ) {
  tm tmp( base );
  return Time( local ? mktime( &tmp ) : timegm( &tmp ), 0 ) + diff;
}
 
tm Time::split( bool local, int* nsecpart /* = 0 */ ) const {
  if ( nsecpart ) *nsecpart = (int)( m_nsecs % SEC_NSECS );
 
  time_t val = (time_t)( m_nsecs / SEC_NSECS );
 
  tm retval;
  if ( local )
    localtime_r( &val, &retval );
  else
    gmtime_r( &val, &retval );
 
  return retval;
}
 
tm Time::utc( int* nsecpart /* = 0 */ ) const { return split( false, nsecpart ); }
 
tm Time::local( int* nsecpart /* = 0 */ ) const { return split( true, nsecpart ); }
 
int Time::year( bool local ) const { return split( local ).tm_year + 1900; }
 
int Time::month( bool local ) const { return split( local ).tm_mon; }
 
int Time::day( bool local ) const { return split( local ).tm_mday; }
 
int Time::hour( bool local ) const { return split( local ).tm_hour; }
 
int Time::minute( bool local ) const { return split( local ).tm_min; }
 
int Time::second( bool local ) const { return split( local ).tm_sec; }
 
int Time::nsecond( void ) const { return (int)( m_nsecs % SEC_NSECS ); }
 
int Time::weekday( bool local ) const { return split( local ).tm_wday; }
 
bool Time::isdst( bool local ) const { return split( local ).tm_isdst > 0; }
 
Time::ValueType Time::utcoffset( int* daylight /* = 0 */ ) const {
  ValueType n = 0;
 
#ifndef WIN32
  tm localtm = local();
  n          = localtm.tm_gmtoff;
  if ( daylight ) *daylight = localtm.tm_isdst;
#else
  // Adapted from WINE.
  time_t utctime = (time_t)( m_nsecs / SEC_NSECS );
  tm     localtm;
  localtime_s( &localtm, &utctime );
  int savedaylight = localtm.tm_isdst;
  tm  gmt;
  gmtime_s( &gmt, &utctime );
 
  gmt.tm_isdst = savedaylight;
  n            = utctime - mktime( &gmt );
 
  if ( daylight ) *daylight = savedaylight;
#endif
  return n * SEC_NSECS;
}
 
#ifdef WIN32
// disable warning
// C4996: 'tzname': This function or variable may be unsafe.
#  pragma warning( push )
#  pragma warning( disable : 4996 )
#endif
 
const char* Time::timezone( int* daylight /* = 0 */ ) const {
  tm localtm = local();
  if ( daylight ) *daylight = localtm.tm_isdst;
  // extern "C" { extern char *tzname [2]; }
  return tzname[localtm.tm_isdst > 0 ? 1 : 0];
}
#ifdef WIN32
#  pragma warning( pop )
#endif
 
std::string Time::format( bool local, std::string spec ) const {
  std::string            result;
  tm                     time   = split( local );
  std::string::size_type length = 0;
 
  // handle the special case of "%f"
  std::string::size_type pos = spec.find( "%f" );
  if ( std::string::npos != pos ) {
    // Get the milliseconds string
    std::string ms = nanoformat( 3, 3 );
    // Replace all the occurrences of '%f' (if not preceded by '%')
    while ( std::string::npos != pos ) {
      if ( pos != 0 && spec[pos - 1] != '%' ) { spec.replace( pos, 2, ms ); }
      pos = spec.find( "%f", pos + 1 ); // search for the next occurrence
    }
  }
  const int MIN_BUF_SIZE = 128;
  do {
    // Guess how much we'll expand.  If we go wrong, we'll expand again. (with a minimum)
    result.resize( std::max<std::string::size_type>(
                       result.size() * 2, std::max<std::string::size_type>( spec.size() * 2, MIN_BUF_SIZE ) ),
                   0 );
    length = ::strftime( &result[0], result.size(), spec.c_str(), &time );
  } while ( !length );
 
  result.resize( length );
  return result;
}
 
std::string Time::nanoformat( size_t minwidth /* = 1 */, size_t maxwidth /* = 9 */ ) const {
  TimeAssert( ( minwidth >= 1 ) && ( minwidth <= maxwidth ) && ( maxwidth <= 9 ),
              "nanoformat options do not satisfy: 1 <= minwidth <= maxwidth <= 9" );
 
  // Calculate the nanosecond fraction.  This will be < 1000000000.
  int value = (int)( m_nsecs % SEC_NSECS );
 
  std::ostringstream buf;
  (void)buf.fill( '0' );
  buf.width( 9 );
  buf << value;
  std::string out = buf.str();
  // Find the last non-0 char before maxwidth, but after minwidth
  // (Note: -1 and +1 are to account for difference between position and size.
  //        moreover, npos + 1 == 0, so it is correct to say that 'not found' means size of 0)
  size_t len = out.find_last_not_of( '0', maxwidth - 1 ) + 1;
  // Truncate the output string to at least minwidth chars
  out.resize( std::max( len, minwidth ) );
  return out;
}
 
unsigned Time::toDosDate( Time time ) {
  // Use local time since DOS does too.
  struct tm localtm = time.local();
 
  unsigned mday = localtm.tm_mday;
  unsigned mon  = localtm.tm_mon + 1;
  unsigned year = ( localtm.tm_year > 80 ? localtm.tm_year - 80 : 0 );
  unsigned sec  = localtm.tm_sec / 2;
  unsigned min  = localtm.tm_min;
  unsigned hour = localtm.tm_hour;
  return ( mday << 16 | mon << 21 | year << 25 | sec | min << 5 | hour << 11 );
}
 
Time Time::fromDosDate( unsigned dosDate ) {
  // DOS times are generally local; treat it as UTC.  This avoids
  // any round-trip conversion and leaves only a presentation as an
  // issue.  Since not much can be known about the origin of the DOS
  // times, it's generally best to present them as such (= in UTC).
  struct tm localtm;
  memset( &localtm, 0, sizeof( localtm ) );
  localtm.tm_mday  = ( dosDate >> 16 ) & 0x1f;
  localtm.tm_mon   = ( ( dosDate >> 21 ) & 0xf ) - 1;
  localtm.tm_year  = ( ( dosDate >> 25 ) & 0x7f ) + 80;
  localtm.tm_hour  = ( dosDate >> 11 ) & 0x1f;
  localtm.tm_min   = ( dosDate >> 5 ) & 0x3f;
  localtm.tm_sec   = ( dosDate & 0x1f ) * 2;
  localtm.tm_isdst = -1;
 
  return Time( mktime( &localtm ), 0 );
}