Time.cpp

Go to the documentation of this file.

// Include files
#include "GaudiKernel/Time.h"

#include "GaudiKernel/time_r.h"

#include <cerrno>
#include <cstdio>
#include <cstring>
#include <ctime>
#include <iostream>

// local
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

//=============================================================================
// Standard constructor, initializes variables
//=============================================================================
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;
  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 );
}

//=============================================================================