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()
{
    __jday = 0;
}
 
Date::Date(const Date& _src)
{
    __jday = _src.__jday;
}
 
Date::Date(int _year, int _month, int _day)
{
    assign(_year, _month, _day);
}
 
Date::Date(long _days)
{
    assign(_days);
}
 
void Date::assign(int _year, int _month, int _day)
{
    __DCL_ASSERT(Date::isValid(_year, _month, _day));
 
    __jday = convertGregorianToJulian(
            _year,
            _month,
            _day
            );
}
 
#define AD_START    220866926           // 0001-01-01
#define BC_END      (AD_START - 367)    // -0001-01-31
 
void Date::assign(long _days)
{
    if (_days < 0)
        __jday = _days + BC_END + 1;
    else if (_days > 0)
        __jday = _days + AD_START - 1;
    else
        // set NULL date
        __jday = _days;
}
 
long Date::days() const
{
    if (__jday <= BC_END)
        return __jday - BC_END - 1;
    else if (__jday >= AD_START)
        return __jday - AD_START + 1;
    else {
        __DCL_ASSERT(__jday == 0);
        return __jday;
    }
}
 
const Date& Date::operator ++ ()
{
    __DCL_ASSERT(__jday != 0);
 
    if (__jday == BC_END)
        __jday = AD_START;
    else
        __jday++;
 
    return *this;
}
 
const Date Date::operator ++ (int)
{
    __DCL_ASSERT(__jday != 0);
 
    Date r = *this;
 
    if (__jday == BC_END)
        __jday = AD_START;
    else
        __jday++;
 
    return r;
}
 
const Date& Date::operator -- ()
{
    __DCL_ASSERT(__jday != 0);
 
    if (__jday == AD_START)
        __jday = BC_END;
    else
        __jday--;
 
    return *this;
}
 
const Date Date::operator -- (int)
{
    __DCL_ASSERT(__jday != 0);
 
    Date r = *this;
 
    if (__jday == AD_START)
        __jday = BC_END;
    else
        __jday--;
 
    return r;
}
 
const Date& Date::operator = (const Date& _src)
{
    __jday = _src.__jday;
    return *this;
}
 
const Date& Date::operator += (long _days)
{
    __DCL_ASSERT(__jday != 0);
 
    if (__jday <= BC_END) {
        __jday += _days - BC_END;
 
        if (__jday <= 0)
            __jday += BC_END;
        else
            __jday += AD_START - 1;
    }
    else {
        __DCL_ASSERT(__jday >= AD_START);
        
        __jday += _days - AD_START;
 
        if (__jday >= 0)
            __jday += AD_START;
        else
            __jday += BC_END + 1;
    }
 
 
    return *this;
}
 
const Date& Date::operator -= (long _days)
{
    __DCL_ASSERT(__jday != 0);
 
    return operator += (-_days);
}
 
DCLCAPI Date operator + (const Date& _date, long _days)
{
    Date r = _date;
    r += _days;
    return r;
}
 
void Date::decode(int& _year, int& _month, int& _day) const
{
    convertJulianToGregorian(__jday, _year, _month, _day);
}
 
int Date::year() const
{
    int year, month, day;
    convertJulianToGregorian(__jday, year, month, day);
    return year;
}
 
int Date::month() const
{
    int year, month, day;
    convertJulianToGregorian(__jday, year, month, day);
    return month;
}
 
int Date::day() const
{
    int year, month, day;
    convertJulianToGregorian(__jday, year, month, day);
    return day;
}
 
int Date::dayOfWeek() const
{
    return (((__jday + 1) % 7) + 7) % 7 + 1;
}
 
int Date::dayOfYear() const
{
    return __jday - 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 year, month, day;
    convertJulianToGregorian(__jday, year, month, day);
    if (month == 2 && isLeapYear(year))
        return 29;
 
    return __monthDays__[month];
}
 
int Date::daysInYear() const
{
    int year, month, day;
    convertJulianToGregorian(__jday, year, month, day);
 
    if (isLeapYear(year))
        return 366;
    return 365;
}
 
String Date::toString() const
{
    int year, month, day;
    decode(year, month, day);
    return String::format(L"%04d-%02d-%02d", year, month, day);
}
 
const wchar_t* Date::FORMAT_STRING = L"%Y-%m-%d";
 
String Date::toStringF(const wchar_t* _format) const
{
    if (!_format)
        _format = FORMAT_STRING;
 
    __DCL_ASSERT(*_format != L'\0');
 
    int year, month, day;
    decode(year, month, day);
 
    struct tm _time;
    memset(&_time, 0, sizeof(struct tm));
    _time.tm_year = year - 1900;
    _time.tm_mon = month - 1;
    _time.tm_mday = day;
    _time.tm_isdst = -1;
 
    CharBuffer* buf = CharBuffer::create(DATETIME_FORMAT_BUFFER_SIZE);
    size_t n = wcsftime(buf->data(), DATETIME_FORMAT_BUFFER_SIZE, _format, &_time);
    __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()
{
    __milliseconds = 0;
}
 
 
Time::Time(const Time& _src)
{
    __milliseconds = _src.__milliseconds;
}
 
#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 _hour, int _min, int _sec, int _millisecond /* = 0 */)
{
    assign(_hour, _min, _sec, _millisecond);
}
 
Time::Time(long _milliseconds)
{
    assign(_milliseconds);
}
 
void Time::assign(int _hour, int _min, int _sec, int _millisecond /* = 0 */)
{
    long msec = _hour * MSEC_PER_HOUR
            + _min * MSEC_PER_MIN
            + _sec * 1000
            + _millisecond;
 
    msec %= MSEC_PER_DAY;
    msec += MSEC_PER_DAY;
    __milliseconds = msec % MSEC_PER_DAY;
}
 
void Time::assign(long _milliseconds)
{
    _milliseconds %= MSEC_PER_DAY;
    _milliseconds += MSEC_PER_DAY;
    __milliseconds = _milliseconds % MSEC_PER_DAY;
}
 
 
const Time& Time::operator = (const Time& _src)
{
    __milliseconds = _src.__milliseconds;
    return *this;
}
 
const Time& Time::operator += (long _milliseconds)
{
    long msec = __milliseconds + _milliseconds;
    msec %= MSEC_PER_DAY;
    msec += MSEC_PER_DAY;
    __milliseconds = msec % MSEC_PER_DAY;
 
    return *this;
}
 
const Time& Time::operator -= (long _milliseconds)
{
    long msec = __milliseconds - _milliseconds;
    msec %= MSEC_PER_DAY;
    msec += MSEC_PER_DAY;
    __milliseconds = msec % MSEC_PER_DAY;
 
    return *this;
}
 
DCLCAPI Time operator + (const Time& _time, long _milliseconds)
{
    Time result = _time;
    result += _milliseconds;
    return result;
}
 
void Time::decode(int& _hour, int& _min, int& _sec, int& _millisecond) const
{
    _hour = __milliseconds / MSEC_PER_HOUR;
    _min = (__milliseconds % MSEC_PER_HOUR) / MSEC_PER_MIN;
    _sec = (__milliseconds % MSEC_PER_MIN) / 1000;
    _millisecond = __milliseconds % 1000;
}
 
int Time::hour() const        // 0 ~ 23
{
    return __milliseconds / MSEC_PER_HOUR;
}
 
int Time::minute() const        // 0 ~ 59
{
    return (__milliseconds % MSEC_PER_HOUR) / MSEC_PER_MIN;
}
 
int Time::second() const        // 0 ~ 59
{
    return (__milliseconds % MSEC_PER_MIN) / 1000;
}
 
int Time::msecond() const  // 0 ~ 999
{
    return __milliseconds % 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* _format)
{
    if (!_format)
        _format = FORMAT_STRING;
 
    __DCL_ASSERT(*_format != L'\0');
    
    struct tm _time;
    memset(&_time, 0, sizeof(struct tm));
    _time.tm_hour = hour();
    _time.tm_min = minute();
    _time.tm_sec = second();
    _time.tm_isdst = -1;
 
    CharBuffer* buf = CharBuffer::create(DATETIME_FORMAT_BUFFER_SIZE);
    size_t n = wcsftime(buf->data(), DATETIME_FORMAT_BUFFER_SIZE, _format, &_time);
    __DCL_ASSERT(buf->__allocLength <= n);
    buf->__dataLength = n;
 
    String r = buf;
    buf->release();
    return r;
}
 
// static members
bool Time::isValid(int _hour, int _min, int _sec, int _millisecond)
{
    return (0 <= _hour && _hour <= 23)
        && (0 <= _min && _min <= 59)
        && (0 <= _sec && _sec <= 59)
        && (0 <= _millisecond && _millisecond <= 999);
}
 

 
Interval::Interval()
{
    __milliseconds = 0;
}
 
Interval::Interval(const Interval& _src)
{
    __milliseconds = _src.__milliseconds;
}
 
Interval::Interval(int _days, int _milliseconds)
{
    assign(_days, _milliseconds);
}
 
Interval::Interval(int _days,
        int _hours, int _minutes, int _seconds,
        int _milliseconds
        )
{
    assign(_days, _hours, _minutes, _seconds, _milliseconds);
}
 
Interval::Interval(int64_t _milliseconds)
{
    assign(_milliseconds);
}
 
void Interval::assign(int _days, int _milliseconds)
{
    __milliseconds = (int64_t)_days * MSEC_PER_DAY + _milliseconds;
}
 
void Interval::assign(int _days,
        int _hours, int _minutes, int _seconds,
        int _milliseconds
        )
{
    __milliseconds= (int64_t)_days * MSEC_PER_DAY
            + (int64_t)_hours * MSEC_PER_HOUR
            + (int64_t)_minutes * MSEC_PER_MIN
            + _seconds * 1000
            + _milliseconds;
}
 
void Interval::assign(int64_t _milliseconds)
{
    __milliseconds = _milliseconds;
}
 
const Interval& Interval::operator = (const Interval& _src)
{
    __milliseconds = _src.__milliseconds;
 
    return *this;
}
 
const Interval& Interval::operator += (const Interval& _iv)
{
    __milliseconds += _iv.__milliseconds;
 
    return *this;
}
 
const Interval& Interval::operator -= (const Interval& _iv)
{
    __milliseconds -= _iv.__milliseconds;
 
    return *this;
}
 
DCLCAPI Interval operator + (const Interval& _iv1, const Interval& _iv2)
{
    Interval r = _iv1.totalMilliSeconds() + _iv2.totalMilliSeconds();
    return r;
}
 
DCLCAPI Interval operator - (const Interval& _iv1, const Interval& _iv2)
{
    Interval r = _iv1.totalMilliSeconds() - _iv2.totalMilliSeconds();
    return r;
}
 
void Interval::decode(long& _days,
        int& _hours, int& _minutes, int& _seconds,
        int& _milliseconds
    ) const
{
    _days = (long)(__milliseconds / MSEC_PER_DAY);
    _hours =  (int)((__milliseconds % MSEC_PER_DAY) / MSEC_PER_HOUR);
    _minutes = (int)((__milliseconds % MSEC_PER_HOUR) / MSEC_PER_MIN);
    _seconds = (int)((__milliseconds % MSEC_PER_MIN) / 1000);
    _milliseconds = (int)(__milliseconds % 1000);
}
 
void Interval::decode(long& _days, long& _milliseconds) const
{
    _days = (long)(__milliseconds / MSEC_PER_DAY);
    _milliseconds = (long)(__milliseconds % MSEC_PER_DAY);
}
 
long Interval::days() const
{
    return (long)(__milliseconds / MSEC_PER_DAY);
}
 
int Interval::hour() const
{
    return (int)((__milliseconds % MSEC_PER_DAY) / MSEC_PER_HOUR);
}
 
int Interval::minute() const
{
    return (int)((__milliseconds % MSEC_PER_HOUR) / MSEC_PER_MIN);
}
 
int Interval::second() const
{
    return (int)((__milliseconds % MSEC_PER_MIN) / 1000);
}
 
int Interval::msecond() const
{
    return (int)(__milliseconds % 1000);
}
 
int64_t Interval::totalHours() const
{
    return __milliseconds / MSEC_PER_HOUR;
}
 
int64_t Interval::totalMinutes() const
{
    return __milliseconds / MSEC_PER_MIN;
}
 
int64_t Interval::totalSeconds() const
{
    return __milliseconds / 1000;
}
 
String Interval::toString() const
{
    long d;
    int h, m, s, msec;
    decode(d, h, m, s, msec);
    if (__milliseconds < 0) {
        return String::format(L"-%ld %02d:%02d:%02d.%03d",
                    -d,
                    -h, -m, -s, -msec
                    );
    }
    else {
        return String::format(L"+%ld %02d:%02d:%02d.%03d",
                    d,
                    h, m, s, msec
                    );
    }
}
 
// static members

DateTime::DateTime(const DateTime& _src)
{
    __date = _src.__date;
    __time = _src.__time;
}
 
DateTime::DateTime(time_t _timer)
{
    assign(_timer);
}
 
DateTime::DateTime(const Date& _date, const Time& _time)
{
    __date = _date;
    __time = _time;
}
 
DateTime::DateTime(int _year, int _month, int _day,
        int _hour, int _min, int _sec, int _millisecond /* = 0 */)
{
    __date.assign(_year, _month, _day);
    __time.assign(_hour, _min, _sec, _millisecond);
}
 
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
 
    __date.assign(
        (long) (719163 + ((_timer + tm_gmtoff) / SEC_PER_DAY))   // 1970-01-01 00:00:00 + time
        );
    __time.assign(
        0,
        0,
        _timer % SEC_PER_DAY + tm_gmtoff,
        0
        );
}
 
void DateTime::assign(const Date& _date, const Time& _time)
{
    __date = _date;
    __time = _time;
}
 
void DateTime::assign(int _year, int _month, int _day,
        int _hour, int _min, int _sec, int _millisecond /* = 0 */)
{
    __date.assign(_year, _month, _day);
    __time.assign(_hour, _min, _sec, _millisecond);
}
 
const DateTime& DateTime::operator = (const DateTime& _src)
{
    __date = _src.__date;
    __time = _src.__time;
 
    return *this;
}
 
const DateTime& DateTime::operator += (const Interval& _iv)
{
    int64_t msec = (int64_t)__date.days() * MSEC_PER_DAY
            + (int64_t)__time.totalMilliSeconds()
            + _iv.totalMilliSeconds();
 
    __date.assign((long)(msec / MSEC_PER_DAY));
    __time.assign((long)(msec % MSEC_PER_DAY));
 
    return *this;
}
 
const DateTime& DateTime::operator -= (const Interval& _iv)
{
    int64_t msec = (int64_t)__date.days() * MSEC_PER_DAY
            + (int64_t)__time.totalMilliSeconds()
            - _iv.totalMilliSeconds();
 
    __date.assign((long)(msec / MSEC_PER_DAY));
    __time.assign((long)(msec % MSEC_PER_DAY));
 
    return *this;
}
 
DCLCAPI DateTime operator + (const DateTime& _dt, const Interval& _iv)
{
    DateTime r = _dt;
    r += _iv;
    return r;
}
 
DCLCAPI DateTime operator + (const Interval& _iv, const DateTime& _dt)
{
    return operator + (_dt, _iv);
}
 
DCLCAPI DateTime operator - (const DateTime& _dt, const Interval& _iv)
{
    DateTime r = _dt;
    r -= _iv;
 
    return r;
}
 
DCLCAPI Interval operator - (const DateTime& _dt1, const DateTime& _dt2)
{
    Interval r(
        (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 r;
}
 
// Date::toString() + Time::toString()
String DateTime::toString() const
{
    return __date.toString() + L" " + __time.toString();
}
 
const wchar_t* DateTime::FORMAT_STRING = L"%Y-%m-%d %H:%M:%S";
 
// strftime
String DateTime::toStringF(const wchar_t* _format) const
{
    if (!_format)
        _format = FORMAT_STRING;
 
    __DCL_ASSERT(*_format != L'\0');
 
    int year, month, day, hour, min, sec, msec;
    __date.decode(year, month, day);
    __time.decode(hour, min, sec, msec);
 
    struct tm time;
    time.tm_year = year - 1900;
    time.tm_mon = month - 1;
    time.tm_mday = day;
    time.tm_hour = hour;
    time.tm_min = min;
    time.tm_sec = sec;
 
    time.tm_wday = 0;
    time.tm_yday = 0;
    time.tm_isdst = -1;
 
    CharBuffer* buf = CharBuffer::create(DATETIME_FORMAT_BUFFER_SIZE);
    size_t n = wcsftime(buf->data(), DATETIME_FORMAT_BUFFER_SIZE, _format, &time);
    __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.__date < _dt2.__date)
        return -1;
    else if (_dt1.__date == _dt2.__date) {
        if (_dt1.__time < _dt2.__time)
            return -1;
        else if (_dt1.__time == _dt2.__time)
            return 0;
    }
    return 1;
}
 
int64_t DateTime::getCurrentTimeMillis()
{
#if __DCL_WINDOWS
    SYSTEMTIME time;
    GetSystemTime(&time);
 
    Date dt(time.wYear, time.wMonth, time.wDay);
    int64_t r = dt.days() * 24;
    r = (r + time.wHour) * 60;
    r = (r + time.wMinute) * 60;
    r = (r + time.wSecond) * 1000;
    r += time.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 r;
#if __DCL_WINDOWS
    struct _timeb timeb;
    _ftime_s(&timeb);
 
    r.__date.assign(
        (long) (719163 + (timeb.time / SEC_PER_DAY)) // 1970-01-01 00:00:00 + time
        );
    r.__time.assign(
        0,
        0,
        timeb.time % SEC_PER_DAY,
        timeb.millitm
        );
#else
    struct timeval tv;
    gettimeofday(&tv, NULL);
 
    r.__date.assign(
        719163 + tv.tv_sec / SEC_PER_DAY // 1970-01-01 00:00:00 + time
        );
    r.__time.assign(
        0,
        0,
        tv.tv_sec % SEC_PER_DAY,
        tv.tv_usec / 1000
        );
#endif
    return r;
}
 
DateTime DateTime::getCurrentLocalTime()
{
    DateTime r;
#if __DCL_WINDOWS
    struct _timeb timeb;
    _ftime_s(&timeb);
 
    r.__date.assign(
        (long) (719163 + ((timeb.time - timeb.timezone * 60) / SEC_PER_DAY)) // 1970-01-01 00:00:00 + time
        );
    r.__time.assign(
        0,
        -timeb.timezone,
        timeb.time % SEC_PER_DAY,
        timeb.millitm
        );
#else
    time_t timer;
    struct tm tm;
    ::time(&timer);
    localtime_r(&timer, &tm);
 
    struct timeval tv;
    gettimeofday(&tv, NULL);
 
    r.__date.assign(
        719163 + (tv.tv_sec + tm.tm_gmtoff) / SEC_PER_DAY    // 1970-01-01 00:00:00 + time
        );
    r.__time.assign(
        0,
        0,
        tv.tv_sec % SEC_PER_DAY + tm.tm_gmtoff,
        tv.tv_usec / 1000
        );
#endif
    return r;
}
 
#if 0
DateTime DateTime::parseF(
        const char* pszDateTimeString,
        const char* _format
        ) __DCL_THROWS1(ParseException*)
{
    __DCL_ASSERT(pszDateTimeString != NULL && *pszDateTimeString != '\0');
    __DCL_ASSERT(_format != NULL && *_format != '\0');
 
    struct tm tm;
    memset(&tm, 0, sizeof(tm));
    const char* p = strptime(pszDateTimeString, _format, &tm);
    if (p == NULL) {
        throw new ParseException(L"no match to format");
    }
    
    if (*p != '\0') {
        throw new ParseException(
            L"extra data",
            p - pszDateTimeString
            );
 
    }
 
    DateTime _dt2(
        tm.tm_year + 1900,
        tm.tm_mon + 1,
        tm.tm_mday,
        tm.tm_hour,
        tm.tm_min,
        tm.tm_sec
        );
 
    return _dt2;
}
#endif
 
__DCL_END_NAMESPACE