【C++源代码】文件夹比较、文件比较的数据结构，定义和实现

说明：本来昨天我想找个程序同步一下自己的PC和笔记本上的数据文件夹，当然这方面的应用程序里面老大应该是Beyond Compare，可惜下载一个，发现又注册，连试用都不让，于是干脆自己花了三个钟头写了一个，提供出来，如果大家有好的建议，不妨告诉我；如果谁正在写这方面的程序，可以参考一下：），还有就是我本来是打算模仿Beyond Compare做个封装的CListCtrl扩展类，后来一动手发现要做UI而且要做得比较好看还是要花点力气的，所以偶就偷懒了一下，如果哪位兄弟愿意实现，可以在我的基础上直接实现下去就是了。

另外，正好昨天把Martin Fowler的<Refactor>英文版读完了一遍，顺便把里面那些理论用到这个小Demo程序来了：）
这是我第一次把源代码放到CSDN论坛上，希望如果版主觉得好，可以提倡一下大家都提供一点自己的心得（有版权的除外），呵呵，这样下次大家搜索的话直接可以有现成的代码用了
========================================================================
思路：
文件夹比较，无非是一个递归比较过程：同名的文件夹，递归比较；同名的文件，比较大小（我使用了位比较，可能比较慢，不过可以通过设置比较函数地址来加入你自己的比较函数）；不同名的文件，就要单独加入了。

定义：
定义了4个类，CFldCmpFileNode, CFldCmpFileTree; CFldCmpNode, CFldCmpTree。
分别是两个树。
CFldCmpFileTree：这个类用于分析指定的文件夹，将其中的文件信息等都填入。CFldCmpFileNode是这个树的节点类。这两个类对用户而已是隐藏的。
CFldCmpTree：是包含比较结果的类，这个类对用户是公开的。

详细设计：
两个树的类都采用了链表结构，Tree中包含了所有根节点（CFldCmpNode）的信息，然后由这些节点分别维护它们自己的子节点。同时，每个节点都有一个指向父节点的指针。

关键问题：
1.文件比较：前面已经说了，类CFldCmpTree支持自定义的比较文件（只限文件之间的比较函数），我提供的默认比较函数使用了位比较（具体的实现是使用了STL里面的bitset，另外一个MFC版本就是直接用CString的Compare比较，可以使用宏_NOT_USE_STL来控制编译STL版本还是MFC版本的比较函数。
2.文件夹Tree的构成：为了便于比较，我没有使用ID+Array的格式定义树，而使用链表来实现是为了能够比较方面的进行递归比较。具体的方法就是递归的比较树的同层的节点。

调用方式：
简单的代码如下：
CFldCmpTree tree;
tree.ParseFolder(szLeftPath, szRightPath);

文件：
FldCmpStruct.h
FldCmpStruct.cpp

使用方法：这个，不用我说了吧，呵呵，加入你自己的工程就可以了

头文件
//
// File : FldCmpStruct.h
// Written by Alva Chien, 2003.3.24
// ======================================================================
// Note:
// To avoid hard code mission, I have change some classes members into
// public property, so, you need fix this (ah, a hard work) before you put
// this file into a security using.
//////////////////////////////////////////////////////////////////////////

#ifndef _H_FLDCMP_STRUCT_
#define _H_FLDCMP_STRUCT_

// User bitset to compare file
#include <bitset>
#include <string>
#include <fstream>
#include <strstream>
using namespace std;

// Include <afxtempl.h> or not
#if !defined(__AFXTEMPL_H__)
#include <afxtempl.h>
#endif // !__AFXTEMPL_H__

// Using ACLib or not
#if !defined(AC_C_COMMON_H_)
# define _NOUSE_ACLIB_
# pragma message("Complied without using ACLib.dll...")
#endif // !AC_C_COMMON_H_

//////////////////////////////////////////////////////////////////////////
// Macro definiton( avoid link to ACLib.dll )
#ifdef _NOUSE_ACLIB_
#define FCS_SAFEDEL(p) if (p != NULL) /
{ /
delete p; /
p = NULL; /
}

inline DWORD FCS_GetFileSize(LPCTSTR lpszFile)
{
ASSERT(lpszFile != NULL);
if (lpszFile == NULL)
return 0;

#ifdef _NOT_USE_STL
DWORD dwSize = 0;
HANDLE hFile;

hFile = CreateFile(lpszFile, // create
GENERIC_READ, // open for writing
0, // do not share
NULL, // no security
OPEN_EXISTING, // existing file only
FILE_ATTRIBUTE_NORMAL, // normal file
NULL); // no attr. template

if (hFile != INVALID_HANDLE_VALUE)
{
dwSize = GetFileSize(hFile, NULL);
if (dwSize == INVALID_FILE_SIZE)
dwSize = 0;

CloseHandle(hFile);
}
return dwSize;
#else
ifstream in(lpszFile);
ASSERT(in != NULL);
in.seekg(0, ios::end);
streampos pos = in.tellg();
return (DWORD)pos;
#endif // _NOT_USE_STL
}
#endif // _NOUSE_ACLIB_

//////////////////////////////////////////////////////////////////////////
// Declarations

// Folder compare function
typedef int (*PFNFCCMPFUNC)(LPARAM, LPARAM, LPARAM);

class CFldCmpFileNode;
class CFldCmpNode;
typedef CFldCmpFileNode *CFldCmpFileNodePtr;
typedef CFldCmpNode *CFldCmpNodePtr;
typedef CTypedPtrArray<CPtrArray, CFldCmpFileNodePtr> CFldCmpFileNodePtrArray;
typedef CTypedPtrArray<CPtrArray, CFldCmpNodePtr> CFldCmpNodePtrArray;

// Compare item type
typedef enum
{
FCT_MATCH, // Match
FCT_LNEW, // Left newer
FCT_RNEW, // Right newer
FCT_LORPHAN, // Left is orphane
FCT_RORPHAN // Right is orpane
}
FldCmpType;

//////////////////////////////////////////////////////////////////////////
// class CFldCmpFileNode
class CFldCmpFileNode
{
// Constructor
public:
CFldCmpFileNode();
virtual ~CFldCmpFileNode();
// ===========================================================================
// Note :
// If you use the Copy Constructor or operator '=' to assign the Node, it may
// leads the memory, for it not release the children.
// In fact, I strongly suggest use the CFldCmpFileTree instead of build a
// tree manualy.
// ===========================================================================
CFldCmpFileNode(const CFldCmpFileNode &fn);
CFldCmpFileNode &operator =(const CFldCmpFileNode &fn);

// Operation
public:
// Clean data
void CleanData();
// Get family nodes
UINT GetFamilyNodeNumber() const;

// Members
public:
// File item
CString m_strName;
BOOL m_bFolder;
COleDateTime m_dtModified;
DWORD m_dwSize;

// Used to build the tree
CFldCmpFileNode *m_pFather;
CFldCmpFileNodePtrArray m_arChildPtrs;
UINT m_nLevel;

// No used
DWORD m_dwData;
};

//////////////////////////////////////////////////////////////////////////
// class CFldCmpFileTree
class CFldCmpFileTree
{
// Constructor
public:
CFldCmpFileTree();
virtual ~CFldCmpFileTree();

// Opertion
public:
// Parse folder
BOOL ParseFolder(
LPCTSTR lpszPath,
CFldCmpFileNodePtr pFa = NULL,
UINT nLevel = 0
);
// Clean data
void CleanData();
// Get node number
UINT GetNodeNumber() const;
// Get root array
const CFldCmpFileNodePtrArray &GetRootArray() const { return m_arRootPtrs; }

#ifdef _DEBUG
// Display tree info
void DisplayDebugInfo(CFldCmpFileNodePtr pFather = NULL);
#endif // _DEBUG

// Members
protected:
// Root item array
CFldCmpFileNodePtrArray m_arRootPtrs;
};

//////////////////////////////////////////////////////////////////////////
// class CFldCmpNode
class CFldCmpNode
{
// Constructor
public:
CFldCmpNode();
virtual ~CFldCmpNode();
CFldCmpNode(const CFldCmpNode &cn);
CFldCmpNode &operator =(const CFldCmpNode &cn);

// Operation
public:
// Clean data
void CleanData();
// Get family nodes
UINT GetFamilyNodeNumber() const;
// Compare two node, used for sort
int Compare(const CFldCmpNode &nc) const;

// Members
public:
FldCmpType m_type; // Type
CString m_strName; // Name
COleDateTime m_dtLeft; // Left last modified time
COleDateTime m_dtRight; // Right last modified time
DWORD m_dwLeftSize; // Left file size
DWORD m_dwRightSize; // Right file size
BOOL m_bFolder; // Folder or not

// Used to build the tree
CFldCmpNodePtr m_pFather; // Pointer of father node
CFldCmpNodePtrArray m_arChildPtrs; // Children node pointer array
UINT m_nLevel; // Level, from the root

// No used
DWORD m_dwData;
};

//////////////////////////////////////////////////////////////////////////
// class CFldCmpTree
class CFldCmpTree
{
// Constrcution
public:
CFldCmpTree();
virtual ~CFldCmpTree();

// Interface
public:
// Clean data
void CleanData();
#ifdef _DEBUG
// Display tree info
void DisplayDebugInfo(CFldCmpNodePtr pFather = NULL);
#endif // _DEBUG
// Get node number
UINT GetNodeNumber() const;
// Combine file tree
BOOL ParseFolder(
LPCTSTR lpszLeft,
LPCTSTR lpszRight
);
// Get root array
const CFldCmpNodePtrArray &GetRootArray() const { return m_arRootPtrs; }
// Sort
void Sort();
// Compare function
void SetCustomSortFunc(PFNFCCMPFUNC);
// Get node full path
CString GetNodeFullPath(
const CFldCmpNodePtr pNode,
BOOL bLeft = TRUE
) const;

// Operations
protected:
// Combine file tree
BOOL CombineFileTrees(
const CFldCmpFileTree &treeLeft,
const CFldCmpFileTree &treeRight
);
// Copy left file tree
BOOL CopyLeftFileTree(
const CFldCmpFileNodePtrArray &arNodePtrs,
CFldCmpNodePtr pFather = NULL
);
// Combine right file tree
BOOL CombineRightTree(
const CFldCmpFileNodePtrArray &arFileNodePtrs,
CFldCmpNodePtr pFather = NULL
);
// Sort function
void SortArray( CFldCmpNodePtrArray &arArray );

// Members
protected:
// Root item array
CFldCmpNodePtrArray m_arRootPtrs;
// File's compare function
PFNFCCMPFUNC m_pFnFileCmp;
// Left path
CString m_strLeftPath;
// Right path
CString m_strRightPath;
};

#endif // _H_FLDCMP_STRUCT_

实现文件上半部分：
//
// File: FldCmpStruct.cpp
// Written by Alva Chien, 2004.3.24
//////////////////////////////////////////////////////////////////////////

#include "stdafx.h"
#include "FldCmpStruct.h"
//////////////////////////////////////////////////////////////////////////
// Default file compare function
// Support a default compare function
int FCS_DefaultFileCmp(
LPARAM lpNode,
LPARAM lpszLeftFile,
LPARAM lpszRightFile
)
{
ASSERT((lpNode != NULL) && (lpszLeftFile != NULL) && (lpszRightFile != NULL));
if((lpNode == NULL) || (lpszLeftFile == NULL) || (lpszRightFile == NULL))
return FALSE;

CFldCmpNodePtr pNode = (CFldCmpNodePtr)lpNode;
if (pNode->m_bFolder) // Folder ?
return 0;

DWORD dwSizeLeft = pNode->m_dwLeftSize, dwSizeRight = pNode->m_dwRightSize;

int nRst = 0;
BOOL bContinue = FALSE;
if (dwSizeLeft == dwSizeRight)
{
#if !defined(_NOT_USE_STL)
// Read the file content
ifstream inLeft((LPCTSTR)lpszLeftFile);
ifstream inRight((LPCTSTR)lpszRightFile);
ASSERT((inLeft != NULL) && (inRight != NULL));
strstream strleft, strright;
strleft<<inLeft.rdbuf();
strright<<inRight.rdbuf();
inLeft.close();
inRight.close();

// In 32 bits computers, sizeof(byte) == 8, so 256 * 8 => 2048
char *pLeft = strleft.str();
char *pRight = strright.str();
int nTime = dwSizeLeft / 256;
if (dwSizeLeft % 256 ) nTime += 1;

// Hard work again, 55555555....
for(int i = 0; i < nTime; i ++)
{
if ( (i != nTime -1) || ( (i == nTime -1) && (dwSizeLeft % 256 == 0)) )
{
bitset<2048> bsLeft(pLeft + i * 2048, 2048);
bitset<2048> bsRight(pRight + i * 2048, 2048);
int nCount = bsLeft.count();
bsLeft &= bsRight;
if (nCount != bsLeft.count())
{
// Not same! out!
bContinue = TRUE;
break;
}
}
else
{
bitset<2048> bsLeft(pLeft + i *2048);
bitset<2048> bsRight(pRight + i * 2048);
int nCount = bsLeft.count();
bsLeft &= bsRight;
if (nCount != bsLeft.count())
{
// Not same! out!
bContinue = TRUE;
break;
}
}
}

delete strleft.str();
delete strright.str();
#else
LPBYTE pLeft = new BYTE[dwSizeLeft];
LPBYTE pRight = new BYTE[dwSizeLeft];
ASSERT((pLeft != NULL) && (pRight != NULL));

CFile fileLeft, fileRight;
if (fileLeft.Open((LPCTSTR)lpszLeftFile, CFile::modeRead))
{
fileLeft.ReadHuge(pLeft, dwSizeLeft);
fileLeft.Close();
}
if (fileRight.Open((LPCTSTR)lpszRightFile, CFile::modeRead))
{
fileRight.ReadHuge(pRight, dwSizeLeft);
fileRight.Close();
}

if (CString(pLeft).Compare(CString(pRight)) == 0)
bContinue = FALSE;

delete [] pLeft;
pLeft = NULL;
delete [] pRight;
pRight = NULL;
#endif // !_NOT_USE_STL

if (!bContinue) return 0;
}

// No same, compare it by the time
if(pNode->m_dtLeft > pNode->m_dtRight) nRst = 1;
else if (pNode->m_dtLeft < pNode->m_dtRight) nRst = -1;
else nRst = 0;

return nRst;
}

//////////////////////////////////////////////////////////////////////////
// class CFldCmpFileNode

// Constructor
CFldCmpFileNode::CFldCmpFileNode()
{
m_strName = _T("");
m_bFolder = FALSE;
m_dtModified = COleDateTime::GetCurrentTime();
m_dwSize = 0;

// Used to build the tree
m_pFather = NULL;
m_arChildPtrs.SetSize(0);
m_nLevel = (UINT)-1;

// Used for arrange
m_dwData = 0;
}

// Decomstructor
CFldCmpFileNode::~CFldCmpFileNode() { CleanData(); }

// Copy constructor
CFldCmpFileNode::CFldCmpFileNode(const CFldCmpFileNode &fn) { *this = fn; }

// Override operator =
CFldCmpFileNode &CFldCmpFileNode::operator =(const CFldCmpFileNode &fn)
{
if ( this != &fn)
{
m_strName = fn.m_strName;
m_bFolder = fn.m_bFolder;
m_dtModified = fn.m_dtModified;
m_dwSize = fn.m_dwSize;

// Used to build the tree
m_pFather = fn.m_pFather;
m_arChildPtrs.RemoveAll();
m_arChildPtrs.Copy(fn.m_arChildPtrs);
m_nLevel = fn.m_nLevel;

// Used for arrange
m_dwData = fn.m_dwData;
}

return *this;
}

// Clean data
void CFldCmpFileNode::CleanData()
{
for(int i = 0; i < m_arChildPtrs.GetSize(); i++)
{
CFldCmpFileNodePtr pNode = m_arChildPtrs.GetAt(i);
ASSERT(pNode != NULL);
pNode->CleanData();
#ifdef _NOUSE_ACLIB_
FCS_SAFEDEL(pNode);
#else
ACC_SAFEDEL(pNode);
#endif // _NOUSE_ACLIB_
}

m_arChildPtrs.RemoveAll();
}

// Get node family number
UINT CFldCmpFileNode::GetFamilyNodeNumber() const
{
UINT nCount = 0;
for(int i = 0; i < m_arChildPtrs.GetSize(); i ++)
nCount += m_arChildPtrs.GetAt(i)->GetFamilyNodeNumber();

nCount += 1; // Himself
return nCount;
}

//////////////////////////////////////////////////////////////////////////
// class CFldCmpFileTree

// Constructor
CFldCmpFileTree::CFldCmpFileTree() { m_arRootPtrs.SetSize(0);}

// Decomstructor
CFldCmpFileTree::~CFldCmpFileTree() { CleanData();}

// Get node number
UINT CFldCmpFileTree::GetNodeNumber() const
{
UINT nCount = 0;
for(int i = 0; i < m_arRootPtrs.GetSize(); i++)
nCount += m_arRootPtrs.GetAt(i)->GetFamilyNodeNumber();

return nCount;
}

// Parse folder
BOOL CFldCmpFileTree::ParseFolder(
LPCTSTR lpszPath,
CFldCmpFileNodePtr pFa,
UINT nLevel
)
{
ASSERT(lpszPath != NULL);
if(lpszPath == NULL) return FALSE;

CString str = lpszPath;
if (str.IsEmpty()) return FALSE;

str.TrimRight();
str.TrimRight(_T('//'));
str += _T("//*.*");

// start working for files
CFileFind finder;
BOOL bWorking = finder.FindFile(str);
while (bWorking)
{
bWorking = finder.FindNextFile();

if (finder.IsDots()) continue;

WIN32_FILE_ATTRIBUTE_DATA fad;
CFldCmpFileNodePtr pNode = new CFldCmpFileNode;
ASSERT(pNode != NULL);
if (pNode == NULL) return FALSE;

pNode->m_strName = finder.GetFileName();
pNode->m_nLevel = nLevel;
pNode->m_pFather = pFa;

if (finder.IsDirectory())
{
pNode->m_bFolder = TRUE;

// Add it into the array
if (pFa == NULL) m_arRootPtrs.Add(pNode);
else pFa->m_arChildPtrs.Add(pNode);

// Recursiving...
if (!ParseFolder(
finder.GetFilePath(),
pNode,
nLevel + 1))
return FALSE;
}
else
{
pNode->m_bFolder = FALSE;

if (GetFileAttributesEx(finder.GetFilePath(), GetFileExInfoStandard, &fad) != FALSE)
{
pNode->m_dtModified = (COleDateTime)fad.ftLastWriteTime;
#ifdef _NOUSE_ACLIB_
pNode->m_dwSize = FCS_GetFileSize(finder.GetFilePath());
#else
pNode->m_dwSize = ACC_GetFileSize(finder.GetFilePath());
#endif // _NOUSE_ACLIB_
}

// Add it
if (pFa == NULL) m_arRootPtrs.Add(pNode);
else pFa->m_arChildPtrs.Add(pNode);
}
}

return TRUE;
}

// Clean data
void CFldCmpFileTree::CleanData()
{
for(int i = 0; i < m_arRootPtrs.GetSize(); i++)
{
CFldCmpFileNodePtr pNode = m_arRootPtrs.GetAt(i);
ASSERT(pNode != NULL);
pNode->CleanData();
#ifdef _NOUSE_ACLIB_
FCS_SAFEDEL(pNode);
#else
ACC_SAFEDEL(pNode);
#endif // _NOUSE_ACLIB_
}

m_arRootPtrs.RemoveAll();
}

#ifdef _DEBUG
// Display debug info
void CFldCmpFileTree::DisplayDebugInfo(CFldCmpFileNodePtr pFather)
{
CFldCmpFileNodePtrArray &rNods = (pFather == NULL)? m_arRootPtrs : pFather->m_arChildPtrs;
for( int i = 0; i < rNods.GetSize(); i ++)
DisplayDebugInfo(rNods.GetAt(i));

// Then clean itselft
if(pFather != NULL)
{
TRACE("Tree Level %d: %s, %s, Father %s, Size %d, Children number %d/n",
pFather->m_nLevel,
pFather->m_strName,
pFather->m_bFolder? _T("Folder") : _T("File"),
(pFather->m_pFather == NULL) ? _T("None") : pFather->m_pFather->m_strName,
pFather->m_dwSize,
pFather->m_arChildPtrs.GetSize()
);
}
}
#endif // _DEBUG

实现文件中间部分
//////////////////////////////////////////////////////////////////////////
// class CFldCmpNode

// Constructor
CFldCmpNode::CFldCmpNode()
{
m_type = FCT_MATCH; // Type
m_strName = _T(""); // Name
m_dtLeft = COleDateTime::GetCurrentTime(); // Left last modified time
m_dtRight = COleDateTime::GetCurrentTime(); // Right last modified time
m_dwLeftSize = 0; // Left file size
m_dwRightSize = 0; // Right file size
m_bFolder = FALSE; // Folder or not

// Used to build the tree
m_pFather = NULL; // Pointer of father node
m_arChildPtrs.SetSize(0); // Children node pointer array
m_nLevel = (UINT)-1; // Level, from the root

// Used data
m_dwData = 0;
}

CFldCmpNode::~CFldCmpNode() { CleanData(); }

CFldCmpNode::CFldCmpNode(const CFldCmpNode &cn) { *this = cn; }

CFldCmpNode&CFldCmpNode::operator =(const CFldCmpNode &cn)
{
if ( this != &cn)
{
m_type = cn.m_type; // Type
m_strName = cn.m_strName; // Name
m_dtLeft = cn.m_dtLeft; // Left last modified time
m_dtRight = cn.m_dtRight; // Right last modified time
m_dwLeftSize = cn.m_dwLeftSize; // Left file size
m_dwRightSize = cn.m_dwRightSize; // Right file size
m_bFolder = cn.m_bFolder; // Folder or not

// Used to build the tree
m_pFather = cn.m_pFather; // Pointer of father node
m_arChildPtrs.RemoveAll();
m_arChildPtrs.Copy(cn.m_arChildPtrs);
m_nLevel = cn.m_nLevel; // Level, from the root

// Used for arrange
m_dwData = cn.m_dwData;
}

return *this;
}

// Clean data
void CFldCmpNode::CleanData()
{
for(int i = 0; i < m_arChildPtrs.GetSize(); i++)
{
CFldCmpNodePtr pNode = m_arChildPtrs.GetAt(i);
ASSERT(pNode != NULL);
pNode->CleanData();
#ifdef _NOUSE_ACLIB_
FCS_SAFEDEL(pNode);
#else
ACC_SAFEDEL(pNode);
#endif // _NOUSE_ACLIB_
}

m_arChildPtrs.RemoveAll();
}

// Get family nodes
UINT CFldCmpNode::GetFamilyNodeNumber() const
{
UINT nCount = 0;
for(int i = 0; i < m_arChildPtrs.GetSize(); i ++)
nCount += m_arChildPtrs.GetAt(i)->GetFamilyNodeNumber();

nCount += 1; // Himself
return nCount;
}

// Compare
int CFldCmpNode::Compare(const CFldCmpNode &nc) const
{
int nRst = 0;
if (m_bFolder && (!nc.m_bFolder)) nRst = -1;
else if((!m_bFolder) && (nc.m_bFolder)) nRst = 1;
else { nRst = lstrcmpi(m_strName, nc.m_strName); }

return nRst;
}

//////////////////////////////////////////////////////////////////////////
// class CFldCmpTree

// Constructor
CFldCmpTree::CFldCmpTree()
{
m_arRootPtrs.SetSize(0);
m_pFnFileCmp = FCS_DefaultFileCmp;
}

// Deconstructor
CFldCmpTree::~CFldCmpTree() { CleanData(); }

// Clean data
void CFldCmpTree::CleanData()
{
for(int i = 0; i < m_arRootPtrs.GetSize(); i++)
{
CFldCmpNodePtr pNode = m_arRootPtrs.GetAt(i);
ASSERT(pNode != NULL);
pNode->CleanData();
#ifdef _NOUSE_ACLIB_
FCS_SAFEDEL(pNode);
#else
ACC_SAFEDEL(pNode);
#endif // _NOUSE_ACLIB_
}

m_arRootPtrs.RemoveAll();
}

#ifdef _DEBUG
// Display tree info
void CFldCmpTree::DisplayDebugInfo(CFldCmpNodePtr pFather)
{
CFldCmpNodePtrArray &rNods = (pFather == NULL)?m_arRootPtrs : pFather->m_arChildPtrs;

// Then clean itselft
if(pFather != NULL)
{
TRACE("Tree Level %d: %s, %s, Father %s, Left Size %d, Right Size %d, Children number %d/n",
pFather->m_nLevel,
pFather->m_strName,
pFather->m_bFolder? _T("Folder") : _T("File"),
(pFather->m_pFather == NULL) ? _T("None") : pFather->m_pFather->m_strName,
pFather->m_dwLeftSize,
pFather->m_dwRightSize,
pFather->m_arChildPtrs.GetSize()
);
}
for( int i = 0; i < rNods.GetSize(); i ++)
DisplayDebugInfo(rNods.GetAt(i));
}
#endif // _DEBUG

// Copy left file tree
BOOL CFldCmpTree::CopyLeftFileTree(
const CFldCmpFileNodePtrArray &arNodePtrs,
CFldCmpNodePtr pFather
)
{
int nSize = arNodePtrs.GetSize();

int i = 0;
for(; i < nSize; i ++)
{
// Add it
CFldCmpFileNodePtr pFile = arNodePtrs.GetAt(i);
CFldCmpNodePtr pNode = new CFldCmpNode;
ASSERT(pNode != NULL);
if (pNode == NULL)
{
CleanData();
return FALSE;
}
pNode->m_strName = pFile->m_strName;
pNode->m_bFolder = pFile->m_bFolder;
pNode->m_dtLeft = pFile->m_dtModified;
pNode->m_dwLeftSize = pFile->m_dwSize;
pNode->m_nLevel = pFile->m_nLevel;
pNode->m_pFather = pFather;
pNode->m_type = FCT_LORPHAN;
if(pFather != NULL)
pFather->m_arChildPtrs.Add(pNode);
else
m_arRootPtrs.Add(pNode);

// Add it's children
CopyLeftFileTree(pFile->m_arChildPtrs, pNode);
}

return TRUE;
}

// Get node number
UINT CFldCmpTree::GetNodeNumber() const
{
UINT nCount = 0;
for(int i = 0; i < m_arRootPtrs.GetSize(); i++)
nCount += m_arRootPtrs.GetAt(i)->GetFamilyNodeNumber();

return nCount;
}

// Combine the right tree
BOOL CFldCmpTree::CombineRightTree(
const CFldCmpFileNodePtrArray &arFileNodePtrs,
CFldCmpNodePtr pFather
)
{
CFldCmpNodePtrArray &arNodes = (pFather == NULL) ? m_arRootPtrs
: pFather->m_arChildPtrs;
BOOL bExist = FALSE;
int i = 0;
int nArSize = arNodes.GetSize();

for(; i < arFileNodePtrs.GetSize(); i ++)
{
// Process each element
CFldCmpFileNodePtr pFileNode = arFileNodePtrs.GetAt(i);
CFldCmpNodePtr pNode = NULL;

bExist = FALSE;
int j = 0;

for(; j < nArSize; j ++)
{
if (arNodes.GetAt(j)->m_strName == pFileNode->m_strName)
{
bExist = TRUE;
break;
}
}

if (bExist)
{
// Set the info
pNode = arNodes.ElementAt(j);
pNode->m_dtRight = pFileNode->m_dtModified;
pNode->m_dwRightSize = pFileNode->m_dwSize;
CString strLeft = GetNodeFullPath(pNode);
CString strRight = GetNodeFullPath(pNode, FALSE);
ASSERT(m_pFnFileCmp != NULL);
int nRst = (m_pFnFileCmp)((LPARAM)pNode,
(LPARAM)(LPCTSTR)strLeft,
(LPARAM)(LPCTSTR)strRight);
if(nRst == 0)
pNode->m_type = FCT_MATCH;
else if (nRst > 0 )
pNode->m_type = FCT_LNEW;
else
pNode->m_type = FCT_RNEW;
}
else
{
pNode = new CFldCmpNode;
ASSERT(pNode != NULL);
pNode->m_type = FCT_RORPHAN;
pNode->m_dtRight = pFileNode->m_dtModified;
pNode->m_dwRightSize = pFileNode->m_dwSize;
pNode->m_nLevel = pFileNode->m_nLevel;
pNode->m_strName = pFileNode->m_strName;
pNode->m_bFolder = pFileNode->m_bFolder;
pNode->m_pFather = pFather;
arNodes.Add(pNode);
}

// The children pointers
CombineRightTree(pFileNode->m_arChildPtrs, pNode);
}

return TRUE;
}

// Combine the file tree
BOOL CFldCmpTree::CombineFileTrees(
const CFldCmpFileTree &treeLeft,
const CFldCmpFileTree &treeRight
)
{
CleanData();

// First: Copy the left
CopyLeftFileTree(treeLeft.GetRootArray());

// Trace info
TRACE0("/nAfter copy left file tree... ===================================/n");
TRACE("/tTotal number is %d... ======================/n/n", GetNodeNumber());
DisplayDebugInfo();
TRACE0("/n");

// Second: Combine the right tree
CombineRightTree(treeRight.GetRootArray());
// Trace info
TRACE0("/nAfter combine right file tree... ===================================/n");
TRACE("/tTotal number is %d... ======================/n/n", GetNodeNumber());
DisplayDebugInfo();
TRACE0("/n");

return TRUE;
}

// Sort the array
void CFldCmpTree::SortArray(
CFldCmpNodePtrArray &arArray
)
{
int nSize = arArray.GetSize();
int i = 0;

// Sort it
for(; i < nSize; i ++)
{
for(int j = i + 1; j < nSize; j ++)
{
CFldCmpNodePtr pNode1 = arArray.ElementAt(i);
CFldCmpNodePtr pNode2 = arArray.ElementAt(j);
if (pNode1->Compare(*pNode2) > 0)
{
// Exchange
CFldCmpNode node;
node = *pNode1;
*pNode1 = *pNode2;
*pNode2 = node;
node.m_arChildPtrs.RemoveAll();
}
}
}

// Recursive sort
for( i = 0; i < nSize; i ++) { SortArray(arArray.ElementAt(i)->m_arChildPtrs); }
}

// Sort
void CFldCmpTree::Sort() { SortArray(m_arRootPtrs); }

// Parse folder
BOOL CFldCmpTree::ParseFolder(LPCTSTR lpszLeft, LPCTSTR lpszRight)
{
ASSERT((lpszLeft != NULL) && (lpszRight != NULL));
if((lpszLeft == NULL) || (lpszRight == NULL))
return FALSE;

m_strLeftPath = lpszLeft;
m_strRightPath = lpszRight;
if (m_strLeftPath.IsEmpty() || m_strRightPath.IsEmpty())
{
m_strLeftPath.Empty();
m_strRightPath.Empty();
return FALSE;
}

CFldCmpFileTree treeLeft, treeRight;
treeLeft.ParseFolder(lpszLeft);
treeRight.ParseFolder(lpszRight);

return CombineFileTrees(treeLeft, treeRight);
}

// Get node full path
CString CFldCmpTree::GetNodeFullPath(const CFldCmpNodePtr pNode, BOOL bLeft) const
{
ASSERT(pNode != NULL);

CString str = _T("");
if(pNode->m_pFather != NULL)
str = GetNodeFullPath(pNode->m_pFather, bLeft);
else
str = bLeft ? m_strLeftPath : m_strRightPath;

str.TrimRight();
str.TrimRight(_T("//"));
str += _T("//");
str += pNode->m_strName;

return str;
}

// Set custom compare function
void CFldCmpTree::SetCustomSortFunc(PFNFCCMPFUNC pFunc)
{
ASSERT(pFunc != NULL);
m_pFnFileCmp = pFunc;
}