simplefilebackup.h

实时文件备份

				{
					if ( *pcstrMask == _T('*') )
						fCharLimit = FALSE;
					else if ( *pcstrMask == _T('.') )
					{
						if ( fCharLimit )
							return FALSE;
						else
							fCharLimit = TRUE;
					}
					else if ( *pcstrMask != _T('?') )
						return FALSE;
					pcstrMask++;
				}
				return !fCharLimit;
			}

			inline static BOOL IsExtMask(LPCTSTR pcstrMask, LPCTSTR* ppStart = NULL)
			{
				BOOL fCharLimit;

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

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

			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;
			}

			static BOOL IsSubNameMatch(LPCTSTR pcstrMask, LPCTSTR pcstrName);
			static BOOL IsSubNameMatchWithoutDot(LPCTSTR pcstrMask, LPCTSTR pcstrName);

			inline BOOL IsNameMatch(LPCTSTR pcstrName) const
			{
				if ( pcstrName == NULL )
					return FALSE;

				if ( m_enumType == SYNC_FILE_MASK_TYPE_ALL )
					return TRUE;

				if ( m_enumType == SYNC_FILE_MASK_TYPE_EXT )
				{
					int nNameLen = _tcslen(pcstrName);
					LPCTSTR pName;

					if ( m_nMaskLen >= nNameLen )
						return FALSE;
					pName = pcstrName + nNameLen - m_nMaskLen;
					return *(pName - 1) == _T('.') && m_csMask.CompareNoCase(pName) == 0;
				}

				{
					LPCTSTR pMask = m_csMask;
					LPCTSTR pOrgName = pcstrName;
					TCHAR tsNameDuplicate[MAX_PATH];
					LPTSTR pName = tsNameDuplicate;
					int nDotCount = 0;

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

			inline const CString& GetMask() const { return m_csMask; }
			inline FILE_MASK_TYPE GetMaskType() const { return m_enumType; }
			inline int GetMaskLen() const { return m_nMaskLen; }
			inline int GetNameRequiredLen() const { return m_nRequiredLen; }
			inline BOOL IsMaskType(FILE_MASK_TYPE type) const { return m_enumType == type; }

		protected:
			CString			m_csMask;
			FILE_MASK_TYPE	m_enumType;
			int				m_nMaskLen;
			int				m_nRequiredLen;
		};

		inline CFilenameMaskList() {}
		inline CFilenameMaskList(LPCTSTR pcstrMasks) { *this = pcstrMasks; }

		inline void Reset() { RemoveAll(); }

		inline CFilenameMaskList& operator =(LPCTSTR pcstrMasks)
		{
			LPCTSTR pChar = pcstrMasks;
			LPCTSTR pStartPos = pcstrMasks;
			int nTokenLen = 0;
			CString csMask;
			LPTSTR pBuf;
			BOOL fIsQuotationMask = FALSE;

			m_clMaskList.RemoveAll();

			while ( *pChar != NULL )
			{
				if ( fIsQuotationMask )
				{
					if ( *pChar == _T('"') )
					{
						if ( nTokenLen > 0 )
						{
							pBuf = csMask.GetBuffer(nTokenLen);
							memcpy(pBuf, pStartPos, nTokenLen * sizeof(TCHAR));
							csMask.ReleaseBuffer(nTokenLen);
							Add(csMask);
						}
						pStartPos = pChar + 1;
						nTokenLen = 0;
						fIsQuotationMask = FALSE;
					}
					else
						nTokenLen++;
				}
				else
				{
					switch ( *pChar )
					{
					case _T('"'):
						fIsQuotationMask = TRUE;
					case _T(';'):
						if ( nTokenLen > 0 )
						{
							pBuf = csMask.GetBuffer(nTokenLen);
							memcpy(pBuf,pStartPos, nTokenLen * sizeof(TCHAR));
							csMask.ReleaseBuffer(nTokenLen);
							Add(csMask);
						}
						pStartPos = pChar + 1;
						nTokenLen = 0;
						break;
					default:
						nTokenLen++;
					}
				}
				pChar++;
			}
			if ( nTokenLen > 0 )
			{
				pBuf = csMask.GetBuffer(nTokenLen);
				memcpy(pBuf, pStartPos, nTokenLen * sizeof(TCHAR));
				csMask.ReleaseBuffer(nTokenLen);
				Add(csMask);
			}

			return *this;
		}

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

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

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

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

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

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

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

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

			return pos1 == pos2;
		}

		inline BOOL operator ==(LPCTSTR pcstrMasks) const
		{
			return *this == CFilenameMaskList(pcstrMasks);
		}

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

		inline BOOL operator !=(LPCTSTR pcstrMasks) const
		{
			return *this != CFilenameMaskList(pcstrMasks);
		}

		inline void Add(LPCTSTR pcstrMask)
		{
			CString csTempMask(CFilenameMask::CleanMask(pcstrMask));
			POSITION pos = m_clMaskList.GetHeadPosition(), posPrev;

			while ( (posPrev = pos) )
			{
				CFilenameMask& mask = m_clMaskList.GetNext(pos);
				int nCompare = mask.Compare(csTempMask);

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

		inline void Remove(LPCTSTR pcstrMask)
		{
			CString csTempMask(CFilenameMask::CleanMask(pcstrMask));