JDateAndTime.hh

Go to the documentation of this file.

#ifndef __JSYSTEM__JDATEANDTIME__
#define __JSYSTEM__JDATEANDTIME__
 
#include <istream>
#include <ostream>
#include <sstream>
#include <limits>
#include <string>
#include <string.h>
#include <time.h>
 
#include "JLang/JComparable.hh"
#include "JLang/JException.hh"
 
 
/**
 * \file
 * Date and time functions.
 *
 * \author mdejong, bjung
 */
namespace JSYSTEM {}
namespace JPP { using namespace JSYSTEM; }
 
namespace JSYSTEM {
  
  using JLANG::JComparable;
  using JLANG::JIOException;
  using JLANG::JParseError;
 
 
  /**
   * Get current local date conform ISO-8601 standard.
   *
   * \return          date
   */
  inline const char* getDate()
  {
    static time_t    ts;
    static const size_t     MAX_SIZE = 256;
    static char      buffer[MAX_SIZE];
 
    time(&ts);
 
    strftime(buffer, MAX_SIZE, "%F", localtime(&ts));
      
    return buffer;
  }
 
  
  /**
   * Get current local time conform ISO-8601 standard.
   *
   * \return          time
   */
  inline const char* getTime()
  {
    static time_t    ts;
    static const size_t     MAX_SIZE = 256;
    static char      buffer[MAX_SIZE];
 
    time(&ts);
 
    strftime(buffer, MAX_SIZE, "%T%z",  localtime(&ts));
    
    return buffer;
  }
 
 
  /**
   * Auxiliary class for date and time.
   *
   * The data structure <tt>time_t</tt> is used for the internal value and
   * the data structure <tt>tm</tt> for the representation.
   *
   * The I/O format conforms with ISO-8601 standard
   * but it is also possible to parse <tt>ROOT TTimeStamp::AsString("c")</tt>.
   */
  struct JDateAndTime :
    JComparable<JDateAndTime>
  {
    /**
     * Constructor.
     *
     * \param  utc      UTC
     */
    JDateAndTime(const bool utc = false)
    {
      set(utc);
    }
 
 
    /**
     * Constructor.
     *
     * \param  t1       time [s]
     * \param  utc      UTC
     */
    JDateAndTime(const time_t t1, const bool utc = false)
    {
      set(t1, utc);
    }
 
 
    /**
     * Constructor.
     *
     * \param  t1       time [s]
     * \param  f1       fraction of seconds
     * \param  utc      UTC
     */
    JDateAndTime(const time_t t1, const float f1, const bool utc = false)
    {
      set(t1, f1, utc);
    }
 
 
    /**
     * Constructor.
     *
     * \param  buffer   date and time
     */
    JDateAndTime(const std::string& buffer)
    {
      std::istringstream is(buffer);
 
      is >> *this;
    }
 
 
    /**
     * Constructor.
     *
     * \param  buffer   date and time
     */
    JDateAndTime(const char* const buffer)
    {
      std::istringstream is(buffer);
 
      is >> *this;
    }
 
 
    /**
     * Less than method.
     *
     * \param  object               date and time
     * \result                      true if this date and time is less than given date and time; else false
     */
    inline bool less(const JDateAndTime& object) const
    {
      return getElapsedTime(object) > 0.0;
    }
 
 
    /**
     * Smart pointer.
     *
     * \return          pointer to time structure
     */
    const tm* operator->() const
    {
      return get();
    }
 
 
    /**
     * Check if UTC time.
     *
     * \return          true if UTC time; else false
     */
    bool isUTC() const
    {
      return utc;
    }
 
 
    time_t getTime() const { return ts; }                      //!< time
 
    int getSeconds() const { return get()->tm_sec; }           //!< seconds after the minute [0-59]
    int getMinutes() const { return get()->tm_min; }           //!< minutes after the hour   [0-59]
    int getHour()    const { return get()->tm_hour; }          //!< hours   after midnight   [0-23]
    int getDay()     const { return get()->tm_mday; }          //!< day   of the month       [1-31]
    int getMonth()   const { return get()->tm_mon  +    1; }   //!< month of the year        [1-12]
    int getYear()    const { return get()->tm_year + 1900; }   //!< year a.d.
    int getDST()     const { return get()->tm_isdst; }         //!< daylight saving time
 
    float getFS()    const { return fs; }                      //!< fraction of second
 
 
    /**
     * Get minimum date and time.
     *
     * \param  utc      UTC
     * \return          value
     */
    static JDateAndTime min(const bool utc = false)
    {
      return JDateAndTime(0, utc);
    }
 
 
    /**
     * Get maximum date and time.
     *
     * \param  utc      UTC
     * \return          value
     */
    static JDateAndTime max(const bool utc = false)
    {
      return JDateAndTime(std::numeric_limits<time_t>::max(), utc);
    }
 
 
    /**
     * Type conversion operator.
     *
     * \return          ASCII formatted date and time
     */
    operator std::string() const
    {
      return this->toString();
    }
 
    
    /**
     * Function to check ISO-8601 conformity.
     *
     * \param  buffer   date and time
     * \return          true if date and time are ISO-8601 conform; else false
     */
    inline static bool isISO8601(const std::string& buffer)
    {
      using namespace std;
 
      try {
 
        JDateAndTime t1(buffer);
 
        return true;
      }
      catch(const std::exception& error) {
        return false;
      }
    }
    
 
    /**
     * Get ASCII formatted date and time.
     *
     * \return          ASCII formatted date and time
     */
    inline std::string toString() const
    {
      using namespace std;
      
      static const size_t     MAX_SIZE = 256;
      static char      buffer[MAX_SIZE];
 
      const size_t pos = strftime(buffer, MAX_SIZE, (isUTC() ? "%FT%TZ" : "%FT%T%z"), this->get());
 
      return string(buffer, pos);
    }
 
 
    /**
     * Set date and time.
     *
     * \param  utc      UTC
     * \return          date and time
     */
    inline const JDateAndTime& operator()(const bool utc = false)
    {
      set(utc);
 
      return *this;
    }
 
 
    /**
     * Set to current local time.
     *
     * \param  utc      UTC
     */
    void set(const bool utc = false)
    {
      time_t tx;
 
      time(&tx);
 
      set(tx, utc);
    }
 
 
    /**
     * Set to given time.
     *
     * \param  t1       time [s]
     * \param  utc      UTC
     */
    void set(const time_t t1, const bool utc = false)
    {
      this->ts  = t1;
      this->utc = utc;
    }
 
 
    /**
     * Set to given time.
     *
     * \param  t1       time [s]
     * \param  f1       fraction of seconds
     * \param  utc      UTC
     */
    void set(const time_t t1, const float f1, const bool utc = false)
    {
      this->ts  = t1;
      this->fs  = f1;
      this->utc = utc;
    }
 
 
    /**
     * Add given time.
     *
     * \param  t1       time [s]
     */
    void add(const time_t t1)
    {
      set(this->ts + t1, this->utc);
    }
 
 
    /**
     * Subtract given time.
     *
     * \param  t1       time [s]
     */
    void sub(const time_t t1)
    {
      set(this->ts - t1, this->utc);
    }
 
 
    /**
     * Get elapsed time to given date and time.
     *
     * \param  object   date and time
     * \return          time [s]
     */
    double getElapsedTime(const JDateAndTime& object) const
    {
      return difftime(object.ts, this->ts) + (object.fs - this->fs);
    }
 
 
    /**
     * Read date and time from input stream.
     *
     * \param  in             input stream
     * \param  object         date and time
     * \return                input stream
     */
    friend inline std::istream& operator>>(std::istream& in, JDateAndTime& object)
    {
      using namespace std;
 
      const size_t LENGTH = 10;                                     // date may contain '-' and/or be followed by ' '
 
      string buffer;
 
      for (int c; (c = in.peek()) != EOF && isspace((char) in.peek()); ) {
        in.ignore(1);
      }
 
      for (int c; (c = in.get()) != EOF && (c != ' ' || buffer.length() == LENGTH); ) {
        buffer.push_back((char) c);
      }
 
      if (in.bad()) {
        THROW(JIOException, "");
      }
 
      // separation of date and time from optional time zone
 
      size_t pos = string::npos;
 
      if (pos == string::npos) { pos = buffer.find('Z', LENGTH); }  // UTC
      if (pos == string::npos) { pos = buffer.find('+', LENGTH); }  // optional time zone
      if (pos == string::npos) { pos = buffer.find('-', LENGTH); }  // optional time zone
 
      tm     tx;
      object.fs = 0;                                                // fraction of seconds
      int    nd = 0;
 
      const string td = buffer.substr(0, pos);
      const char*  pd = NULL;
 
      switch (td.length()) {
 
      case 29:
      case 28:
      case 27:
      case 26:
      case 25:
      case 24:
      case 23:
      case 22:
      case 21:
        pd = strptime(td.c_str(), "%Y-%m-%d %H:%M:%S",  &tx);  sscanf(pd, "%f%n", &object.fs, &nd);  pd += nd;
        break;
 
      case 19:
        pd = strptime(td.c_str(), "%Y-%m-%dT%H:%M:%S",  &tx);
        break;
 
      case 15:
        pd = strptime(td.c_str(), "%Y%m%dT%H%M%s",      &tx);
        break;
      
      case 10:
        pd = strptime(td.c_str(), "%Y-%m-%d",           &tx);
        break;
      }
 
      if (pd == NULL || *pd != '\0') {
        THROW(JParseError, "invalid input <" << buffer << ">");
      }
 
      tm    ty;
 
      ty.tm_hour = 0;
      ty.tm_min  = 0;
 
      if (pos != string::npos && (buffer[pos] == '+' || 
                                  buffer[pos] == '-')) {
 
        const string tz = buffer.substr(pos + 1);
        const char*  pz = tz.c_str();
 
        switch (tz.length()) {
 
        case 2:
          pz = strptime(tz.c_str(), "%H",                 &ty);
          break;
 
        case 4:
          pz = strptime(tz.c_str(), "%H%M",               &ty);
          break;
            
        case 5:
          pz = strptime(tz.c_str(), "%H:%M",              &ty);
          break;
        }
 
        if (pz == NULL || *pz != '\0') {
          THROW(JParseError, "invalid input <" << buffer << ">");
        }
      }
 
      tx.tm_isdst = 0;                                              // switch off day light saving time
 
      time_t t1 = mktime(&tx);
 
      t1  -=  (ty.tm_hour * 60 + ty.tm_min) * 60;                   // correct time zone
      t1  +=  mktime(localtime(&t1)) - mktime(gmtime(&t1));         // 
 
      object.set(t1, buffer[pos] == 'Z');
      
      return in;
    }
 
 
    /**
     * Write date and time to output stream.
     *
     * \param  out            output stream
     * \param  object         date and time
     * \return                output stream
     */
    friend inline std::ostream& operator<<(std::ostream& out, const JDateAndTime& object)
    {
      return out << object.toString();
    }
 
 
  private:
 
    /**
     * Get representation.
     */
    tm* get() const
    {
      return (this->tp  = (utc ? gmtime(&ts) : localtime(&ts)));
    }
 
    time_t      ts;                   //!< value
    float       fs  = 0.0;            //!< fraction of second
    mutable tm* tp;                   //!< representation
    bool        utc = false;          //!< UTC
  };
 
 
  /**
   * Function object to get current date and time.
   */
  static JDateAndTime getDateAndTime;
}
 
#endif