filebackup.h

实时文件备份

			{
				LPWSTR pNewMask = pcwsNewMask;
				int nQuestionMarkLen = 0;

				while ( *pcwsMask != NULL )
				{
					if ( *pcwsMask == L'*' )
					{
						*pNewMask++ = L'*';
						nQuestionMarkLen = 0;
						while ( *pcwsMask == L'*' || *pcwsMask == L'?' )
							pcwsMask++;
						continue;
					}
					else if ( *pcwsMask == L'?' )
						nQuestionMarkLen++;
					else
					{
						while ( nQuestionMarkLen > 0 )
						{
							*pNewMask++ = L'?';
							nQuestionMarkLen--;
						}
						*pNewMask++ = *pcwsMask;
					}
					pcwsMask++;
				}
				*pNewMask = NULL;
				return pcwsNewMask;
			}
/*			inline static CString CleanMask(LPCTSTR pcstrMask)
			{
				CString csNewMask;
				int nOrgMaskLen = _tcslen(pcstrMask);
				LPCTSTR pOrgMask = pcstrMask;
				LPTSTR pNewMask = csNewMask.GetBuffer(nOrgMaskLen + 1);
				int nQuestionMarkLen = 0;

				while ( *pOrgMask != NULL )
				{
					if ( *pOrgMask == _T('*') )
					{
						*pNewMask++ = _T('*');
						nQuestionMarkLen = 0;
						while ( *pOrgMask == _T('*') || *pOrgMask == _T('?') )
							pOrgMask++;
						continue;
					}
					else if ( *pOrgMask == _T('?') )
						nQuestionMarkLen++;
					else
					{
						while ( nQuestionMarkLen > 0 )
						{
							*pNewMask++ = _T('?');
							nQuestionMarkLen--;
						}
						*pNewMask++ = *pOrgMask;
					}
					pOrgMask++;
				}

				*pNewMask = NULL;
				csNewMask.ReleaseBuffer();
				return csNewMask;
			}
*/
			inline BOOL IsNameMatch(LPCSTR pcsName) const
			{
				if ( !pcsName )
					return FALSE;

				if ( m_enumType == SYNC_FILE_MASK_TYPE_ALL )
					return TRUE;
				else
				{
					WCHAR wsName[MAX_PATH];
					int nLen = ::MultiByteToWideChar(CFileBackup::GetCodePage(), 0, pcsName, -1, wsName, sizeof(wsName) / sizeof(*wsName));

					return nLen == 0 ? FALSE : IsNameMatch(wsName);
				}
			}
			inline BOOL IsNameMatch(LPCWSTR pcwsName) const
			{
				if ( pcwsName == NULL )
					return FALSE;

				if ( m_enumType == SYNC_FILE_MASK_TYPE_ALL )
					return TRUE;
				else if ( m_enumType == SYNC_FILE_MASK_TYPE_EXT )
				{
					int nNameLen = ::wcslen(pcwsName);
					LPCWSTR pName;

					if ( m_nMaskLen >= nNameLen )
						return FALSE;
					pName = pcwsName + nNameLen - m_nMaskLen;
					return *(pName - 1) == L'.' && MaskStringCompareNoCase(pName) == 0;
				}
				else
				{
					LPCWSTR pMask = m_pwsMask;
					LPCWSTR pOrgName = pcwsName;
					WCHAR wsNameDuplicate[MAX_PATH];
					LPWSTR pName = wsNameDuplicate;
					int nDotCount = 0;

					while ( *pOrgName != NULL )
						if ( *pOrgName >= L'A' && *pOrgName <= L'Z' )
							*pName++ = *pOrgName++ + (L'a' - L'A');
						else if ( *pOrgName == L'.' )
						{
							*pName++ = L'.';
							pOrgName++;
							nDotCount++;
						}
						else
							*pName++ = *pOrgName++;
					*pName = NULL;
					while ( pName > wsNameDuplicate && *(pName - 1) == L'.' )
					{
							*--pName = NULL;
							nDotCount--;
					}
					if ( pName == wsNameDuplicate )
						return FALSE;
					pName = wsNameDuplicate;
					if ( nDotCount != 0 )
					{
						while ( *pMask != NULL )
						{
							if ( *pMask == L'*' || *pMask == L'?' )
								return IsSubNameMatchW(pMask, pName);
							else if ( *pMask != *pName )
								return FALSE;
							pName++;
							pMask++;
						}
						return *pName == NULL;	//	*pMask == NULL
					}
					else
					{
						while ( *pMask != NULL )
						{
							if ( *pMask == L'*' || *pMask == L'?' )
								return IsSubNameMatchWithoutDotW(pMask, pName);
							else if ( *pMask != *pName )
								return *pName == NULL && *pMask == L'.' && *(pMask + 1) == NULL;
							pName++;
							pMask++;
						}
						return *pName == NULL;	//	*pMask == NULL
					}
				}
			}

#ifdef UNICODE
			inline const CString GetMask() const
			{
				switch ( m_enumType )
				{
				case SYNC_FILE_MASK_TYPE_ALL:
					return CString(L"*.*");
				case SYNC_FILE_MASK_TYPE_EXT:
					{
						CString csRet;
						LPWSTR pwsBuf = csRet.GetBuffer(m_nMaskLen + 2);

						*pwsBuf++ = L'*';
						*pwsBuf++ = L'.';
						::memcpy(pwsBuf, m_pwsMask, m_nMaskLen * sizeof(WCHAR));
						csRet.ReleaseBuffer(m_nMaskLen + 2);
						return csRet;
					}
				case SYNC_FILE_MASK_TYPE_OTHER:
					return CString(m_pwsMask);
				}
			}
#else
			inline const CString GetMask() const
			{
				switch ( m_enumType )
				{
				case SYNC_FILE_MASK_TYPE_ALL:
					return CString("*.*");
				case SYNC_FILE_MASK_TYPE_EXT:
					{
						if ( m_pwsMask == NULL || m_nMaskLen == 0 )
							return CString("*.");
						else
						{
							int nLen = ::WideCharToMultiByte(CFileBackup::GetCodePage(), 0, m_pwsMask, m_nMaskLen + 1, NULL, 0, NULL, NULL);

							if ( nLen == 0 )
								return CString(L"*.");
							else
							{
								CString csRet;
								LPSTR psBuf = csRet.GetBuffer(nLen - 1 + 2);

								*psBuf++ = '*';
								*psBuf++ = '.';
								::WideCharToMultiByte(CFileBackup::GetCodePage(), 0, m_pwsMask, m_nMaskLen + 1, psBuf, nLen, NULL, NULL);
								csRet.ReleaseBuffer(nLen -1 + 2);
								return csRet;
							}
						}
					}
				case SYNC_FILE_MASK_TYPE_OTHER:
					{
						CString csRet;

						if ( m_pwsMask != NULL || m_nMaskLen != 0 )
						{
							int nLen = ::WideCharToMultiByte(CFileBackup::GetCodePage(), 0, m_pwsMask, m_nMaskLen + 1, NULL, 0, NULL, NULL);

							if ( nLen != 0 )
							{
								LPSTR psBuf = csRet.GetBuffer(nLen - 1);

								::WideCharToMultiByte(CFileBackup::GetCodePage(), 0, m_pwsMask, m_nMaskLen + 1, psBuf, nLen, NULL, NULL);
								csRet.ReleaseBuffer(nLen - 1);
							}
						}
						return csRet;
					}
				}
			}
#endif
			inline FILE_MASK_TYPE GetMaskType() const { return m_enumType; }
			inline BOOL IsMaskType(FILE_MASK_TYPE type) const { return m_enumType == type ? TRUE : FALSE; }

		protected:
			static BOOL IsSubNameMatchW(LPCWSTR pcwsMask, LPCWSTR pcwsName);
			static BOOL IsSubNameMatchWithoutDotW(LPCWSTR pcwsMask, LPCWSTR pcwsName);

		protected:
			LPWSTR			m_pwsMask;
			int				m_nMaskLen;
			int				m_nRequiredLen;
			FILE_MASK_TYPE	m_enumType;
		};

		inline CFilenameMaskListW() {}
		inline CFilenameMaskListW(LPCSTR pcsMasks) { *this = pcsMasks; }
		inline CFilenameMaskListW(LPCWSTR pcwsMasks) { *this = pcwsMasks; }

		inline void Reset() { RemoveAll(); }

		inline CFilenameMaskListW& operator =(LPCSTR pcsMasks)
		{
			LPCSTR pChar = pcsMasks;
			LPCSTR pStartPos = pcsMasks;
			int nTokenLen = 0;
			char sMask[MAX_PATH];
			BOOL fIsQuotationMask = FALSE;

			m_clMaskList.RemoveAll();

			while ( *pChar != NULL )
			{
				if ( fIsQuotationMask )
				{
					if ( *pChar == '"' )
					{
						if ( nTokenLen > 0 )
						{
							memcpy(sMask, pStartPos, nTokenLen);
							sMask[nTokenLen] = NULL;
							Add(sMask);
						}
						pStartPos = pChar + 1;
						nTokenLen = 0;
						fIsQuotationMask = FALSE;
					}
					else
						nTokenLen++;
				}
				else
				{
					switch ( *pChar )
					{
					case '"':
						fIsQuotationMask = TRUE;
					case ';':
						if ( nTokenLen > 0 )
						{
							memcpy(sMask, pStartPos, nTokenLen);
							sMask[nTokenLen] = NULL;
							Add(sMask);
						}
						pStartPos = pChar + 1;
						nTokenLen = 0;
						break;
					default:
						nTokenLen++;
					}
				}
				pChar++;
			}
			if ( nTokenLen > 0 )
			{
				memcpy(sMask, pStartPos, nTokenLen);
				sMask[nTokenLen] = NULL;
				Add(sMask);
			}

			return *this;
		}
		inline CFilenameMaskListW& operator =(LPCWSTR pcwsMasks)
		{
			LPCWSTR pChar = pcwsMasks;
			LPCWSTR pStartPos = pcwsMasks;
			int nTokenLen = 0;
			WCHAR wsMask[MAX_PATH];
			BOOL fIsQuotationMask = FALSE;

			m_clMaskList.RemoveAll();

			while ( *pChar != NULL )
			{
				if ( fIsQuotationMask )
				{
					if ( *pChar == L'"' )
					{
						if ( nTokenLen > 0 )
						{
							memcpy(wsMask, pStartPos, nTokenLen * sizeof(WCHAR));
							wsMask[nTokenLen] = NULL;
							Add(wsMask);
						}
						pStartPos = pChar + 1;
						nTokenLen = 0;
						fIsQuotationMask = FALSE;
					}
					else
						nTokenLen++;
				}
				else
				{
					switch ( *pChar )
					{
					case L'"':
						fIsQuotationMask = TRUE;
					case L';':
						if ( nTokenLen > 0 )
						{
							memcpy(wsMask, pStartPos, nTokenLen * sizeof(WCHAR));
							wsMask[nTokenLen] = NULL;
							Add(wsMask);
						}
						pStartPos = pChar + 1;
						nTokenLen = 0;
						break;
					default:
						nTokenLen++;
					}
				}
				pChar++;
			}
			if ( nTokenLen > 0 )
			{
				memcpy(wsMask, pStartPos, nTokenLen * sizeof(WCHAR));
				wsMask[nTokenLen] = NULL;
				Add(wsMask);
			}

			return *this;
		}

		inline CString WriteToString () const
		{
			CString csMasks;
			POSITION pos;
			BOOL fFirstMask;
			PTSTR pBuf;
			int nBufLen = 0;
			CString csTemp;

			pos = m_clMaskList.GetHeadPosition();
			fFirstMask = TRUE;
			while ( pos )
			{
				CFilenameMaskW& mask = m_clMaskList.GetNext(pos);
				if ( fFirstMask )
					fFirstMask = FALSE;
				else
					nBufLen++;
				switch ( mask.GetMaskType() )
				{
				case CFilenameMaskW::SYNC_FILE_MASK_TYPE_ALL:
					nBufLen += 3;
					break;
				case CFilenameMaskW::SYNC_FILE_MASK_TYPE_EXT:
					csTemp = mask.GetMask();
					nBufLen += csTemp.GetLength() + (csTemp.Find(_T(';')) != -1 ? 4 : 2);
					break;
				default:
					csTemp = mask.GetMask();
					nBufLen += csTemp.GetLength();
					if ( csTemp.Find(_T(';')) != -1 )
						nBufLen += 2;
				}
			}
			pos = m_clMaskList.GetHeadPosition();
			fFirstMask = TRUE;
			pBuf = csMasks.GetBuffer(nBufLen);
			while ( pos )
			{
				CFilenameMaskW& mask = m_clMaskList.GetNext(pos);
				if ( fFirstMask )
					fFirstMask = FALSE;
				else
					*pBuf++ = _T(';');
				switch ( mask.GetMaskType() )
				{
				case CFilenameMaskW::SYNC_FILE_MASK_TYPE_ALL:
					*pBuf++ = _T('*');
					*pBuf++ = _T('.');
					*pBuf++ = _T('*');
					break;
				case CFilenameMaskW::SYNC_FILE_MASK_TYPE_EXT:
					csTemp = mask.GetMask();
					if ( csTemp.Find(_T(';')) != -1 )
					{
						LPCTSTR pTChar = (LPCTSTR)csTemp;

						*pBuf++ = _T('"');
						*pBuf++ = _T('*');
						*pBuf++ = _T('.');
						while ( *pTChar )
							*pBuf++ = *pTChar++;
						*pBuf++ = _T('"');
					}
					else
					{
						LPCTSTR pTChar = (LPCTSTR)csTemp;

						*pBuf++ = _T('*');
						*pBuf++ = _T('.');
						while ( *pTChar )
							*pBuf++ = *pTChar++;
					}
					break;
				default:
					csTemp = mask.GetMask();
					if ( csTemp.Find(_T(';')) != -1 )
					{
						LPCTSTR pTChar = (LPCTSTR)csTemp;

						*pBuf++ = _T('"');
						while ( *pTChar )
							*pBuf++ = *pTChar++;
						*pBuf++ = _T('"');
					}
					else
					{
						LPCTSTR pTChar = (LPCTSTR)csTemp;

						while ( *pTChar )
							*pBuf++ = *pTChar++;
					}
				}
			}
			csMasks.ReleaseBuffer(nBufLen);
			return csMasks;
		}

		inline BOOL operator ==(CFilenameMaskListW& objMaskList) const
		{
			POSITION pos1 = m_clMaskList.GetHeadPosition(), pos2 = objMaskList.m_clMaskList.GetHeadPosition();

			while ( pos1 && pos2 )
			{
				CFilenameMaskW &mask1 = m_clMaskList.GetNext(pos1), &mask2 = objMaskList.m_clMaskList.GetNext(pos2);
				if ( mask1 != mask2 )
					return FALSE;
			}

			return pos1 == pos2;
		}

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

		inline BOOL operator !=(CFilenameMaskListW& objMaskList) const
		{