1191 lines
75 KiB
C++
1191 lines
75 KiB
C++
|
||
|
||
///////////////////////////////////////////////////////////////////
|
||
// INCLUDE
|
||
///////////////////////////////////////////////////////////////////
|
||
|
||
#include "STDAFX.H"
|
||
#include "TIMESET.H"
|
||
#include <TIME.H>
|
||
#include "COMMONMACROS.H"
|
||
#include "BASESET.H"
|
||
#include "DEBUGUTIL.H"
|
||
#include "SAFESTRINGMACROS.H"
|
||
|
||
#if defined(_US)
|
||
#include <sys/timeb.h>
|
||
#endif // #if defined(_US)
|
||
|
||
#ifdef _DEBUG
|
||
#define new new(_NORMAL_BLOCK,__FILE__,__LINE__)
|
||
#endif
|
||
|
||
///////////////////////////////////////////////////////////////////
|
||
// IMPLEMENTATION
|
||
///////////////////////////////////////////////////////////////////
|
||
|
||
//*---------------------------------------------------------------
|
||
// TYPE : FUNCTION
|
||
// NAME : CTimeSet::CTimeSet
|
||
//*---------------------------------------------------------------
|
||
// DESC : 생성자
|
||
// PARM : N/A
|
||
// RETV : N/A
|
||
// PRGM : B4nFter
|
||
//*---------------------------------------------------------------
|
||
CTimeSet::CTimeSet()
|
||
{
|
||
Reset();
|
||
}
|
||
|
||
|
||
//*---------------------------------------------------------------
|
||
// TYPE : FUNCTION
|
||
// NAME : CTimeSet::CTimeSet
|
||
//*---------------------------------------------------------------
|
||
// DESC : 생성자
|
||
// PARM : N/A
|
||
// RETV : N/A
|
||
// PRGM : B4nFter
|
||
//*---------------------------------------------------------------
|
||
CTimeSet::CTimeSet(WORD wYear, WORD wMonth, WORD wDay, WORD wHour, WORD wMinute, WORD wSecond)
|
||
{
|
||
Set(wYear, wMonth, wDay, wHour, wMinute,wSecond);
|
||
}
|
||
|
||
|
||
CTimeSet::CTimeSet(const __time32_t& pTime, bool pIsLocal)
|
||
{
|
||
Set(pTime, pIsLocal);
|
||
}
|
||
|
||
|
||
CTimeSet::CTimeSet(const __time64_t& pTime, bool pIsLocal)
|
||
{
|
||
Set(pTime, pIsLocal);
|
||
}
|
||
|
||
CTimeSet::CTimeSet(const char* szTime, bool pIsLocal)
|
||
{
|
||
char szYear[5] = {0,};
|
||
char szMonth[3] = {0,};
|
||
char szDay[3] = {0,};
|
||
char szHour[3] = {0,};
|
||
char szMin[3] = {0,};
|
||
|
||
int nYear = 0;
|
||
int nMonth = 0;
|
||
int nDay = 0;
|
||
int nHour = 0;
|
||
int nMin = 0;
|
||
|
||
sscanf_s (szTime, "%4s%2s%2s%2s%2s",
|
||
szYear, sizeof(szYear),
|
||
szMonth, sizeof(szMonth),
|
||
szDay, sizeof(szDay),
|
||
szHour, sizeof(szHour),
|
||
szMin, sizeof(szMin));
|
||
|
||
nYear = atoi (szYear);
|
||
nMonth = atoi (szMonth);
|
||
nDay = atoi (szDay);
|
||
nHour = atoi (szHour);
|
||
nMin = atoi (szMin);
|
||
|
||
Set (nYear, nMonth, nDay, nHour, nMin, 0);
|
||
}
|
||
|
||
//*---------------------------------------------------------------
|
||
// TYPE : FUNCTION
|
||
// NAME : CTimeSet::CTimeSet
|
||
//*---------------------------------------------------------------
|
||
// DESC : 생성자
|
||
// PARM : N/A
|
||
// RETV : N/A
|
||
// PRGM : B4nFter
|
||
//*---------------------------------------------------------------
|
||
CTimeSet::CTimeSet(const FILETIME& stTime)
|
||
{
|
||
Set(stTime);
|
||
}
|
||
|
||
|
||
//*---------------------------------------------------------------
|
||
// TYPE : FUNCTION
|
||
// NAME : CTimeSet::CTimeSet
|
||
//*---------------------------------------------------------------
|
||
// DESC : 생성자
|
||
// PARM : N/A
|
||
// RETV : N/A
|
||
// PRGM : B4nFter
|
||
//*---------------------------------------------------------------
|
||
CTimeSet::CTimeSet(const SYSTEMTIME& stTime)
|
||
{
|
||
Set(stTime);
|
||
}
|
||
|
||
|
||
//*---------------------------------------------------------------
|
||
// TYPE : FUNCTION
|
||
// NAME : CTimeSet::CTimeSet
|
||
//*---------------------------------------------------------------
|
||
// DESC : 생성자
|
||
// PARM : N/A
|
||
// RETV : N/A
|
||
// PRGM : B4nFter
|
||
//*---------------------------------------------------------------
|
||
CTimeSet::CTimeSet(const DBTIMESTAMP& stTime)
|
||
{
|
||
Set(stTime);
|
||
}
|
||
|
||
|
||
//*---------------------------------------------------------------
|
||
// TYPE : FUNCTION
|
||
// NAME : CTimeSet::Reset
|
||
//*---------------------------------------------------------------
|
||
// DESC : 시간 객체 정보를 리셋 (현재시간으로 세팅)
|
||
// PARM : N/A
|
||
// RETV : N/A
|
||
// PRGM : B4nFter
|
||
//*---------------------------------------------------------------
|
||
VOID CTimeSet::Reset()
|
||
{
|
||
::GetLocalTime(&m_stLocalTime);
|
||
memset(&m_stDbTimeStamp, 0, sizeof(m_stDbTimeStamp));
|
||
memset(&m_DBTimeStampStruct, 0, sizeof(m_DBTimeStampStruct));
|
||
}
|
||
|
||
|
||
//*---------------------------------------------------------------
|
||
// TYPE : FUNCTION
|
||
// NAME : CTimeSet::Set
|
||
//*---------------------------------------------------------------
|
||
// DESC : 시간 정보를 세팅
|
||
// PARM : 1 . wYear - 년
|
||
// 2 . wMonth - 월
|
||
// 3 . wDay - 일
|
||
// 4 . wHour - 시
|
||
// 5 . wMinute - 분
|
||
// 6 . wSecond - 초
|
||
// RETV : N/A
|
||
// PRGM : B4nFter
|
||
//*---------------------------------------------------------------
|
||
VOID CTimeSet::Set(WORD wYear, WORD wMonth, WORD wDay, WORD wHour, WORD wMinute,WORD wSecond)
|
||
{
|
||
m_stLocalTime.wYear = wYear;
|
||
m_stLocalTime.wMonth = wMonth;
|
||
m_stLocalTime.wDay = wDay;
|
||
m_stLocalTime.wDayOfWeek = 0;
|
||
m_stLocalTime.wHour = wHour;
|
||
m_stLocalTime.wMinute = wMinute;
|
||
m_stLocalTime.wSecond = wSecond;
|
||
m_stLocalTime.wMilliseconds = 0;
|
||
}
|
||
|
||
VOID CTimeSet::Set(const __time32_t& pTime, bool pIsLocal)
|
||
{
|
||
tm stTm;
|
||
// ::memset(&stTm, 0, sizeof(stTm)); // 영향 없음 (헤더 주석 참조할 것)
|
||
|
||
if (pIsLocal) {
|
||
ConvertTimeT32ToTm_LC(pTime, &stTm);
|
||
}
|
||
else {
|
||
ConvertTimeT32ToTm_GM(pTime, &stTm);
|
||
}
|
||
|
||
m_stLocalTime.wYear = stTm.tm_year;
|
||
m_stLocalTime.wMonth = stTm.tm_mon;
|
||
m_stLocalTime.wDay = stTm.tm_mday;
|
||
m_stLocalTime.wDayOfWeek = 0;
|
||
m_stLocalTime.wHour = stTm.tm_hour;
|
||
m_stLocalTime.wMinute = stTm.tm_min;
|
||
m_stLocalTime.wSecond = stTm.tm_sec;
|
||
m_stLocalTime.wMilliseconds = 0;
|
||
}
|
||
|
||
VOID CTimeSet::Set(const __time64_t& pTime, bool pIsLocal)
|
||
{
|
||
tm stTm;
|
||
// ::memset(&stTm, 0, sizeof(stTm)); // 영향 없음 (헤더 주석 참조할 것)
|
||
|
||
if (pIsLocal) {
|
||
ConvertTimeT64ToTm_LC(pTime, &stTm);
|
||
}
|
||
else {
|
||
ConvertTimeT64ToTm_GM(pTime, &stTm);
|
||
}
|
||
|
||
m_stLocalTime.wYear = stTm.tm_year;
|
||
m_stLocalTime.wMonth = stTm.tm_mon;
|
||
m_stLocalTime.wDay = stTm.tm_mday;
|
||
m_stLocalTime.wDayOfWeek = 0;
|
||
m_stLocalTime.wHour = stTm.tm_hour;
|
||
m_stLocalTime.wMinute = stTm.tm_min;
|
||
m_stLocalTime.wSecond = stTm.tm_sec;
|
||
m_stLocalTime.wMilliseconds = 0;
|
||
}
|
||
|
||
//*---------------------------------------------------------------
|
||
// TYPE : FUNCTION
|
||
// NAME : CTimeSet::Set
|
||
//*---------------------------------------------------------------
|
||
// DESC : 시간 정보를 세팅
|
||
// PARM : 1 . stTime - FILETIME 시간정보
|
||
// RETV : N/A
|
||
// PRGM : B4nFter
|
||
//*---------------------------------------------------------------
|
||
VOID CTimeSet::Set(const FILETIME& stTime)
|
||
{
|
||
FILETIME stFileTime;
|
||
::FileTimeToLocalFileTime(&stTime, &stFileTime);
|
||
::FileTimeToSystemTime(&stFileTime, &m_stLocalTime);
|
||
}
|
||
|
||
|
||
//*---------------------------------------------------------------
|
||
// TYPE : FUNCTION
|
||
// NAME : CTimeSet::Set
|
||
//*---------------------------------------------------------------
|
||
// DESC : 시간 정보를 세팅
|
||
// PARM : 1 . stTime - SYSTEMTIME 시간정보
|
||
// RETV : N/A
|
||
// PRGM : B4nFter
|
||
//*---------------------------------------------------------------
|
||
VOID CTimeSet::Set(const SYSTEMTIME& stTime)
|
||
{
|
||
m_stLocalTime = stTime;
|
||
}
|
||
|
||
|
||
//*---------------------------------------------------------------
|
||
// TYPE : FUNCTION
|
||
// NAME : CTimeSet::Set
|
||
//*---------------------------------------------------------------
|
||
// DESC : 시간 정보를 세팅
|
||
// PARM : 1 . stTime - DBTIMESTAMP 시간정보
|
||
// RETV : N/A
|
||
// PRGM : B4nFter
|
||
//*---------------------------------------------------------------
|
||
VOID CTimeSet::Set(const DBTIMESTAMP& stTime)
|
||
{
|
||
FILETIME stFileTime;
|
||
|
||
ConvertDbTimeStampToFileTime(&stTime, &stFileTime);
|
||
::FileTimeToSystemTime(&stFileTime, &m_stLocalTime);
|
||
}
|
||
|
||
|
||
//*---------------------------------------------------------------
|
||
// TYPE : FUNCTION
|
||
// NAME : CTimeSet::GetTimeTo
|
||
//*---------------------------------------------------------------
|
||
// DESC : 현재 객체에 지정된 시간에서 인자로 전달된 특정 시간까지의 남은 초 반환
|
||
// PARM : 1 . eDayOfWeek - 주
|
||
// 2 . wHour - 시
|
||
// 3 . wMinute - 분
|
||
// 4 . wSecond - 초
|
||
// RETV : 인자로 전달된 특정 시간까지의 남은 초
|
||
// PRGM : B4nFter
|
||
//*---------------------------------------------------------------
|
||
DWORD CTimeSet::GetTimeTo(EF_DAYOFWEEK eDayOfWeek, WORD wHour, WORD wMinute, WORD wSecond)
|
||
{
|
||
DN_ASSERT((EV_DAYOFWEEK_SUN <= eDayOfWeek) && (eDayOfWeek <= EV_DAYOFWEEK_SAT), "Invalid!");
|
||
DN_ASSERT(wHour < 24, "Invalid!");
|
||
DN_ASSERT(wMinute < 60, "Invalid!");
|
||
DN_ASSERT(wSecond < 60, "Invalid!");
|
||
|
||
DWORD dwCurSec = (m_stLocalTime.wSecond) + (m_stLocalTime.wMinute*60) + (m_stLocalTime.wHour*60*60) + (m_stLocalTime.wDayOfWeek*60*60*24);
|
||
DWORD dwArgSec = (wSecond) + (wMinute*60) + (wHour*60*60) + (eDayOfWeek*60*60*24);
|
||
|
||
if (dwCurSec < dwArgSec) {
|
||
return((dwArgSec-dwCurSec)*1000);
|
||
}
|
||
else if (dwArgSec < dwCurSec) {
|
||
return((7*24*60*60 - dwCurSec + dwArgSec)*1000);
|
||
}
|
||
else {
|
||
return (0);
|
||
}
|
||
}
|
||
|
||
|
||
//*---------------------------------------------------------------
|
||
// TYPE : FUNCTION
|
||
// NAME : CTimeSet::GetTimeTo
|
||
//*---------------------------------------------------------------
|
||
// DESC : 현재 객체에 지정된 시간에서 인자로 전달된 특정 시간까지의 남은 초 반환
|
||
// PARM : 1 . wHour - 시
|
||
// 2 . wMinute - 분
|
||
// 3 . wSecond - 초
|
||
// RETV : 인자로 전달된 특정 시간까지의 남은 초
|
||
// PRGM : B4nFter
|
||
//*---------------------------------------------------------------
|
||
DWORD CTimeSet::GetTimeTo(WORD wHour, WORD wMinute, WORD wSecond)
|
||
{
|
||
DN_ASSERT(wHour < 24, "Invalid!");
|
||
DN_ASSERT(wMinute < 60, "Invalid!");
|
||
DN_ASSERT(wSecond < 60, "Invalid!");
|
||
|
||
DWORD dwCurSec = (m_stLocalTime.wSecond) + (m_stLocalTime.wMinute*60) + (m_stLocalTime.wHour*60*60);
|
||
DWORD dwArgSec = (wSecond) + (wMinute*60) + (wHour*60*60);
|
||
|
||
if (dwCurSec < dwArgSec) {
|
||
return((dwArgSec-dwCurSec)*1000);
|
||
}
|
||
else if (dwArgSec < dwCurSec) {
|
||
return((24*60*60 - dwCurSec + dwArgSec)*1000);
|
||
}
|
||
else {
|
||
return (0);
|
||
}
|
||
}
|
||
|
||
|
||
//*---------------------------------------------------------------
|
||
// TYPE : FUNCTION
|
||
// NAME : CTimeSet::GetTimeTo
|
||
//*---------------------------------------------------------------
|
||
// DESC : 현재 객체에 지정된 시간에서 인자로 전달된 특정 시간까지의 남은 초 반환
|
||
// PARM : 1 . wMinute - 분
|
||
// 2 . wSecond - 초
|
||
// RETV : 인자로 전달된 특정 시간까지의 남은 초
|
||
// PRGM : B4nFter
|
||
//*---------------------------------------------------------------
|
||
DWORD CTimeSet::GetTimeTo(WORD wMinute, WORD wSecond)
|
||
{
|
||
DN_ASSERT(wMinute < 60, "Invalid!");
|
||
DN_ASSERT(wSecond < 60, "Invalid!");
|
||
|
||
DWORD dwCurSec = (m_stLocalTime.wSecond) + (m_stLocalTime.wMinute*60);
|
||
DWORD dwArgSec = (wSecond) + (wMinute*60);
|
||
|
||
if (dwCurSec < dwArgSec) {
|
||
return((dwArgSec-dwCurSec)*1000);
|
||
}
|
||
else if (dwArgSec < dwCurSec) {
|
||
return((60*60 - dwCurSec + dwArgSec)*1000);
|
||
}
|
||
else {
|
||
return (0);
|
||
}
|
||
}
|
||
|
||
|
||
//*---------------------------------------------------------------
|
||
// TYPE : FUNCTION
|
||
// NAME : CTimeSet::CompareFileTime
|
||
//*---------------------------------------------------------------
|
||
// DESC : 두 개의 FILETIME 시간 중 어느쪽이 큰지 반환
|
||
// PARM : 1 . stFileTime1 - FILETIME 시간정보 1
|
||
// 2 . stFileTime2 - FILETIME 시간정보 2
|
||
// RETV : -1 : stFileTime1 이 큼 / 0 : 둘 다 같음 / 1 : stFileTime2 가 큼
|
||
// PRGM : B4nFter
|
||
//*---------------------------------------------------------------
|
||
INT CTimeSet::CompareFileTime(const FILETIME& stFileTime1, const FILETIME& stFileTime2)
|
||
{
|
||
return(::CompareFileTime(&stFileTime1, &stFileTime2));
|
||
}
|
||
|
||
|
||
//*---------------------------------------------------------------
|
||
// TYPE : FUNCTION
|
||
// NAME : CTimeSet::CheckIntegrity
|
||
//*---------------------------------------------------------------
|
||
// DESC : 객체의 현재 시간정보의 무결성 체크
|
||
// PARM : N/A
|
||
// RETV : TRUE - 성공 / FALSE - 실패
|
||
// PRGM : B4nFter
|
||
//*---------------------------------------------------------------
|
||
BOOL CTimeSet::CheckIntegrity()
|
||
{
|
||
if (!m_stLocalTime.wMonth || m_stLocalTime.wMonth > 12) { return FALSE; }
|
||
if (m_stLocalTime.wDayOfWeek > 6) { return FALSE; }
|
||
if (!m_stLocalTime.wDay || m_stLocalTime.wDay > 31) { return FALSE; }
|
||
if (m_stLocalTime.wHour > 24) { return FALSE; }
|
||
if (m_stLocalTime.wMinute > 60) { return FALSE; }
|
||
if (m_stLocalTime.wSecond > 60) { return FALSE; }
|
||
if (m_stLocalTime.wMilliseconds > 999) { return FALSE; }
|
||
return TRUE;
|
||
}
|
||
|
||
|
||
//*---------------------------------------------------------------
|
||
// TYPE : FUNCTION
|
||
// NAME : CTimeSet::AddSecond
|
||
//*---------------------------------------------------------------
|
||
// DESC : 현재 객체의 시간정보에 N 초만큼 더함
|
||
// PARM : 1 . i64Second - 초 (±)
|
||
// RETV : N/A
|
||
// PRGM : B4nFter
|
||
//*---------------------------------------------------------------
|
||
VOID CTimeSet::AddSecond(INT64 i64Second)
|
||
{
|
||
DN_ASSERT(0 != i64Second, "Invalid!");
|
||
|
||
FILETIME stFileTime;
|
||
::SystemTimeToFileTime(&m_stLocalTime, &stFileTime);
|
||
ULARGE_INTEGER uValue;
|
||
uValue.LowPart = stFileTime.dwLowDateTime;
|
||
uValue.HighPart = stFileTime.dwHighDateTime;
|
||
uValue.QuadPart += (i64Second * 10000000); // 100-nano로 변환
|
||
stFileTime.dwLowDateTime = uValue.LowPart;
|
||
stFileTime.dwHighDateTime = uValue.HighPart;
|
||
::FileTimeToSystemTime(&stFileTime, &m_stLocalTime);
|
||
}
|
||
|
||
|
||
//*---------------------------------------------------------------
|
||
// TYPE : FUNCTION
|
||
// NAME : CTimeSet::operator-
|
||
//*---------------------------------------------------------------
|
||
// DESC : 현재 객체의 시간정보에 다른 시간객체의 시간정보를 뺌
|
||
// PARM : 1 . Time - 시간객체
|
||
// RETV : 현재 객체에서 다른 객체의 시간정보를 뺀 값 (단위:초)
|
||
// PRGM : B4nFter
|
||
//*---------------------------------------------------------------
|
||
INT64 CTimeSet::operator-(const CTimeSet& pTime) const
|
||
{
|
||
FILETIME stFileTime;
|
||
|
||
::SystemTimeToFileTime(&m_stLocalTime, &stFileTime);
|
||
LARGE_INTEGER lValue1;
|
||
lValue1.LowPart = stFileTime.dwLowDateTime;
|
||
lValue1.HighPart = static_cast<LONG>(stFileTime.dwHighDateTime);
|
||
|
||
::SystemTimeToFileTime(&pTime.m_stLocalTime, &stFileTime);
|
||
LARGE_INTEGER lValue2;
|
||
lValue2.LowPart = stFileTime.dwLowDateTime;
|
||
lValue2.HighPart = static_cast<LONG>(stFileTime.dwHighDateTime);
|
||
|
||
lValue1.QuadPart /= 10000000; // 100-nano를 초로 변환.
|
||
lValue2.QuadPart /= 10000000;
|
||
return(static_cast<INT64>(lValue1.QuadPart - lValue2.QuadPart));
|
||
}
|
||
|
||
|
||
//*---------------------------------------------------------------
|
||
// TYPE : FUNCTION
|
||
// NAME : CTimeSet::GetTimeT32_LC
|
||
//*---------------------------------------------------------------
|
||
// DESC : 현재 시간정보를 __time32_t 시간정보로 변환
|
||
// PARM : N/A
|
||
// RETV : __time32_t 시간정보
|
||
// PRGM : B4nFter
|
||
// P.S.>
|
||
// - _mktime32() 을 사용하며 이것은 현재 시스템의 달력시간을 기준으로 변환
|
||
// - 달력시간 (Calendar Value) 은 환경변수 TZ 의 영향을 받음 (ex> 대한민국 TZ = GMT - 09:00:00)
|
||
//*---------------------------------------------------------------
|
||
__time32_t CTimeSet::GetTimeT32_LC() const
|
||
{
|
||
tm stTm;
|
||
// ::memset(&stTm, 0, sizeof(stTm)); // 영향 없음 (헤더 주석 참조할 것)
|
||
|
||
stTm.tm_year = m_stLocalTime.wYear - DF_TM_YEAR_EPOCH;
|
||
stTm.tm_mon = m_stLocalTime.wMonth - 1;
|
||
stTm.tm_mday = m_stLocalTime.wDay;
|
||
stTm.tm_hour = m_stLocalTime.wHour;
|
||
stTm.tm_min = m_stLocalTime.wMinute;
|
||
stTm.tm_sec = m_stLocalTime.wSecond;
|
||
#if defined(_US)
|
||
_timeb summertime;
|
||
_ftime(&summertime);
|
||
stTm.tm_isdst = summertime.dstflag;
|
||
#else
|
||
stTm.tm_isdst = 0; // Seriously, i don't know.
|
||
#endif
|
||
|
||
return(::_mktime32(&stTm));
|
||
}
|
||
|
||
|
||
//*---------------------------------------------------------------
|
||
// TYPE : FUNCTION
|
||
// NAME : CTimeSet::GetTimeT64_LC
|
||
//*---------------------------------------------------------------
|
||
// DESC : 현재 시간정보를 __time64_t 시간정보로 변환
|
||
// PARM : N/A
|
||
// RETV : __time64_t 시간정보
|
||
// PRGM : B4nFter
|
||
// P.S.>
|
||
// - _mktime64() 을 사용하며 이것은 현재 시스템의 달력시간을 기준으로 변환
|
||
// - 달력시간 (Calendar Value) 은 환경변수 TZ 의 영향을 받음 (ex> 대한민국 TZ = GMT - 09:00:00)
|
||
//*---------------------------------------------------------------
|
||
__time64_t CTimeSet::GetTimeT64_LC() const
|
||
{
|
||
tm stTm;
|
||
// ::memset(&stTm, 0, sizeof(stTm)); // 영향 없음 (헤더 주석 참조할 것)
|
||
|
||
stTm.tm_year = m_stLocalTime.wYear - DF_TM_YEAR_EPOCH;
|
||
stTm.tm_mon = m_stLocalTime.wMonth - 1;
|
||
stTm.tm_mday = m_stLocalTime.wDay;
|
||
stTm.tm_hour = m_stLocalTime.wHour;
|
||
stTm.tm_min = m_stLocalTime.wMinute;
|
||
stTm.tm_sec = m_stLocalTime.wSecond;
|
||
#if defined(_US)
|
||
__timeb64 summertime;
|
||
_ftime64(&summertime);
|
||
stTm.tm_isdst = summertime.dstflag;
|
||
#else
|
||
stTm.tm_isdst = 0; // Seriously, i don't know.
|
||
#endif
|
||
return(::_mktime64(&stTm));
|
||
}
|
||
|
||
|
||
//*---------------------------------------------------------------
|
||
// TYPE : FUNCTION
|
||
// NAME : CTimeSet::GetTimeT32_GM
|
||
//*---------------------------------------------------------------
|
||
// DESC : 현재 시간정보를 __time32_t 시간정보로 변환
|
||
// PARM : N/A
|
||
// RETV : __time32_t 시간정보
|
||
// PRGM : B4nFter
|
||
// P.S.>
|
||
// - _mkgmtime32() 을 사용하며 이것은 GMT 기준으로 변환
|
||
// - GMT (Greenwich Mean Time) 은 영국 그리니치 천문대 기준의 세계 표준시 (시간관련 C 런타임 라이브러리에서는 UTC (Coodinated Universal Time, 협정 세계시) 와 사실상 같은 의미로 사용됨)
|
||
//*---------------------------------------------------------------
|
||
__time32_t CTimeSet::GetTimeT32_GM() const
|
||
{
|
||
tm stTm;
|
||
// ::memset(&stTm, 0, sizeof(stTm)); // 영향 없음 (헤더 주석 참조할 것)
|
||
|
||
stTm.tm_year = m_stLocalTime.wYear - DF_TM_YEAR_EPOCH;
|
||
stTm.tm_mon = m_stLocalTime.wMonth - 1;
|
||
stTm.tm_mday = m_stLocalTime.wDay;
|
||
stTm.tm_hour = m_stLocalTime.wHour;
|
||
stTm.tm_min = m_stLocalTime.wMinute;
|
||
stTm.tm_sec = m_stLocalTime.wSecond;
|
||
|
||
return(::_mkgmtime32(&stTm));
|
||
}
|
||
|
||
|
||
//*---------------------------------------------------------------
|
||
// TYPE : FUNCTION
|
||
// NAME : CTimeSet::GetTimeT64_GM
|
||
//*---------------------------------------------------------------
|
||
// DESC : 현재 시간정보를 __time64_t 시간정보로 변환
|
||
// PARM : N/A
|
||
// RETV : __time64_t 시간정보
|
||
// PRGM : B4nFter
|
||
// P.S.>
|
||
// - _mkgmtime64() 을 사용하며 이것은 GMT 기준으로 변환
|
||
// - GMT (Greenwich Mean Time) 은 영국 그리니치 천문대 기준의 세계 표준시 (시간관련 C 런타임 라이브러리에서는 UTC (Coodinated Universal Time, 협정 세계시) 와 사실상 같은 의미로 사용됨)
|
||
//*---------------------------------------------------------------
|
||
__time64_t CTimeSet::GetTimeT64_GM() const
|
||
{
|
||
tm stTm;
|
||
// ::memset(&stTm, 0, sizeof(stTm)); // 영향 없음 (헤더 주석 참조할 것)
|
||
|
||
stTm.tm_year = m_stLocalTime.wYear - DF_TM_YEAR_EPOCH;
|
||
stTm.tm_mon = m_stLocalTime.wMonth - 1;
|
||
stTm.tm_mday = m_stLocalTime.wDay;
|
||
stTm.tm_hour = m_stLocalTime.wHour;
|
||
stTm.tm_min = m_stLocalTime.wMinute;
|
||
stTm.tm_sec = m_stLocalTime.wSecond;
|
||
|
||
return(::_mkgmtime64(&stTm));
|
||
}
|
||
|
||
|
||
TIMESTAMP_STRUCT& CTimeSet::GetDBTimeStampStruct()
|
||
{
|
||
m_DBTimeStampStruct.year = m_stLocalTime.wYear;
|
||
m_DBTimeStampStruct.month = m_stLocalTime.wMonth;
|
||
m_DBTimeStampStruct.day = m_stLocalTime.wDay;
|
||
m_DBTimeStampStruct.hour = m_stLocalTime.wHour;
|
||
m_DBTimeStampStruct.minute = m_stLocalTime.wMinute;
|
||
m_DBTimeStampStruct.second = m_stLocalTime.wSecond;
|
||
m_DBTimeStampStruct.fraction = static_cast<ULONG>(m_stLocalTime.wMilliseconds*1000000);
|
||
|
||
return m_DBTimeStampStruct;
|
||
}
|
||
|
||
//*---------------------------------------------------------------
|
||
// TYPE : FUNCTION
|
||
// NAME : CTimeSet::GetDbTimeStamp
|
||
//*---------------------------------------------------------------
|
||
// DESC : 현재 객체에 지정된 시간정보를 DBTIMESTAMP 형태로 반환
|
||
// PARM : N/A
|
||
// RETV : DBTIMESTAMP 시간정보
|
||
// PRGM : B4nFter
|
||
//*---------------------------------------------------------------
|
||
DBTIMESTAMP& CTimeSet::GetDbTimeStamp()
|
||
{
|
||
m_stDbTimeStamp.year = m_stLocalTime.wYear;
|
||
m_stDbTimeStamp.month = m_stLocalTime.wMonth;
|
||
m_stDbTimeStamp.day = m_stLocalTime.wDay;
|
||
m_stDbTimeStamp.hour = m_stLocalTime.wHour;
|
||
m_stDbTimeStamp.minute = m_stLocalTime.wMinute;
|
||
m_stDbTimeStamp.second = m_stLocalTime.wSecond;
|
||
m_stDbTimeStamp.fraction = static_cast<ULONG>(m_stLocalTime.wMilliseconds*1000000);
|
||
return m_stDbTimeStamp;
|
||
}
|
||
|
||
DBDATE& CTimeSet::GetDBDate()
|
||
{
|
||
m_DBDate.year = m_stLocalTime.wYear;
|
||
m_DBDate.month = m_stLocalTime.wMonth;
|
||
m_DBDate.day = m_stLocalTime.wDay;
|
||
|
||
return m_DBDate;
|
||
}
|
||
|
||
//*---------------------------------------------------------------
|
||
// TYPE : FUNCTION
|
||
// NAME : CTimeSet::ConvertFileTimeToDbTimeStamp
|
||
//*---------------------------------------------------------------
|
||
// DESC : 특정 FILETIME 시간정보를 DBTIMESTAMP 시간정보로 변환
|
||
// PARM : 1 . lpFileTime - 시간정보
|
||
// 2 . lpDbTime - DBTIMESTAMP 시간정보 출력버퍼
|
||
// RETV : N/A
|
||
// PRGM : B4nFter
|
||
//*---------------------------------------------------------------
|
||
VOID CTimeSet::ConvertFileTimeToDbTimeStamp(const FILETIME* lpFileTime, DBTIMESTAMP* lpDbTime)
|
||
{
|
||
DN_ASSERT(NULL != lpFileTime, "Invalid!");
|
||
DN_ASSERT(NULL != lpDbTime, "Invalid!");
|
||
|
||
SYSTEMTIME stSystemTime;
|
||
::FileTimeToSystemTime(lpFileTime, &stSystemTime);
|
||
|
||
lpDbTime->year = stSystemTime.wYear;
|
||
lpDbTime->month = stSystemTime.wMonth;
|
||
lpDbTime->day = stSystemTime.wDay;
|
||
lpDbTime->hour = stSystemTime.wHour;
|
||
lpDbTime->minute = stSystemTime.wMinute;
|
||
lpDbTime->second = stSystemTime.wSecond;
|
||
lpDbTime->fraction = static_cast<ULONG>(stSystemTime.wMilliseconds * 1000000);
|
||
|
||
if (lpDbTime->year < 1900) {
|
||
lpDbTime->year = 1900;
|
||
}
|
||
}
|
||
|
||
|
||
//*---------------------------------------------------------------
|
||
// TYPE : FUNCTION
|
||
// NAME : CTimeSet::ConvertDbTimeStampToFileTime
|
||
//*---------------------------------------------------------------
|
||
// DESC : 특정 DBTIMESTAMP 시간정보를 FILETIME 시간정보로 변환
|
||
// PARM : 1 . lpDbTime - DBTIMESTAMP 시간정보
|
||
// 2 . lpFileTime - FILETIME 시간정보 출력버퍼
|
||
// RETV : N/A
|
||
// PRGM : B4nFter
|
||
//*---------------------------------------------------------------
|
||
VOID CTimeSet::ConvertDbTimeStampToFileTime(const DBTIMESTAMP* lpDbTime, FILETIME* lpFileTime)
|
||
{
|
||
DN_ASSERT(NULL != lpDbTime, "Invalid!");
|
||
DN_ASSERT(NULL != lpFileTime, "Invalid!");
|
||
|
||
SYSTEMTIME stSystemTime;
|
||
// ::memset(&stSystemTime, 0, sizeof(stSystemTime)); // 아래 모든 멤버를 세팅하고 있음
|
||
|
||
stSystemTime.wDayOfWeek = 0;
|
||
stSystemTime.wYear = lpDbTime->year;
|
||
stSystemTime.wMonth = lpDbTime->month;
|
||
stSystemTime.wDay = lpDbTime->day;
|
||
stSystemTime.wHour = lpDbTime->hour;
|
||
stSystemTime.wMinute = lpDbTime->minute;
|
||
stSystemTime.wSecond = lpDbTime->second;
|
||
stSystemTime.wMilliseconds = static_cast<WORD>(lpDbTime->fraction / 1000000);
|
||
|
||
::SystemTimeToFileTime(&stSystemTime, lpFileTime);
|
||
}
|
||
|
||
|
||
//*---------------------------------------------------------------
|
||
// TYPE : FUNCTION
|
||
// NAME : CTimeSet::ConvertTmToTimeT32_LC
|
||
//*---------------------------------------------------------------
|
||
// DESC : 특정 tm 시간정보를 __time32_t 시간정보로 변환
|
||
// PARM : 1 . lpTm - tm 시간정보
|
||
// RETV : __time32_t 시간정보
|
||
// PRGM : B4nFter
|
||
// P.S.>
|
||
// - _mktime32() 을 사용하며 이것은 현재 시스템의 달력시간을 기준으로 변환
|
||
// - 달력시간 (Calendar Value) 은 환경변수 TZ 의 영향을 받음 (ex> 대한민국 TZ = GMT - 09:00:00)
|
||
//*---------------------------------------------------------------
|
||
__time32_t CTimeSet::ConvertTmToTimeT32_LC(tm* lpTm)
|
||
{
|
||
DN_ASSERT(NULL != lpTm, "Invalid!");
|
||
|
||
return(::_mktime32(lpTm));
|
||
}
|
||
|
||
|
||
//*---------------------------------------------------------------
|
||
// TYPE : FUNCTION
|
||
// NAME : CTimeSet::ConvertTmToTimeT64_LC
|
||
//*---------------------------------------------------------------
|
||
// DESC : 특정 tm 시간정보를 __time64_t 시간정보로 변환
|
||
// PARM : 1 . lpTm - tm 시간정보
|
||
// RETV : __time64_t 시간정보
|
||
// PRGM : B4nFter
|
||
// P.S.>
|
||
// - _mktime64() 을 사용하며 이것은 현재 시스템의 달력시간을 기준으로 변환
|
||
// - 달력시간 (Calendar Value) 은 환경변수 TZ 의 영향을 받음 (ex> 대한민국 TZ = GMT - 09:00:00)
|
||
//*---------------------------------------------------------------
|
||
__time64_t CTimeSet::ConvertTmToTimeT64_LC(tm* lpTm)
|
||
{
|
||
DN_ASSERT(NULL != lpTm, "Invalid!");
|
||
|
||
return(::_mktime64(lpTm));
|
||
}
|
||
|
||
|
||
//*---------------------------------------------------------------
|
||
// TYPE : FUNCTION
|
||
// NAME : CTimeSet::ConvertTmToTimeT32_GM
|
||
//*---------------------------------------------------------------
|
||
// DESC : 특정 tm 시간정보를 __time32_t 시간정보로 변환
|
||
// PARM : 1 . lpTm - tm 시간정보
|
||
// RETV : __time32_t 시간정보
|
||
// PRGM : B4nFter
|
||
// P.S.>
|
||
// - _mkgmtime32() 을 사용하며 이것은 GMT 기준으로 변환
|
||
// - GMT (Greenwich Mean Time) 은 영국 그리니치 천문대 기준의 세계 표준시 (시간관련 C 런타임 라이브러리에서는 UTC (Coodinated Universal Time, 협정 세계시) 와 사실상 같은 의미로 사용됨)
|
||
//*---------------------------------------------------------------
|
||
__time32_t CTimeSet::ConvertTmToTimeT32_GM(tm* lpTm)
|
||
{
|
||
DN_ASSERT(NULL != lpTm, "Invalid!");
|
||
|
||
return(::_mkgmtime32(lpTm));
|
||
}
|
||
|
||
|
||
//*---------------------------------------------------------------
|
||
// TYPE : FUNCTION
|
||
// NAME : CTimeSet::ConvertTmToTimeT64_GM
|
||
//*---------------------------------------------------------------
|
||
// DESC : 특정 tm 시간정보를 __time64_t 시간정보로 변환
|
||
// PARM : 1 . lpTm - tm 시간정보
|
||
// RETV : __time64_t 시간정보
|
||
// PRGM : B4nFter
|
||
// P.S.>
|
||
// - _mkgmtime64() 을 사용하며 이것은 GMT 기준으로 변환
|
||
// - GMT (Greenwich Mean Time) 은 영국 그리니치 천문대 기준의 세계 표준시 (시간관련 C 런타임 라이브러리에서는 UTC (Coodinated Universal Time, 협정 세계시) 와 사실상 같은 의미로 사용됨)
|
||
//*---------------------------------------------------------------
|
||
__time64_t CTimeSet::ConvertTmToTimeT64_GM(tm* lpTm)
|
||
{
|
||
DN_ASSERT(NULL != lpTm, "Invalid!");
|
||
|
||
return(::_mkgmtime64(lpTm));
|
||
}
|
||
|
||
|
||
//*---------------------------------------------------------------
|
||
// TYPE : FUNCTION
|
||
// NAME : CTimeSet::ConvertDbTimeStampToTimeT32_LC
|
||
//*---------------------------------------------------------------
|
||
// DESC : 특정 DBTIMESTAMP 시간정보를 __time32_t 시간정보로 변환
|
||
// PARM : 1 . lpDbTime - DBTIMESTAMP 시간정보
|
||
// RETV : __time32_t 시간정보
|
||
// PRGM : B4nFter
|
||
// P.S.>
|
||
// - _mktime32() 을 사용하며 이것은 현재 시스템의 달력시간을 기준으로 변환
|
||
// - 달력시간 (Calendar Value) 은 환경변수 TZ 의 영향을 받음 (ex> 대한민국 TZ = GMT - 09:00:00)
|
||
//*---------------------------------------------------------------
|
||
__time32_t CTimeSet::ConvertDbTimeStampToTimeT32_LC(const DBTIMESTAMP*lpDbTime)
|
||
{
|
||
DN_ASSERT(NULL != lpDbTime, "Invalid!");
|
||
|
||
tm stTm;
|
||
// ::memset(&stTm, 0, sizeof(stTm)); // 영향 없음 (헤더 주석 참조할 것)
|
||
|
||
stTm.tm_year = lpDbTime->year - DF_TM_YEAR_EPOCH;
|
||
stTm.tm_mon = lpDbTime->month - 1;
|
||
stTm.tm_mday = lpDbTime->day;
|
||
stTm.tm_hour = lpDbTime->hour;
|
||
stTm.tm_min = lpDbTime->minute;
|
||
stTm.tm_sec = lpDbTime->second;
|
||
#if defined(_US)
|
||
_timeb summertime;
|
||
_ftime(&summertime);
|
||
stTm.tm_isdst = summertime.dstflag;
|
||
#else
|
||
stTm.tm_isdst = 0; // Seriously, i don't know.
|
||
#endif
|
||
return(::_mktime32(&stTm));
|
||
}
|
||
|
||
|
||
//*---------------------------------------------------------------
|
||
// TYPE : FUNCTION
|
||
// NAME : CTimeSet::ConvertDbTimeStampToTimeT64_LC
|
||
//*---------------------------------------------------------------
|
||
// DESC : 특정 DBTIMESTAMP 시간정보를 __time64_t 시간정보로 변환
|
||
// PARM : 1 . lpDbTime - DBTIMESTAMP 시간정보
|
||
// RETV : __time64_t 시간정보
|
||
// PRGM : B4nFter
|
||
// P.S.>
|
||
// - _mktime64() 을 사용하며 이것은 현재 시스템의 달력시간을 기준으로 변환
|
||
// - 달력시간 (Calendar Value) 은 환경변수 TZ 의 영향을 받음 (ex> 대한민국 TZ = GMT - 09:00:00)
|
||
//*---------------------------------------------------------------
|
||
__time64_t CTimeSet::ConvertDbTimeStampToTimeT64_LC(const DBTIMESTAMP* lpDbTime)
|
||
{
|
||
DN_ASSERT(NULL != lpDbTime, "Invalid!");
|
||
|
||
tm stTm;
|
||
// ::memset(&stTm, 0, sizeof(stTm)); // 영향 없음 (헤더 주석 참조할 것)
|
||
|
||
stTm.tm_year = lpDbTime->year - DF_TM_YEAR_EPOCH;
|
||
stTm.tm_mon = lpDbTime->month - 1;
|
||
stTm.tm_mday = lpDbTime->day;
|
||
stTm.tm_hour = lpDbTime->hour;
|
||
stTm.tm_min = lpDbTime->minute;
|
||
stTm.tm_sec = lpDbTime->second;
|
||
#if defined(_US)
|
||
__timeb64 summertime;
|
||
_ftime64(&summertime);
|
||
stTm.tm_isdst = summertime.dstflag;
|
||
#else
|
||
stTm.tm_isdst = 0; // Seriously, i don't know.
|
||
#endif
|
||
return(::_mktime64(&stTm));
|
||
}
|
||
|
||
|
||
//*---------------------------------------------------------------
|
||
// TYPE : FUNCTION
|
||
// NAME : CTimeSet::ConvertDbTimeStampToTimeT32_GM
|
||
//*---------------------------------------------------------------
|
||
// DESC : 특정 DBTIMESTAMP 시간정보를 __time32_t 시간정보로 변환
|
||
// PARM : 1 . lpDbTime - DBTIMESTAMP 시간정보
|
||
// RETV : __time32_t 시간정보
|
||
// PRGM : B4nFter
|
||
// P.S.>
|
||
// - _mkgmtime32() 을 사용하며 이것은 GMT 기준으로 변환
|
||
// - GMT (Greenwich Mean Time) 은 영국 그리니치 천문대 기준의 세계 표준시 (시간관련 C 런타임 라이브러리에서는 UTC (Coodinated Universal Time, 협정 세계시) 와 사실상 같은 의미로 사용됨)
|
||
//*---------------------------------------------------------------
|
||
__time32_t CTimeSet::ConvertDbTimeStampToTimeT32_GM(const DBTIMESTAMP*lpDbTime)
|
||
{
|
||
DN_ASSERT(NULL != lpDbTime, "Invalid!");
|
||
|
||
tm stTm;
|
||
// ::memset(&stTm, 0, sizeof(stTm)); // 영향 없음 (헤더 주석 참조할 것)
|
||
|
||
stTm.tm_year = lpDbTime->year - DF_TM_YEAR_EPOCH;
|
||
stTm.tm_mon = lpDbTime->month - 1;
|
||
stTm.tm_mday = lpDbTime->day;
|
||
stTm.tm_hour = lpDbTime->hour;
|
||
stTm.tm_min = lpDbTime->minute;
|
||
stTm.tm_sec = lpDbTime->second;
|
||
|
||
return(::_mkgmtime32(&stTm));
|
||
}
|
||
|
||
|
||
//*---------------------------------------------------------------
|
||
// TYPE : FUNCTION
|
||
// NAME : CTimeSet::ConvertDbTimeStampToTimeT64_GM
|
||
//*---------------------------------------------------------------
|
||
// DESC : 특정 DBTIMESTAMP 시간정보를 __time64_t 시간정보로 변환
|
||
// PARM : 1 . lpDbTime - DBTIMESTAMP 시간정보
|
||
// RETV : __time64_t 시간정보
|
||
// PRGM : B4nFter
|
||
// P.S.>
|
||
// - _mkgmtime64() 을 사용하며 이것은 GMT 기준으로 변환
|
||
// - GMT (Greenwich Mean Time) 은 영국 그리니치 천문대 기준의 세계 표준시 (시간관련 C 런타임 라이브러리에서는 UTC (Coodinated Universal Time, 협정 세계시) 와 사실상 같은 의미로 사용됨)
|
||
//*---------------------------------------------------------------
|
||
__time64_t CTimeSet::ConvertDbTimeStampToTimeT64_GM(const DBTIMESTAMP* lpDbTime)
|
||
{
|
||
DN_ASSERT(NULL != lpDbTime, "Invalid!");
|
||
|
||
tm stTm;
|
||
// ::memset(&stTm, 0, sizeof(stTm)); // 영향 없음 (헤더 주석 참조할 것)
|
||
|
||
stTm.tm_year = lpDbTime->year - DF_TM_YEAR_EPOCH;
|
||
stTm.tm_mon = lpDbTime->month - 1;
|
||
stTm.tm_mday = lpDbTime->day;
|
||
stTm.tm_hour = lpDbTime->hour;
|
||
stTm.tm_min = lpDbTime->minute;
|
||
stTm.tm_sec = lpDbTime->second;
|
||
|
||
return(::_mkgmtime64(&stTm));
|
||
}
|
||
|
||
|
||
//*---------------------------------------------------------------
|
||
// TYPE : FUNCTION
|
||
// NAME : CTimeSet::ConvertTimeT32ToTm_LC
|
||
//*---------------------------------------------------------------
|
||
// DESC : 특정 __time32_t 시간정보를 tm 시간정보로 변환
|
||
// PARM : 1 . pTimeT32 - __time32_t 시간정보
|
||
// 2 . lpTm - tm 시간정보 출력버퍼
|
||
// RETV : TRUE - 성공 / FALSE - 실패
|
||
// PRGM : B4nFter
|
||
// P.S.>
|
||
// - _localtime32_s() 을 사용하며 이것은 현재 시스템의 달력시간을 기준으로 변환
|
||
// - 달력시간 (Calendar Value) 은 환경변수 TZ 의 영향을 받음 (ex> 대한민국 TZ = GMT - 09:00:00)
|
||
//*---------------------------------------------------------------
|
||
BOOL CTimeSet::ConvertTimeT32ToTm_LC(__time32_t pTimeT32, tm* lpTm)
|
||
{
|
||
DN_ASSERT(NULL != lpTm, "Invalid!");
|
||
|
||
errno_t aRetVal = ::_localtime32_s(lpTm, &pTimeT32);
|
||
if (aRetVal) {
|
||
return FALSE;
|
||
}
|
||
|
||
lpTm->tm_year += DF_TM_YEAR_EPOCH;
|
||
lpTm->tm_mon += 1;
|
||
|
||
return TRUE;
|
||
}
|
||
|
||
|
||
//*---------------------------------------------------------------
|
||
// TYPE : FUNCTION
|
||
// NAME : CTimeSet::ConvertTimeT64ToTm_LC
|
||
//*---------------------------------------------------------------
|
||
// DESC : 특정 __time64_t 시간정보를 tm 시간정보로 변환
|
||
// PARM : 1 . pTimeT64 - __time64_t 시간정보
|
||
// 2 . lpTm - tm 시간정보 출력버퍼
|
||
// RETV : TRUE - 성공 / FALSE - 실패
|
||
// PRGM : B4nFter
|
||
// P.S.>
|
||
// - _localtime64_s() 을 사용하며 이것은 현재 시스템의 달력시간을 기준으로 변환
|
||
// - 달력시간 (Calendar Value) 은 환경변수 TZ 의 영향을 받음 (ex> 대한민국 TZ = GMT - 09:00:00)
|
||
//*---------------------------------------------------------------
|
||
BOOL CTimeSet::ConvertTimeT64ToTm_LC(__time64_t pTimeT64, tm* lpTm)
|
||
{
|
||
DN_ASSERT(NULL != lpTm, "Invalid!");
|
||
|
||
errno_t aRetVal = ::_localtime64_s(lpTm, &pTimeT64);
|
||
if (aRetVal) {
|
||
return FALSE;
|
||
}
|
||
|
||
lpTm->tm_year += DF_TM_YEAR_EPOCH;
|
||
lpTm->tm_mon += 1;
|
||
|
||
return TRUE;
|
||
}
|
||
|
||
|
||
//*---------------------------------------------------------------
|
||
// TYPE : FUNCTION
|
||
// NAME : CTimeSet::ConvertTimeT32ToTm_GM
|
||
//*---------------------------------------------------------------
|
||
// DESC : 특정 __time32_t 시간정보를 tm 시간정보로 변환
|
||
// PARM : 1 . pTimeT32 - __time32_t 시간정보
|
||
// 2 . lpTm - tm 시간정보 출력버퍼
|
||
// RETV : TRUE - 성공 / FALSE - 실패
|
||
// PRGM : B4nFter
|
||
// P.S.>
|
||
// - _gmtime32_s() 을 사용하며 이것은 GMT 기준으로 변환
|
||
// - GMT (Greenwich Mean Time) 은 영국 그리니치 천문대 기준의 세계 표준시 (시간관련 C 런타임 라이브러리에서는 UTC (Coodinated Universal Time, 협정 세계시) 와 사실상 같은 의미로 사용됨)
|
||
//*---------------------------------------------------------------
|
||
BOOL CTimeSet::ConvertTimeT32ToTm_GM(__time32_t pTimeT32, tm* lpTm)
|
||
{
|
||
DN_ASSERT(NULL != lpTm, "Invalid!");
|
||
|
||
errno_t aRetVal = ::_gmtime32_s(lpTm, &pTimeT32);
|
||
if (aRetVal) {
|
||
return FALSE;
|
||
}
|
||
|
||
lpTm->tm_year += DF_TM_YEAR_EPOCH;
|
||
lpTm->tm_mon += 1;
|
||
|
||
return TRUE;
|
||
}
|
||
|
||
|
||
//*---------------------------------------------------------------
|
||
// TYPE : FUNCTION
|
||
// NAME : CTimeSet::ConvertTimeT64ToTm_GM
|
||
//*---------------------------------------------------------------
|
||
// DESC : 특정 __time64_t 시간정보를 tm 시간정보로 변환
|
||
// PARM : 1 . pTimeT64 - __time64_t 시간정보
|
||
// 2 . lpTm - tm 시간정보 출력버퍼
|
||
// RETV : TRUE - 성공 / FALSE - 실패
|
||
// PRGM : B4nFter
|
||
// P.S.>
|
||
// - _gmtime32_s() 을 사용하며 이것은 GMT 기준으로 변환
|
||
// - GMT (Greenwich Mean Time) 은 영국 그리니치 천문대 기준의 세계 표준시 (시간관련 C 런타임 라이브러리에서는 UTC (Coodinated Universal Time, 협정 세계시) 와 사실상 같은 의미로 사용됨)
|
||
//*---------------------------------------------------------------
|
||
BOOL CTimeSet::ConvertTimeT64ToTm_GM(__time64_t pTimeT64, tm* lpTm)
|
||
{
|
||
DN_ASSERT(NULL != lpTm, "Invalid!");
|
||
|
||
errno_t aRetVal = ::_gmtime64_s(lpTm, &pTimeT64);
|
||
if (aRetVal) {
|
||
return FALSE;
|
||
}
|
||
|
||
lpTm->tm_year += DF_TM_YEAR_EPOCH;
|
||
lpTm->tm_mon += 1;
|
||
|
||
return TRUE;
|
||
}
|
||
|
||
|
||
//*---------------------------------------------------------------
|
||
// TYPE : FUNCTION
|
||
// NAME : CTimeSet::ConvertTimeT32ToDbTimeStamp_LC
|
||
//*---------------------------------------------------------------
|
||
// DESC : 특정 __time32_t 시간정보를 DBTIMESTAMP 시간정보로 변환
|
||
// PARM : 1 . pTimeT32 - __time32_t 시간정보
|
||
// 2 . lpDbTime - DBTIMESTAMP 시간정보 출력버퍼
|
||
// RETV : TRUE - 성공 / FALSE - 실패
|
||
// PRGM : B4nFter
|
||
// P.S.>
|
||
// - _localtime32_s() 을 사용하며 이것은 현재 시스템의 달력시간을 기준으로 변환
|
||
// - 달력시간 (Calendar Value) 은 환경변수 TZ 의 영향을 받음 (ex> 대한민국 TZ = GMT - 09:00:00)
|
||
//*---------------------------------------------------------------
|
||
BOOL CTimeSet::ConvertTimeT32ToDbTimeStamp_LC(__time32_t pTimeT32, DBTIMESTAMP* lpDbTime)
|
||
{
|
||
DN_ASSERT(NULL != lpDbTime, "Invalid!");
|
||
|
||
tm stTm;
|
||
errno_t aRetVal = ::_localtime32_s(&stTm, &pTimeT32);
|
||
if (aRetVal) {
|
||
return FALSE;
|
||
}
|
||
|
||
lpDbTime->year = static_cast<SHORT>(stTm.tm_year + DF_TM_YEAR_EPOCH);
|
||
lpDbTime->month = static_cast<USHORT>(stTm.tm_mon + 1);
|
||
lpDbTime->day = static_cast<USHORT>(stTm.tm_mday);
|
||
lpDbTime->hour = static_cast<USHORT>(stTm.tm_hour);
|
||
lpDbTime->minute = static_cast<USHORT>(stTm.tm_min);
|
||
lpDbTime->second = static_cast<USHORT>(stTm.tm_sec);
|
||
lpDbTime->fraction = 0;
|
||
|
||
return TRUE;
|
||
}
|
||
|
||
|
||
//*---------------------------------------------------------------
|
||
// TYPE : FUNCTION
|
||
// NAME : CTimeSet::ConvertTimeT64ToDbTimeStamp_LC
|
||
//*---------------------------------------------------------------
|
||
// DESC : 특정 __time64_t 시간정보를 DBTIMESTAMP 시간정보로 변환
|
||
// PARM : 1 . pTimeT64 - __time64_t 시간정보
|
||
// 2 . lpDbTime - DBTIMESTAMP 시간정보 출력버퍼
|
||
// RETV : TRUE - 성공 / FALSE - 실패
|
||
// PRGM : B4nFter
|
||
// P.S.>
|
||
// - _localtime64_s() 을 사용하며 이것은 현재 시스템의 달력시간을 기준으로 변환
|
||
// - 달력시간 (Calendar Value) 은 환경변수 TZ 의 영향을 받음 (ex> 대한민국 TZ = GMT - 09:00:00)
|
||
//*---------------------------------------------------------------
|
||
BOOL CTimeSet::ConvertTimeT64ToDbTimeStamp_LC(__time64_t pTimeT64, DBTIMESTAMP* lpDbTime)
|
||
{
|
||
DN_ASSERT(NULL != lpDbTime, "Invalid!");
|
||
|
||
tm stTm;
|
||
errno_t aRetVal = ::_localtime64_s(&stTm, &pTimeT64);
|
||
if (aRetVal) {
|
||
return FALSE;
|
||
}
|
||
|
||
lpDbTime->year = static_cast<SHORT>(stTm.tm_year + DF_TM_YEAR_EPOCH);
|
||
lpDbTime->month = static_cast<USHORT>(stTm.tm_mon + 1);
|
||
lpDbTime->day = static_cast<USHORT>(stTm.tm_mday);
|
||
lpDbTime->hour = static_cast<USHORT>(stTm.tm_hour);
|
||
lpDbTime->minute = static_cast<USHORT>(stTm.tm_min);
|
||
lpDbTime->second = static_cast<USHORT>(stTm.tm_sec);
|
||
lpDbTime->fraction = 0;
|
||
|
||
return TRUE;
|
||
}
|
||
|
||
|
||
//*---------------------------------------------------------------
|
||
// TYPE : FUNCTION
|
||
// NAME : CTimeSet::ConvertTimeT32ToDbTimeStamp_GM
|
||
//*---------------------------------------------------------------
|
||
// DESC : 특정 __time32_t 시간정보를 DBTIMESTAMP 시간정보로 변환
|
||
// PARM : 1 . pTimeT32 - __time32_t 시간정보
|
||
// 2 . lpDbTime - DBTIMESTAMP 시간정보 출력버퍼
|
||
// RETV : TRUE - 성공 / FALSE - 실패
|
||
// PRGM : B4nFter
|
||
// P.S.>
|
||
// - _gmtime32_s() 을 사용하며 이것은 GMT 기준으로 변환
|
||
// - GMT (Greenwich Mean Time) 은 영국 그리니치 천문대 기준의 세계 표준시 (시간관련 C 런타임 라이브러리에서는 UTC (Coodinated Universal Time, 협정 세계시) 와 사실상 같은 의미로 사용됨)
|
||
//*---------------------------------------------------------------
|
||
BOOL CTimeSet::ConvertTimeT32ToDbTimeStamp_GM(__time32_t pTimeT32, DBTIMESTAMP* lpDbTime)
|
||
{
|
||
DN_ASSERT(NULL != lpDbTime, "Invalid!");
|
||
|
||
tm stTm;
|
||
errno_t aRetVal = ::_gmtime32_s(&stTm, &pTimeT32);
|
||
if (aRetVal) {
|
||
return FALSE;
|
||
}
|
||
|
||
lpDbTime->year = static_cast<SHORT>(stTm.tm_year + DF_TM_YEAR_EPOCH);
|
||
lpDbTime->month = static_cast<USHORT>(stTm.tm_mon + 1);
|
||
lpDbTime->day = static_cast<USHORT>(stTm.tm_mday);
|
||
lpDbTime->hour = static_cast<USHORT>(stTm.tm_hour);
|
||
lpDbTime->minute = static_cast<USHORT>(stTm.tm_min);
|
||
lpDbTime->second = static_cast<USHORT>(stTm.tm_sec);
|
||
lpDbTime->fraction = 0;
|
||
|
||
return TRUE;
|
||
}
|
||
|
||
|
||
//*---------------------------------------------------------------
|
||
// TYPE : FUNCTION
|
||
// NAME : CTimeSet::ConvertTimeT64ToDbTimeStamp_GM
|
||
//*---------------------------------------------------------------
|
||
// DESC : 특정 __time64_t 시간정보를 DBTIMESTAMP 시간정보로 변환
|
||
// PARM : 1 . pTimeT64 - __time64_t 시간정보
|
||
// 2 . lpDbTime - DBTIMESTAMP 시간정보 출력버퍼
|
||
// RETV : TRUE - 성공 / FALSE - 실패
|
||
// PRGM : B4nFter
|
||
// P.S.>
|
||
// - _gmtime32_s() 을 사용하며 이것은 GMT 기준으로 변환
|
||
// - GMT (Greenwich Mean Time) 은 영국 그리니치 천문대 기준의 세계 표준시 (시간관련 C 런타임 라이브러리에서는 UTC (Coodinated Universal Time, 협정 세계시) 와 사실상 같은 의미로 사용됨)
|
||
//*---------------------------------------------------------------
|
||
BOOL CTimeSet::ConvertTimeT64ToDbTimeStamp_GM(__time64_t pTimeT64, DBTIMESTAMP* lpDbTime)
|
||
{
|
||
DN_ASSERT(NULL != lpDbTime, "Invalid!");
|
||
|
||
tm stTm;
|
||
errno_t aRetVal = ::_gmtime64_s(&stTm, &pTimeT64);
|
||
if (aRetVal) {
|
||
return FALSE;
|
||
}
|
||
|
||
lpDbTime->year = static_cast<SHORT>(stTm.tm_year + DF_TM_YEAR_EPOCH);
|
||
lpDbTime->month = static_cast<USHORT>(stTm.tm_mon + 1);
|
||
lpDbTime->day = static_cast<USHORT>(stTm.tm_mday);
|
||
lpDbTime->hour = static_cast<USHORT>(stTm.tm_hour);
|
||
lpDbTime->minute = static_cast<USHORT>(stTm.tm_min);
|
||
lpDbTime->second = static_cast<USHORT>(stTm.tm_sec);
|
||
lpDbTime->fraction = 0;
|
||
|
||
return TRUE;
|
||
}
|
||
|
||
|
||
CTimeSet::EF_DAYOFWEEK CTimeSet::CalculateDayOfWeek() // 20100728
|
||
{
|
||
return(CTimeSet::CalculateDayOfWeek(m_stLocalTime.wYear, m_stLocalTime.wMonth, m_stLocalTime.wDay));
|
||
}
|
||
|
||
|
||
CTimeSet::EF_DAYOFWEEK CTimeSet::CalculateDayOfWeek(WORD wYear, WORD wMonth, WORD wDay) // 20100728
|
||
{
|
||
INT aMonthDays[] = { 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 }; // 12 Month
|
||
|
||
long aTotal = (wYear-1)*365L + (wYear-1)/4 - (wYear-1)/100 + (wYear-1)/400;
|
||
|
||
if (!(wYear%4) && (wYear%100) || !(wYear%400)) {
|
||
++aMonthDays[1];
|
||
}
|
||
|
||
for (int aIndex = 0 ; wMonth-1 > aIndex ; ++aIndex) {
|
||
aTotal += aMonthDays[aIndex];
|
||
}
|
||
|
||
aTotal += wDay;
|
||
|
||
return(static_cast<CTimeSet::EF_DAYOFWEEK>(aTotal % 7));
|
||
}
|
||
|