www.pudn.com > acdx.rar > TimeStamp.cpp

#include "StdAfx.h" 
#include "TimeStamp.h" 
 
#include  
 
 
#if defined(_DEBUG) 
#define new DEBUG_NEW 
#undef THIS_FILE 
static char THIS_FILE[] = __FILE__; 
#endif 
 
 
///////////////////////////////////////////////////////////////////////////////////////// 
// conversion methods 
 
double DoubleFromDate(DATE date) 
{ 
	// No problem if positive 
	if (date >= 0) 
		return date; 
 
	try 
	{ 
		// If negative, must convert since negative dates not continuous 
		// (examples: -1.25 to -.75, -1.50 to -.50, -1.75 to -.25) 
		double temp = ceil(date); 
		return temp - (date - temp); 
	} 
	catch(...) 
	{ 
		_ASSERT(FALSE); 
	} 
} 
 
DATE DateFromDouble(double date) 
{ 
	// No problem if positive 
	if (date >= 0) 
		return date; 
	try 
	{ 
		// If negative, must convert since negative dates not continuous 
		// (examples: -.75 to -1.25, -.50 to -1.50, -.25 to -1.75) 
		double temp = floor(date); // dbl is now whole part 
		return temp + (temp - date); 
	} 
	catch(...) 
	{ 
		_ASSERT(FALSE); 
	} 
} 
 
 
 
///////////////////////////////////////////////////////////////////////////// 
// TimeStamp class 
 
////////////////////////////////////////////////////////////////////////////////////// 
// constructors 
 
//##ModelId=424BB63F03E0 
TimeStamp::TimeStamp() 
{  
	m_timestamp = 0;  
	m_valid = valid;  
 
	setDefaultFormat(); 
} 
 
//##ModelId=424BB63F03E1 
TimeStamp::TimeStamp(TimeStamp& dateSrc) 
{  
	m_timestamp = dateSrc.m_timestamp;  
	m_valid = dateSrc.m_valid;  
 
	setDefaultFormat(); 
} 
 
//##ModelId=424BB6400007 
TimeStamp::TimeStamp(VARIANT& varSrc) 
{  
	*this = varSrc;  
 
	setDefaultFormat(); 
} 
 
//##ModelId=424BB6400009 
TimeStamp::TimeStamp(DATE dtSrc) 
{  
	m_timestamp = dtSrc;  
	m_valid = valid;  
 
	setDefaultFormat(); 
} 
 
//##ModelId=424BB6400017 
TimeStamp::TimeStamp(SYSTEMTIME& systimeSrc) 
{  
	*this = systimeSrc;  
 
	setDefaultFormat(); 
} 
 
//##ModelId=424BB6400019 
TimeStamp::TimeStamp(FILETIME& filetimeSrc) 
{  
	*this = filetimeSrc;  
 
	setDefaultFormat(); 
} 
 
//##ModelId=424BB6400027 
TimeStamp::TimeStamp(long year, long month, long day, 
	           long hour, long minute, long second ) 
{  
	setDateTime(year, month, day, hour, minute, second);  
 
	setDefaultFormat(); 
} 
 
////////////////////////////////////////////////////////////////////////////////////// 
// get current time stamp 
 
//##ModelId=424BB64000A5 
void TimeStamp::getCurTimeStamp	() 
{ 
	// get local time 
	SYSTEMTIME sysTime; 
	::GetLocalTime(&sysTime); 
 
	// convert to variant date 
	*this = sysTime; 
} 
 
//##ModelId=424BB64000A6 
void TimeStamp::getCurTimeStamp ( DATE & timestamp ) 
{	 
	// get local time 
	SYSTEMTIME sysTime; 
	::GetLocalTime(&sysTime); 
 
	// convert to variant date 
	SystemTimeToVariantTime(&sysTime,×tamp); 
} 
 
 
 
//##ModelId=424BB64000B4 
void TimeStamp::getCurTimeStamp ( string & str ) 
{ 
	DATE timestamp; 
	getCurTimeStamp(timestamp); 
 
	getTimeStamp(timestamp,str); 
} 
 
 
////////////////////////////////////////////////////////////////////////////////////// 
// access methods 
 
//##ModelId=424BB64000C4 
long TimeStamp::getYear() 
{ 
	if ( m_valid != valid ) 
		return -1; 
 
	SYSTEMTIME sysTime; 
	if ( VariantTimeToSystemTime(m_timestamp,&sysTime) ) 
		return (long) sysTime.wYear; 
	else 
		return -1; 
} 
 
//##ModelId=424BB64000C5 
long TimeStamp::getMonth() 
{ 
	if ( m_valid != valid ) 
		return -1; 
 
	SYSTEMTIME sysTime; 
	if ( VariantTimeToSystemTime(m_timestamp,&sysTime) ) 
		return (long) sysTime.wMonth; 
	else 
		return -1; 
} 
 
//##ModelId=424BB64000D2 
long TimeStamp::getDay() 
{ 
	if ( m_valid != valid ) 
		return -1; 
 
	SYSTEMTIME sysTime; 
	if ( VariantTimeToSystemTime(m_timestamp,&sysTime) ) 
		return (long) sysTime.wDay; 
	else 
		return -1; 
} 
 
//##ModelId=424BB64000D3 
long TimeStamp::getHour() 
{ 
	if ( m_valid != valid ) 
		return -1; 
 
	SYSTEMTIME sysTime; 
	if ( VariantTimeToSystemTime(m_timestamp,&sysTime) ) 
		return (long) sysTime.wHour; 
	else 
		return -1; 
} 
 
//##ModelId=424BB64000E2 
long TimeStamp::getMinute() 
{ 
	if ( m_valid != valid ) 
		return -1; 
 
	SYSTEMTIME sysTime; 
	if ( VariantTimeToSystemTime(m_timestamp,&sysTime) ) 
		return (long) sysTime.wMinute; 
	else 
		return -1; 
} 
 
//##ModelId=424BB64000E3 
long TimeStamp::getSecond() 
{ 
	if ( m_valid != valid ) 
		return -1; 
 
	SYSTEMTIME sysTime; 
	if ( VariantTimeToSystemTime(m_timestamp,&sysTime) ) 
		return (long) sysTime.wSecond; 
	else 
		return -1; 
} 
 
//##ModelId=424BB64000E4 
long TimeStamp::getDayOfWeek() 
{ 
	if ( m_valid != valid ) 
		return -1; 
 
	SYSTEMTIME sysTime; 
	if ( VariantTimeToSystemTime(m_timestamp,&sysTime) ) 
		return (long) sysTime.wDay; 
	else 
		return -1; 
} 
 
//##ModelId=424BB6400112 
void TimeStamp::operator=( VARIANT& varSrc ) 
{ 
	if (varSrc.vt == VT_DATE) 
	{ 
		m_timestamp = varSrc.date; 
		m_valid = valid; 
	} 
} 
 
//##ModelId=424BB6400122 
void TimeStamp::operator=(DATE dtSrc) 
{ 
	m_timestamp = dtSrc; 
	m_valid = valid; 
} 
 
//##ModelId=424BB6400131 
void TimeStamp::operator=( SYSTEMTIME & sysTime ) 
{ 
	if ( SystemTimeToVariantTime(&sysTime,&m_timestamp) )		 
		m_valid = valid; 
	else 
		m_valid = invalid; 
} 
 
//##ModelId=424BB640014F 
void TimeStamp::operator=( FILETIME & fileTime ) 
{ 
	m_valid = invalid; 
 
	// convert to sys time then to ole time 
	SYSTEMTIME sysTime; 
	if ( FileTimeToSystemTime(&fileTime, &sysTime) ) 
	{ 
		if ( SystemTimeToVariantTime(&sysTime,&m_timestamp) )		 
			m_valid = valid; 
	} 
} 
 
//##ModelId=424BB640017E 
bool TimeStamp::operator<( const TimeStamp& ts) 
{ 
	// Handle negative dates 
	return DoubleFromDate(m_timestamp) < DoubleFromDate(ts.m_timestamp); 
} 
 
//##ModelId=424BB640018E 
bool TimeStamp::operator>( const TimeStamp& ts) 
{ 
	// Handle negative dates 
	return DoubleFromDate(m_timestamp) > DoubleFromDate(ts.m_timestamp); 
} 
 
//##ModelId=424BB6400190 
bool TimeStamp::operator<=( const TimeStamp& ts) 
{ 
	// Handle negative dates 
	return DoubleFromDate(m_timestamp) <= DoubleFromDate(ts.m_timestamp); 
} 
 
//##ModelId=424BB640019E 
bool TimeStamp::operator>=( const TimeStamp& ts) 
{ 
	// Handle negative dates 
	return DoubleFromDate(m_timestamp) >= DoubleFromDate(ts.m_timestamp); 
} 
 
//##ModelId=424BB64001A0 
TimeStamp TimeStamp::operator+( TimeStamp & ts ) 
{ 
	TimeStamp result; 
 
	// Compute the actual date difference by adding underlying dates 
	result = DateFromDouble(DoubleFromDate(m_timestamp) + ts.m_timestamp); 
 
	result.isValid(); 
 
	return result; 
} 
 
//##ModelId=424BB64001AE 
TimeStamp TimeStamp::operator-( TimeStamp & ts ) 
{ 
	TimeStamp result; 
 
 
	// Return result (span can't be invalid, so don't check range) 
	return DoubleFromDate(m_timestamp) - DoubleFromDate(ts.m_timestamp); 
} 
 
//##ModelId=424BB64001CE 
void TimeStamp::setDateTime(long year, long month, long day, 
	                    long hour, long minute, long second ) 
{ 
	// convert to sys time 
	SYSTEMTIME sysTime; 
	sysTime.wYear = year;  
	sysTime.wMonth = minute;  
	sysTime.wDay = day;  
	sysTime.wHour = hour;  
	sysTime.wMinute = minute;  
	sysTime.wSecond = second;  
 
	// convert to ole date 
	if ( SystemTimeToVariantTime(&sysTime,&m_timestamp) )		 
		m_valid = valid; 
	else 
		m_valid = invalid; 
} 
 
 
//##ModelId=424BB6400269 
bool TimeStamp::isValid () 
{ 
	// about year 100 to about 9999 
	if ( m_timestamp > MAX_DATE || m_timestamp < MIN_DATE )  
	{ 
		m_valid = invalid; 
		return false; 
	} 
 
	else 
	{ 
		m_valid = valid; 
		return true; 
	} 
} 
 
 
//////////////////////////////////////////////////////////////////// 
// format methods 
 
//##ModelId=424BB6400048 
void TimeStamp::setDefaultFormat () 
{ 
	// "h:mm:ss tt" 
	string str = "h:mm:ss tt"; 
	setFormat(str); 
} 
 
//##ModelId=424BB6400046 
string TimeStamp::format ( LPTSTR strFormat ) 
{ 
	// #DGH 
	// need to modify  
	// and check  
 
	// init sys time struct 
	SYSTEMTIME sysTime; 
	memset(&sysTime,0,sizeof(sysTime)); 
	VariantTimeToSystemTime(m_timestamp,&sysTime); 
 
	// set the flags 
	DWORD flags = 0; 
 
	// get time 
	char str[128]; 
	DWORD count =  
	GetTimeFormat( LOCALE_USER_DEFAULT, flags, &sysTime,  
		           strFormat, str, 128 ); 
 
	if ( count == 0 ) 
	{ 
		DWORD error = GetLastError(); 
		return string(""); 
	} 
	else 
	{ 
		return string( str ); 
	} 
} 
 
 
//##ModelId=424BB6400055 
void TimeStamp::setFormat ( string & strFormat ) 
{ 
 
	// "h:mm:ss tt" 
	if ( strFormat == "h:mm:ss tt" ) 
	{ 
		m_standard = true; 
	} 
 
	// "hh:mm:ss tt" 
	else if ( strFormat == "hh:mm:ss tt" ) 
	{ 
		m_standard = true; 
	} 
 
	// "H:mm:ss" 
	else if ( strFormat == "H:mm:ss" ) 
	{ 
		m_standard = false; 
	} 
 
	// "HH:mm:ss" 
	else if ( strFormat == "HH:mm:ss" ) 
	{ 
		m_standard = false; 
	} 
	else  
		return; 
 
	m_format = strFormat; 
} 
 
//##ModelId=424BB6400095 
void TimeStamp::getTimeStamp ( DATE timestamp, string & timestampStr ) 
{ 
	TCHAR str[128]; 
 
	// init sys time struct 
	SYSTEMTIME sysTime; 
	VariantTimeToSystemTime(timestamp,&sysTime); 
 
	// get date 
	DWORD count = 
	GetDateFormat( LOCALE_USER_DEFAULT,  
	               DATE_SHORTDATE,  
				   &sysTime,  
		           NULL, str, 128 ); 
 
	if ( count != 0 ) 
		timestampStr = str; 
 
	// get time 
	count =  
	GetTimeFormat( LOCALE_USER_DEFAULT,  
	               0,  
	               &sysTime,  
		           "hh::mm::ss tt", str, 128 ); 
 
	if ( count != 0 ) 
	{ 
		timestampStr += " "; 
		timestampStr += str; 
	} 
} 
 
 
 
 
//##ModelId=424BB6400084 
bool TimeStamp::getTimeStamp ( string & timestamp, string & format, DWORD flags, LCID lcid) 
{ 
	TCHAR str[128]; 
	DWORD error; 
 
	bool success = true; 
 
	// init sys time struct 
	SYSTEMTIME sysTime; 
	VariantTimeToSystemTime(m_timestamp,&sysTime); 
 
	// get time 
	DWORD count =  
	GetTimeFormat( lcid, flags, &sysTime,  
		           format.c_str(), str, 128 ); 
 
	if ( count == 0 ) 
	{ 
		error   = GetLastError(); 
		success = false; 
	} 
	else 
		timestamp = str; 
 
	// get date 
	count = 
	GetDateFormat( lcid, flags, &sysTime,  
		           format.c_str(), str, 128 ); 
 
	if ( count == 0 ) 
	{ 
		error   = GetLastError(); 
		success = false; 
	} 
	else 
	{ 
		timestamp += " "; 
		timestamp += str; 
	} 
 
	return success; 
} 
 
 
 
//##ModelId=424BB6400076 
bool TimeStamp::getTimeStamp ( string & str, bool showSeconds ) 
{ 
	string timeStr; 
	getTimeStr( timeStr, false ); 
 
	string dateStr; 
	getDateStr( dateStr, true ); 
 
	stringstream strm; 
	strm << dateStr; 
	strm << " " << timeStr; 
 
	str = strm.str(); 
	return true; 
} 
 
//##ModelId=424BB6400057 
void TimeStamp::getTimeStr ( string & timeStr, bool showSeconds ) 
{ 
	// init sys time struct 
	SYSTEMTIME sysTime; 
	memset(&sysTime,0,sizeof(sysTime)); 
	VariantTimeToSystemTime(m_timestamp,&sysTime); 
 
	// get the seconds 
	DWORD flags = 0; 
	if ( !showSeconds ) 
	{ 
		flags |= TIME_NOSECONDS; 
		sysTime.wSecond = 0; 
	} 
 
	// set military flags 
	if ( !m_standard ) 
		flags |= TIME_FORCE24HOURFORMAT | TIME_NOTIMEMARKER; 
 
	// get time 
	char str[128]; 
	DWORD count =  
	GetTimeFormat( LOCALE_USER_DEFAULT, flags, &sysTime,  
		           m_format.c_str(), str, 128 ); 
 
	if ( count == 0 ) 
	{ 
		DWORD error = GetLastError(); 
	} 
	else 
		timeStr = str; 
} 
 
//##ModelId=424BB6400066 
void TimeStamp::getDateStr ( string & dateStr, bool useShortDateFormat ) 
{ 
	// init sys time struct 
	SYSTEMTIME time; 
	memset(&time,0,sizeof(time)); 
 
	// get the time 
	time.wMonth = getMonth(); 
	time.wDay = getDay(); 
	time.wYear = getYear(); 
 
 
	// set flags 
	DWORD flags = 0; 
	if ( useShortDateFormat ) 
		flags |= DATE_SHORTDATE; 
	else 
		flags |= DATE_LONGDATE; 
 
	// get time 
	char str[128]; 
 
	DWORD count = 
	GetDateFormat( LOCALE_USER_DEFAULT, flags, &time,  
		           NULL, str, 128 ); 
 
	if ( count == 0 ) 
	{ 
		DWORD error = GetLastError(); 
	} 
	else 
		dateStr = str; 
}