Time.cpp

Go to the documentation of this file.

// $Id: Time.cpp,v 1.1 2006/01/26 09:24:03 hmd Exp $
// Include files
#include "GaudiKernel/Time.h"

#include "GaudiKernel/time_r.h"

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

// 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, 0) != 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);
}

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