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 <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 (&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, sizeof (val), 0);
  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 retriving 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);
  return *(local ? localtime (&val) : gmtime (&val));
}

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 (&utctime);
  int           savedaylight = localtm.tm_isdst;
  tm            gmt = *gmtime (&utctime);
  
  gmt.tm_isdst = savedaylight;
  n = utctime - mktime (&gmt);
  
  if (daylight) *daylight = savedaylight;
#endif
  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, const std::string &spec) const {
  // FIXME: This doesn't account for nsecs part!
  std::string   result;
  tm            time = split (local);
  int           length = 0;
  
  do
  {
    // Guess how much we'll expand.  If we go wrong, we'll expand again.
    result.resize (result.size() ? result.size()*2 : spec.size()*2, 0);
    length = ::strftime (&result[0], result.size(), spec.c_str(), &time);
  } while (! length);
  
  result.resize (length);
  return result;
}

std::string Time::nanoformat (int minwidth /* = 1 */, int 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);
  
  // Calculate modulus by which we truncate value.  If maxwidth is
  // say 3, we want to mask of the last 6 digits.
  int modulus = 1;
  for (int i = 0; i < 9 - maxwidth; ++i)
    modulus *= 10;

  // Round value by the desired modulus.
  int rem = value % modulus;
  value -= rem;
  if (rem > modulus / 2)
    value += modulus;
  
  // Format it, then strip off digits from the right as long as
  // we zeroes.  The above guarantees enough zeroes on right to
  // satisfy maxwidth so we need to concern ourselves only about
  // minwidth.
  char buf [10];
  char *p = buf + 8;
  sprintf (buf, "%09d", value);
  while (p > buf + minwidth - 1 && *p == '0')
    *p-- = '\0';
  
  return buf;
}


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

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