hightime.cpp

Time to number format convertor

	if (GetStatus() == valid && ConvertLongLongToTime(m_liTime, tmTemp))
		return tmTemp.nDay;
	else
		return HIGH_DATETIME_ERROR;
} // CHighTime::GetDay()

int CHighTime::GetHour() const        // hour in day (0-23)
{
	_HighTimeFormat tmTemp;
	if (GetStatus() == valid && ConvertLongLongToTime(m_liTime, tmTemp))
		return tmTemp.nHour;
	else
		return HIGH_DATETIME_ERROR;
} // CHighTime::GetHour()

int CHighTime::GetMinute() const      // minute in hour (0-59)
{
	_HighTimeFormat tmTemp;
	if (GetStatus() == valid && ConvertLongLongToTime(m_liTime, tmTemp))
		return tmTemp.nMinute;
	else
		return HIGH_DATETIME_ERROR;

} // CHighTime::GetMinute()

int CHighTime::GetSecond() const      // second in minute (0-59)
{
	_HighTimeFormat tmTemp;
	if (GetStatus() == valid && ConvertLongLongToTime(m_liTime, tmTemp))
		return tmTemp.nSecond;
	else
		return HIGH_DATETIME_ERROR;
} // CHighTime::GetSecond()

int CHighTime::GetMilliSecond() const // millisecond in minute (0-999)
{
	_HighTimeFormat tmTemp;
	if (GetStatus() == valid && ConvertLongLongToTime(m_liTime, tmTemp))
		return tmTemp.nMilli;
	else
		return HIGH_DATETIME_ERROR;
} // CHighTime::GetMilliSecond()

int CHighTime::GetMicroSecond() const // microsecond in minute (0-999)
{
	_HighTimeFormat tmTemp;
	if (GetStatus() == valid && ConvertLongLongToTime(m_liTime, tmTemp))
		return tmTemp.nMicro;
	else
		return HIGH_DATETIME_ERROR;
} // CHighTime::GetMicroSecond()

int CHighTime::GetNanoSecond() const  // nanosecond in minute (0-999), step of 100ns
{
	_HighTimeFormat tmTemp;
	if (GetStatus() == valid && ConvertLongLongToTime(m_liTime, tmTemp))
		return tmTemp.nNano;
	else
		return HIGH_DATETIME_ERROR;
} // CHighTime::GetNanoSecond()

int CHighTime::GetDayOfWeek() const   // 1=Sun, 2=Mon, ..., 7=Sat
{
	_HighTimeFormat tmTemp;
	if (GetStatus() == valid && ConvertLongLongToTime(m_liTime, tmTemp))
		return tmTemp.nDayOfWeek;
	else
		return HIGH_DATETIME_ERROR;
} // CHighTime::GetDayOfWeek()

int CHighTime::GetDayOfYear() const   // days since start of year, Jan 1 = 1
{
	_HighTimeFormat tmTemp;
	if (GetStatus() == valid && ConvertLongLongToTime(m_liTime, tmTemp))
		return tmTemp.nDayOfYear;
	else
		return HIGH_DATETIME_ERROR;
} // CHighTime::GetDayOfYear()

BOOL CHighTime::GetAsSystemTime(SYSTEMTIME& sysTime) const
{
	BOOL bRetVal = FALSE;
	if (GetStatus() == valid)
	{
		_HighTimeFormat tmTemp;
		if (ConvertLongLongToTime(m_liTime, tmTemp))
		{
			sysTime.wYear = (WORD) tmTemp.nYear;
			sysTime.wMonth = (WORD) tmTemp.nMonth;
			sysTime.wDayOfWeek = (WORD) (tmTemp.nDayOfWeek - 1);
			sysTime.wDay = (WORD) tmTemp.nDay;
			sysTime.wHour = (WORD) tmTemp.nHour;
			sysTime.wMinute = (WORD) tmTemp.nMinute;
			sysTime.wSecond = (WORD) tmTemp.nSecond;
			sysTime.wMilliseconds = (WORD)tmTemp.nMilli;

			bRetVal = TRUE;
		}
	}

	return bRetVal;
} // CHighTime::GetAsSystemTime()

// CHighTime math
CHighTime CHighTime::operator+(const CHighTimeSpan &dateSpan) const
{
	CHighTime dateResult;    // Initializes m_status to valid

	// If either operand NULL, result NULL
	if (GetStatus() == null || dateSpan.GetStatus() == null)
	{
		dateResult.SetStatus(null);
		return dateResult;
	}

	// If either operand invalid, result invalid
	if (GetStatus() == invalid || dateSpan.GetStatus() == invalid)
	{
		dateResult.SetStatus(invalid);
		return dateResult;
	}

	// Compute the actual date difference by adding underlying dates
	dateResult.m_liTime.QuadPart = m_liTime.QuadPart + dateSpan.m_liSpan.QuadPart;

	// Validate within range
	//dateResult.CheckRange();

	return dateResult;
} // CHighTime::operator+()

CHighTime CHighTime::operator-(const CHighTimeSpan &dateSpan) const
{
	CHighTime dateResult;    // Initializes m_status to valid

	// If either operand NULL, result NULL
	if (GetStatus() == null || dateSpan.GetStatus() == null)
	{
		dateResult.SetStatus(null);
		return dateResult;
	}

	// If either operand invalid, result invalid
	if (GetStatus() == invalid || dateSpan.GetStatus() == invalid)
	{
		dateResult.SetStatus(invalid);
		return dateResult;
	}

	// Compute the actual date difference by adding underlying dates
	dateResult.m_liTime.QuadPart = m_liTime.QuadPart - dateSpan.m_liSpan.QuadPart;

	// Validate within range
	//dateResult.CheckRange();

	return dateResult;
} // CHighTime::operator-()


// CHighTimeSpan math
CHighTimeSpan CHighTime::operator-(const CHighTime& date) const
{
	CHighTimeSpan spanResult;

	// If either operand NULL, result NULL
	if (GetStatus() == null || date.GetStatus() == null)
	{
		spanResult.SetStatus(CHighTimeSpan::null);
		return spanResult;
	}

	// If either operand invalid, result invalid
	if (GetStatus() == invalid || date.GetStatus() == invalid)
	{
		spanResult.SetStatus(CHighTimeSpan::invalid);
		return spanResult;
	}

    spanResult.m_liSpan.QuadPart = m_liTime.QuadPart - date.m_liTime.QuadPart;


	return spanResult;
} // CHighTime::operator-()

// String helper functions
int CHighTime::FindStr(LPCTSTR pszSource, LPCTSTR pszSub, int nStart)
{
	int nLength = strlen(pszSource);
	if (nStart > nLength)
		return -1;

	// find first
	LPSTR pszSearch = (LPSTR)strstr(pszSource + nStart, pszSub);

	// return -1 for not found
	return (pszSearch == NULL) ? -1 : (int)(pszSearch - pszSource);
} // CHighTime::FindStr()

int CHighTime::ReplaceStr(LPSTR pszDest, int nDestSize, LPCTSTR pszMask, LPCTSTR pszSource)
{
    int nCount, iInsertLen, iReplaceLen, iMoveLen, iDestLen;
    LPSTR pSearch, pStartPos;

    nCount = 0;
    pStartPos = pszDest;
    while ( (pSearch = strstr(pStartPos, pszMask)) != NULL) {
        pStartPos = pSearch + 1;
        ++nCount;
    }

    if (nCount > 0) {

        iReplaceLen = strlen(pszMask);
        iInsertLen = strlen(pszSource);

        // Can destination take the target?
        if ((int)strlen(pszDest) + nCount*(iInsertLen - iReplaceLen) > nDestSize) 
            return 0; // no => do nothing

        iDestLen = strlen(pszDest);
        pStartPos = pszDest;
        while ( (pSearch = strstr(pStartPos, pszMask)) != NULL) {
           
            iMoveLen = iDestLen - (pSearch - pszDest);
            if (iReplaceLen != iInsertLen ) {
                memmove(pSearch + (iInsertLen - iReplaceLen), pSearch, iMoveLen);
                iDestLen += iInsertLen - iReplaceLen;
                pszDest[iDestLen] = '\0';
            }
            memcpy(pSearch, pszSource, iInsertLen);

            pStartPos = pSearch + 1;
        }
    }
    return nCount;
} // CHighTime::ReplaceStr()

// Formatting, Non MFC
LPCTSTR CHighTime::Format(LPSTR pBuffer, int iBufferLen, LPCTSTR pFormat) const
{
	_HighTimeFormat tmHighTimeTemp;
    tm tmTemp;
    LPSTR szTemp = NULL;
    int iPos;

	// If null, return empty string
	if (pBuffer == NULL || GetStatus() == null || iBufferLen <= 0)
		return NULL;

	// If invalid, return DateTime resource string
	if (GetStatus() == invalid || !ConvertLongLongToTime(m_liTime, tmHighTimeTemp))
	{
		strncpy(pBuffer, INVALID_DATETIME, iBufferLen);
		return pBuffer;
	}

    if (iBufferLen <= 10)
        szTemp = new CHAR[10];
    else
        szTemp = new CHAR[iBufferLen+1];
    // Add milli, micro & nano part!!!!!!
    //%s for the millisecond part
    //%u for the microsecond part
    //%n for the nanosecond part
    strncpy(pBuffer, pFormat, iBufferLen);

    iPos = FindStr(pBuffer, "%s", 0);
    if (iPos >= 0) {
        wsprintf(szTemp,"%03d",tmHighTimeTemp.nMilli);
        ReplaceStr(pBuffer, iBufferLen, "%s", szTemp);
    }
    iPos = FindStr(pBuffer, "%#s", 0);
    if (iPos >= 0) {
        wsprintf(szTemp,"%d",tmHighTimeTemp.nMilli);
        ReplaceStr(pBuffer, iBufferLen, "%#s", szTemp);
    }

    iPos = FindStr(pBuffer, "%u", 0);
    if (iPos >= 0) {
        wsprintf(szTemp,"%03d",tmHighTimeTemp.nMicro);
        ReplaceStr(pBuffer, iBufferLen, "%u", szTemp);
    }
    iPos = FindStr(pBuffer, "%#u", 0);
    if (iPos >= 0) {
        wsprintf(szTemp,"%d",tmHighTimeTemp.nMicro);
        ReplaceStr(pBuffer, iBufferLen, "%#u", szTemp);
    }

    iPos = FindStr(pBuffer, "%n", 0);
    if (iPos >= 0) {
        wsprintf(szTemp,"%03d",tmHighTimeTemp.nNano);
        ReplaceStr(pBuffer, iBufferLen, "%n", szTemp);
    }
    iPos = FindStr(pBuffer, "%#n", 0);
    if (iPos >= 0) {
        wsprintf(szTemp,"%d",tmHighTimeTemp.nNano);
        ReplaceStr(pBuffer, iBufferLen, "%#n", szTemp);
    }

	// Convert tm from internal format to standard format
    ConvertToStandardFormat(tmHighTimeTemp, tmTemp);

	// Fill in the buffer, disregard return value as it's not necessary
    strcpy(szTemp, pBuffer);
	strftime(pBuffer, iBufferLen, szTemp, &tmTemp);

    delete [] szTemp;

	return pBuffer;
} // CHighTime::Format()

// formatting
#if defined(USE_MFC)
CString CHighTime::Format(LPCTSTR lpszFormat) const
{
    CString szParse(lpszFormat);
    CString szTemp,strDate;
	_HighTimeFormat tmHighTimeTemp;
    tm tmTemp;
    int iPos;

	// If null, return empty string
	if (GetStatus() == null)
		return strDate;

	// If invalid, return DateTime resource string
	if (GetStatus() == invalid || !ConvertLongLongToTime(m_liTime, tmHighTimeTemp))
	{
		VERIFY(strDate.LoadString(AFX_IDS_INVALID_DATETIME));
		return strDate;
	}

    // Add milli, micro & nano part!!!!!!
    //%s for the millisecond part
    //%u for the microsecond part
    //%n for the nanosecond part
    iPos = szParse.Find("%s", 0);
    if (iPos >= 0) {
        szTemp.Format("%03d",abs(tmHighTimeTemp.nMilli));
        szParse.Replace("%s",szTemp);
    }
    iPos = szParse.Find("%#s", 0);
    if (iPos >= 0) {
        szTemp.Format("%d",abs(tmHighTimeTemp.nMilli));
        szParse.Replace("%#s",szTemp);
    }
    iPos = szParse.Find("%u", 0);
    if (iPos >= 0) {
        szTemp.Format("%03d",abs(tmHighTimeTemp.nMicro));
        szParse.Replace("%u",szTemp);
    }
    iPos = szParse.Find("%#u", 0);
    if (iPos >= 0) {
        szTemp.Format("%d",abs(tmHighTimeTemp.nMicro));
        szParse.Replace("%#u",szTemp);
    }
    iPos = szParse.Find("%n", 0);
    if (iPos >= 0) {
        szTemp.Format("%03d",abs(tmHighTimeTemp.nNano));
        szParse.Replace("%n",szTemp);
    }
    iPos = szParse.Find("%#n", 0);
    if (iPos >= 0) {
        szTemp.Format("%d",abs(tmHighTimeTemp.nNano));
        szParse.Replace("%#n",szTemp);
    }

    // Convert tm from internal format to standard format
    ConvertToStandardFormat(tmHighTimeTemp, tmTemp);

	// Fill in the buffer, disregard return value as it's not necessary
	strftime(strDate.GetBuffer(MAX_TIME_BUFFER_SIZE), MAX_TIME_BUFFER_SIZE, 
              szParse.GetBuffer(szParse.GetLength()), &tmTemp);
    szParse.ReleaseBuffer();
	strDate.ReleaseBuffer();

	return strDate;
} // CHighTime::Format()

CString CHighTime::Format(UINT nFormatID) const
{
	CString strFormat;
	VERIFY(strFormat.LoadString(nFormatID) != 0);
	return Format(strFormat);
} // CHighTime::Format()

// serialization
#ifdef _DEBUG
CDumpContext& AFXAPI operator<<(CDumpContext& dc, CHighTime dateSrc)
{
	dc << "\nCHighTime Object:";
	dc << "\n\tm_status = " << (long)dateSrc.m_status;
	dc << "\n\tdate = " << dateSrc.m_liTime.HighPart;
	return dc << "." << dateSrc.m_liTime.LowPart;
} //  operator<<(CDumpContext, CHighTime)
#endif // _DEBUG

CArchive& AFXAPI operator<<(CArchive& ar, CHighTime dateSrc)
{
	ar << (long)dateSrc.m_status;
	ar << dateSrc.m_liTime.HighPart;
	return ar << dateSrc.m_liTime.LowPart;
} // operator<<(CArchive, CHighTime)

CArchive& AFXAPI operator>>(CArchive& ar, CHighTime& dateSrc)
{
	ar >> (long&)dateSrc.m_status;
	ar >> dateSrc.m_liTime.HighPart;
	return ar >> dateSrc.m_liTime.LowPart;
} // operator>>(CArchive, CHighTime)
#endif // defined(USE_MFC)