TnbTime.h

[詳解]

#pragma once
#include "TnbStr.h"
#include "TnbComparable.h"
#ifndef _WIN32_WCE
 #include <time.h>
 #include <tchar.h>
#endif
 
 
 
//TNB Library
namespace TNB
{
 
 
 
class CFileTimeEx : public FILETIME, public IComparableT<TNB::CFileTimeEx> 
{
    DEFSUPER(FILETIME);
public:
 
    CFileTimeEx(void) : _super()
    {
        Empty(); 
    }
 
    CFileTimeEx(bool b) : _super()
    {
        operator=(GetCurrent());
    }
 
    CFileTimeEx(const FILETIME& ft) : _super()
    {
        operator=(ft); 
    }
 
    CFileTimeEx(const SYSTEMTIME& st) : _super()
    {
        operator=(st); 
    }
 
    CFileTimeEx(const time_t& tm) : _super()
    {
        operator=(tm); 
    }
 
    CFileTimeEx& operator=(const FILETIME& ft)
    {
        _super::dwLowDateTime = ft.dwLowDateTime;
        _super::dwHighDateTime = ft.dwHighDateTime;
        return *this;
    }
 
    CFileTimeEx& operator=(const SYSTEMTIME& st)
    {
        FILETIME ft;
        if ( ! ::SystemTimeToFileTime(&st, &ft) || ! ::LocalFileTimeToFileTime(&ft, this) )
        {
            Empty();
        }
        return *this;
    }
 
    CFileTimeEx& operator=(const time_t& tm)
    {
        ULONGLONG ull = tm;
        ull += 11644473600;
        ull *= 10000000;
        m_Refer() = ull;
        return *this;
    }
 
    time_t ToTimet(void)
    {
        ULONGLONG ull = m_Refer();
        ull /= 10000000;
        ull -= 11644473600;
        return static_cast<time_t>(ull & DWORD_MAX);
    }
 
    void Empty(void)
    {
        m_Refer() = 0;
    }
 
    bool IsEmpty(void) const
    {
        return m_Refer() == 0;
    }
 
    virtual INT_PTR Compare(const CFileTimeEx& t) const
    {
        return ::CompareFileTime(this, &t);
    }
 
    CFileTimeEx& operator+=(LONGLONG llMs)
    {
        (m_Refer()) += (llMs * 10000);
        return *this;
    }
 
    CFileTimeEx& operator-=(LONGLONG llMs)
     {
        (m_Refer()) -= (llMs * 10000);
        return *this;
    }
 
    CFileTimeEx operator+(LONGLONG llMs) const
    {
        CFileTimeEx t = *this;
        return t += llMs;
    }
 
    CFileTimeEx operator-=(LONGLONG llMs) const
     {
        CFileTimeEx t = *this;
        return t -= llMs;
    }
 
    LONGLONG operator-(const CFileTimeEx& t) const 
    {
        LONGLONG r = (m_Refer() - t.m_Refer()) / 10000;
        return r;
    }
 
    CStr Format(LPCTSTR lpszFormat = NULL) const;
 
    operator FILETIME*(void)
    {
        return this;
    }
 
    static CFileTimeEx GetCurrent(void);
 
private:
    const ULONGLONG& m_Refer(void) const
    {
        return *reinterpret_cast<const ULONGLONG*>(&(_super::dwLowDateTime));
    }
    ULONGLONG& m_Refer(void)
    {
        return *reinterpret_cast<ULONGLONG*>(&(_super::dwLowDateTime));
    }
};
 
 
 
class CSystemTime : public SYSTEMTIME, public IComparableT<TNB::CSystemTime> 
{
    DEFSUPER(SYSTEMTIME);
public:
 
    CSystemTime(void) : _super()
    {
        Empty();
    }
 
    CSystemTime(const SYSTEMTIME& st) : _super()
    {
        operator=(st); 
    }
 
    CSystemTime(const FILETIME& ft) : _super()
    {
        operator=(ft); 
    }
 
    CSystemTime(const time_t& tm) : _super()
    {
        operator=(tm); 
    }
 
    CSystemTime& operator=(const SYSTEMTIME& st)
    {
        ASSERTLIB( offsetof(CSystemTime, wYear) == sizeof(this) ); //wYearが vtable の次にあることを確認
        SYSTEMTIME* P = this;
        *P = st;
        return *this;
    }
 
    CSystemTime& operator=(const FILETIME& ft)
    {
        FILETIME ff;
        if ( ! ::FileTimeToLocalFileTime(&ft, &ff) || ! ::FileTimeToSystemTime(&ff, this) )
        {
            Empty();
        }
        return *this;
    }
 
    CSystemTime& operator=(const time_t& tm)
    {
        CFileTimeEx ft(tm);
        return operator=(ft);
    }
 
    void Set(int iYear, int iMonth, int iDay)
    {
        Empty();
        _super::wYear = ToWord(iYear);
        _super::wMonth = ToWord(iMonth);
        _super::wDay = ToWord(iDay);
    }
 
    WORD GetYear(void) const    { return _super::wYear; }
    WORD GetMonth(void) const   { return _super::wMonth; }
    WORD GetDay(void) const     { return _super::wDay; }
    WORD GetHour(void) const    { return _super::wHour; }
    WORD GetMinute(void) const  { return _super::wMinute; }
    WORD GetSecond(void) const  { return _super::wSecond; }
    WORD GetMillSec(void) const { return _super::wMilliseconds; }
 
    void Empty(void)
    {
        memset(&(_super::wYear), 0, sizeof(SYSTEMTIME));
    }
 
    bool IsEmpty(void) const
    {
        return _super::wYear == 0;
    }
 
    bool IsValid(void) const
    {
        FILETIME ft;
        return !! ::SystemTimeToFileTime(this, &ft);
    }
 
    virtual INT_PTR Compare(const CSystemTime& t) const
    {
        int r = wYear - t.wYear;
        if ( r != 0 ) { return r; }
        r = wMonth - t.wMonth;
        if ( r != 0 ) { return r; }
        r = wDay - t.wDay;
        if ( r != 0 ) { return r; }
        r = wHour - t.wHour;
        if ( r != 0 ) { return r; }
        r = wMinute - t.wMinute;
        if ( r != 0 ) { return r; }
        r = wSecond - t.wSecond;
        if ( r != 0 ) { return r; }
        return wMilliseconds - t.wMilliseconds;
    }
 
    CSystemTime& AddYear(int iYear)
    {
        int y = _super::wYear + iYear;
        _super::wYear = static_cast<WORD>(y);
        return *this;
    }
 
    CSystemTime& AddMonth(int iMonth)
    {
        if ( iMonth != 0 )
        {
            FILETIME ft;
            bool boRc = !! ::SystemTimeToFileTime(this, &ft);
            iMonth += _super::wMonth;
            while ( iMonth > 12 )
            {
                iMonth -= 12;
                _super::wYear++;
            }
            while ( iMonth < 1 )
            {
                iMonth += 12;
                _super::wYear--;
            }
            _super::wMonth = static_cast<WORD>(iMonth);
            if ( boRc )
            {
                while ( ! ::SystemTimeToFileTime(this, &ft) )
                {
                    _super::wDay--;
                    if ( _super::wDay == 0 )
                    {
                        Empty();
                        break;
                    }
                }
            }
        }
        return *this;
    }
 
    CSystemTime& AddDay(int iDay)
    {
        return AddHour(iDay * 24);
    }
 
    CSystemTime& AddHour(int iHour)
    {
        return AddMinute(iHour * 60);
    }
 
    CSystemTime& AddMinute(int iMinute)
    {
        return AddSecond(iMinute * 60);
    }
 
    CSystemTime& AddSecond(LONGLONG iSecond)
    {
        return AddMillSec(iSecond * 1000);
    }
 
    CSystemTime& AddMillSec(LONGLONG llMillSec)
    {
        return operator=(CFileTimeEx(*this) + llMillSec);
    }
 
    LONGLONG operator-(const CSystemTime& t) const 
    {
        return CFileTimeEx(*this) - CFileTimeEx(t);
    }
    
    CSystemTime LocalToUtc(void) const
    {
        FILETIME ft1;
        FILETIME ft2;
        CSystemTime st;
        if ( ! ::SystemTimeToFileTime(this, &ft1)
            || ! ::LocalFileTimeToFileTime(&ft1, &ft2)
            || ! ::FileTimeToSystemTime(&ft2, &st) )
        {
            st.Empty();
        }
        return st;
    }
 
    CSystemTime UtcToLocal(void) const
    {
        FILETIME ft1;
        FILETIME ft2;
        CSystemTime st;
        if ( ! ::SystemTimeToFileTime(this, &ft1)
            || ! ::FileTimeToLocalFileTime(&ft1, &ft2)
            || ! ::FileTimeToSystemTime(&ft2, &st) )
        {
            st.Empty();
        }
        return st;
    }
 
    #ifndef _WIN32_WCE
 
    CSystemTime LocalToTzSpecificLocal(LPTIME_ZONE_INFORMATION lpTzInfo) const
    {
        CSystemTime r;
        CSystemTime st = LocalToUtc();
        if ( ! ::SystemTimeToTzSpecificLocalTime(lpTzInfo, &r, &st) )
        {
            r.Empty();
        }
        return r;
    }
 
    #endif
 
    void StringTo(LPCTSTR lpsz)
    {
        CStr s = lpsz;
        s.Remove(_T('-'));
        s.Remove(_T(':'));
        s.Remove(_T('/'));
        s.Remove(_T('.'));
        s.Remove(_T('\''));
        s.Remove(_T(' '));
        s += _T("000000000000000000");
        _super::wYear = static_cast<WORD>(s.Mid(0, 4).ToInt());
        _super::wMonth = static_cast<WORD>(s.Mid(4, 2).ToInt());
        _super::wDay = static_cast<WORD>(s.Mid(6, 2).ToInt());
        _super::wHour = static_cast<WORD>(s.Mid(8, 2).ToInt());
        _super::wMinute = static_cast<WORD>(s.Mid(10, 2).ToInt());
        _super::wSecond = static_cast<WORD>(s.Mid(12, 2).ToInt());
        _super::wMilliseconds = static_cast<WORD>(s.Mid(14, 3).ToInt());
        _super::wDayOfWeek = 0;
    }
 
    CStr Format(LPCTSTR lpszFormat = NULL) const
    {
        if ( lpszFormat == NULL )
        {
            lpszFormat = _T("%Y-%m-%d %H:%M:%S");
        }
        CStr s;
        if ( IsValid() )
        {
            tm tTime;
            tTime.tm_year   = wYear - 1900; /* years since 1900 */
            tTime.tm_mon    = wMonth - 1;   /* months since January - [0,11] */
            tTime.tm_mday   = wDay;         /* day of the month - [1,31] */
            tTime.tm_hour   = wHour;        /* hours since midnight - [0,23] */
            tTime.tm_min    = wMinute;      /* minutes after the hour - [0,59] */
            tTime.tm_sec    = wSecond;      /* seconds after the minute - [0,59] */
            if ( _tcsftime(s.GetBuffer(1024), 1024, lpszFormat, &tTime) == 0 )
            {
                s.Empty();
            }
            s.ReleaseBuffer();
        }
        return s;
    }
 
    CStr ToTimeString(void) const
    {
        return CStr::Fmt(_T("%02d:%02d:%02d.%03d"), wHour, wMinute, wSecond, wMilliseconds);
    }
 
    int ToJapaneseEra(int& _iYear) const
    {
        CSystemTime st;
        st.Set(1868, 1, 25);    
        if ( *this < st )
        {
            return -1;
        }
        st.Set(1912, 7, 30);    
        if ( *this < st )
        {
            //明治だ
            _iYear = _super::wYear - 1868 +1;
            return 0;
        }
        st.Set(1926, 12, 25);   
        if ( *this < st )
        {
            //大正だ
            _iYear = _super::wYear - 1912 +1;
            return 1;
        }
        st.Set(1989, 1, 7); 
        if ( *this < st )
        {
            //昭和だ
            _iYear = _super::wYear - 1926 +1;
            return 2;
        }
        st.Set(2019, 5, 1); 
        if ( *this < st )
        {
            //平成だ
            _iYear = _super::wYear - 1989 +1;
            return 3;
        }
        _iYear = _super::wYear - 2019 +1;
        return 4;
    }
 
    static CSystemTime GetCurrent(void)
    {
        SYSTEMTIME st;
        ::GetLocalTime(&st);
        return st;
    }
 
    static CSystemTime GetCurrentUtc(void)
    {
        SYSTEMTIME st;
        ::GetSystemTime(&st);
        return st;
    }
 
    static DWORD GetDayOfTheWeek(const SYSTEMTIME& t)
    {
        DWORD dwYear    = t.wYear;
        DWORD dwMonth   = t.wMonth;
        DWORD dwDay     = t.wDay;
        if ( dwMonth == 1 || dwMonth == 2 )
        {
            dwMonth += 12;
            dwYear--;
        }
        double d = dwYear + (dwYear / 4) - (dwYear / 100) + (dwYear / 400) + (2.6 * dwMonth) + 1.6 + dwDay;
        return DWORD(d) % 7;
    }
 
    static bool IsLeap(DWORD dwYear)
    {
        if ( (dwYear % 4) == 0 && (dwYear % 100) != 0 || (dwYear % 400) == 0 )
        {
            return true;
        }
        return false;
    }
 
    static DWORD GetEndOfMonth(DWORD dwYear, DWORD dwMonth)
    {
        switch ( dwMonth )
        {
        case 2:
            return IsLeap(dwYear) ? 29 : 28;
        case 4:
        case 6:
        case 9:
        case 11:
            return 30;
        default:
            break;
        }
        return 31;
    }
};
 
 
 
inline CStr CFileTimeEx::Format(LPCTSTR lpszFormat) const
{
    CSystemTime st;
    ::FileTimeToSystemTime(this, &st);
    return st.Format(lpszFormat);
}
 
 
 
inline CFileTimeEx CFileTimeEx::GetCurrent(void)
{
    #ifndef _WIN32_WCE
        FILETIME ft;
        ::GetSystemTimeAsFileTime(&ft);
        return ft;
    #else
        return CSystemTime::GetCurrent();
    #endif
}
 
 
 
};//TNB
 
 
 
#ifdef _TnbDOXYGEN  //Document作成用シンボル
 
struct SYSTEMTIME 
{
    WORD wYear;         
    WORD wMonth;        
    WORD wDayOfWeek;    
    WORD wDay;          
    WORD wHour;         
    WORD wMinute;       
    WORD wSecond;       
    WORD wMilliseconds; 
};
 
struct FILETIME 
{
    DWORD dwLowDateTime;    
    DWORD dwHighDateTime;   
};
 
#endif