Consolidate FolderCmp (2)

Store pointer to CDiffContext as a member in FolderCmp.
Next planned step is to have the folder compare threads create a reusable FolderCmp instance in advance rather than repeatedly create dedicated ones for every single file comparison.

diff --git a/Src/DirScan.cpp b/Src/DirScan.cpp
index 2bbf08c..6136c0c 100644 (file)
--- a/Src/DirScan.cpp
+++ b/Src/DirScan.cpp
@@ -48,7 +48,7 @@ using Poco::Environment;
 using Poco::Stopwatch;
 
 // Static functions (ie, functions only used locally)
-void CompareDiffItem(DIFFITEM &di, CDiffContext *pCtxt);
+static void CompareDiffItem(DIFFITEM &di, CDiffContext *pCtxt);
 static void StoreDiffData(DIFFITEM &di, CDiffContext *pCtxt,
                const FolderCmp *pCmpData);
 static DIFFITEM *AddToList(const String &sLeftDir, const String &sRightDir, const DirItem *lent, const DirItem *rent,
@@ -803,7 +803,7 @@ static void UpdateDiffItem(DIFFITEM &di, bool & bExists, CDiffContext *pCtxt)
  * @todo For date compare, maybe we should use creation date if modification
  * date is missing?
  */
-void CompareDiffItem(DIFFITEM &di, CDiffContext * pCtxt)
+static void CompareDiffItem(DIFFITEM &di, CDiffContext * pCtxt)
 {
        int nDirs = pCtxt->GetCompareDirs();
        // Clear rescan-request flag (not set by all codepaths)
@@ -824,8 +824,8 @@ void CompareDiffItem(DIFFITEM &di, CDiffContext * pCtxt)
                        )
                {
                        di.diffcode.diffcode |= DIFFCODE::INCLUDED;
-                       FolderCmp folderCmp;
-                       di.diffcode.diffcode |= folderCmp.prepAndCompareFiles(pCtxt, di);
+                       FolderCmp folderCmp(pCtxt);
+                       di.diffcode.diffcode |= folderCmp.prepAndCompareFiles(di);
                        StoreDiffData(di, pCtxt, &folderCmp);
                }
                else

diff --git a/Src/FolderCmp.cpp b/Src/FolderCmp.cpp
index 6918aa4..5df5f6d 100644 (file)
--- a/Src/FolderCmp.cpp
+++ b/Src/FolderCmp.cpp
@@ -28,8 +28,9 @@ using CompareEngines::TimeSizeCompare;
 
 static void GetComparePaths(CDiffContext * pCtxt, const DIFFITEM &di, PathContext & files);
 
-FolderCmp::FolderCmp()
-: m_pDiffUtilsEngine(nullptr)
+FolderCmp::FolderCmp(CDiffContext *pCtxt)
+: m_pCtxt(pCtxt)
+, m_pDiffUtilsEngine(nullptr)
 , m_pByteCompare(nullptr)
 , m_pBinaryCompare(nullptr)
 , m_pTimeSizeCompare(nullptr)
@@ -42,7 +43,7 @@ FolderCmp::~FolderCmp()
 {
 }
 
-bool FolderCmp::RunPlugins(CDiffContext * pCtxt, PluginsContext * plugCtxt, String &errStr)
+bool FolderCmp::RunPlugins(PluginsContext * plugCtxt, String &errStr)
 {
        // FIXME:
        return true;
@@ -60,18 +61,18 @@ void FolderCmp::CleanupAfterPlugins(PluginsContext *plugCtxt)
  * @param [in, out] di Compared files with associated data.
  * @return Compare result code.
  */
-int FolderCmp::prepAndCompareFiles(CDiffContext * pCtxt, DIFFITEM &di)
+int FolderCmp::prepAndCompareFiles(DIFFITEM &di)
 {
        int nIndex;
-       int nCompMethod = pCtxt->GetCompareMethod();
-       int nDirs = pCtxt->GetCompareDirs();
+       int nCompMethod = m_pCtxt->GetCompareMethod();
+       int nDirs = m_pCtxt->GetCompareDirs();
 
        unsigned code = DIFFCODE::FILE | DIFFCODE::CMPERR;
 
        if ((nCompMethod == CMP_CONTENT || nCompMethod == CMP_QUICK_CONTENT) &&
-               ((di.diffFileInfo[0].size > pCtxt->m_nBinaryCompareLimit && di.diffFileInfo[0].size != DirItem::FILE_SIZE_NONE) ||
-                (di.diffFileInfo[1].size > pCtxt->m_nBinaryCompareLimit && di.diffFileInfo[1].size != DirItem::FILE_SIZE_NONE) ||
-                (nDirs > 2 && di.diffFileInfo[2].size > pCtxt->m_nBinaryCompareLimit && di.diffFileInfo[2].size != DirItem::FILE_SIZE_NONE)))
+               ((di.diffFileInfo[0].size > m_pCtxt->m_nBinaryCompareLimit && di.diffFileInfo[0].size != DirItem::FILE_SIZE_NONE) ||
+                (di.diffFileInfo[1].size > m_pCtxt->m_nBinaryCompareLimit && di.diffFileInfo[1].size != DirItem::FILE_SIZE_NONE) ||
+                (nDirs > 2 && di.diffFileInfo[2].size > m_pCtxt->m_nBinaryCompareLimit && di.diffFileInfo[2].size != DirItem::FILE_SIZE_NONE)))
        {
                nCompMethod = CMP_BINARY_CONTENT;
        }
@@ -85,7 +86,7 @@ int FolderCmp::prepAndCompareFiles(CDiffContext * pCtxt, DIFFITEM &di)
                        m_diffFileData.m_textStats[nIndex].clear();
 
                PathContext tFiles;
-               GetComparePaths(pCtxt, di, tFiles);
+               GetComparePaths(m_pCtxt, di, tFiles);
                struct change *script10 = nullptr;
                struct change *script12 = nullptr;
                struct change *script02 = nullptr;
@@ -106,12 +107,12 @@ int FolderCmp::prepAndCompareFiles(CDiffContext * pCtxt, DIFFITEM &di)
                PrediffingInfo * infoPrediffer = nullptr;
 
                // Get existing or new plugin infos
-               if (pCtxt->m_piPluginInfos != nullptr)
-                       pCtxt->FetchPluginInfos(filteredFilenames, &infoUnpacker,
+               if (m_pCtxt->m_piPluginInfos != nullptr)
+                       m_pCtxt->FetchPluginInfos(filteredFilenames, &infoUnpacker,
                                        &infoPrediffer);
 
                FileTextEncoding encoding[3];
-               bool bForceUTF8 = pCtxt->GetCompareOptions(nCompMethod)->m_bIgnoreCase;
+               bool bForceUTF8 = m_pCtxt->GetCompareOptions(nCompMethod)->m_bIgnoreCase;
 
                for (nIndex = 0; nIndex < nDirs; nIndex++)
                {
@@ -133,7 +134,7 @@ int FolderCmp::prepAndCompareFiles(CDiffContext * pCtxt, DIFFITEM &di)
                        // Unpacked files will be deleted at end of this function.
                        filepathTransformed[nIndex] = filepathUnpacked[nIndex];
 
-                       encoding[nIndex] = GuessCodepageEncoding(filepathTransformed[nIndex], pCtxt->m_iGuessEncodingType);
+                       encoding[nIndex] = GuessCodepageEncoding(filepathTransformed[nIndex], m_pCtxt->m_iGuessEncodingType);
                        m_diffFileData.m_FileLocation[nIndex].encoding = encoding[nIndex];
                }
 
@@ -181,9 +182,9 @@ int FolderCmp::prepAndCompareFiles(CDiffContext * pCtxt, DIFFITEM &di)
                // If either file is larger than limit compare files by quick contents
                // This allows us to (faster) compare big binary files
                if (nCompMethod == CMP_CONTENT && 
-                       (di.diffFileInfo[0].size > pCtxt->m_nQuickCompareLimit ||
-                       di.diffFileInfo[1].size > pCtxt->m_nQuickCompareLimit || 
-                       (nDirs > 2 && di.diffFileInfo[2].size > pCtxt->m_nQuickCompareLimit)))
+                       (di.diffFileInfo[0].size > m_pCtxt->m_nQuickCompareLimit ||
+                       di.diffFileInfo[1].size > m_pCtxt->m_nQuickCompareLimit ||
+                       (nDirs > 2 && di.diffFileInfo[2].size > m_pCtxt->m_nQuickCompareLimit)))
                {
                        nCompMethod = CMP_QUICK_CONTENT;
                }
@@ -196,14 +197,14 @@ int FolderCmp::prepAndCompareFiles(CDiffContext * pCtxt, DIFFITEM &di)
                                        m_pDiffUtilsEngine.reset(new CompareEngines::DiffUtils());
                                m_pDiffUtilsEngine->SetCodepage(codepage);
                                bool success = m_pDiffUtilsEngine->SetCompareOptions(
-                                               *pCtxt->GetCompareOptions(CMP_CONTENT));
+                                               *m_pCtxt->GetCompareOptions(CMP_CONTENT));
                                if (success)
                                {
-                                       if (pCtxt->m_pFilterList != nullptr)
-                                               m_pDiffUtilsEngine->SetFilterList(pCtxt->m_pFilterList.get());
+                                       if (m_pCtxt->m_pFilterList != nullptr)
+                                               m_pDiffUtilsEngine->SetFilterList(m_pCtxt->m_pFilterList.get());
                                        else
                                                m_pDiffUtilsEngine->ClearFilterList();
-                                       m_pDiffUtilsEngine->SetFilterCommentsManager(pCtxt->m_pFilterCommentsManager);
+                                       m_pDiffUtilsEngine->SetFilterCommentsManager(m_pCtxt->m_pFilterCommentsManager);
                                        m_pDiffUtilsEngine->SetFileData(2, m_diffFileData.m_inf);
                                        code = m_pDiffUtilsEngine->diffutils_compare_files();
                                        m_pDiffUtilsEngine->GetDiffCounts(m_ndiffs, m_ntrivialdiffs);
@@ -227,14 +228,14 @@ int FolderCmp::prepAndCompareFiles(CDiffContext * pCtxt, DIFFITEM &di)
                                        m_pDiffUtilsEngine.reset(new CompareEngines::DiffUtils());
                                m_pDiffUtilsEngine->SetCodepage(codepage);
                                bool success = m_pDiffUtilsEngine->SetCompareOptions(
-                                               *pCtxt->GetCompareOptions(CMP_CONTENT));
+                                               *m_pCtxt->GetCompareOptions(CMP_CONTENT));
                                if (success)
                                {
-                                       if (pCtxt->m_pFilterList != nullptr)
-                                               m_pDiffUtilsEngine->SetFilterList(pCtxt->m_pFilterList.get());
+                                       if (m_pCtxt->m_pFilterList != nullptr)
+                                               m_pDiffUtilsEngine->SetFilterList(m_pCtxt->m_pFilterList.get());
                                        else
                                                m_pDiffUtilsEngine->ClearFilterList();
-                                       m_pDiffUtilsEngine->SetFilterCommentsManager(pCtxt->m_pFilterCommentsManager);
+                                       m_pDiffUtilsEngine->SetFilterCommentsManager(m_pCtxt->m_pFilterCommentsManager);
 
                                        bool bRet;
                                        int bin_flag10 = 0, bin_flag12 = 0, bin_flag02 = 0;
@@ -324,12 +325,12 @@ int FolderCmp::prepAndCompareFiles(CDiffContext * pCtxt, DIFFITEM &di)
                                if (m_pByteCompare == nullptr)
                                        m_pByteCompare.reset(new ByteCompare());
                                bool success = m_pByteCompare->SetCompareOptions(
-                                       *pCtxt->GetCompareOptions(CMP_QUICK_CONTENT));
+                                       *m_pCtxt->GetCompareOptions(CMP_QUICK_CONTENT));
        
                                if (success)
                                {
-                                       m_pByteCompare->SetAdditionalOptions(pCtxt->m_bStopAfterFirstDiff);
-                                       m_pByteCompare->SetAbortable(pCtxt->GetAbortable());
+                                       m_pByteCompare->SetAdditionalOptions(m_pCtxt->m_bStopAfterFirstDiff);
+                                       m_pByteCompare->SetAbortable(m_pCtxt->GetAbortable());
                                        m_pByteCompare->SetFileData(2, m_diffFileData.m_inf);
        
                                        // use our own byte-by-byte compare
@@ -351,13 +352,13 @@ int FolderCmp::prepAndCompareFiles(CDiffContext * pCtxt, DIFFITEM &di)
                                if (m_pByteCompare == nullptr)
                                        m_pByteCompare.reset(new ByteCompare());
                                bool success = m_pByteCompare->SetCompareOptions(
-                                       *pCtxt->GetCompareOptions(CMP_QUICK_CONTENT));
+                                       *m_pCtxt->GetCompareOptions(CMP_QUICK_CONTENT));
        
                                if (success)
                                {
                                        /* \93r\92\86 */
-                                       m_pByteCompare->SetAdditionalOptions(pCtxt->m_bStopAfterFirstDiff);
-                                       m_pByteCompare->SetAbortable(pCtxt->GetAbortable());
+                                       m_pByteCompare->SetAdditionalOptions(m_pCtxt->m_bStopAfterFirstDiff);
+                                       m_pByteCompare->SetAbortable(m_pCtxt->GetAbortable());
 
                                        // 10
                                        m_pByteCompare->SetFileData(2, diffdata10.m_inf);
@@ -445,7 +446,7 @@ exitPrepAndCompare:
 
                // When comparing empty file and nonexistent file, `DIFFCODE::SAME` flag is set to the variable `code`, so change the flag to `DIFFCODE::DIFF`
                // Also when disabling ignore codepage option and the encodings of files are not equal, change the flag to `DIFFCODE::DIFF even if  `DIFFCODE::SAME` flag is set to the variable `code`
-               if (!di.diffcode.existAll() || (!pCtxt->m_bIgnoreCodepage && !std::equal(encoding + 1, encoding + nDirs, encoding)))
+               if (!di.diffcode.existAll() || (!m_pCtxt->m_bIgnoreCodepage && !std::equal(encoding + 1, encoding + nDirs, encoding)))
                        code = (code & ~DIFFCODE::COMPAREFLAGS) | DIFFCODE::DIFF;
        }
        else if (nCompMethod == CMP_BINARY_CONTENT)
@@ -454,7 +455,7 @@ exitPrepAndCompare:
                        m_pBinaryCompare.reset(new BinaryCompare());
 
                PathContext tFiles;
-               GetComparePaths(pCtxt, di, tFiles);
+               GetComparePaths(m_pCtxt, di, tFiles);
                code = m_pBinaryCompare->CompareFiles(tFiles, di);
        }
        else if (nCompMethod == CMP_DATE || nCompMethod == CMP_DATE_SIZE || nCompMethod == CMP_SIZE)
@@ -462,8 +463,8 @@ exitPrepAndCompare:
                if (m_pTimeSizeCompare == nullptr)
                        m_pTimeSizeCompare.reset(new TimeSizeCompare());
 
-               m_pTimeSizeCompare->SetAdditionalOptions(pCtxt->m_bIgnoreSmallTimeDiff);
-               code = m_pTimeSizeCompare->CompareFiles(nCompMethod, pCtxt->GetCompareDirs(), di);
+               m_pTimeSizeCompare->SetAdditionalOptions(m_pCtxt->m_bIgnoreSmallTimeDiff);
+               code = m_pTimeSizeCompare->CompareFiles(nCompMethod, m_pCtxt->GetCompareDirs(), di);
        }
        else
        {

diff --git a/Src/FolderCmp.h b/Src/FolderCmp.h
index ceb5814..9b507fa 100644 (file)
--- a/Src/FolderCmp.h
+++ b/Src/FolderCmp.h
@@ -38,11 +38,11 @@ struct PluginsContext
 class FolderCmp
 {
 public:
-       FolderCmp();
+       explicit FolderCmp(CDiffContext *pCtxt);
        ~FolderCmp();
-       bool RunPlugins(CDiffContext * pCtxt, PluginsContext * plugCtxt, String &errStr);
+       bool RunPlugins(PluginsContext * plugCtxt, String &errStr);
        void CleanupAfterPlugins(PluginsContext *plugCtxt);
-       int prepAndCompareFiles(CDiffContext * pCtxt, DIFFITEM &di);
+       int prepAndCompareFiles(DIFFITEM &di);
 
        int m_ndiffs;
        int m_ntrivialdiffs;
@@ -50,6 +50,7 @@ public:
        DiffFileData m_diffFileData;
 
 private:
+       CDiffContext *const m_pCtxt;
        std::unique_ptr<CompareEngines::DiffUtils> m_pDiffUtilsEngine;
        std::unique_ptr<CompareEngines::ByteCompare> m_pByteCompare;
        std::unique_ptr<CompareEngines::BinaryCompare> m_pBinaryCompare;

diff --git a/Src/HexMergeDoc.cpp b/Src/HexMergeDoc.cpp
index 17db52a..8fd872a 100644 (file)
--- a/Src/HexMergeDoc.cpp
+++ b/Src/HexMergeDoc.cpp
@@ -73,8 +73,8 @@ static void UpdateDiffItem(int nBuffers, DIFFITEM &di, CDiffContext *pCtxt)
        // Clear flags
        di.diffcode.diffcode &= ~(DIFFCODE::TEXTFLAGS | DIFFCODE::COMPAREFLAGS | DIFFCODE::COMPAREFLAGS3WAY);
        // Really compare
-       FolderCmp folderCmp;
-       di.diffcode.diffcode |= folderCmp.prepAndCompareFiles(pCtxt, di);
+       FolderCmp folderCmp(pCtxt);
+       di.diffcode.diffcode |= folderCmp.prepAndCompareFiles(di);
 }
 
 /**