filebackupe.h

实时文件备份

					nLen = 0;
					while ( *pTChar && *pTChar != _T('\\') )
						tsPathName[nLen++] = LOWER(*pTChar++);
					tsPathName[nLen] = NULL;
					pItem = pItem->m_pFirstChild;
					nCompare = -1;
					while ( pItem && (nLen != *(pItem->m_ptsName - 1) || (nCompare = _tcsncmp(pItem->m_ptsName, tsPathName, nLen)) < 0) )
						pItem = pItem->m_pNextSibling;
					if ( !pItem || nCompare != 0 )
						return fInclude ? INCLUDE_ITEM : INTERMEDIA_ITEM;
					pTChar++;
				}
			}

			inline BOOL MatchFilePathname(LPCTSTR pctsFilePathname)
			{
				CParsedPathItem* pItem;
				LPCTSTR pTChar = pctsFilePathname;
				BOOL fInclude = FALSE;
				TCHAR tsPathName[MAX_PATH];
				int nLen;
				int nCompare;

				if ( (m_dwFlags & CParsedPathItem::ITEM_MASK) == CParsedPathItem::ROOT_ITEM )
				{
					int nDrive;

					switch ( m_dwFlags & CParsedPathItem::ITEM_TYPE_MASK )
					{
					case CParsedPathItem::INCLUDE_ITEM:
						if ( m_dwFlags & CParsedPathItem::FILE_ATTRIBUTES_MASK_MASK )
						{
							DWORD dwFileAttributes = ::GetFileAttributes(pctsFilePathname);

							if ( (dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) || (((m_dwFlags & CParsedPathItem::FILE_ATTRIBUTES_MASK_MASK) == CParsedPathItem::INCLUDE_FILE_ATTRIBUTES_MASK ? TRUE : FALSE) ^ (m_dwFileAttributesMask & dwFileAttributes)) )
								return FALSE;
						}
						if ( (m_dwFlags & CParsedPathItem::FILENAME_MASK_MASK) && m_pFilenameMaskList )
						{
							LPCTSTR pLastBackSlash, pTempTChar;

							for ( pLastBackSlash = pTempTChar = pTChar + 2; *++pTempTChar; )
								if ( *pTempTChar == _T('\\') )
									pLastBackSlash = pTempTChar;
							if ( ++pLastBackSlash == pTempTChar || (((m_dwFlags & CParsedPathItem::FILENAME_MASK_MASK) == CParsedPathItem::INCLUDE_FILENAME_MASK ? TRUE : FALSE) ^ m_pFilenameMaskList->IsNameMatch(pLastBackSlash)) )
								return FALSE;
						}
						fInclude = TRUE;
						break;
					case CParsedPathItem::INTERMEDIA_ITEM:
						break;
					default:
						return FALSE;
					}
					if ( pctsFilePathname[1] != _T(':') || pctsFilePathname[2] != _T('\\') )
						return FALSE;
					else if ( *pctsFilePathname >= _T('A') && *pctsFilePathname <= _T('Z') )
						nDrive = *pctsFilePathname - _T('A');
					else if ( *pctsFilePathname >= _T('a') && *pctsFilePathname <= _T('z') )
						nDrive = *pctsFilePathname - _T('a');
					else
						return FALSE;
					pItem = m_pFirstChild;
					while ( pItem && (int)pItem->m_ptsName < nDrive )
						pItem = pItem->m_pNextSibling;
					if ( !pItem || (int)pItem->m_ptsName != nDrive )
						return fInclude;
					pTChar += 3;
				}
				else
					pItem = this;

				while ( 1 )
				{
					switch ( pItem->m_dwFlags & CParsedPathItem::ITEM_TYPE_MASK )
					{
					case CParsedPathItem::INCLUDE_ITEM:
						if ( pItem->m_dwFlags & CParsedPathItem::FILE_ATTRIBUTES_MASK_MASK )
						{
							DWORD dwFileAttributes = ::GetFileAttributes(pctsFilePathname);

							if ( (dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) || (((pItem->m_dwFlags & CParsedPathItem::FILE_ATTRIBUTES_MASK_MASK) == CParsedPathItem::INCLUDE_FILE_ATTRIBUTES_MASK ? TRUE : FALSE) ^ (pItem->m_dwFileAttributesMask & dwFileAttributes)) )
								return FALSE;
						}
						if ( (pItem->m_dwFlags & CParsedPathItem::FILENAME_MASK_MASK) && pItem->m_pFilenameMaskList )
						{
							LPCTSTR pLastBackSlash, pTempTChar;

							for ( pLastBackSlash = pTempTChar = pTChar; *pTempTChar; pTempTChar++ )
								if ( *pTempTChar == _T('\\') )
									pLastBackSlash = pTempTChar;
							if ( ++pLastBackSlash == pTempTChar || (((pItem->m_dwFlags & CParsedPathItem::FILENAME_MASK_MASK) == CParsedPathItem::INCLUDE_FILENAME_MASK ? TRUE : FALSE) ^ pItem->m_pFilenameMaskList->IsNameMatch(pLastBackSlash)) )
								return FALSE;
						}
						fInclude = TRUE;
						break;
					case CParsedPathItem::INTERMEDIA_ITEM:
						break;
					default:
						return FALSE;
					}
					nLen = 0;
					while ( *pTChar && *pTChar != _T('\\') )
						tsPathName[nLen++] = LOWER(*pTChar++);
					tsPathName[nLen] = NULL;
					pItem = pItem->m_pFirstChild;
					nCompare = -1;
					while ( pItem && (nLen != *(pItem->m_ptsName - 1) || (nCompare = _tcsncmp(pItem->m_ptsName, tsPathName, nLen)) < 0) )
						pItem = pItem->m_pNextSibling;
					if ( !pItem || nCompare != 0 )
						return fInclude;
					pTChar++;
				}
			}

			void GetIncludeItems(CList<CParsedPathItem*, CParsedPathItem*>& objList)
			{
				if ( (m_dwFlags & ITEM_TYPE_MASK) == INCLUDE_ITEM )
					objList.AddTail(this);
				else if ( m_pFirstChild != NULL )
					m_pFirstChild->GetIncludeItems(objList);
				if ( m_pNextSibling != NULL )
					m_pNextSibling->GetIncludeItems(objList);
			}

			inline CString GetItemFullPath()
			{
				CString csPath;
				CParsedPathItem* pTempItem = this;
				int nLen = 0;
				LPTSTR pts;

				while ( !pTempItem->IsRootItem() )
				{
					nLen += pTempItem->GetItemStringLength() + 1;
					pTempItem = pTempItem->m_pParent;
				}
				nLen -= 2;
				if ( nLen <= 0 )
					return csPath;
				pts = csPath.GetBuffer(nLen) + nLen;
				pTempItem = this;
				while ( !pTempItem->IsRootItem() )
				{
					if ( pTempItem->IsNormalItem() )
					{
						pts -= (DWORD)*(pTempItem->m_ptsName - 1);
						::memcpy(pts, pTempItem->m_ptsName, (DWORD)*(pTempItem->m_ptsName - 1) * sizeof(TCHAR));
						*--pts = _T('\\');
					}
					else
					{
						*--pts = _T(':');
						*--pts = (TCHAR)(_T('a') + (int)pTempItem->m_ptsName);
					}
					pTempItem = pTempItem->m_pParent;
				}
				csPath.ReleaseBuffer(nLen);
				if ( nLen < 3 )
					csPath += _T('\\');
				return csPath;
			}

			inline void GetItemFullPath(LPTSTR pPath)
			{
				CParsedPathItem* pTempItem = this;
				int nLen = 0;
				LPTSTR pts;

				while ( !pTempItem->IsRootItem() )
				{
					nLen += pTempItem->GetItemStringLength() + 1;
					pTempItem = pTempItem->m_pParent;
				}
				if ( --nLen <= 0 )
				{
					*pPath = NULL;
					return;
				}
				pts = pPath + nLen;
				*pts = NULL;
				pTempItem = this;
				while ( !pTempItem->IsRootItem() )
					if ( pTempItem->IsNormalItem() )
					{
						pts -= (DWORD)*(pTempItem->m_ptsName - 1);
						_tcscpy(pts, pTempItem->m_ptsName);
						*--pts = _T('\\');
					}
					else
					{
						*--pts = _T(':');
						*--pts = (TCHAR)(_T('a') + (int)pTempItem->m_ptsName);
					}
				ASSERT(pts == pPath);
			}

			inline DWORD GetItemStringLength() const
			{
				switch ( m_dwFlags & ITEM_MASK )
				{
				case ROOT_ITEM:
					return 0;
				case DRIVE_ITEM:
					return 3;
				case DIRECTORY_OR_FILE_ITEM:
					(DWORD)*(m_ptsName - 1);
				}
			}

			inline BOOL IsRootItem() const { return (m_dwFlags & ITEM_MASK) == ROOT_ITEM ? TRUE : FALSE; }
			inline BOOL IsDriveItem() const { return (m_dwFlags & ITEM_MASK) == DRIVE_ITEM ? TRUE : FALSE; }
			inline BOOL IsNormalItem() const { return (m_dwFlags & ITEM_MASK) == DIRECTORY_OR_FILE_ITEM ? TRUE : FALSE; }

		protected:
			inline BOOL SetItemData(LPCTSTR pctsItemName, LPCTSTR pctsFilenameMask, DWORD dwFileAttributesMask, DWORD dwFlags)
			{
				ClearItemData();

				switch ( dwFlags & ITEM_MASK )
				{
				case ROOT_ITEM:
					m_ptsName = NULL;
					break;
				case DRIVE_ITEM:
					if ( pctsItemName == NULL || !(*pctsItemName >= _T('A') && *pctsItemName <= _T('Z') || *pctsItemName >= _T('a') && *pctsItemName <= _T('z')) )
						return FALSE;
					m_ptsName = (LPTSTR)(*pctsItemName >= _T('a') ? *pctsItemName - _T('a') : *pctsItemName - _T('A'));
					break;
				case DIRECTORY_OR_FILE_ITEM:
					if ( pctsItemName && *pctsItemName != NULL && *pctsItemName != _T('\\') )
					{
						LPTSTR pTChar = (LPTSTR)pctsItemName;
						int nLen;

						while ( *pTChar != NULL && *pTChar != _T('\\') )
							pTChar++;
						nLen = pTChar - pctsItemName;
						m_ptsName = (pTChar = new TCHAR[nLen + 2]) + 1;
						*pTChar++ = nLen;
						while ( nLen-- > 0 )
						{
							*pTChar++ =	LOWER(*pctsItemName);	//	*pctsItemName >= _T('a') && *pctsItemName <= _T('z') ? *pctsItemName - _T('a') + _T('A') : *pctsItemName;
							pctsItemName++;
						}
						*pTChar = NULL;
						break;
					}
				default:
					return FALSE;
				}
				if ( (dwFlags & ITEM_TYPE_MASK) != INCLUDE_ITEM )
					dwFlags &= ITEM_TYPE_MASK | ITEM_MASK;
				else
				{
					if ( (dwFlags & FILENAME_MASK_MASK) && pctsFilenameMask )
					{
						CFilenameMaskList* pFilenameMaskList = new CFilenameMaskList(pctsFilenameMask);

						if ( pFilenameMaskList->IsAvailable(_T("*.*")) )
						{
							delete pFilenameMaskList;
							if ( (dwFlags & FILENAME_MASK_MASK) == INCLUDE_FILENAME_MASK )
								dwFlags &= ~FILENAME_MASK_MASK;
							else
								dwFlags = dwFlags & ITEM_MASK | EXCLUDE_ITEM;
						}
						else
							m_pFilenameMaskList = pFilenameMaskList;
					}
					if ( dwFlags & FILE_ATTRIBUTES_MASK_MASK )
						m_dwFileAttributesMask = dwFileAttributesMask;
				}
				m_dwFlags = dwFlags;
				return TRUE;
			}

			inline void ClearItemData()
			{
				if ( m_pFirstChild )
					delete m_pFirstChild;
				if ( m_pNextSibling )
					delete m_pNextSibling;

				if ( (m_dwFlags & ITEM_MASK) == DIRECTORY_OR_FILE_ITEM && m_ptsName )
					delete[] (m_ptsName - 1);
				m_ptsName = NULL;
				if ( m_pFilenameMaskList )
				{
					delete m_pFilenameMaskList;
					m_pFilenameMaskList = NULL;
				}
				m_dwFlags = m_dwFileAttributesMask = NULL;
			}

		protected:
			DWORD								m_dwFlags;
			LPTSTR								m_ptsName;
			CFilenameMaskList*					m_pFilenameMaskList;
			DWORD								m_dwFileAttributesMask;

			CParsedPathItem*					m_pFirstChild;
			CParsedPathItem*					m_pNextSibling;

			CParsedPathItem*					m_pParent;
		};

		inline CFileFilter() : m_pRootParsedPathItem(NULL) {}
		inline ~CFileFilter() { if ( m_pRootParsedPathItem ) delete m_pRootParsedPathItem; }

		inline void Reset() { if ( m_pRootParsedPathItem ) delete m_pRootParsedPathItem; m_pRootParsedPathItem = NULL; }

		inline BOOL AddIncludePath(LPCTSTR pctsPath, LPCTSTR pctsFilenameMask, BOOL fIsIncludeFilenameMask, DWORD* pdwFileAttributesMask, BOOL fIsIncludeFileAttributesMask)
		{
			if ( pctsPath && *pctsPath )
			{
				if ( pctsPath[1] != _T(':') || pctsPath[2] != NULL && pctsPath[2] != _T('\\') || !(*pctsPath >=_T('a') && *pctsPath <= _T('z') || *pctsPath >=_T('A') && *pctsPath <= _T('Z')) )
					return FALSE;
				if ( !m_pRootParsedPathItem )
					m_pRootParsedPathItem = new CParsedPathItem(NULL, NULL, 0, CParsedPathItem::ROOT_ITEM | CParsedPathItem::INTERMEDIA_ITEM);
				return m_pRootParsedPathItem->AddIncludePath(pctsPath, pctsFilenameMask, fIsIncludeFilenameMask, pdwFileAttributesMask, fIsIncludeFileAttributesMask);
			}
			else
			{
				DWORD dwFlags = CParsedPathItem::ROOT_ITEM | CParsedPathItem::INCLUDE_ITEM;

				if ( pctsFilenameMask )
					dwFlags |= fIsIncludeFilenameMask ? CParsedPathItem::INCLUDE_FILENAME_MASK : CParsedPathItem::EXCLUDE_FILENAME_MASK;
				if ( pdwFileAttributesMask )
					dwFlags |= fIsIncludeFileAttributesMask ? CParsedPathItem::INCLUDE_FILE_ATTRIBUTES_MASK : CParsedPathItem::EXCLUDE_FILE_ATTRIBUTES_MASK;

				if ( !m_pRootParsedPathItem )
				{
					m_pRootParsedPathItem = new CParsedPathItem(NULL, pctsFilenameMask, pdwFileAttributesMask ? *pdwFileAttributesMask : 0, dwFlags);
					return TRUE;
				}
				else
					return m_pRootParsedPathItem->SetItemData(NULL, pctsFilenameMask, pdwFileAttributesMask ? *pdwFileAttributesMask : 0, dwFlags);
			}
		}

		inline BOOL AddExcludePath(LPCTSTR pctsPath)
		{
			if ( !m_pRootParsedPathItem )
				return FALSE;
			else
				return m_pRootParsedPathItem->AddExcludePath(pctsPath, FALSE);
		}

		inline BOOL MatchFilePathname(LPCTSTR pctsFilePathname)
		{
			if ( pctsFilePathname == NULL || m_pRootParsedPathItem == NULL )
				return FALSE;
			else
				return m_pRootParsedPathItem->MatchFilePathname(pctsFilePathname);
		}

		inline CParsedPathItem::PARSED_PATH_ITEM_FLAGS_BIT_MASK MatchFilePathname(LPCTSTR pctsFilePathname, CParsedPathItem*& pItem)
		{
			if ( pctsFilePathname == NULL || m_pRootParsedPathItem == NULL )
				return CParsedPathItem::EXCLUDE_ITEM;
			else
				return m_pRootParsedPathItem->MatchFilePathname(pctsFilePathname, pItem);
		}

		inline BOOL GetDriveBasePath(TCHAR tDrive, CString& csBasePath, CParsedPathItem*& pItem)
		{
			if ( !m_pRootParsedPathItem || !(tDrive >= _T('A') && tDrive <= _T('Z') || tDrive >= _T('a') && tDrive <= _T('z')) )
				return FALSE;
			else
			{
				CParsedPathItem *pDriveItem = m_pRootParsedPathItem->m_pFirstChild, *pTempItem;
				int nDrive = tDrive >= _T('a') ? tDrive - _T('a') : tDrive - _T('A');
				int nLen;
				LPTSTR pBuf;
				BOOL fOnlyDrive;

				while ( pDriveItem && (int)pDriveItem->m_ptsName < nDrive )
					pDriveItem = pDriveItem->m_pNextSibling;
				if ( !pDriveItem || (int)pDriveItem->m_ptsName != nDrive )
					return FALSE;
				for ( nLen = 2, pTempItem = pDriveItem->m_pFirstChild; pTempItem && !pTempItem->m_pNextSibling; pTempItem = pTempItem->m_pFirstChild )
					nLen += *(pTempItem->m_ptsName - 1) + 1;
				if ( nLen < 3 )
				{
					fOnlyDrive = TRUE;
					nLen = 3;
				}
				else
					fOnlyDrive = FALSE;
				pBuf = csBasePath.GetBuffer(nLen);
				*pBuf++ = _T('A') + nDrive;
				*pBuf++ = _T(':');
				while ( pDriveItem->m_pFirstChild && !pDriveItem->m_pFirstChild->m_pNextSibling )
				{
					pDriveItem = pDriveItem->m_pFirstChild;
					*pBuf++ = _T('\\');
					_tcscpy(pBuf, pDriveItem->m_ptsName);
					pBuf += *(pDriveItem->m_ptsName - 1);
				}
				pItem = pDriveItem;
				if ( fOnlyDrive )
					*pBuf++ = _T('\\');
				csBasePath.ReleaseBuffer(nLen);
				return TRUE;
			}
		}

		inline CParsedPathItem* GetFirstAvailableDrive()
		{
			return !m_pRootParsedPathItem ? NULL : m_pRootParsedPathItem->m_pFirstChild;
		}

		inline TCHAR GetNextAvailableDrive(CParsedPathItem*& pDriveItem)
		{
			TCHAR tRet = NULL;

			if ( pDriveItem && (pDriveItem->m_dwFlags & CParsedPathItem::ITEM_MASK) == CParsedPathItem::DRIVE_ITEM )
			{
				tRet = _T('A') + (int)pDriveItem->m_ptsName;
				pDriveItem = pDriveItem->m_pNextSibling;
			}
			return tRet;
		}

		//	Must return long pathname, actually this class should handle long pathname only