publicfunction.cpp

多线程下载的

	ASSERT ( lpszFindPath && strlen(lpszFindPath) > 0 );
	dwAmountBytes = 0;
	StrAryResFile.RemoveAll();
	StrArySubDirectory.RemoveAll();

	char szFindPath[MAX_PATH] = {0}, szMultiFindFilter[1024]={0}, szMultiExcludeFilter[1024]={0};
	STRNCPY_SZ ( szFindPath, lpszFindPath );
	STRNCPY_SZ ( szMultiFindFilter, lpszMultiFindFilter );
	StandardizationPathBuffer ( szFindPath, sizeof(szFindPath), '\\' );

	char *token = strtok( szMultiFindFilter, f_seps );
	while( token != NULL )
	{
		/* While there are tokens in "string" */
		char szFindFile[MAX_PATH] = {0};
		hwSnprintf ( szFindFile, sizeof(szFindFile)-1, "%s%s", szFindPath, token );
		CHwDir dir ( szFindFile, bSerachSubDir, bAbsolutePath, &m_pHwDir );
		if ( dir.m_pStrAryResFile && dir.m_pStrArySubDirectory )
		{
			StrAryResFile.Append ( *(dir.m_pStrAryResFile) );
			StrArySubDirectory.Append ( *(dir.m_pStrArySubDirectory) );
			dwAmountBytes += (DWORD)dir.GetAmountBytes();
		}
		/* Get next token: */
		token = strtok( NULL, f_seps );
		if ( m_bCancel ) break;
		m_pHwDir = NULL;
	}
}

void CHwDirEx::Cancel()
{
	m_bCancel = TRUE;
	if ( m_pHwDir )
		m_pHwDir->Cancel ();
}

CString GetOneLine(CString &str)
{
	int nPos = str.Find ( "\r\n", 0 );
	if ( nPos < 0 ) return "";
	CString csOneLine = str.Left ( nPos );
	str = str.Mid ( nPos + 2 );
	return csOneLine;
}

int CalcCharCount ( LPCTSTR lpszText, char chCalc )
{
	int nLen = STRLEN_SZ(lpszText);
	int nCount = 0;
	for ( int i=0; i<nLen; i++ )
	{
		if ( (BYTE)lpszText[i] == (BYTE)chCalc )
			nCount ++;
	}
	return nCount;
}

#define  TIME_START_YEAR  1900
BOOL CopyBuffer_Date ( int *data, SYSTEMTIME &SysTime )
{
	const int nMinDateDigitCount = 3;
	ASSERT_ADDRESS ( data, nMinDateDigitCount * sizeof(int) );

	/********年(1000 ~ 9999)********/
	if ( data[0] < 1000 || data[0] >= 9999 )
		return FALSE;
	SysTime.wYear = data[0];

	/********月(1--12)********/
	if ( data[1] < 1 || data[1] > 12 )
		return FALSE;
	SysTime.wMonth = data[1];

	/********日(1--31)********/
	if ( data[2] < 1 && data[2] > 31 )
		return FALSE;
	SysTime.wDay = data[2];

	return TRUE;
}

BOOL CopyBuffer_Time ( int *data, SYSTEMTIME &SysTime )
{
	const int nMinDateDigitCount = 3;
	ASSERT_ADDRESS ( data, nMinDateDigitCount * sizeof(int) );

	/********时(0--23)********/
	if ( data[0] <0 || data[0] > 23 )
		return FALSE;
	SysTime.wHour = data[0];

	/********分(0--59)********/
	if ( data[1] < 0 || data[1] > 59 )
		return FALSE;
	SysTime.wMinute = data[1];

	/********秒********/
	if ( data[2] < 0 || data[2] > 59 )
		return FALSE;
	SysTime.wSecond = data[2];

	return TRUE;
}

//
// ConvertStrToCTime() 将一个表示日期的字符串（按年、月、日、时、分、秒的顺序，
// 如"2001-08-09 18:03:30"）转成 CTime 格式.
// return : ------------------------------------------------------------
//		0	-	错误
//		1	-	是时期时间
//		2	-	是日期
//		3	-	是时间
//
int ConvertStrToCTime(char *chtime, CTime &cTime )
{
	int  i, j, k;
	char tmpbuf[8] = {0};
	int  value[6] = {0};
	SYSTEMTIME SysTime = {0};

	if ((!chtime) ) return FALSE; /* invalid parameter */

	memset((void *)value, 0, sizeof(value));
	for (i=0, j=0, k=0;  ; i++)
	{
		if (chtime[i]<'0' || chtime[i]>'9') /* 非数字字符 */
		{
			tmpbuf[j] = '\0';
			if ( j > 0 )
			{
				value[k++] = atoi(tmpbuf);
				j = 0;
				if ( k >= 6 ) break;
			}
			if ( chtime[i] == '\0' ) break;
		}
		else if (j < 7) tmpbuf[j++] = chtime[i];
	}
	if ( k < 3 ) return 0;
	if	(
			CalcCharCount ( chtime, '-' ) < 2
			&&
			CalcCharCount ( chtime, '/' ) < 2
			&&
			CalcCharCount ( chtime, ':' ) < 2
		)
		return 0;

	int nRet = 0;
	// 是日期时间
	if	(
			( k>=6 )
			&&
			CopyBuffer_Date ( value, SysTime )
			&&
			CopyBuffer_Time ( &value[3], SysTime )
		)
	{
		nRet = 1;
	}
	// 是日期
	else if	(
			(k>=3)
			&&
			CopyBuffer_Date ( value, SysTime )
		)
	{
		nRet = 2;
	}

	// 是时间
	if	(
			(k>=3)
			&&
			CopyBuffer_Time ( value, SysTime )
		)
	{
		nRet = 3;
	}
	
	if ( SysTime.wYear < 1971 )
		SysTime.wYear = 1971;
	if ( SysTime.wMonth < 1 )
		SysTime.wMonth = 1;
	if ( SysTime.wDay < 1 )
		SysTime.wDay = 1;

	CTime tTemp ( SysTime );
	cTime = tTemp;

	return nRet;
}

CCriticalSection f_CSFor_DbgLog;
void DbgLog ( LPCTSTR lpszFormat, ... )
{
	// 格式化
	f_CSFor_DbgLog.Lock ();
	char szLogBuf[1024*4] = {0};
	char *p = szLogBuf;
	*p = '[';
	p ++;
	char szTime[32] = {0};
	int nLen = (int)GetCurTimeString ( szTime, sizeof(szTime) );
	strcpy ( p, szTime );
	p += nLen;
	*p = ']';
	p ++;
	*p = ' ';
	p ++;
	
	va_list  va;
	va_start (va, lpszFormat);
	_vsnprintf ( p, sizeof(szLogBuf)-1-(int)(p-szLogBuf), (const char*)lpszFormat, va);
	va_end(va);
	WriteDataToFile ( "c:\\debug.txt", szLogBuf, strlen(szLogBuf), "ab+" );
	f_CSFor_DbgLog.Unlock ();
}

int GetMouthByShortStr ( LPCTSTR lpszShortMonth )
{
	const char* szConstMonth[] =
	{
		"jan", "feb", "mar", "apr", "may", "jun", "jul", "aug", "sep", "oct", "nov", "dec", ""
	};

	CString csShortMonth = GET_SAFE_STRING ( lpszShortMonth );
	for ( int i=0; i<sizeof(szConstMonth)/sizeof(szConstMonth[0]); i++ )
	{
		if ( csShortMonth.CompareNoCase ( szConstMonth[i] ) == 0 )
		{
			return ( i+1 );
		}
	}

	return -1;
};

CString hwFormatMessage ( DWORD dwErrorCode )
{
	CString csError;
	LPVOID pv;
    FormatMessage (
		FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM,
		NULL,
		dwErrorCode,
		MAKELANGID(LANG_NEUTRAL,SUBLANG_DEFAULT),
		(LPTSTR)&pv,
		0,
		NULL);
	if(pv)
	{
		csError = (char*)pv;
		LocalFree ( pv );
	}

	return csError;
}

/********************************************************************************
* Function Type	:	Global
* Parameter		:	filename		-	文件名
*					data			-	要保存的数据
*					mode			-	文件打开的模式
*					size			-	数据大小
*					nStartPos		-	文件开始位置
* Return Value	:	>=0				-	写入文件的大小
*					-1				-	写操作失败
* Description	:	保存数据到文件
*********************************************************************************/
int WriteDataToFile(LPCTSTR filename,char* data,long size,LPCTSTR mode, int nStartPos/*=-1*/ )
{
	ASSERT ( filename && strlen(filename) > 0 );
	FILE *fp;
	long retval;
	fp=fopen((const char*)filename,(const char*)mode);
	if ( fp!=NULL)
	{
		if ( nStartPos >= 0 )
		{
			if ( fseek ( fp, nStartPos, SEEK_SET ) != 0 )
				return -1;
		}
		retval = (long)fwrite(data,sizeof(UCHAR),size,fp);
		fclose(fp);
		if(retval != size)
		{
			return -1;
		}
		else 	return retval;
	}
	else
	{
		return -1;
	}
}
/********************************************************************************
* Function Type	:	Global
* Parameter		:	filename		-	文件名
*					data			-	读到的数据存于此缓冲
*					size			-	缓冲大小
*					nStartPos		-	文件开始位置
* Return Value	:	>=0				-	读到数据的大小
*					-1				-	操作失败
* Description	:	从文件中读取数据
*********************************************************************************/
int ReadDataFromFile(LPCTSTR filename,char* data,long size, int nStartPos/*=-1*/)
{
	FILE *fp;
	long retval;
	fp=fopen((const char*)filename,"rb");
	if ( fp!=NULL)
	{
		if ( nStartPos >= 0 )
		{
			if ( fseek ( fp, nStartPos, SEEK_SET ) != 0 )
				return -1;
		}
		retval = (long)fread(data,sizeof(char), size, fp);
		fclose(fp);
		if ( retval >= 0 ) return retval;
	}
	return -1;
}

CString Data2HexString ( int nOffset, char *data, int size )
{
	CString csHexString, csTemp, csOffset;
	if ( nOffset >= 0 )
	{
		csOffset.Format ( "%08xh: ", nOffset );
		csHexString += csOffset;
	}
	for ( int i=0; i<size; i++ )
	{
		csTemp.Format ( "%02X ", (BYTE)data[i] );
		csHexString += csTemp;
		if ( (i+1) % 16 == 0 )
		{
			csHexString += "\r\n";
			if ( nOffset >= 0 )
			{
				nOffset += 16;
				csOffset.Format ( "%08xh: ", nOffset );
				csHexString += csOffset;
			}
		}
	}
	return csHexString;
}

//
// 为了方便 strchr() 或 strrchr() 函数正确查找字符，将字符串中的中文字符串用指定的字符替换掉
//
void ReplaceChineseStrToEnglish ( char *szBuf, char cReplace )
{
	if ( !szBuf ) return;
	for ( int i=0; szBuf[i] != '\0'; i++ )
	{
		if ( szBuf[i] < 0 && szBuf[i+1] != '\0' )
		{
			szBuf[i] = cReplace;
			szBuf[i+1] = cReplace;
			i ++;
		}
	}
}

/********************************************************************************
* Function Type	:	Global
* Parameter		:	lpszDirName		-	[in] 目录名
* Return Value	:	没有路径的文件名
* Description	:	确保路径存在，如果目录不存在就创建目录,可以创建多层次的目录
*********************************************************************************/
char* MakeSureDirectory(LPCTSTR lpszDirName)
{
	char tempbuf[255];
	char *p1 = NULL, *p2 = (char*)lpszDirName;
	int len;
	while(1)
	{
		p1 = hwStrChr((const char*)p2,'\\');
		if( p1 )
		{
			ZeroMemory(tempbuf,sizeof(tempbuf));
			len = (int)((p1 - lpszDirName > sizeof(tempbuf)) ? sizeof(tempbuf) : (p1 - lpszDirName));
			if(len < 1)	//如：“\123\456\”目录，第一个就是“\”
			{
				p2 = p1 + 1;
				continue;
			}
			strncpy((char*)tempbuf,(const char*)lpszDirName, len);
			if(_access((const char*)tempbuf,0) == -1)	//Not exist
			{
				if(_mkdir((const char*)tempbuf) != 0)
					return FALSE;
			}
			p2 = p1 + 1;
		}
		else break;
	}
	
	return p2;
}

int hwSnprintf ( char *buffer, int count, const char *format, ... )
{
	if ( count < 1 ) return 0;
	ASSERT_ADDRESS ( buffer, count );
	memset ( buffer, 0, count );
	// 格式化
	va_list  va;
	va_start (va, format);
	int nRet = _vsnprintf ( buffer, count, (const char*)format, va);
	va_end(va);
	buffer [count-1] = '\0';

	int nLen = nRet;
	if ( nLen < 0 ) nLen = strlen(buffer);
	if ( nLen > count ) nLen = count;

	return nLen;
}

//
//
// 从一个完整的全路径名(包含文件名)中分离出路径（没有文件名）和
// 文件名，如：从“E:\001\002.exe”中分得“E:\001\”，结果存入到
// lsOnlyPath中，“002.exe”存入szOnlyFileName中
//
BOOL PartFileAndPathByFullPath (
		IN LPCTSTR lpszFilePath,			// 全路径名(包含文件名)
		OUT char *szOnlyFileName,			// 光文件名（没有路径）
		int nFileNameSize,
		OUT char *szOnlyPath /*=NULL*/,		// 光路径（没有文件名）
		int nPathSize/*=0*/
	)
{