datetime.h

Go to the documentation of this file.

/**********************************************************//**
 **
 ** @file base/datetime.h
 **
 ** Copyright (C) 2012  Xpace, LLC.  All rights reserved
 **
 ** www.xpace.net
 **
 **************************************************************/

#ifndef XPACE_DATETIME_H
#define XPACE_DATETIME_H

#include "base/types.h"

namespace Xpace
{
  class XPACE_EXPORT DateTime;

  // ================================ DATE ====================
 
  class XPACE_EXPORT Date
  {
  public:
    Date
      ();

    /// @param year the year [-4194304..4194303]
    /// @param month the month [1..12]
    /// @param day the day [1..31]
    Date
      (int year,
       uint month,
       uint day);

    /// @param the date in string form  
    /// @param format the format of the date e.g. "yyyy-MM-dd"
    Date
      (const String& str,
       const String& format);

    /// @param year the year [-4194304..4194303]
    /// @param month the month [1..12]
    /// @param day the day [1..31]
    void set
      (int year,
       uint month,
       uint day);

    int32 toInt
      ()
      const
    {
      return val;
    }

    Date
      (int32 v) :
        val(v)
    {
    }

    int getYear
      ()
      const;
    uint getMonth
      ()
      const;
    uint getDay
      ()
      const;

    /// @param date in syyyymmdd format
    void setYMD
      (int ymd);

    /// @return date in syyyymmdd format
    int getYMD
      ()
      const;

    enum { maxLength = 14 };
    /// @param sep if true, leave space for separators among yyyy mm dd
    ///   NB buffer's length is NOT checked 
    /// @retval buf the buffer into which to store the date (and its length)
    void toString
      (String16* buf,
       bool sep = false)          
      const;

    /// @param format the format of the date e.g. "yyyy-MM-dd"
    String toString
      (const String& format)
      const;

    /// increment date
    ///@ param days increment by this many days
    Date& operator+=
      (int days);

  private:
    friend class DateTime;
    int32 val;
  };

  // ================================ TIME ====================

  class XPACE_EXPORT Time
  {
    friend class DateTime;
  public:
    Time
      ();

    /// @param hour the hour [0..23]
    /// @param minute the minute [0..59]
    /// @param second the second [0..60]
    /// @param precision 0 = seconds, 1 = tenths, 2 = hundredths, 3 = milliseconds
    /// @param fraction number of tenths, hundredths, milliseconds
    Time
      (uint hour,
       uint minute,
       uint second,
       uint precision = 0,
       uint fraction = 0);

    /// @param the time in hhmmssfff format
    /// @param precision 0 = seconds, 1 = tenths, 2 = hundredths, 3 = milliseconds
    Time
      (uint hmsf,
       uint precision = 0);

    /// @param the time in string form  
    /// @param format the format of the time e.g. "hh:mm:ss"
    Time
      (const String& str,
       const String& format);

    /// @param hour the hour (0..23)
    /// @param minute the minute (0..59)
    /// @param second the second (0..60)
    /// @param precision 0 = seconds, 1 = tenths, 2 = hundredths, 3 = milliseconds
    /// @param fraction number of tenths, hundredths, millisecondseconds
    void set
      (uint hour,
       uint minute,
       uint second,
       uint precision = 0,
       uint fraction = 0);

    void setHMSF
      (uint hmsf, 
       uint precision = 0);

    uint getHour
      ()
      const;
    uint getMinute
      ()
      const;
    uint getSecond
      ()
      const;
    uint getPrecision
      ()
      const;
    uint getFraction
      ()
      const;
    uint getMillisecond
      ()
      const;

    /// @param precision force this precision 
    /// @return time in hhmmssfff format
    uint getHMSF
      (uint precision = 0)
      const;

    /// @param use this precision
    /// @return seconds * 10^precision + fraction
    uint toUint
      (uint precision = 0)
      const;
    /// @param val seconds + 10^precision + fraction
    /// @param precision force this precision
    static 
    Time fromUint
      (uint val,
       uint precision = 0);

    enum { maxLength = 18 };
    /// @param precision force this precision; if ~0, use internal precision
    /// @retval buf the buffer into which to store the time (and its length)
    void toString
      (String16* buf,
       uint precision = ~0,
       bool sep = false,           // if true, leave space for separators among hh mm ss
       bool dec = false)           // if true, leave space for decimal
      const;

    /// @param format the format of the time e.g. "hh:mm:ss"
    String toString
      (const String& format)
      const;

    /// increment/decrement the time
    /// @param increment the time by this many units
    ///   if precision == 0, unit = second; if precision = 1, unit = tenths; etc.
    ///   wrap on under/overflow
    Time& operator+=
      (int delta);

  private:
    uint32 val;
  };

  // ================================ DATE-TIME ===============

  class DateTime
  {
  public:
    /// @ param date the date
    /// @ param time the time
    DateTime
      (const Date& date = Date(),
       const Time& time = Time());
    /// @param the date-time in string form  
    /// @param format the format of the date-time e.g. "yyyy-MM-dd hh:mm:ss"
    DateTime
      (const String& str,
       const String& format);

    /// @ param date the date
    /// @ param time the time
    void set
      (const Date& date,
       const Time& time);

    Date getDate
      ()
      const;
    Time getTime
      ()
      const;

    // TODO: syyyyMMddhhmmss format

    /// @param the desired precision 0 = seconds, 1 = tenths, 2 = hundredths, 3 = milliseconds
    /// @return the date-time as an int64
    int64 toInt
      (uint precision = 0)
      const;
    
    /// set the date-time from an int64
    /// @param val the int64
    /// @param precision the desired precision
    DateTime
      (int64 val,
       uint precision = 0);

    /// increment/decrement the date-time
    /// @param increment the date-time by this many units. 
    ///   if precision == 0, unit = second; if precision = 1, unit = tenths; etc.
    DateTime& operator+=
      (int delta);

    /// @param format the format of the date-time e.g. "yyyy-MM-dd hh:mm:ss"
    String toString
      (const String& format)
      const;

    #ifdef _WINBASE_
    /// set the date-time from a SYSTEMTIME
    /// @param the SYSTEMTIME
    /// @param precision the desired precision
    DateTime
      (const SYSTEMTIME& systime,
       uint precision = 0);
    #endif

  private:
    Date date;
    Time time;
  };

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

  inline
  Date::Date
    () :
      val(~0)
  {
  }

  inline
  Time::Time
    () :
      val(~0)
  {
  }

  inline 
  Date DateTime::getDate
    ()
    const
  {
    return date;
  }

  inline 
  Time DateTime::getTime
    ()
    const
  {
    return time;
  }
}

#endif