DateTime.cpp

Go to the documentation of this file.

#include <dcl/Config.h>
 
#if __DCL_WINDOWS
    #include <windows.h>    // GetSystemTime
    #include <sys/timeb.h>  // _ftime_s
    #include <time.h>       // _get_timezone
#else
    #include <sys/time.h>   // gettimeofday
    #include <time.h>       // localtime_r
#endif
 
#include <string.h>         // memset
#include <wchar.h>          // wcsftime
 
#include <dcl/DateTime.h>
 
#if __DCL_HAVE_ALLOC_DEBUG
#undef __DCL_ALLOC_LEVEL
#define __DCL_ALLOC_LEVEL   __DCL_ALLOC_INTERNAL
#endif
 
#if __DCL_DEBUG
#undef __THIS_FILE__
static const char_t __THIS_FILE__[] = __T("dcl/DateTime.cpp");
#endif
 
__DCL_BEGIN_NAMESPACE
 
Date::Date()
{
    m_nJDay = 0;
}
 
Date::Date(const Date& src)
{
    m_nJDay = src.m_nJDay;
}
 
Date::Date(int nYear, int nMonth, int nDay)
{
    assign(nYear, nMonth, nDay);
}
 
Date::Date(long nDays)
{
    assign(nDays);
}
 
void Date::assign(int nYear, int nMonth, int nDay)
{
    __DCL_ASSERT(Date::isValid(nYear, nMonth, nDay));
 
    m_nJDay = convertGregorianToJulian(
            nYear,
            nMonth,
            nDay
            );
}
 
#define AD_START    220866926           // 0001-01-01
#define BC_END      (AD_START - 367)    // -0001-01-31
 
void Date::assign(long nDays)
{
    if (nDays < 0)
        m_nJDay = nDays + BC_END + 1;
    else if (nDays > 0)
        m_nJDay = nDays + AD_START - 1;
    else
        // set NULL date
        m_nJDay = nDays;
}
 
long Date::days() const
{
    if (m_nJDay <= BC_END)
        return m_nJDay - BC_END - 1;
    else if (m_nJDay >= AD_START)
        return m_nJDay - AD_START + 1;
    else {
        __DCL_ASSERT(m_nJDay == 0);
        return m_nJDay;
    }
}
 
const Date& Date::operator ++ ()
{
    __DCL_ASSERT(m_nJDay != 0);
 
    if (m_nJDay == BC_END)
        m_nJDay = AD_START;
    else
        m_nJDay++;
 
    return *this;
}
 
const Date Date::operator ++ (int)
{
    __DCL_ASSERT(m_nJDay != 0);
 
    Date dSave = m_nJDay;
 
    if (m_nJDay == BC_END)
        m_nJDay = AD_START;
    else
        m_nJDay++;
 
    return dSave;
}
 
const Date& Date::operator -- ()
{
    __DCL_ASSERT(m_nJDay != 0);
 
    if (m_nJDay == AD_START)
        m_nJDay = BC_END;
    else
        m_nJDay--;
 
    return *this;
}
 
const Date Date::operator -- (int)
{
    __DCL_ASSERT(m_nJDay != 0);
 
    Date dSave = m_nJDay;
 
    if (m_nJDay == AD_START)
        m_nJDay = BC_END;
    else
        m_nJDay--;
 
    return dSave;
}
 
const Date& Date::operator = (const Date& src)
{
    m_nJDay = src.m_nJDay;
    return *this;
}
 
const Date& Date::operator += (long nDays)
{
    __DCL_ASSERT(m_nJDay != 0);
 
    if (m_nJDay <= BC_END) {
        m_nJDay += nDays - BC_END;
 
        if (m_nJDay <= 0)
            m_nJDay += BC_END;
        else
            m_nJDay += AD_START - 1;
    }
    else {
        __DCL_ASSERT(m_nJDay >= AD_START);
        
        m_nJDay += nDays - AD_START;
 
        if (m_nJDay >= 0)
            m_nJDay += AD_START;
        else
            m_nJDay += BC_END + 1;
    }
 
 
    return *this;
}
 
const Date& Date::operator -= (long nDays)
{
    __DCL_ASSERT(m_nJDay != 0);
 
    return operator += (-nDays);
}
 
DCLCAPI Date operator + (const Date& d, long nDays)
{
    Date result = d;
    result += nDays;
    return result;
}
 
void Date::decode(int& nYear, int& nMonth, int& nDay) const
{
    convertJulianToGregorian(m_nJDay, nYear, nMonth, nDay);
}
 
int Date::year() const
{
    int nYear, nMonth, nDay;
    convertJulianToGregorian(m_nJDay, nYear, nMonth, nDay);
    return nYear;
}
 
int Date::month() const
{
    int nYear, nMonth, nDay;
    convertJulianToGregorian(m_nJDay, nYear, nMonth, nDay);
    return nMonth;
}
 
int Date::day() const
{
    int nYear, nMonth, nDay;
    convertJulianToGregorian(m_nJDay, nYear, nMonth, nDay);
    return nDay;
}
 
int Date::dayOfWeek() const
{
    return (((m_nJDay + 1) % 7) + 7) % 7 + 1;
}
 
int Date::dayOfYear() const
{
    return m_nJDay - convertGregorianToJulian(year(), 1, 1) + 1;
}
 
static const int monthDays[] = 
{
//      1   2   3   4   5   6   7   8   9  10  11  12
    0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31
};
 
int Date::daysInMonth() const
{
    int nYear, nMonth, nDay;
    convertJulianToGregorian(m_nJDay, nYear, nMonth, nDay);
    if (nMonth == 2 && isLeapYear(nYear))
        return 29;
 
    return monthDays[nMonth];
}
 
int Date::daysInYear() const
{
    int nYear, nMonth, nDay;
    convertJulianToGregorian(m_nJDay, nYear, nMonth, nDay);
 
    if (isLeapYear(nYear))
        return 366;
    return 365;
}
 
String Date::toString() const
{
    int nYear, nMonth, nDay;
    decode(nYear, nMonth, nDay);
    return String::format(L"%04d-%02d-%02d", nYear, nMonth, nDay);
}
 
const wchar_t* Date::FORMAT_STRING = L"%Y-%m-%d";
 
String Date::toStringF(const wchar_t* pszFormat) const
{
    if (!pszFormat)
        pszFormat = FORMAT_STRING;
 
    __DCL_ASSERT(*pszFormat != L'\0');
 
    int nYear, nMonth, nDay;
    decode(nYear, nMonth, nDay);
 
    struct tm t;
    memset(&t, 0, sizeof(struct tm));
    t.tm_year = nYear - 1900;
    t.tm_mon = nMonth - 1;
    t.tm_mday = nDay;
    t.tm_isdst = -1;
 
    CharBuffer* buf = CharBuffer::create(DATETIME_FORMAT_BUFFER_SIZE);
    size_t n = wcsftime(buf->data(), DATETIME_FORMAT_BUFFER_SIZE, pszFormat, &t);
    __DCL_ASSERT(buf->__allocLength >= n);
    buf->__dataLength = n;
 
    String r = buf;
    buf->release();
    return r;
}
 
// 알고리즘 출처
// Communications of the ACM, Vol 6, No 8.
long Date::convertGregorianToJulian(
        int y, int m, int d
        )
{
    if (y == 0) {
        __DCL_ASSERT(m == 0 && d == 0);
        return 0;
    }
 
    y += 600000;
 
    int c, ya;
    if (m > 2)
         m -= 3;
    else {
        m += 9;
        y--;
    }
    c = y / 100;
    ya = y - 100 * c;
 
    return (146097 * c) / 4
            + (1461 * ya) / 4
            + (153 * m + 2) / 5
            + d
            + 1721119;
}
 
void Date::convertJulianToGregorian(
        long j,
        int& y, int& m, int& d
        )
{
    if (j == 0) {
        y = 0;
        m = 0;
        d = 0;
    }
    else {
        j -= 1721119;
 
        y = (4 * j - 1) / 146097;
        j = 4 * j - 1 - 146097 * y;
        d = j / 4;
 
        j = (4 * d + 3) / 1461;
        d = 4 * d + 3 - 1461 * j;
        d = (d + 4) / 4;
 
        m = (5 * d - 3) / 153;
        d = 5 * d - 3 - 153 * m;
        d = (d + 5 ) / 5;
 
        y = 100 * y + j;
        if (m < 10)
            m += 3;
        else {
            m -= 9;
            y++;
        }
 
        y -= 600000;
    }
}
 
bool Date::isValid(int y, int m, int d)
{
    if (y == 0) {
        // null date
        if (m == 0 && d == 0)
            return true;
    }
    else {
        if ((-9999 <= y && y <= 9999) &&
                (0 < m && m <= 12)
                && (0 < d)) {
            if (m == 2 && d == 29)
                return Date::isLeapYear(y);
            else
                return d <= monthDays[m];
        }
    }
    return false;
}
 
bool Date::isLeapYear(int y)
{
    return (y % 4 == 0 && y % 100 != 0) || y % 400 == 0;
}
 

 
Time::Time()
{
    m_uMilliSeconds = 0;
}
 
 
Time::Time(const Time& src)
{
    m_uMilliSeconds = src.m_uMilliSeconds;
}
 
#define SEC_PER_DAY     86400
#define MSEC_PER_DAY    86400000
#define SEC_PER_HOUR    3600
#define MSEC_PER_HOUR   3600000
#define SEC_PER_MIN     60
#define MSEC_PER_MIN    60000
 
Time::Time(int nHour, int nMin, int nSec, int nMSec /* = 0 */)
{
    assign(nHour, nMin, nSec, nMSec);
}
 
Time::Time(long nTotalMSecs)
{
    assign(nTotalMSecs);
}
 
void Time::assign(int nHour, int nMin, int nSec, int nMSec /* = 0 */)
{
    long ms = nHour * MSEC_PER_HOUR
            + nMin * MSEC_PER_MIN
            + nSec * 1000
            + nMSec;
 
    ms %= MSEC_PER_DAY;
    ms += MSEC_PER_DAY;
    m_uMilliSeconds = ms % MSEC_PER_DAY;
}
 
void Time::assign(long nTotalMSecs)
{
    nTotalMSecs %= MSEC_PER_DAY;
    nTotalMSecs += MSEC_PER_DAY;
    m_uMilliSeconds = nTotalMSecs % MSEC_PER_DAY;
}
 
 
const Time& Time::operator = (const Time& src)
{
    m_uMilliSeconds = src.m_uMilliSeconds;
    return *this;
}
 
const Time& Time::operator += (long nMilliSeconds)
{
    long ms = m_uMilliSeconds + nMilliSeconds;
    ms %= MSEC_PER_DAY;
    ms += MSEC_PER_DAY;
    m_uMilliSeconds = ms % MSEC_PER_DAY;
 
    return *this;
}
 
const Time& Time::operator -= (long nMilliSeconds)
{
    long ms = m_uMilliSeconds - nMilliSeconds;
    ms %= MSEC_PER_DAY;
    ms += MSEC_PER_DAY;
    m_uMilliSeconds = ms % MSEC_PER_DAY;
 
    return *this;
}
 
DCLCAPI Time operator + (const Time& t, long nMilliSeconds)
{
    Time result = t;
    result += nMilliSeconds;
    return result;
}
 
void Time::decode(int& nHour, int& nMin, int& nSec, int& nMSec) const
{
    nHour = m_uMilliSeconds / MSEC_PER_HOUR;
    nMin = (m_uMilliSeconds % MSEC_PER_HOUR) / MSEC_PER_MIN;
    nSec = (m_uMilliSeconds % MSEC_PER_MIN) / 1000;
    nMSec = m_uMilliSeconds % 1000;
}
 
int Time::hour() const        // 0 ~ 23
{
    return m_uMilliSeconds / MSEC_PER_HOUR;
}
 
int Time::minute() const        // 0 ~ 59
{
    return (m_uMilliSeconds % MSEC_PER_HOUR) / MSEC_PER_MIN;
}
 
int Time::second() const        // 0 ~ 59
{
    return (m_uMilliSeconds % MSEC_PER_MIN) / 1000;
}
 
int Time::msecond() const  // 0 ~ 999
{
    return m_uMilliSeconds % 1000;
}
 
// HH:MM:SS.MS
String Time::toString() const
{
    return String::format(L"%02d:%02d:%02d.%03d",
            hour(),
            minute(),
            second(),
            msecond()
            );
}
 
const wchar_t* Time::FORMAT_STRING = L"%H:%M:%S";
 
String Time::toStringF(const wchar_t* pszFormat)
{
    if (!pszFormat)
        pszFormat = FORMAT_STRING;
 
    __DCL_ASSERT(*pszFormat != L'\0');
    
    struct tm t;
    memset(&t, 0, sizeof(struct tm));
    t.tm_hour = hour();
    t.tm_min = minute();
    t.tm_sec = second();
    t.tm_isdst = -1;
 
    CharBuffer* buf = CharBuffer::create(DATETIME_FORMAT_BUFFER_SIZE);
    size_t n = wcsftime(buf->data(), DATETIME_FORMAT_BUFFER_SIZE, pszFormat, &t);
    __DCL_ASSERT(buf->__allocLength <= n);
    buf->__dataLength = n;
 
    String r = buf;
    buf->release();
    return r;
}
 
// static members
bool Time::isValid(int nHour, int nMin, int nSec, int nMSec)
{
    return (0 <= nHour && nHour <= 23)
        && (0 <= nMin && nMin <= 59)
        && (0 <= nSec && nSec <= 59)
        && (0 <= nMSec && nMSec <= 999);
}
 

 
Interval::Interval()
{
    m_nMilliSeconds = 0;
}
 
Interval::Interval(const Interval& src)
{
    m_nMilliSeconds = src.m_nMilliSeconds;
}
 
Interval::Interval(int nDays, int nMilliSeconds)
{
    assign(nDays, nMilliSeconds);
}
 
Interval::Interval(int nDays,
        int nHours, int nMinutes, int nSeconds,
        int nMilliSeconds
        )
{
    assign(nDays, nHours, nMinutes, nSeconds, nMilliSeconds);
}
 
Interval::Interval(int64_t nTotalMilliSeconds)
{
    assign(nTotalMilliSeconds);
}
 
void Interval::assign(int nDays, int nMilliSeconds)
{
    m_nMilliSeconds = (int64_t)nDays * MSEC_PER_DAY + nMilliSeconds;
}
 
void Interval::assign(int nDays,
        int nHours, int nMinutes, int nSeconds,
        int nMilliSeconds
        )
{
    m_nMilliSeconds= (int64_t)nDays * MSEC_PER_DAY
            + (int64_t)nHours * MSEC_PER_HOUR
            + (int64_t)nMinutes * MSEC_PER_MIN
            + nSeconds * 1000
            + nMilliSeconds;
}
 
void Interval::assign(int64_t nTotalMilliSeconds)
{
    m_nMilliSeconds = nTotalMilliSeconds;
}
 
const Interval& Interval::operator = (const Interval& src)
{
    m_nMilliSeconds = src.m_nMilliSeconds;
 
    return *this;
}
 
const Interval& Interval::operator += (const Interval& iv)
{
    m_nMilliSeconds += iv.m_nMilliSeconds;
 
    return *this;
}
 
const Interval& Interval::operator -= (const Interval& iv)
{
    m_nMilliSeconds -= iv.m_nMilliSeconds;
 
    return *this;
}
 
DCLCAPI Interval operator + (const Interval& iv1, const Interval& iv2)
{
    Interval iv = iv1.totalMilliSeconds() + iv2.totalMilliSeconds();
    return iv;
}
 
DCLCAPI Interval operator - (const Interval& iv1, const Interval& iv2)
{
    Interval iv = iv1.totalMilliSeconds() - iv2.totalMilliSeconds();
    return iv;
}
 
void Interval::decode(long& nDays,
        int& nHours, int& nMinutes, int& nSeconds,
        int& nMilliSeconds
        ) const
{
    nDays = (long)(m_nMilliSeconds / MSEC_PER_DAY);
    nHours =  (int)((m_nMilliSeconds % MSEC_PER_DAY) / MSEC_PER_HOUR);
    nMinutes = (int)((m_nMilliSeconds % MSEC_PER_HOUR) / MSEC_PER_MIN);
    nSeconds = (int)((m_nMilliSeconds % MSEC_PER_MIN) / 1000);
    nMilliSeconds = (int)(m_nMilliSeconds % 1000);
}
 
void Interval::decode(long& nDays, long& nMilliSeconds)
{
    nDays = (long)(m_nMilliSeconds / MSEC_PER_DAY);
    nMilliSeconds = (long)(m_nMilliSeconds % MSEC_PER_DAY);
}
 
long Interval::days() const
{
    return (long)(m_nMilliSeconds / MSEC_PER_DAY);
}
 
int Interval::hour() const
{
    return (int)((m_nMilliSeconds % MSEC_PER_DAY) / MSEC_PER_HOUR);
}
 
int Interval::minute() const
{
    return (int)((m_nMilliSeconds % MSEC_PER_HOUR) / MSEC_PER_MIN);
}
 
int Interval::second() const
{
    return (int)((m_nMilliSeconds % MSEC_PER_MIN) / 1000);
}
 
int Interval::msecond() const
{
    return (int)(m_nMilliSeconds % 1000);
}
 
int64_t Interval::totalHours() const
{
    return m_nMilliSeconds / MSEC_PER_HOUR;
}
 
int64_t Interval::totalMinutes() const
{
    return m_nMilliSeconds / MSEC_PER_MIN;
}
 
int64_t Interval::totalSeconds() const
{
    return m_nMilliSeconds / 1000;
}
 
String Interval::toString() const
{
    long d;
    int h, m, s, ms;
    decode(d, h, m, s, ms);
    if (m_nMilliSeconds < 0) {
        return String::format(L"-%ld %02d:%02d:%02d.%03d",
                        -d,
                        -h, -m, -s, -ms
                        );
    }
    else {
        return String::format(L"+%ld %02d:%02d:%02d.%03d",
                        d,
                        h, m, s, ms
                        );
    }
}
 
// static members

DateTime::DateTime(const DateTime& src)
{
    m_date = src.m_date;
    m_time = src.m_time;
}
 
DateTime::DateTime(time_t time)
{
    assign(time);
}
 
DateTime::DateTime(const Date& date, const Time& time)
{
    m_date = date;
    m_time = time;
}
 
DateTime::DateTime(int nYear, int nMonth, int nDay,
        int nHour, int nMin, int nSec, int nMSec /* = 0 */)
{
    m_date.assign(nYear, nMonth, nDay);
    m_time.assign(nHour, nMin, nSec, nMSec);
}
 
void DateTime::assign(time_t timer)
{
    long tm_gmtoff = 0;
 
#if __DCL_WINDOWS
    long seconds;
    _get_timezone(&seconds);
    tm_gmtoff = -seconds;
#else
    struct tm tm;
    localtime_r(&timer, &tm);
    tm_gmtoff = tm.tm_gmtoff;
#endif
 
    m_date.assign(
            (long) (719163 + ((timer + tm_gmtoff) / SEC_PER_DAY))    // 1970-01-01 00:00:00 + time
            );
    m_time.assign(
            0,
            0,
            timer % SEC_PER_DAY + tm_gmtoff,
            0
            );
}
 
void DateTime::assign(const Date& date, const Time& time)
{
    m_date = date;
    m_time = time;
}
 
void DateTime::assign(int nYear, int nMonth, int nDay,
        int nHour, int nMin, int nSec, int nMSec /* = 0 */)
{
    m_date.assign(nYear, nMonth, nDay);
    m_time.assign(nHour, nMin, nSec, nMSec);
}
 
const DateTime& DateTime::operator = (const DateTime& src)
{
    m_date = src.m_date;
    m_time = src.m_time;
 
    return *this;
}
 
const DateTime& DateTime::operator += (const Interval& iv)
{
    int64_t ms = (int64_t)m_date.days() * MSEC_PER_DAY
            + (int64_t)m_time.totalMilliSeconds()
            + iv.totalMilliSeconds();
 
    m_date.assign((long)(ms / MSEC_PER_DAY));
    m_time.assign((long)(ms % MSEC_PER_DAY));
 
    return *this;
}
 
const DateTime& DateTime::operator -= (const Interval& iv)
{
    int64_t ms = (int64_t)m_date.days() * MSEC_PER_DAY
            + (int64_t)m_time.totalMilliSeconds()
            - iv.totalMilliSeconds();
 
    m_date.assign((long)(ms / MSEC_PER_DAY));
    m_time.assign((long)(ms % MSEC_PER_DAY));
 
    return *this;
}
 
DCLCAPI DateTime operator + (const DateTime& dt, const Interval& iv)
{
    DateTime dtResult = dt;
    dtResult += iv;
    return dtResult;
}
 
DCLCAPI DateTime operator + (const Interval& iv, const DateTime& dt)
{
    return operator + (dt, iv);
}
 
DCLCAPI DateTime operator - (const DateTime& dt, const Interval& iv)
{
    DateTime dtResult = dt;
    dtResult -= iv;
 
    return dtResult;
}
 
DCLCAPI Interval operator - (const DateTime& dt1, const DateTime& dt2)
{
    Interval ivResult(
        (int64_t)dt1.date().days() * MSEC_PER_DAY
        + (int64_t)dt1.time().totalMilliSeconds()
        - (int64_t)dt2.date().days() * MSEC_PER_DAY
        - (int64_t)dt2.time().totalMilliSeconds()
        );
 
    return ivResult;
}
 
// Date::toString() + Time::toString()
String DateTime::toString() const
{
    return m_date.toString() + L" " + m_time.toString();
}
 
const wchar_t* DateTime::FORMAT_STRING = L"%Y-%m-%d %H:%M:%S";
 
// strftime
String DateTime::toStringF(const wchar_t* pszFormat) const
{
    if (!pszFormat)
        pszFormat = FORMAT_STRING;
 
    __DCL_ASSERT(*pszFormat != L'\0');
 
    int nYear, nMonth, nDay, nHour, nMin, nSec, nMSec;
    m_date.decode(nYear, nMonth, nDay);
    m_time.decode(nHour, nMin, nSec, nMSec);
 
    struct tm t;
    t.tm_year = nYear - 1900;
    t.tm_mon = nMonth - 1;
    t.tm_mday = nDay;
    t.tm_hour = nHour;
    t.tm_min = nMin;
    t.tm_sec = nSec;
 
    t.tm_wday = 0;
    t.tm_yday = 0;
    t.tm_isdst = -1;
 
    CharBuffer* buf = CharBuffer::create(DATETIME_FORMAT_BUFFER_SIZE);
    size_t n = wcsftime(buf->data(), DATETIME_FORMAT_BUFFER_SIZE, pszFormat, &t);
    __DCL_ASSERT(buf->__allocLength >= n);
    buf->__dataLength = n;
    __DCL_ASSERT(buf->data()[buf->__dataLength] == __T('\0'));
 
    String r = buf;
    buf->release();
    return r;
}
 
// static members
int DateTime::compare(const DateTime& dt1, const DateTime& dt2)
{
    if (dt1.m_date < dt2.m_date)
        return -1;
    else if (dt1.m_date == dt2.m_date) {
        if (dt1.m_time < dt2.m_time)
            return -1;
        else if (dt1.m_time == dt2.m_time)
            return 0;
    }
    return 1;
}
 
int64_t DateTime::getCurrentTimeMillis()
{
#if __DCL_WINDOWS
    SYSTEMTIME t;
    GetSystemTime(&t);
 
    Date dt(t.wYear, t.wMonth, t.wDay);
    int64_t r = dt.days() * 24;
    r = (r + t.wHour) * 60;
    r = (r + t.wMinute) * 60;
    r = (r + t.wSecond) * 1000;
    r += t.wMilliseconds;
    return r;
#else
    struct timeval tv;
    gettimeofday(&tv, NULL);
    int64_t r = tv.tv_sec * 1000;
    r += tv.tv_usec / 1000;
    return r;
#endif
}
 
DateTime DateTime::getCurrentUTCTime()
{
    DateTime dt;
#if __DCL_WINDOWS
    struct _timeb t;
    _ftime_s(&t);
 
    dt.m_date.assign(
            (long) (719163 + (t.time / SEC_PER_DAY)) // 1970-01-01 00:00:00 + time
            );
    dt.m_time.assign(
            0,
            0,
            t.time % SEC_PER_DAY,
            t.millitm
            );
#else
    struct timeval tv;
    gettimeofday(&tv, NULL);
 
    dt.m_date.assign(
            719163 + tv.tv_sec / SEC_PER_DAY // 1970-01-01 00:00:00 + time
            );
    dt.m_time.assign(
            0,
            0,
            tv.tv_sec % SEC_PER_DAY,
            tv.tv_usec / 1000
            );
#endif
    return dt;
}
 
DateTime DateTime::getCurrentLocalTime()
{
    DateTime dt;
#if __DCL_WINDOWS
    struct _timeb t;
    _ftime_s(&t);
 
    dt.m_date.assign(
            (long) (719163 + ((t.time - t.timezone * 60) / SEC_PER_DAY)) // 1970-01-01 00:00:00 + time
            );
    dt.m_time.assign(
            0,
            -t.timezone,
            t.time % SEC_PER_DAY,
            t.millitm
            );
#else
    time_t timer;
    struct tm tm;
    ::time(&timer);
    localtime_r(&timer, &tm);
 
    struct timeval tv;
    gettimeofday(&tv, NULL);
 
    dt.m_date.assign(
            719163 + (tv.tv_sec + tm.tm_gmtoff) / SEC_PER_DAY    // 1970-01-01 00:00:00 + time
            );
    dt.m_time.assign(
            0,
            0,
            tv.tv_sec % SEC_PER_DAY + tm.tm_gmtoff,
            tv.tv_usec / 1000
            );
#endif
    return dt;
}
 
#if 0
DateTime DateTime::parseF(
        const char* pszDateTimeString,
        const char* pszFormat
        ) __DCL_THROWS1(ParseException*)
{
    __DCL_ASSERT(pszDateTimeString != NULL && *pszDateTimeString != '\0');
    __DCL_ASSERT(pszFormat != NULL && *pszFormat != '\0');
 
    struct tm tm;
    memset(&tm, 0, sizeof(tm));
    const char* p = strptime(pszDateTimeString, pszFormat, &tm);
    if (p == NULL) {
        throw new ParseException(L"no match to format");
    }
    
    if (*p != '\0') {
        throw new ParseException(
            L"extra data",
            p - pszDateTimeString
            );
 
    }
 
    DateTime dt(
            tm.tm_year + 1900,
            tm.tm_mon + 1,
            tm.tm_mday,
            tm.tm_hour,
            tm.tm_min,
            tm.tm_sec
            );
 
    return dt;
}
#endif
 
__DCL_END_NAMESPACE