filebackup.h

实时文件备份

			{
				CFilenameMaskA& mask = m_clMaskList.GetNext(pos);
				int nCompare = mask.Compare(pcwsMask);

				switch ( nCompare )
				{
				case 1:
					m_clMaskList.InsertBefore(posPrev, CFilenameMaskA(pcwsMask));
				case 0:
					return;
				}
			}
			m_clMaskList.AddTail(CFilenameMaskA(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 = CFilenameMaskA::CleanMask(pcsMask, sCleanMask);
			while ( (posPrev = pos) )
			{
				CFilenameMaskA& 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 = CFilenameMaskA::CleanMask(pcwsMask, wsCleanMask);
			while ( (posPrev = pos) )
			{
				CFilenameMaskA& 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 )
			{
				CFilenameMaskA& mask = m_clMaskList.GetNext(pos);
				if ( mask == pcstrMask )
					return TRUE;
			}
			return FALSE;
		}

		inline BOOL IsNameMatch(LPCSTR pcsName) const
		{
			POSITION pos = m_clMaskList.GetHeadPosition();

			while ( pos )
			{
				CFilenameMaskA& mask = m_clMaskList.GetNext(pos);
				if ( mask.IsNameMatch(pcsName) )
					return TRUE;
			}
			return FALSE;
		}
		inline BOOL IsNameMatch(LPCWSTR pcwsName) const
		{
			char sName[MAX_PATH];

			if ( ::WideCharToMultiByte(CFileBackup::GetCodePage(), 0, pcwsName, -1, sName, sizeof(sName), NULL, NULL) == 0 )
				return FALSE;
			else
				return IsNameMatch(sName);
		}

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

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

	class CFilenameMaskListW
	{
	public:
		class CFilenameMaskW
		{
		public:
			typedef enum
			{
				SYNC_FILE_MASK_TYPE_OTHER				= 0,
				SYNC_FILE_MASK_TYPE_ALL					= 1,
				SYNC_FILE_MASK_TYPE_EXT					= 2,
			} FILE_MASK_TYPE;

			inline CFilenameMaskW() : m_pwsMask(NULL), m_nMaskLen(0), m_nRequiredLen(0), m_enumType(SYNC_FILE_MASK_TYPE_OTHER) {}
			inline CFilenameMaskW(LPCSTR pcsMask) { *this = pcsMask; }
			inline CFilenameMaskW(LPCWSTR pcwsMask) { *this = pcwsMask; }

			inline ~CFilenameMaskW() { MaskStringEmpty(); }

			inline void MaskStringEmpty() { if ( m_pwsMask != NULL ) delete[] m_pwsMask; m_pwsMask = NULL; m_nMaskLen = 0; m_nRequiredLen = 0; }
			inline DWORD MaskStringGetLength() const { return m_nMaskLen; }
			inline void MaskStringMakeLower()
			{
				LPWSTR pws = m_pwsMask;

				while ( *pws != NULL )
				{
					if ( *pws >= L'A' && *pws <= L'Z' )
						*pws = *pws + (L'a' - L'A');
					pws++;
				}
			}
			inline void MaskStringMakeUpper()
			{
				LPWSTR pws = m_pwsMask;

				while ( *pws != NULL )
				{
					if ( *pws >= L'a' && *pws <= L'z' )
						*pws = *pws - L'a' + L'A';
					pws++;
				}
			}
			inline BOOL MaskStringSetValue(LPCSTR psValue)
			{
				MaskStringEmpty();
				if ( psValue != NULL && *psValue != NULL )
				{
					int nLen;

					nLen = ::MultiByteToWideChar(CFileBackup::GetCodePage(), 0, psValue, -1, NULL, 0);
					if ( nLen == 0 )
						return FALSE;
					m_pwsMask = new WCHAR[nLen];
					m_nMaskLen = ::MultiByteToWideChar(CFileBackup::GetCodePage(), 0, psValue, -1, m_pwsMask, nLen);
					if ( m_nMaskLen == 0 )
					{
						delete[] m_pwsMask;
						m_pwsMask = NULL;
						return FALSE;
					}
					else
						return TRUE;
				}
				else
					return FALSE;
			}
			inline BOOL MaskStringSetValue(LPCWSTR pwsValue)
			{
				MaskStringEmpty();
				if ( pwsValue != NULL && *pwsValue != NULL )
				{
					m_nMaskLen = ::wcslen(pwsValue);
					m_pwsMask = new WCHAR[m_nMaskLen + 1];
					::memcpy(m_pwsMask, pwsValue, (m_nMaskLen + 1) * sizeof(WCHAR));
					return TRUE;
				}
				else
					return FALSE;
			}
			inline int MaskStringCompareNoCase(LPCSTR psStr) const
			{
				WCHAR wsStr[MAX_PATH];

				if ( ::MultiByteToWideChar(CFileBackup::GetCodePage(), 0, psStr, -1, wsStr, sizeof(wsStr) / sizeof(*wsStr)) == 0 )
					return 1;
				else
					return ::wcsicmp(m_pwsMask, wsStr);
			}
			inline int MaskStringCompareNoCase(LPCWSTR pwsStr) const
			{
				return ::wcsicmp(m_pwsMask, pwsStr);
			}

			inline void Reset() { MaskStringEmpty(); m_enumType = SYNC_FILE_MASK_TYPE_OTHER; }

			inline CFilenameMaskW& operator =(LPCSTR pcsMask)
			{
				LPCSTR pStart;

				if ( IsAllMask(pcsMask) )
				{
					m_enumType = SYNC_FILE_MASK_TYPE_ALL;
					MaskStringEmpty();
				}
				else if ( IsExtMask(pcsMask, &pStart) )
				{
					m_enumType = SYNC_FILE_MASK_TYPE_EXT;
					MaskStringSetValue(pStart);
				}
				else
				{
					char sCleanMask[MAX_PATH];
					LPCWSTR pMask;

					m_enumType = SYNC_FILE_MASK_TYPE_OTHER;
					MaskStringSetValue(CleanMask(pcsMask, sCleanMask));

					pMask = m_pwsMask;
					m_nRequiredLen = 0;
					while ( *pMask != NULL )
					{
						if ( *pMask != L'*' && *pMask != L'?' )
							m_nRequiredLen++;
						pMask++;
					}
				}
				MaskStringMakeLower();
				return *this;
			}
			inline CFilenameMaskW& operator =(LPCWSTR pcwsMask)
			{
				LPCWSTR pStart;

				if ( IsAllMask(pcwsMask) )
				{
					m_enumType = SYNC_FILE_MASK_TYPE_ALL;
					MaskStringEmpty();
				}
				else if ( IsExtMask(pcwsMask, &pStart) )
				{
					m_enumType = SYNC_FILE_MASK_TYPE_EXT;
					MaskStringSetValue(pStart);
				}
				else
				{
					WCHAR wsCleanMask[MAX_PATH];
					LPCWSTR pMask;

					m_enumType = SYNC_FILE_MASK_TYPE_OTHER;
					MaskStringSetValue(CleanMask(pcwsMask, wsCleanMask));

					pMask = m_pwsMask;
					m_nRequiredLen = 0;
					while ( *pMask != NULL )
					{
						if ( *pMask != L'*' && *pMask != L'?' )
							m_nRequiredLen++;
						pMask++;
					}
				}
				MaskStringMakeLower();
				return *this;
			}

			inline BOOL operator ==(LPCSTR pcsMask) const
			{
				LPCSTR pStart;
				char sCleanMask[MAX_PATH];

				if ( IsAllMask(pcsMask) )
					return m_enumType == SYNC_FILE_MASK_TYPE_ALL;
				else if ( IsExtMask(pcsMask, &pStart) )
					return m_enumType == SYNC_FILE_MASK_TYPE_EXT && MaskStringCompareNoCase(pStart) == 0;
				else
					return m_enumType == SYNC_FILE_MASK_TYPE_OTHER && MaskStringCompareNoCase(CleanMask(pcsMask, sCleanMask)) == 0;
			}
			inline BOOL operator ==(LPCWSTR pcwsMask) const
			{
				LPCWSTR pStart;
				WCHAR wsCleanMask[MAX_PATH];

				if ( IsAllMask(pcwsMask) )
					return m_enumType == SYNC_FILE_MASK_TYPE_ALL;
				else if ( IsExtMask(pcwsMask, &pStart) )
					return m_enumType == SYNC_FILE_MASK_TYPE_EXT && MaskStringCompareNoCase(pStart) == 0;
				else
					return m_enumType == SYNC_FILE_MASK_TYPE_OTHER && MaskStringCompareNoCase(CleanMask(pcwsMask, wsCleanMask)) == 0;
			}

			inline BOOL operator ==(const CFilenameMaskW& mask) const
			{
				return m_enumType == mask.m_enumType && m_nMaskLen == mask.m_nMaskLen && m_nRequiredLen == mask.m_nRequiredLen && MaskStringCompareNoCase(mask.m_pwsMask) == 0;
			}

			inline BOOL operator !=(const CFilenameMaskW& mask) const
			{
				return !(*this == mask);
			}

			inline int Compare(LPCSTR pcsMask) const
			{
				LPCSTR pStart;
				char sCleanMask[MAX_PATH];

				if ( IsAllMask(pcsMask) )
					return m_enumType == SYNC_FILE_MASK_TYPE_ALL ? 0 : 1;
				else if ( IsExtMask(pcsMask, &pStart) )
					return m_enumType == SYNC_FILE_MASK_TYPE_EXT ? MaskStringCompareNoCase(pStart) : m_enumType == SYNC_FILE_MASK_TYPE_ALL ? -1 : 1;
				else
					return m_enumType == SYNC_FILE_MASK_TYPE_OTHER ? MaskStringCompareNoCase(CleanMask(pcsMask, sCleanMask)) : -1;
			}
			inline int Compare(LPCWSTR pcwsMask) const
			{
				LPCWSTR pStart;
				WCHAR wsCleanMask[MAX_PATH];

				if ( IsAllMask(pcwsMask) )
					return m_enumType == SYNC_FILE_MASK_TYPE_ALL ? 0 : 1;
				else if ( IsExtMask(pcwsMask, &pStart) )
					return m_enumType == SYNC_FILE_MASK_TYPE_EXT ? MaskStringCompareNoCase(pStart) : m_enumType == SYNC_FILE_MASK_TYPE_ALL ? -1 : 1;
				else
					return m_enumType == SYNC_FILE_MASK_TYPE_OTHER ? MaskStringCompareNoCase(CleanMask(pcwsMask, wsCleanMask)) : -1;
			}

			inline static BOOL IsAllMask(LPCSTR pcsMask)
			{
				BOOL fCharLimit;

				if ( pcsMask == NULL || *pcsMask == NULL )
					return TRUE;

				fCharLimit = TRUE;
				while ( *pcsMask != NULL )
				{
					if ( *pcsMask == '*' )
						fCharLimit = FALSE;
					else if ( *pcsMask == '.' )
					{
						if ( fCharLimit )
							return FALSE;
						else
							fCharLimit = TRUE;
					}
					else if ( *pcsMask != '?' )
						return FALSE;
					pcsMask++;
				}
				return !fCharLimit;
			}
			inline static BOOL IsAllMask(LPCWSTR pcwsMask)
			{
				BOOL fCharLimit;

				if ( pcwsMask == NULL || *pcwsMask == NULL )
					return TRUE;

				fCharLimit = TRUE;
				while ( *pcwsMask != NULL )
				{
					if ( *pcwsMask == L'*' )
						fCharLimit = FALSE;
					else if ( *pcwsMask == L'.' )
					{
						if ( fCharLimit )
							return FALSE;
						else
							fCharLimit = TRUE;
					}
					else if ( *pcwsMask != L'?' )
						return FALSE;
					pcwsMask++;
				}
				return !fCharLimit;
			}

			inline static BOOL IsExtMask(LPCSTR pcsMask, LPCSTR* ppStart = NULL)
			{
				BOOL fCharLimit;

				if ( pcsMask == NULL || *pcsMask == NULL )
					return FALSE;

				fCharLimit = TRUE;
				while ( *pcsMask != NULL )
				{
					if ( *pcsMask == '*' )
						fCharLimit = FALSE;
					else if ( *pcsMask == '.' )
					{
						if ( fCharLimit )
							return FALSE;
						else
						{
							if ( *++pcsMask == NULL )
								return FALSE;
							if ( ppStart != NULL )
								*ppStart = pcsMask;
							do
							{
								if ( *pcsMask == '*' || *pcsMask == '?' || *pcsMask == '.' )
									return FALSE;
							} while ( *++pcsMask != NULL );
							return TRUE;
						}
					}
					else if ( *pcsMask != '?' )
						return FALSE;
					pcsMask++;
				}
				return FALSE;
			}
			inline static BOOL IsExtMask(LPCWSTR pcwsMask, LPCWSTR* ppStart = NULL)
			{
				BOOL fCharLimit;

				if ( pcwsMask == NULL || *pcwsMask == NULL )
					return FALSE;

				fCharLimit = TRUE;
				while ( *pcwsMask != NULL )
				{
					if ( *pcwsMask == L'*' )
						fCharLimit = FALSE;
					else if ( *pcwsMask == L'.' )
					{
						if ( fCharLimit )
							return FALSE;
						else
						{
							if ( *++pcwsMask == NULL )
								return FALSE;
							if ( ppStart != NULL )
								*ppStart = pcwsMask;
							do
							{
								if ( *pcwsMask == L'*' || *pcwsMask == L'?' || *pcwsMask == L'.' )
									return FALSE;
							} while ( *++pcwsMask != NULL );
							return TRUE;
						}
					}
					else if ( *pcwsMask != L'?' )
						return FALSE;
					pcwsMask++;
				}
				return FALSE;
			}

			inline static LPCSTR CleanMask(LPCSTR pcsMask, LPSTR pcsNewMask)
			{
				LPSTR pNewMask = pcsNewMask;
				int nQuestionMarkLen = 0;

				while ( *pcsMask != NULL )
				{
					if ( *pcsMask == '*' )
					{
						*pNewMask++ = '*';
						nQuestionMarkLen = 0;
						while ( *pcsMask == '*' || *pcsMask == '?' )
							pcsMask++;
						continue;
					}
					else if ( *pcsMask == '?' )
						nQuestionMarkLen++;
					else
					{
						while ( nQuestionMarkLen > 0 )
						{
							*pNewMask++ = '?';
							nQuestionMarkLen--;
						}
						*pNewMask++ = *pcsMask;
					}
					pcsMask++;
				}
				*pNewMask = NULL;
				return pcsNewMask;
			}
			inline static LPCWSTR CleanMask(LPCWSTR pcwsMask, LPWSTR pcwsNewMask)