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 <cerrno>
#include <cstdio>
#include <cstring>
#include <ctime>
#include <sys/time.h>
 
using namespace Gaudi;
 
//-----------------------------------------------------------------------------
// Implementation file for class : Gaudi::Time
// Based on seal::Time
// 2005-12-15 : Marco Clemencic
//-----------------------------------------------------------------------------
 
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;
}

Time Time::current( void ) {
  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 );
}

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;
 
  tm localtm = local();
  n          = localtm.tm_gmtoff;
  if ( daylight ) *daylight = localtm.tm_isdst;
 
  return n * SEC_NSECS;
}

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];
}

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 std::size_t 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( result.size() * 2, std::max( 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 );
}