filebackup.h

实时文件备份

							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 == NULL )
					return FALSE;

				if ( m_enumType == SYNC_FILE_MASK_TYPE_ALL )
					return TRUE;
				else if ( m_enumType == SYNC_FILE_MASK_TYPE_EXT )
				{
					int nNameLen = ::strlen(pcsName);
					LPCSTR pName;

					if ( m_nMaskLen >= nNameLen )
						return FALSE;
					pName = pcsName + nNameLen - m_nMaskLen;
					return *(pName - 1) == '.' && MaskStringCompareNoCase(pName) == 0;
				}
				else
				{
					LPCSTR pMask = m_psMask;
					LPCSTR pOrgName = pcsName;
					char sNameDuplicate[MAX_PATH];
					LPSTR pName = sNameDuplicate;
					int nDotCount = 0;

					while ( *pOrgName != NULL )
						if ( *pOrgName >= 'A' && *pOrgName <= 'Z' )
							*pName++ = *pOrgName++ + ('a' - 'A');
						else if ( *pOrgName == '.' )
						{
							*pName++ = '.';
							pOrgName++;
							nDotCount++;
						}
						else
							*pName++ = *pOrgName++;
					*pName = NULL;
					while ( pName > sNameDuplicate && *(pName - 1) == '.' )
					{
							*--pName = NULL;
							nDotCount--;
					}
					if ( pName == sNameDuplicate )
						return FALSE;
					pName = sNameDuplicate;
					if ( nDotCount != 0 )
					{
						while ( *pMask != NULL )
						{
							if ( *pMask == '*' || *pMask == '?' )
								return IsSubNameMatchA(pMask, pName);
							else if ( *pMask != *pName )
								return FALSE;
							pName++;
							pMask++;
						}
						return *pName == NULL;	//	*pMask == NULL
					}
					else
					{
						while ( *pMask != NULL )
						{
							if ( *pMask == '*' || *pMask == '?' )
								return IsSubNameMatchWithoutDotA(pMask, pName);
							else if ( *pMask != *pName )
								return *pName == NULL && *pMask == '.' && *(pMask + 1) == NULL;
							pName++;
							pMask++;
						}
						return *pName == NULL;	//	*pMask == NULL
					}
				}
			}
			inline BOOL IsNameMatch(LPCWSTR pcwsName) const
			{
				if ( !pcwsName )
					return FALSE;

				if ( m_enumType == SYNC_FILE_MASK_TYPE_ALL )
					return TRUE;
				else
				{
					char sName[MAX_PATH];
					int nLen = ::WideCharToMultiByte(CFileBackup::GetCodePage(), 0, pcwsName, -1, sName, MAX_PATH, NULL, NULL);

					return nLen == 0 ? FALSE : IsNameMatch(sName);
				}
			}

#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:
					{
						if ( m_psMask == NULL || m_nMaskLen == 0 )
							return CString(L"*.");
						else
						{
							int nLen = ::MultiByteToWideChar(CFileBackup::GetCodePage(), 0, m_psMask, m_nMaskLen, NULL, 0);

							if ( nLen == 0 )
								return CString(L"*.");
							else
							{
								CString csRet;
								LPWSTR pwsBuf = csRet.GetBuffer(nLen + 2);

								*pwsBuf++ = L'*';
								*pwsBuf++ = L'.';
								::MultiByteToWideChar(CFileBackup::GetCodePage(), 0, m_psMask, m_nMaskLen, pwsBuf, nLen);
								csRet.ReleaseBuffer(nLen + 2);
								return csRet;
							}
						}
					}
				case SYNC_FILE_MASK_TYPE_OTHER:
					{
						CString csRet;

						if ( m_psMask != NULL && m_nMaskLen != 0 )
						{
							int nLen = ::MultiByteToWideChar(CFileBackup::GetCodePage(), 0, m_psMask, m_nMaskLen, NULL, 0);

							if ( nLen != 0 )
							{
								LPWSTR pwsBuf = csRet.GetBuffer(nLen);

								::MultiByteToWideChar(CFileBackup::GetCodePage(), 0, m_psMask, m_nMaskLen, pwsBuf, nLen);
								csRet.ReleaseBuffer(nLen);
							}
						}
						return csRet;
					}
				}
			}
#else
			inline const CString GetMask() const
			{
				switch ( m_enumType )
				{
				case SYNC_FILE_MASK_TYPE_ALL:
					return CString("*.*");
				case SYNC_FILE_MASK_TYPE_EXT:
					{
						CString csRet;
						LPSTR psBuf = csRet.GetBuffer(m_nMaskLen + 2);

						*psBuf++ = '*';
						*psBuf++ = '.';
						::memcpy(psBuf, m_psMask, m_nMaskLen);
						csRet.ReleaseBuffer(m_nMaskLen + 2);
						return csRet;
					}
				case SYNC_FILE_MASK_TYPE_OTHER:
					return CString(m_psMask);
				}
			}
#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 IsSubNameMatchA(LPCSTR pcsMask, LPCSTR pcsName);
			static BOOL IsSubNameMatchWithoutDotA(LPCSTR pcsMask, LPCSTR pcsName);

		protected:
			LPSTR			m_psMask;
			int				m_nMaskLen;
			int				m_nRequiredLen;
			FILE_MASK_TYPE	m_enumType;
		};

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

		inline void Reset() { RemoveAll(); }

		inline CFilenameMaskListA& 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 CFilenameMaskListA& 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 )
			{
				CFilenameMaskA& mask = m_clMaskList.GetNext(pos);
				if ( fFirstMask )
					fFirstMask = FALSE;
				else
					nBufLen++;
				switch ( mask.GetMaskType() )
				{
				case CFilenameMaskA::SYNC_FILE_MASK_TYPE_ALL:
					nBufLen += 3;
					break;
				case CFilenameMaskA::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 )
			{
				CFilenameMaskA& mask = m_clMaskList.GetNext(pos);
				if ( fFirstMask )
					fFirstMask = FALSE;
				else
					*pBuf++ = _T(';');
				switch ( mask.GetMaskType() )
				{
				case CFilenameMaskA::SYNC_FILE_MASK_TYPE_ALL:
					*pBuf++ = _T('*');
					*pBuf++ = _T('.');
					*pBuf++ = _T('*');
					break;
				case CFilenameMaskA::SYNC_FILE_MASK_TYPE_EXT:
					if ( mask.GetMask().Find(_T(';')) != -1 )
					{
						csTemp = mask.GetMask();
						LPCTSTR pTChar = (LPCTSTR)csTemp;

						*pBuf++ = _T('"');
						*pBuf++ = _T('*');
						*pBuf++ = _T('.');
						while ( *pTChar )
							*pBuf++ = *pTChar++;
						*pBuf++ = _T('"');
					}
					else
					{
						csTemp = mask.GetMask();
						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 ==(CFilenameMaskListA& objMaskList) const
		{
			POSITION pos1 = m_clMaskList.GetHeadPosition(), pos2 = objMaskList.m_clMaskList.GetHeadPosition();

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

			return pos1 == pos2 ? TRUE : FALSE;
		}

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

		inline BOOL operator !=(CFilenameMaskListA& objMaskList) const
		{
			return !(operator ==(objMaskList));
		}

		inline BOOL operator !=(LPCTSTR pctsMasks) const
		{
			return *this != CFilenameMaskListA(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 = CFilenameMaskA::CleanMask(pcsMask, sCleanMask);
			while ( (posPrev = pos) )
			{
				CFilenameMaskA& mask = m_clMaskList.GetNext(pos);
				int nCompare = mask.Compare(pcsMask);

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