www.pudn.com > FileFinder_Ce_demo.zip > CeFileFind.cpp

// CeFileFind.cpp : implementation file 
// 
 
#include "stdafx.h" 
#include "CeFileFind.h" 
 
 
#ifdef _DEBUG 
#define new DEBUG_NEW 
#undef THIS_FILE 
static char THIS_FILE[] = __FILE__; 
#endif 
 
 
#define DELETE_POINTER(ptr)		if( ptr != NULL )	\ 
								{					\ 
									delete ptr;		\ 
									ptr = NULL;		\ 
								} 
 
#define DIR_SEPERATOR		'\\' 
 
///////////////////////////////////////////////////////////////////////////// 
// CCeFileFind 
 
CCeFileFind::CCeFileFind() 
			:m_hFileHandle(NULL), // initialize to NULL 
			m_pfiledata(NULL) 
{ 
} 
 
CCeFileFind::~CCeFileFind() 
{ 
	Close(); 
} 
 
 
// Operations 
BOOL CCeFileFind::FindFile(LPCTSTR pstrName) 
{ 
 
	Close(); 
 
	// if NULL , wild card search  
	if( NULL == pstrName ) 
	{ 
		m_csRoot = DIR_SEPERATOR; 
		pstrName = _T("\\*.*"); 
		 
	} 
	else 
	{ 
 
		m_csRoot = pstrName; 
		int nPos = m_csRoot.ReverseFind( '\\' ); 
		if( nPos == 0 ) 
			m_csRoot = '\\'; 
		else 
			m_csRoot = m_csRoot.Left( nPos ); 
	 
	} 
 
	m_pNextdata = new WIN32_FIND_DATA; 
	// search for file 
	m_hFileHandle = FindFirstFile( pstrName, m_pNextdata ); 
	 
	if ( m_hFileHandle == INVALID_HANDLE_VALUE ) 
	{ 
		Close(); 
		return FALSE; 
	} 
 
	// file was found 
	return TRUE; 
} 
 
 
BOOL CCeFileFind::FindNextFile() 
{ 
	ASSERT(m_hFileHandle != NULL); 
 
	if (m_hFileHandle == NULL) 
		return FALSE; 
 
	if (m_pfiledata == NULL) 
		m_pfiledata = new WIN32_FIND_DATA; 
 
	AssertDoneNext(); 
 
	LPWIN32_FIND_DATA pTemp = m_pfiledata; 
	m_pfiledata = m_pNextdata; 
	m_pNextdata = pTemp; 
 
	return ::FindNextFile(m_hFileHandle, m_pNextdata); 
} 
 
 
void CCeFileFind::Close() 
{ 
	DELETE_POINTER( m_pfiledata ); 
	DELETE_POINTER( m_pNextdata ); 
 
	if( m_hFileHandle!= NULL && m_hFileHandle != INVALID_HANDLE_VALUE ) 
	{ 
		::FindClose( m_hFileHandle ); 
		m_hFileHandle = NULL; 
	} 
} 
 
BOOL CCeFileFind::MatchesMask(DWORD dwMask) const 
{ 
	ASSERT(m_hFileHandle != NULL); 
	AssertDoneNext(); 
 
	if ( m_pfiledata != NULL) 
		return (!!(m_pfiledata->dwFileAttributes & dwMask) ); 
	else 
		return FALSE; 
} 
 
 
CString GetRoot() const 
{ 
	ASSERT(m_hFileHandle != NULL); 
	ASSERT(pTimeStamp != NULL); 
	AssertDoneNext(); 
 
	if (m_pfiledata != NULL && pTimeStamp != NULL) 
		return m_csRoot; 
	else 
		return ""; 
 
} 
 
BOOL CCeFileFind::GetLastAccessTime(FILETIME* pTimeStamp) const 
{ 
	ASSERT(m_hFileHandle != NULL); 
	ASSERT(pTimeStamp != NULL); 
	AssertDoneNext(); 
 
	if (m_pfiledata != NULL && pTimeStamp != NULL) 
	{ 
		*pTimeStamp = m_pfiledata -> ftLastAccessTime; 
		return TRUE; 
	} 
	else 
		return FALSE; 
} 
 
BOOL CCeFileFind::GetLastWriteTime(FILETIME* pTimeStamp) const 
{ 
	ASSERT(m_hFileHandle != NULL); 
	ASSERT(pTimeStamp != NULL); 
	AssertDoneNext(); 
 
	if (m_pfiledata != NULL && pTimeStamp != NULL) 
	{ 
		*pTimeStamp = m_pfiledata -> ftLastWriteTime; 
		return TRUE; 
	} 
	else 
		return FALSE; 
} 
 
BOOL CCeFileFind::GetCreationTime(FILETIME* pTimeStamp) const 
{ 
	ASSERT(m_hFileHandle != NULL); 
	AssertDoneNext(); 
 
	if (m_pfiledata != NULL && pTimeStamp != NULL) 
	{ 
		*pTimeStamp = m_pfiledata -> ftCreationTime; 
		return TRUE; 
	} 
	else 
		return FALSE; 
} 
 
BOOL CCeFileFind::GetLastAccessTime(CTime& refTime) const 
{ 
	ASSERT(m_hFileHandle != NULL); 
	AssertDoneNext(); 
 
	if (m_pfiledata != NULL) 
	{ 
		refTime = CTime( m_pfiledata -> ftLastAccessTime ); 
		return TRUE; 
	} 
	else 
		return FALSE; 
} 
 
BOOL CCeFileFind::GetLastWriteTime(CTime& refTime) const 
{ 
	ASSERT(m_hFileHandle != NULL); 
	AssertDoneNext(); 
 
	if (m_pfiledata != NULL) 
	{ 
		refTime = CTime( m_pfiledata -> ftLastWriteTime ); 
		return TRUE; 
	} 
	else 
		return FALSE; 
} 
 
BOOL CCeFileFind::GetCreationTime(CTime& refTime) const 
{ 
	ASSERT(m_hFileHandle != NULL); 
	AssertDoneNext(); 
 
	if (m_pfiledata != NULL) 
	{ 
		refTime = CTime( m_pfiledata -> ftCreationTime ); 
		return TRUE; 
	} 
	else 
		return FALSE; 
} 
 
BOOL CCeFileFind::IsDots() const 
{ 
	ASSERT(m_hFileHandle != NULL); 
	AssertDoneNext(); 
 
	// return TRUE if the file name is "." or ".." and 
	// the file is a directory 
 
	BOOL bResult = FALSE; 
	if (m_pfiledata != NULL && IsDirectory()) 
	{ 
		LPWIN32_FIND_DATA pFindData = m_pfiledata; 
		if (pFindData->cFileName[0] == '.') 
		{ 
			if (pFindData->cFileName[1] == '\0' || 
				(pFindData->cFileName[1] == '.' && 
				 pFindData->cFileName[2] == '\0')) 
			{ 
				bResult = TRUE; 
			} 
		} 
	} 
 
	return bResult; 
} 
 
BOOL CCeFileFind::IsArchived( ) const 
{ 
	ASSERT(m_hFileHandle != NULL); 
	AssertDoneNext(); 
 
	if (m_pfiledata != NULL) 
	{ 
		if( m_pfiledata -> dwFileAttributes == FILE_ATTRIBUTE_ARCHIVE ) 
			return TRUE; 
		else 
			return FALSE; 
	} 
	return FALSE; 
 
} 
 
BOOL CCeFileFind::IsCompressed() const 
{ 
	ASSERT(m_hFileHandle != NULL); 
	AssertDoneNext(); 
 
	if (m_pfiledata != NULL) 
	{ 
		if( m_pfiledata -> dwFileAttributes == FILE_ATTRIBUTE_COMPRESSED ) 
			return TRUE; 
		else 
			return FALSE; 
	} 
	return FALSE; 
} 
 
 
BOOL CCeFileFind::IsDirectory() const 
{ 
	ASSERT(m_hFileHandle != NULL); 
	AssertDoneNext(); 
 
	if (m_pfiledata != NULL) 
	{ 
		if( m_pfiledata -> dwFileAttributes == FILE_ATTRIBUTE_DIRECTORY ) 
			return TRUE; 
		else 
			return FALSE; 
	} 
	return FALSE; 
} 
 
BOOL CCeFileFind::IsHidden() const 
{ 
	ASSERT(m_hFileHandle != NULL); 
	AssertDoneNext(); 
 
	if (m_pfiledata != NULL) 
	{ 
		if( m_pfiledata -> dwFileAttributes == FILE_ATTRIBUTE_HIDDEN ) 
			return TRUE; 
		else 
			return FALSE; 
	} 
	return FALSE; 
} 
 
 
BOOL CCeFileFind::IsNormal() const 
{ 
	ASSERT(m_hFileHandle != NULL); 
	AssertDoneNext(); 
 
	if (m_pfiledata != NULL) 
	{ 
		if( m_pfiledata -> dwFileAttributes == FILE_ATTRIBUTE_NORMAL ) 
			return TRUE; 
		else 
			return FALSE; 
	} 
	return FALSE; 
} 
 
BOOL CCeFileFind::IsReadOnly() const 
{ 
	ASSERT(m_hFileHandle != NULL); 
	AssertDoneNext(); 
 
	if (m_pfiledata != NULL) 
	{ 
		if( m_pfiledata -> dwFileAttributes == FILE_ATTRIBUTE_READONLY ) 
			return TRUE; 
		else 
			return FALSE; 
	} 
	return FALSE; 
} 
 
BOOL CCeFileFind::IsSystem() const 
{ 
	ASSERT(m_hFileHandle != NULL); 
	AssertDoneNext(); 
 
	if (m_pfiledata != NULL) 
	{ 
		if( m_pfiledata -> dwFileAttributes == FILE_ATTRIBUTE_SYSTEM ) 
			return TRUE; 
		else 
			return FALSE; 
	} 
	return FALSE; 
} 
 
 
BOOL CCeFileFind::IsTemporary() const 
{ 
	ASSERT(m_hFileHandle != NULL); 
	AssertDoneNext(); 
 
	if (m_pfiledata != NULL) 
	{ 
		if( m_pfiledata -> dwFileAttributes == FILE_ATTRIBUTE_TEMPORARY ) 
			return TRUE; 
		else 
			return FALSE; 
	} 
	return FALSE; 
} 
 
 
CString CCeFileFind::GetFilePath() const 
{ 
	ASSERT(m_hFileHandle != NULL); 
	AssertDoneNext(); 
 
	CString csResult = m_csRoot; 
	if (csResult[csResult.GetLength()-1] != DIR_SEPERATOR ) 
		csResult += DIR_SEPERATOR; 
	csResult += GetFileName(); 
	return csResult; 
} 
 
 
CString CCeFileFind::GetFileName() const 
{ 
	ASSERT(m_hFileHandle != NULL); 
	AssertDoneNext(); 
 
	CString ret; 
 
	if (m_pfiledata != NULL) 
		ret = m_pfiledata->cFileName; 
	return ret; 
} 
 
DWORD CCeFileFind::GetLength() const 
{ 
	ASSERT(m_hFileHandle != NULL); 
	AssertDoneNext(); 
 
	if (m_pfiledata != NULL) 
		return m_pfiledata -> nFileSizeLow; 
	else 
		return 0; 
} 
 
 
void CCeFileFind::AssertDoneNext() const 
{ 
	// if you trip the ASSERT in the else side, you've called 
	// a Get() function without having done at least one 
	// FindNextFile() call 
 
	if (m_hFileHandle == NULL) 
		ASSERT( m_pfiledata == NULL && m_pNextdata == NULL); 
	else 
		ASSERT( m_pfiledata != NULL && m_pNextdata != NULL); 
}