filebackup.h

实时文件备份

			return !(operator ==(objMaskList));
		}

		inline BOOL operator !=(LPCTSTR pctsMasks) const
		{
			return *this != CFilenameMaskListW(pctsMasks);
		}

		inline void Add(LPCSTR pcsMask)
		{
			char sCleanMask[MAX_PATH];
			POSITION pos = m_clMaskList.GetHeadPosition(), posPrev;

			if ( pcsMask != NULL )
				if ( *pcsMask == NULL )
					pcsMask = NULL;
				else
					pcsMask = CFilenameMaskW::CleanMask(pcsMask, sCleanMask);
			while ( (posPrev = pos) )
			{
				CFilenameMaskW& mask = m_clMaskList.GetNext(pos);
				int nCompare = mask.Compare(pcsMask);

				switch ( nCompare )
				{
				case 1:
					m_clMaskList.InsertBefore(posPrev, CFilenameMaskW(pcsMask));
				case 0:
					return;
				}
			}
			m_clMaskList.AddTail(CFilenameMaskW(pcsMask));
		}
		inline void Add(LPCWSTR pcwsMask)
		{
			WCHAR wsCleanMask[MAX_PATH];
			POSITION pos = m_clMaskList.GetHeadPosition(), posPrev;

			if ( pcwsMask != NULL )
				if ( *pcwsMask == NULL )
					pcwsMask = NULL;
				else
					pcwsMask = CFilenameMaskW::CleanMask(pcwsMask, wsCleanMask);
			while ( (posPrev = pos) )
			{
				CFilenameMaskW& mask = m_clMaskList.GetNext(pos);
				int nCompare = mask.Compare(pcwsMask);

				switch ( nCompare )
				{
				case 1:
					m_clMaskList.InsertBefore(posPrev, CFilenameMaskW(pcwsMask));
				case 0:
					return;
				}
			}
			m_clMaskList.AddTail(CFilenameMaskW(pcwsMask));
		}

		inline void Remove(LPCSTR pcsMask)
		{
			char sCleanMask[MAX_PATH];
			POSITION pos = m_clMaskList.GetHeadPosition(), posPrev;

			if ( pcsMask != NULL )
				if ( *pcsMask == NULL )
					pcsMask = NULL;
				else
					pcsMask = CFilenameMaskW::CleanMask(pcsMask, sCleanMask);
			while ( (posPrev = pos) )
			{
				CFilenameMaskW& mask = m_clMaskList.GetNext(pos);
				int nCompare = mask.Compare(pcsMask);

				switch ( nCompare )
				{
				case 0:
					m_clMaskList.RemoveAt(posPrev);
				case 1:
					return;
				}
			}
		}
		inline void Remove(LPCWSTR pcwsMask)
		{
			WCHAR wsCleanMask[MAX_PATH];
			POSITION pos = m_clMaskList.GetHeadPosition(), posPrev;

			if ( pcwsMask != NULL )
				if ( *pcwsMask == NULL )
					pcwsMask = NULL;
				else
					pcwsMask = CFilenameMaskW::CleanMask(pcwsMask, wsCleanMask);
			while ( (posPrev = pos) )
			{
				CFilenameMaskW& mask = m_clMaskList.GetNext(pos);
				int nCompare = mask.Compare(pcwsMask);

				switch ( nCompare )
				{
				case 0:
					m_clMaskList.RemoveAt(posPrev);
				case 1:
					return;
				}
			}
		}

		inline void RemoveAll() { m_clMaskList.RemoveAll(); }

		inline BOOL IsAvailable(LPCTSTR pcstrMask) const
		{
			POSITION pos = m_clMaskList.GetHeadPosition();

			while ( pos )
			{
				CFilenameMaskW& mask = m_clMaskList.GetNext(pos);
				if ( mask == pcstrMask )
					return TRUE;
			}
			return FALSE;
		}

		inline BOOL IsNameMatch(LPCSTR pcsName) const
		{
			WCHAR wsName[MAX_PATH];

			if ( ::MultiByteToWideChar(CFileBackup::GetCodePage(), 0, pcsName, -1, wsName, sizeof(wsName) / sizeof(*wsName)) == 0 )
				return FALSE;
			else
				return IsNameMatch(wsName);
		}
		inline BOOL IsNameMatch(LPCWSTR pcwsName) const
		{
			POSITION pos = m_clMaskList.GetHeadPosition();

			while ( pos )
			{
				CFilenameMaskW& mask = m_clMaskList.GetNext(pos);
				if ( mask.IsNameMatch(pcwsName) )
					return TRUE;
			}
			return FALSE;
		}

		inline int GetCount() const { m_clMaskList.GetCount(); }
		inline BOOL IsEmpty() const { return m_clMaskList.GetCount() == 0; }

	protected:
		CList<CFilenameMaskW, CFilenameMaskW>		m_clMaskList;
	};

	class CFileFilterA
	{
	public:
		class CParsedPathItemA
		{
		public:
			friend class CFileFilterA;

			typedef enum
			{
				INTERMEDIA_ITEM					= 0L,
				INCLUDE_ITEM					= 1L,
				EXCLUDE_ITEM					= 2L,
				ITEM_TYPE_MASK					= 3L,
				ROOT_ITEM						= (0L << 2),
				DRIVE_ITEM						= (1L << 2),
				DIRECTORY_OR_FILE_ITEM			= (2L << 2),
				ITEM_MASK						= (3L << 2),
				NO_FILENAME_MASK				= (0L << 4),
				INCLUDE_FILENAME_MASK			= (1L << 4),
				EXCLUDE_FILENAME_MASK			= (2L << 4),
				FILENAME_MASK_MASK				= (3L << 4),
				NO_FILE_ATTRIBUTES_MASK			= (0L << 6),
				INCLUDE_FILE_ATTRIBUTES_MASK	= (1L << 6),
				EXCLUDE_FILE_ATTRIBUTES_MASK	= (2L << 6),
				FILE_ATTRIBUTES_MASK_MASK		= (3L << 6),
			} PARSED_PATH_ITEM_FLAGS_BIT_MASK;

			inline CParsedPathItemA(LPCSTR pcsItemName, LPCSTR pcsFilenameMask, DWORD dwFileAttributesMask, DWORD dwFlags) : m_pParent(NULL), m_pFirstChild(NULL), m_pNextSibling(NULL), m_dwFlags(0), m_psName(NULL), m_pFilenameMaskList(NULL), m_dwFileAttributesMask(0)
			{
				SetItemData(pcsItemName, pcsFilenameMask, dwFileAttributesMask, dwFlags);
			}
			inline CParsedPathItemA(LPCWSTR pcwsItemName, LPCWSTR pcwsFilenameMask, DWORD dwFileAttributesMask, DWORD dwFlags) : m_pParent(NULL), m_pFirstChild(NULL), m_pNextSibling(NULL), m_dwFlags(0), m_psName(NULL), m_pFilenameMaskList(NULL), m_dwFileAttributesMask(0)
			{
				SetItemData(pcwsItemName, pcwsFilenameMask, dwFileAttributesMask, dwFlags);
			}

			inline CParsedPathItemA(CParsedPathItemA* pParent, LPCSTR pcsItemName, LPCSTR pcsFilenameMask, DWORD dwFileAttributesMask, DWORD dwFlags) : m_pParent(NULL), m_pFirstChild(NULL), m_pNextSibling(NULL), m_dwFlags(0), m_psName(NULL), m_pFilenameMaskList(NULL), m_dwFileAttributesMask(0)
			{
				SetItemData(pcsItemName, pcsFilenameMask, dwFileAttributesMask, dwFlags);
				m_pParent = pParent;
			}
			inline CParsedPathItemA(CParsedPathItemA* pParent, LPCWSTR pcwsItemName, LPCWSTR pcwsFilenameMask, DWORD dwFileAttributesMask, DWORD dwFlags) : m_pParent(NULL), m_pFirstChild(NULL), m_pNextSibling(NULL), m_dwFlags(0), m_psName(NULL), m_pFilenameMaskList(NULL), m_dwFileAttributesMask(0)
			{
				SetItemData(pcwsItemName, pcwsFilenameMask, dwFileAttributesMask, dwFlags);
				m_pParent = pParent;
			}

			inline ~CParsedPathItemA()
			{
				ClearItemData();
				m_pParent = NULL;
			}

			BOOL AddIncludePath(LPCSTR pcsPath, LPCSTR pcsFilenameMask, BOOL fIsIncludeFilenameMask, DWORD* pdwFileAttributesMask, BOOL fIsIncludeFileAttributesMask);
			BOOL AddExcludePath(LPCSTR pcsPath, BOOL fUnderIncludePath);

			inline PARSED_PATH_ITEM_FLAGS_BIT_MASK MatchFilePathname(LPCSTR pcsFilePathname, CParsedPathItemA*& pItem)
			{
				LPCSTR pChar = pcsFilePathname;
				BOOL fInclude = FALSE;
				CHAR sPathName[MAX_PATH];
				int nLen;
				int nCompare;

				pItem = this;
				if ( (m_dwFlags & CParsedPathItemA::ITEM_MASK) == CParsedPathItemA::ROOT_ITEM )
				{
					int nDrive;

					switch ( m_dwFlags & CParsedPathItemA::ITEM_TYPE_MASK )
					{
					case CParsedPathItemA::INCLUDE_ITEM:
						if ( m_dwFlags & CParsedPathItemA::FILE_ATTRIBUTES_MASK_MASK )
						{
							DWORD dwFileAttributes = ::GetFileAttributesA(pcsFilePathname);

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

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

				while ( 1 )
				{
					switch ( pItem->m_dwFlags & CParsedPathItemA::ITEM_TYPE_MASK )
					{
					case CParsedPathItemA::INCLUDE_ITEM:
						if ( pItem->m_dwFlags & CParsedPathItemA::FILE_ATTRIBUTES_MASK_MASK )
						{
							DWORD dwFileAttributes = ::GetFileAttributesA(pcsFilePathname);

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

							for ( pLastBackSlash = pTempTChar = pChar; *pTempTChar; pTempTChar++ )
								if ( *pTempTChar == '\\' )
									pLastBackSlash = pTempTChar;
							if ( ++pLastBackSlash == pTempTChar || (((pItem->m_dwFlags & CParsedPathItemA::FILENAME_MASK_MASK) == CParsedPathItemA::INCLUDE_FILENAME_MASK ? TRUE : FALSE) ^ pItem->m_pFilenameMaskList->IsNameMatch(pLastBackSlash)) )
								return EXCLUDE_ITEM;
						}
						fInclude = TRUE;
						break;
					case CParsedPathItemA::INTERMEDIA_ITEM:
						break;
					default:
						return EXCLUDE_ITEM;
					}
					nLen = 0;
					while ( *pChar != NULL && *pChar != '\\' )
						sPathName[nLen++] = LOWER(*pChar++);
					sPathName[nLen] = NULL;
					pItem = pItem->m_pFirstChild;
					nCompare = -1;
					while ( pItem != NULL && (nLen != pItem->m_nNameLength || (nCompare = ::strncmp(pItem->m_psName, sPathName, nLen)) < 0) )
						pItem = pItem->m_pNextSibling;
					if ( !pItem || nCompare != 0 )
						return fInclude ? INCLUDE_ITEM : INTERMEDIA_ITEM;
					pChar++;
				}
			}
			inline PARSED_PATH_ITEM_FLAGS_BIT_MASK MatchFilePathname(LPCWSTR pcwsFilePathname, CParsedPathItemA*& pItem)
			{
				char sFilePathname[MAX_PATH * 2];

				if ( ::WideCharToMultiByte(CFileBackup::GetCodePage(), 0, pcwsFilePathname, -1, sFilePathname, sizeof(sFilePathname), NULL, NULL) == 0 )
					return EXCLUDE_ITEM;
				else
					return MatchFilePathname(sFilePathname, pItem);
			}

			inline BOOL MatchFilePathname(LPCSTR pcsFilePathname)
			{
				CParsedPathItemA* pItem;
				LPCSTR pChar = pcsFilePathname;
				BOOL fInclude = FALSE;
				CHAR sPathName[MAX_PATH];
				int nLen;
				int nCompare;

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

					switch ( m_dwFlags & CParsedPathItemA::ITEM_TYPE_MASK )
					{
					case CParsedPathItemA::INCLUDE_ITEM:
						if ( m_dwFlags & CParsedPathItemA::FILE_ATTRIBUTES_MASK_MASK )
						{
							DWORD dwFileAttributes = ::GetFileAttributesA(pcsFilePathname);

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

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

				while ( 1 )
				{
					switch ( pItem->m_dwFlags & CParsedPathItemA::ITEM_TYPE_MASK )
					{
					case CParsedPathItemA::INCLUDE_ITEM:
						if ( pItem->m_dwFlags & CParsedPathItemA::FILE_ATTRIBUTES_MASK_MASK )
						{
							DWORD dwFileAttributes = ::GetFileAttributesA(pcsFilePathname);

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

							for ( pLastBackSlash = pTempTChar = pChar; *pTempTChar; pTempTChar++ )
								if ( *pTempTChar == '\\' )
									pLastBackSlash = pTempTChar;
							if ( ++pLastBackSlash == pTempTChar || (((pItem->m_dwFlags & CParsedPathItemA::FILENAME_MASK_MASK) == CParsedPathItemA::INCLUDE_FILENAME_MASK ? TRUE : FALSE) ^ pItem->m_pFilenameMaskList->IsNameMatch(pLastBackSlash)) )
								return FALSE;
						}
						fInclude = TRUE;
						break;
					case CParsedPathItemA::INTERMEDIA_ITEM:
						break;
					default:
						return FALSE;
					}
					nLen = 0;
					while ( *pChar && *pChar != '\\' )
						sPathName[nLen++] = LOWER(*pChar++);
					sPathName[nLen] = NULL;
					pItem = pItem->m_pFirstChild;
					nCompare = -1;
					while ( pItem && (nLen != pItem->m_nNameLength || (nCompare = ::strncmp(pItem->m_psName, sPathName, nLen)) < 0) )
						pItem = pItem->m_pNextSibling;
					if ( !pItem || nCompare != 0 )
						return fInclude;
					pChar++;
				}
			}
			inline BOOL MatchFilePathname(LPCWSTR pcwsFilePathname)
			{
				char sFilePathname[MAX_PATH * 2];

				if ( ::WideCharToMultiByte(CFileBackup::GetCodePage(), 0, pcwsFilePathname, -1, sFilePathname, sizeof(sFilePathname), NULL, NULL) == 0 )
					return FALSE;
				else
					return MatchFilePathname(sFilePathname);
			}

			void GetIncludeItems(CList<CParsedPathItemA*, CParsedPathItemA*>& 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;
				CParsedPathItemA* 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);
						_tcscpy(pts, pTempItem->m_ptsName);
						*--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 BOOL GetItemFullPath(LPSTR pPath, int nMax)
			{
				CParsedPathItemA* pTempItem = this;
				int nLen = 0;
				LPSTR ps;

				while ( !pTempItem->IsRootItem() )
				{
					nLen += pTempItem->IsDriveItem() ? 2 : pTempItem->m_nNameLength + 1;
					pTempItem = pTempItem-