5.21

1 files changed, 309 insertions, 320 deletions

diff --git a/algorithm.cpp b/algorithm.cpp
index 2415cd18..dd068e0d 100644
--- a/algorithm.cpp
+++ b/algorithm.cpp
@@ -25,7 +25,7 @@ using namespace std::rel_ops;
 
 void zen::swapGrids(const MainConfiguration& config, FolderComparison& folderCmp)
 {
-    std::for_each(begin(folderCmp), end(folderCmp), std::mem_fun_ref(&BaseDirPair::flip));
+    std::for_each(begin(folderCmp), end(folderCmp), [](BaseDirPair& baseObj) { baseObj.flip(); });
     redetermineSyncDirection(config, folderCmp, [](const std::wstring&) {});
 }
 
@@ -36,22 +36,22 @@ namespace
 class Redetermine
 {
 public:
-    static void execute(const DirectionSet& dirCfgIn, HierarchyObject& hierObj)
-    {
-        Redetermine(dirCfgIn).recurse(hierObj);
-    }
+    static void execute(const DirectionSet& dirCfgIn, HierarchyObject& hierObj) { Redetermine(dirCfgIn).recurse(hierObj); }
 
 private:
     Redetermine(const DirectionSet& dirCfgIn) : dirCfg(dirCfgIn) {}
 
     void recurse(HierarchyObject& hierObj) const
     {
-        std::for_each(hierObj.refSubFiles().begin(), hierObj.refSubFiles().end(), [&](FilePair&    fileObj) { (*this)(fileObj); });
-        std::for_each(hierObj.refSubLinks().begin(), hierObj.refSubLinks().end(), [&](SymlinkPair& linkObj) { (*this)(linkObj); });
-        std::for_each(hierObj.refSubDirs ().begin(), hierObj.refSubDirs ().end(), [&](DirPair&      dirObj) { (*this)(dirObj); });
+        for (FilePair& fileObj : hierObj.refSubFiles())
+            processFile(fileObj);
+        for (SymlinkPair& linkObj : hierObj.refSubLinks())
+            processLink(linkObj);
+        for (DirPair& dirObj : hierObj.refSubDirs())
+            processDir(dirObj);
     }
 
-    void operator()(FilePair& fileObj) const
+    void processFile(FilePair& fileObj) const
     {
         const CompareFilesResult cat = fileObj.getCategory();
 
@@ -92,7 +92,7 @@ private:
         }
     }
 
-    void operator()(SymlinkPair& linkObj) const
+    void processLink(SymlinkPair& linkObj) const
     {
         switch (linkObj.getLinkCategory())
         {
@@ -124,7 +124,7 @@ private:
         }
     }
 
-    void operator()(DirPair& dirObj) const
+    void processDir(DirPair& dirObj) const
     {
         const CompareDirResult cat = dirObj.getDirCategory();
 
@@ -162,28 +162,26 @@ private:
 
 //---------------------------------------------------------------------------------------------------------------
 
-struct AllEqual //test if non-equal items exist in scanned data
+//test if non-equal items exist in scanned data
+bool allItemsCategoryEqual(const HierarchyObject& hierObj)
 {
-    bool operator()(const HierarchyObject& hierObj) const
-    {
-        return std::all_of(hierObj.refSubFiles().begin(), hierObj.refSubFiles().end(),
-        [](const FilePair& fileObj) { return fileObj.getCategory() == FILE_EQUAL; })&&  //files
+    return std::all_of(hierObj.refSubFiles().begin(), hierObj.refSubFiles().end(),
+    [](const FilePair& fileObj) { return fileObj.getCategory() == FILE_EQUAL; })&&   //files
 
-        std::all_of(hierObj.refSubLinks().begin(), hierObj.refSubLinks().end(),
-        [](const SymlinkPair& linkObj) { return linkObj.getLinkCategory() == SYMLINK_EQUAL; })&&  //symlinks
+    std::all_of(hierObj.refSubLinks().begin(), hierObj.refSubLinks().end(),
+    [](const SymlinkPair& linkObj) { return linkObj.getLinkCategory() == SYMLINK_EQUAL; })&&   //symlinks
 
-        std::all_of(hierObj.refSubDirs(). begin(), hierObj.refSubDirs(). end(),
-                    [](const DirPair& dirObj)
-        {
-            return dirObj.getDirCategory() == DIR_EQUAL && AllEqual()(dirObj); //short circuit-behavior!
-        });    //directories
-    }
-};
+    std::all_of(hierObj.refSubDirs(). begin(), hierObj.refSubDirs().end(),
+                [](const DirPair& dirObj)
+    {
+        return dirObj.getDirCategory() == DIR_EQUAL && allItemsCategoryEqual(dirObj); //short circuit-behavior!
+    });    //directories
+}
 }
 
 bool zen::allElementsEqual(const FolderComparison& folderCmp)
 {
-    return std::all_of(begin(folderCmp), end(folderCmp), AllEqual());
+    return std::all_of(begin(folderCmp), end(folderCmp), [](const BaseDirPair& baseObj) { return allItemsCategoryEqual(baseObj); });
 }
 
 //---------------------------------------------------------------------------------------------------------------
@@ -224,7 +222,7 @@ bool stillInSync(const InSyncFile& dbFile, CompareVariant compareVar, size_t fil
     switch (compareVar)
     {
         case CMP_BY_TIME_SIZE:
-            if (dbFile.inSyncType == IN_SYNC_BINARY_EQUAL) return true; //special rule: this is already "good enough" for CMP_BY_TIME_SIZE!
+            if (dbFile.cmpVar == CMP_BY_CONTENT) return true; //special rule: this is already "good enough" for CMP_BY_TIME_SIZE!
 
             return //case-sensitive short name match is a database invariant!
                 CmpFileTime::getResult(dbFile.left.lastWriteTimeRaw, dbFile.right.lastWriteTimeRaw, fileTimeTolerance) == CmpFileTime::TIME_EQUAL;
@@ -232,7 +230,7 @@ bool stillInSync(const InSyncFile& dbFile, CompareVariant compareVar, size_t fil
 
         case CMP_BY_CONTENT:
             //case-sensitive short name match is a database invariant!
-            return dbFile.inSyncType == IN_SYNC_BINARY_EQUAL;
+            return dbFile.cmpVar == CMP_BY_CONTENT;
             //in contrast to comparison, we don't care about modification time here!
     }
     assert(false);
@@ -273,14 +271,14 @@ bool stillInSync(const InSyncSymlink& dbLink, CompareVariant compareVar, size_t
     switch (compareVar)
     {
         case CMP_BY_TIME_SIZE:
-            if (dbLink.inSyncType == IN_SYNC_BINARY_EQUAL) return true; //special rule: this is already "good enough" for CMP_BY_TIME_SIZE!
+            if (dbLink.cmpVar == CMP_BY_CONTENT) return true; //special rule: this is already "good enough" for CMP_BY_TIME_SIZE!
 
             return //case-sensitive short name match is a database invariant!
                 CmpFileTime::getResult(dbLink.left.lastWriteTimeRaw, dbLink.right.lastWriteTimeRaw, fileTimeTolerance) == CmpFileTime::TIME_EQUAL;
 
         case CMP_BY_CONTENT:
             //case-sensitive short name match is a database invariant!
-            return dbLink.inSyncType == IN_SYNC_BINARY_EQUAL;
+            return dbLink.cmpVar == CMP_BY_CONTENT;
             //in contrast to comparison, we don't care about modification time here!
     }
     assert(false);
@@ -314,98 +312,175 @@ bool stillInSync(const InSyncDir& dbDir)
 
 //----------------------------------------------------------------------------------------------
 
-class RedetermineAuto
+class DetectMovedFiles
 {
 public:
-    static void execute(BaseDirPair& baseDirectory, std::function<void(const std::wstring&)> reportWarning)
-    {
-        RedetermineAuto(baseDirectory, reportWarning);
-    }
+    static void execute(BaseDirPair& baseDirectory, const InSyncDir& dbContainer) { DetectMovedFiles(baseDirectory, dbContainer); }
 
 private:
-    RedetermineAuto(BaseDirPair& baseDirectory, std::function<void(const std::wstring&)> reportWarning) :
-        txtBothSidesChanged(_("Both sides have changed since last synchronization.")),
-        txtNoSideChanged(_("Cannot determine sync-direction:") + L" \n" + _("No change since last synchronization.")),
-        txtDbNotInSync(_("Cannot determine sync-direction:") + L" \n" + _("The database entry is not in sync considering current settings.")),
+    DetectMovedFiles(BaseDirPair& baseDirectory, const InSyncDir& dbContainer) :
         cmpVar(baseDirectory.getCompVariant()),
-        fileTimeTolerance(baseDirectory.getFileTimeTolerance()),
-        reportWarning_(reportWarning)
+        fileTimeTolerance(baseDirectory.getFileTimeTolerance())
     {
-        if (AllEqual()(baseDirectory)) //nothing to do: abort and don't show any nag-screens
-            return;
+        recurse(baseDirectory);
+
+        if (!exLeftOnly.empty() && !exRightOnly.empty())
+            detectFilePairs(dbContainer);
+    }
 
-        //try to load sync-database files
-        std::shared_ptr<InSyncDir> lastSyncState = loadDBFile(baseDirectory);
-        if (!lastSyncState)
+    void recurse(HierarchyObject& hierObj)
+    {
+        for (FilePair& fileObj : hierObj.refSubFiles())
         {
-            //set conservative "two-way" directions
-            DirectionSet twoWayCfg = getTwoWaySet();
+            const CompareFilesResult cat = fileObj.getCategory();
 
-            Redetermine::execute(twoWayCfg, baseDirectory);
-            return;
+            if (cat == FILE_LEFT_SIDE_ONLY)
+            {
+                if (fileObj.getFileId<LEFT_SIDE>() != FileId())
+                {
+                    auto rv = exLeftOnly.insert(std::make_pair(fileObj.getFileId<LEFT_SIDE>(), &fileObj));
+                    assert(rv.second);
+                    if (!rv.second) //duplicate file ID!
+                        rv.first->second = nullptr;
+                }
+            }
+            else if (cat == FILE_RIGHT_SIDE_ONLY)
+            {
+                if (fileObj.getFileId<RIGHT_SIDE>() != FileId())
+                {
+                    auto rv = exRightOnly.insert(std::make_pair(fileObj.getFileId<RIGHT_SIDE>(), &fileObj));
+                    assert(rv.second);
+                    if (!rv.second) //duplicate file ID!
+                        rv.first->second = nullptr;
+                }
+            }
         }
+        for (DirPair& dirObj : hierObj.refSubDirs())
+            recurse(dirObj);
+    }
 
-        //-> considering filter not relevant:
-        //if narrowing filter: all ok; if widening filter (if file ex on both sides -> conflict, fine; if file ex. on one side: copy to other side: fine)
+    void detectFilePairs(const InSyncDir& container) const
+    {
+        for (auto& dbFile : container.files)
+            findAndSetMovePair(dbFile.second);
 
-        recurse(baseDirectory, &*lastSyncState);
+        for (auto& dbDir : container.dirs)
+            detectFilePairs(dbDir.second);
+    }
 
-        //----------- detect renamed files -----------------
-        if (!exLeftOnly.empty() && !exRightOnly.empty())
-            detectRenamedFiles(*lastSyncState);
+    static bool sameSizeAndDateLeft(const FilePair& fsObj, const InSyncFile& dbEntry)
+    {
+        return fsObj.getFileSize<LEFT_SIDE>() == dbEntry.fileSize &&
+               sameFileTime(fsObj.getLastWriteTime<LEFT_SIDE>(), dbEntry.left.lastWriteTimeRaw, 2); //respect 2 second FAT/FAT32 precision!
+        //PS: *never* allow 2 sec tolerance as container predicate!!
+        // => no strict weak ordering relation! reason: no transitivity of equivalence!
+    }
+    static bool sameSizeAndDateRight(const FilePair& fsObj, const InSyncFile& dbEntry)
+    {
+        return fsObj.getFileSize<RIGHT_SIDE>() == dbEntry.fileSize &&
+               sameFileTime(fsObj.getLastWriteTime<RIGHT_SIDE>(), dbEntry.right.lastWriteTimeRaw, 2);
     }
 
-    std::shared_ptr<InSyncDir> loadDBFile(const BaseDirPair& baseDirObj) //return nullptr on failure
+    void findAndSetMovePair(const InSyncFile& dbEntry) const
     {
-        try
-        {
-            return loadLastSynchronousState(baseDirObj); //throw FileError, FileErrorDatabaseNotExisting
-        }
-        catch (FileErrorDatabaseNotExisting&) {} //let's ignore this error, it seems there's no value in reporting it other than confuse users
-        catch (FileError& error) //e.g. incompatible database version
+        const FileId idLeft  = dbEntry.left .fileId;
+        const FileId idRight = dbEntry.right.fileId;
+
+        if (idLeft  != FileId() &&
+            idRight != FileId() &&
+            stillInSync(dbEntry, cmpVar, fileTimeTolerance))
         {
-            reportWarning_(error.toString() + L" \n\n" +
-                           _("Setting default synchronization directions: Old files will be overwritten with newer files."));
+            auto itL = exLeftOnly.find(idLeft);
+            if (itL != exLeftOnly.end())
+                if (FilePair* fileLeftOnly = itL->second) //= nullptr, if duplicate ID!
+                    if (sameSizeAndDateLeft(*fileLeftOnly, dbEntry))
+                    {
+                        auto itR = exRightOnly.find(idRight);
+                        if (itR != exRightOnly.end())
+                            if (FilePair* fileRightOnly = itR->second) //= nullptr, if duplicate ID!
+                                if (sameSizeAndDateRight(*fileRightOnly, dbEntry))
+                                    if (fileLeftOnly ->getMoveRef() == nullptr && //the db may contain duplicate file ids on left or right side: e.g. consider aliasing through symlinks
+                                        fileRightOnly->getMoveRef() == nullptr)   //=> should not be a problem (same id, size, date => alias!) but don't let a row participate in two move pairs!
+                                    {
+                                        fileLeftOnly ->setMoveRef(fileRightOnly->getId()); //found a pair, mark it!
+                                        fileRightOnly->setMoveRef(fileLeftOnly ->getId()); //
+                                    }
+                    }
         }
-        return nullptr;
     }
 
-    void recurse(HierarchyObject& hierObj, const InSyncDir* dbContainer)
+    const CompareVariant cmpVar;
+    const size_t fileTimeTolerance;
+
+    std::map<FileId, FilePair*> exLeftOnly;  //FilePair* == nullptr for duplicate ids! => consider aliasing through symlinks!
+    std::map<FileId, FilePair*> exRightOnly; //=> avoid ambiguity for mixtures of files/symlinks on one side and allow 1-1 mapping only!
+
+    /*
+    detect renamed files:
+
+     X  ->  |_|      Create right
+    |_| ->   Y       Delete right
+
+    is detected as:
+
+    Rename Y to X on right
+
+    Algorithm:
+    ----------
+    DB-file left  <--- (name, size, date) --->  DB-file right
+       |                                             |
+       |  (file ID, size, date)                      |  (file ID, size, date)
+      \|/                                           \|/
+    file left only                             file right only
+
+       FAT caveat: File Ids are generally not stable when file is either moved or renamed!
+       => 1. Move/rename operations on FAT cannot be detected reliably.
+       => 2. database generally contains wrong file ID on FAT after renaming from .ffs_tmp files => correct file Ids in database only after next sync
+       => 3. even exFAT screws up (but less than FAT) and changes IDs after file move. Did they learn nothing from the past?
+
+    Possible refinement
+    -------------------
+    If the file ID is wrong (FAT) or not available, we could at least allow direct association by name, instead of breaking the chain completely: support NTFS -> FAT
+    */
+};
+
+//----------------------------------------------------------------------------------------------
+
+class RedetermineTwoWay
+{
+public:
+    static void execute(BaseDirPair& baseDirectory, const InSyncDir& dbContainer) { RedetermineTwoWay(baseDirectory, dbContainer); }
+
+private:
+    RedetermineTwoWay(BaseDirPair& baseDirectory, const InSyncDir& dbContainer) :
+        txtBothSidesChanged(_("Both sides have changed since last synchronization.")),
+        txtNoSideChanged(_("Cannot determine sync-direction:") + L" \n" + _("No change since last synchronization.")),
+        txtDbNotInSync(_("Cannot determine sync-direction:") + L" \n" + _("The database entry is not in sync considering current settings.")),
+        cmpVar(baseDirectory.getCompVariant()),
+        fileTimeTolerance(baseDirectory.getFileTimeTolerance())
+    {
+        //-> considering filter not relevant:
+        //if narrowing filter: all ok; if widening filter (if file ex on both sides -> conflict, fine; if file ex. on one side: copy to other side: fine)
+
+        recurse(baseDirectory, &dbContainer);
+    }
+
+    void recurse(HierarchyObject& hierObj, const InSyncDir* dbContainer) const
     {
-        std::for_each(hierObj.refSubFiles().begin(), hierObj.refSubFiles().end(), [&](FilePair&    fileObj) { processFile   (fileObj, dbContainer); });
-        std::for_each(hierObj.refSubLinks().begin(), hierObj.refSubLinks().end(), [&](SymlinkPair& linkObj) { processSymlink(linkObj, dbContainer); });
-        std::for_each(hierObj.refSubDirs ().begin(), hierObj.refSubDirs ().end(), [&](DirPair&      dirObj) { processDir    (dirObj,  dbContainer); });
+        for (FilePair& fileObj : hierObj.refSubFiles())
+            processFile(fileObj, dbContainer);
+        for (SymlinkPair& linkObj : hierObj.refSubLinks())
+            processSymlink(linkObj, dbContainer);
+        for (DirPair& dirObj : hierObj.refSubDirs())
+            processDir(dirObj, dbContainer);
     }
 
-    void processFile(FilePair& fileObj, const InSyncDir* dbContainer)
+    void processFile(FilePair& fileObj, const InSyncDir* dbContainer) const
     {
         const CompareFilesResult cat = fileObj.getCategory();
         if (cat == FILE_EQUAL)
             return;
 
-        //----------------- prepare detection of renamed files -----------------
-        if (cat == FILE_LEFT_SIDE_ONLY)
-        {
-            if (fileObj.getFileId<LEFT_SIDE>() != FileId())
-            {
-                auto rv = exLeftOnly.insert(std::make_pair(fileObj.getFileId<LEFT_SIDE>(), &fileObj));
-                assert(rv.second);
-                if (!rv.second) //duplicate file ID!
-                    rv.first->second = nullptr;
-            }
-        }
-        else if (cat == FILE_RIGHT_SIDE_ONLY)
-        {
-            if (fileObj.getFileId<RIGHT_SIDE>() != FileId())
-            {
-                auto rv = exRightOnly.insert(std::make_pair(fileObj.getFileId<RIGHT_SIDE>(), &fileObj));
-                assert(rv.second);
-                if (!rv.second) //duplicate file ID!
-                    rv.first->second = nullptr;
-            }
-        }
-        //----------------------------------------------------------------------
-
         //##################### schedule old temporary files for deletion ####################
         if (cat == FILE_LEFT_SIDE_ONLY && endsWith(fileObj.getShortName<LEFT_SIDE>(), TEMP_FILE_ENDING))
             return fileObj.setSyncDir(SyncDirection::LEFT);
@@ -443,7 +518,7 @@ private:
         }
     }
 
-    void processSymlink(SymlinkPair& linkObj, const InSyncDir* dbContainer)
+    void processSymlink(SymlinkPair& linkObj, const InSyncDir* dbContainer) const
     {
         const CompareSymlinkResult cat = linkObj.getLinkCategory();
         if (cat == SYMLINK_EQUAL)
@@ -479,7 +554,7 @@ private:
         }
     }
 
-    void processDir(DirPair& dirObj, const InSyncDir* dbContainer)
+    void processDir(DirPair& dirObj, const InSyncDir* dbContainer) const
     {
         const CompareDirResult cat = dirObj.getDirCategory();
 
@@ -522,58 +597,7 @@ private:
             }
         }
 
-        recurse(dirObj, dbEntry ? &dbEntry->second : nullptr); //recursion
-    }
-
-    //note: - we cannot integrate this traversal into "recurse()" since it may take a *slightly* different path: e.g. file renamed on both sides
-    void detectRenamedFiles(InSyncDir& container)
-    {
-        std::for_each(container.files.begin(), container.files.end(),
-        [&](std::pair<const Zstring, InSyncFile>& dbFile) { findAndSetMovePair(dbFile.second); });
-
-        std::for_each(container.dirs.begin(), container.dirs.end(),
-        [&](std::pair<const Zstring, InSyncDir>& dbDir) { detectRenamedFiles(dbDir.second); });
-    }
-
-    static bool sameSizeAndDateLeft(const FilePair& fsObj, const InSyncFile& dbEntry)
-    {
-        return fsObj.getFileSize<LEFT_SIDE>() == dbEntry.fileSize &&
-               sameFileTime(fsObj.getLastWriteTime<LEFT_SIDE>(), dbEntry.left.lastWriteTimeRaw, 2); //respect 2 second FAT/FAT32 precision!
-        //PS: *never* allow 2 sec tolerance as container predicate!!
-        // => no strict weak ordering relation! reason: no transitivity of equivalence!
-    }
-    static bool sameSizeAndDateRight(const FilePair& fsObj, const InSyncFile& dbEntry)
-    {
-        return fsObj.getFileSize<RIGHT_SIDE>() == dbEntry.fileSize &&
-               sameFileTime(fsObj.getLastWriteTime<RIGHT_SIDE>(), dbEntry.right.lastWriteTimeRaw, 2);
-    }
-
-    void findAndSetMovePair(const InSyncFile& dbEntry) const
-    {
-        const FileId idLeft  = dbEntry.left .fileId;
-        const FileId idRight = dbEntry.right.fileId;
-
-        if (idLeft  != FileId() &&
-            idRight != FileId() &&
-            stillInSync(dbEntry, cmpVar, fileTimeTolerance))
-        {
-            auto itL = exLeftOnly.find(idLeft);
-            if (itL != exLeftOnly.end())
-                if (FilePair* fileLeftOnly = itL->second) //= nullptr, if duplicate ID!
-                    if (sameSizeAndDateLeft(*fileLeftOnly, dbEntry))
-                    {
-                        auto itR = exRightOnly.find(idRight);
-                        if (itR != exRightOnly.end())
-                            if (FilePair* fileRightOnly = itR->second) //= nullptr, if duplicate ID!
-                                if (sameSizeAndDateRight(*fileRightOnly, dbEntry))
-                                    if (fileLeftOnly ->getMoveRef() == nullptr && //the db may contain duplicate file ids on left or right side: e.g. consider aliasing through symlinks
-                                        fileRightOnly->getMoveRef() == nullptr)   //=> should not be a problem (same id, size, date => alias!) but don't let a row participate in two move pairs!
-                                    {
-                                        fileLeftOnly ->setMoveRef(fileRightOnly->getId()); //found a pair, mark it!
-                                        fileRightOnly->setMoveRef(fileLeftOnly ->getId()); //
-                                    }
-                    }
-        }
+        recurse(dirObj, dbEntry ? &dbEntry->second : nullptr);
     }
 
     const std::wstring txtBothSidesChanged;
@@ -582,51 +606,6 @@ private:
 
     const CompareVariant cmpVar;
     const size_t fileTimeTolerance;
-    std::function<void(const std::wstring&)> reportWarning_;
-
-    std::map<FileId, FilePair*> exLeftOnly;  //FilePair* == nullptr for duplicate ids! => consider aliasing through symlinks!
-    std::map<FileId, FilePair*> exRightOnly; //=> avoid ambiguity for mixtures of files/symlinks on one side and allow 1-1 mapping only!
-
-    /*
-    detect renamed files
-
-     X  ->  |_|      Create right
-    |_| ->   Y       Delete right
-
-    is detected as:
-
-    Rename Y to X on right
-
-    Algorithm:
-    ----------
-    DB-file left  <--- (name, size, date) --->  DB-file right
-       |                                             |
-       |  (file ID, size, date)                      |  (file ID, size, date)
-      \|/                                           \|/
-    file left only                             file right only
-
-       FAT caveat: File Ids are generally not stable when file is either moved or renamed!
-       => 1. Move/rename operations on FAT cannot be detected reliably.
-       => 2. database generally contains wrong file ID on FAT after renaming from .ffs_tmp files => correct file Ids in database only after next sync
-       => 3. even exFAT screws up (but less than FAT) and changes IDs after file move. Did they learn nothing from the past?
-
-    Possible refinement
-    -------------------
-    If the file ID is wrong (FAT) or not available, we could at least allow direct association by name, instead of breaking the chain completely: support NTFS -> FAT
-
-    1. find equal entries in database:
-    	std::hash_map: DB* |-> DB*       onceEqual
-
-    2. build alternative mappings if file Id is available for database entries:
-    	std::map: FielId |-> DB*  leftIdToDbRight
-    	std::map: FielId |-> DB* rightIdToDbRight
-
-    3. collect files on one side during determination of sync directions:
-    	std::vector<FilePair*, DB*>   exLeftOnlyToDbRight   -> first try to use file Id, if failed associate via file name instead
-    	std::hash_map<DB*, FilePair*> dbRightToexRightOnly  ->
-
-    4. find renamed pairs
-    */
 };
 }
 
@@ -652,15 +631,40 @@ std::vector<DirectionConfig> zen::extractDirectionCfg(const MainConfiguration& m
 }
 
 
-void zen::redetermineSyncDirection(const DirectionConfig& directConfig, BaseDirPair& baseDirectory, std::function<void(const std::wstring&)> reportWarning)
+void zen::redetermineSyncDirection(const DirectionConfig& dirCfg, BaseDirPair& baseDirectory, std::function<void(const std::wstring&)> reportWarning)
 {
-    if (directConfig.var == DirectionConfig::AUTOMATIC)
-        RedetermineAuto::execute(baseDirectory, reportWarning);
-    else
+    //try to load sync-database files
+    std::shared_ptr<InSyncDir> lastSyncState;
+    if (dirCfg.var == DirectionConfig::TWOWAY || detectMovedFilesEnabled(dirCfg))
+        try
+        {
+            if (allItemsCategoryEqual(baseDirectory))
+                return; //nothing to do: abort and don't even try to open db files
+
+            lastSyncState = loadLastSynchronousState(baseDirectory); //throw FileError, FileErrorDatabaseNotExisting
+        }
+        catch (FileErrorDatabaseNotExisting&) {} //let's ignore this error, there's no value in reporting it other than confuse users
+        catch (FileError& error) //e.g. incompatible database version
+        {
+            reportWarning(error.toString() +
+                          (dirCfg.var == DirectionConfig::TWOWAY ?
+                           L" \n\n" + _("Setting default synchronization directions: Old files will be overwritten with newer files.") : std::wstring()));
+        }
+
+    //set sync directions
+    if (dirCfg.var == DirectionConfig::TWOWAY)
     {
-        DirectionSet dirCfg = extractDirections(directConfig);
-        Redetermine::execute(dirCfg, baseDirectory);
+        if (lastSyncState)
+            RedetermineTwoWay::execute(baseDirectory, *lastSyncState);
+        else //default fallback
+            Redetermine::execute(getTwoWayUpdateSet(), baseDirectory);
     }
+    else
+        Redetermine::execute(extractDirections(dirCfg), baseDirectory);
+
+    //detect renamed files
+    if (lastSyncState)
+        DetectMovedFiles::execute(baseDirectory, *lastSyncState);
 }
 
 
@@ -681,113 +685,88 @@ void zen::redetermineSyncDirection(const MainConfiguration& mainCfg, FolderCompa
     }
 }
 
-
 //---------------------------------------------------------------------------------------------------------------
-class SetNewDirection
-{
-public:
-    SetNewDirection(SyncDirection newDirection) : newDirection_(newDirection) {}
 
-    void operator()(FilePair& fileObj) const
+struct SetNewDirection
+{
+    static void execute(FilePair& fileObj, SyncDirection newDirection)
     {
         if (fileObj.getCategory() != FILE_EQUAL)
-            fileObj.setSyncDir(newDirection_);
+            fileObj.setSyncDir(newDirection);
     }
 
-    void operator()(SymlinkPair& linkObj) const
+    static void execute(SymlinkPair& linkObj, SyncDirection newDirection)
     {
         if (linkObj.getLinkCategory() != SYMLINK_EQUAL)
-            linkObj.setSyncDir(newDirection_);
+            linkObj.setSyncDir(newDirection);
     }
 
-    void operator()(DirPair& dirObj) const
+    static void execute(DirPair& dirObj, SyncDirection newDirection)
     {
         if (dirObj.getDirCategory() != DIR_EQUAL)
-            dirObj.setSyncDir(newDirection_);
-        execute(dirObj); //recursion
+            dirObj.setSyncDir(newDirection);
+
+        //recurse:
+        for (FilePair& fileObj : dirObj.refSubFiles())
+            execute(fileObj, newDirection);
+        for (SymlinkPair& linkObj : dirObj.refSubLinks())
+            execute(linkObj, newDirection);
+        for (DirPair& dirObj2 : dirObj.refSubDirs())
+            execute(dirObj2, newDirection);
     }
-
-private:
-    void execute(HierarchyObject& hierObj) const
-    {
-        std::for_each(hierObj.refSubFiles().begin(), hierObj.refSubFiles().end(), [&](FilePair&    fileObj) { (*this)(fileObj); });
-        std::for_each(hierObj.refSubLinks().begin(), hierObj.refSubLinks().end(), [&](SymlinkPair& linkObj) { (*this)(linkObj); });
-        std::for_each(hierObj.refSubDirs ().begin(), hierObj.refSubDirs ().end(), [&](DirPair&      dirObj) { (*this)(dirObj); });
-    }
-
-    const SyncDirection newDirection_;
 };
 
 
 void zen::setSyncDirectionRec(SyncDirection newDirection, FileSystemObject& fsObj)
 {
-    SetNewDirection dirSetter(newDirection);
-
     //process subdirectories also!
     struct Recurse: public FSObjectVisitor
     {
-        Recurse(const SetNewDirection& ds) : dirSetter_(ds) {}
+        Recurse(SyncDirection newDir) : newDir_(newDir) {}
         virtual void visit(const FilePair& fileObj)
         {
-            dirSetter_(const_cast<FilePair&>(fileObj)); //phyiscal object is not const in this method anyway
+            SetNewDirection::execute(const_cast<FilePair&>(fileObj), newDir_); //phyiscal object is not const in this method anyway
         }
         virtual void visit(const SymlinkPair& linkObj)
         {
-            dirSetter_(const_cast<SymlinkPair&>(linkObj)); //
+            SetNewDirection::execute(const_cast<SymlinkPair&>(linkObj), newDir_); //
         }
         virtual void visit(const DirPair& dirObj)
         {
-            dirSetter_(const_cast<DirPair&>(dirObj)); //
+            SetNewDirection::execute(const_cast<DirPair&>(dirObj), newDir_); //
         }
     private:
-        const SetNewDirection& dirSetter_;
-    } recurse(dirSetter);
-    fsObj.accept(recurse);
+        SyncDirection newDir_;
+    } setDirVisitor(newDirection);
+    fsObj.accept(setDirVisitor);
 }
 
 //--------------- functions related to filtering ------------------------------------------------------------------------------------
 
+namespace
+{
 template <bool include>
-class InOrExcludeAllRows
+void inOrExcludeAllRows(zen::HierarchyObject& hierObj)
 {
-public:
-    void operator()(zen::BaseDirPair& baseDirectory) const //be careful with operator() to no get called by std::for_each!
-    {
-        execute(baseDirectory);
-    }
-
-    void execute(zen::HierarchyObject& hierObj) const //don't create ambiguity by replacing with operator()
-    {
-        std::for_each(hierObj.refSubFiles().begin(), hierObj.refSubFiles().end(), [&](FilePair&    fileObj) { (*this)(fileObj); });
-        std::for_each(hierObj.refSubLinks().begin(), hierObj.refSubLinks().end(), [&](SymlinkPair& linkObj) { (*this)(linkObj); });
-        std::for_each(hierObj.refSubDirs ().begin(), hierObj.refSubDirs ().end(), [&](DirPair&      dirObj) { (*this)(dirObj); });
-    }
-
-private:
-    void operator()(zen::FilePair& fileObj) const
-    {
+    for (FilePair& fileObj : hierObj.refSubFiles())
         fileObj.setActive(include);
-    }
-
-    void operator()(zen::SymlinkPair& linkObj) const
-    {
+    for (SymlinkPair& linkObj : hierObj.refSubLinks())
         linkObj.setActive(include);
-    }
-
-    void operator()(zen::DirPair& dirObj) const
+    for (DirPair& dirObj : hierObj.refSubDirs())
     {
         dirObj.setActive(include);
-        execute(dirObj); //recursion
+        inOrExcludeAllRows<include>(dirObj); //recurse
     }
-};
+}
+}
 
 
 void zen::setActiveStatus(bool newStatus, zen::FolderComparison& folderCmp)
 {
     if (newStatus)
-        std::for_each(begin(folderCmp), end(folderCmp), InOrExcludeAllRows<true>());  //include all rows
+        std::for_each(begin(folderCmp), end(folderCmp), [](BaseDirPair& baseDirObj) { inOrExcludeAllRows<true>(baseDirObj); }); //include all rows
     else
-        std::for_each(begin(folderCmp), end(folderCmp), InOrExcludeAllRows<false>()); //exclude all rows
+        std::for_each(begin(folderCmp), end(folderCmp), [](BaseDirPair& baseDirObj) { inOrExcludeAllRows<false>(baseDirObj); }); //exclude all rows
 }
 
 
@@ -804,9 +783,9 @@ void zen::setActiveStatus(bool newStatus, zen::FileSystemObject& fsObj)
         virtual void visit(const DirPair& dirObj)
         {
             if (newStatus_)
-                InOrExcludeAllRows<true>().execute(const_cast<DirPair&>(dirObj)); //object is not physically const here anyway
+                inOrExcludeAllRows<true>(const_cast<DirPair&>(dirObj)); //object is not physically const here anyway
             else
-                InOrExcludeAllRows<false>().execute(const_cast<DirPair&>(dirObj)); //
+                inOrExcludeAllRows<false>(const_cast<DirPair&>(dirObj)); //
         }
     private:
         const bool newStatus_;
@@ -851,29 +830,34 @@ template <FilterStrategy strategy>
 class ApplyHardFilter
 {
 public:
-    ApplyHardFilter(const HardFilter& filterProcIn) : filterProc(filterProcIn) {}
+    static void execute(HierarchyObject& hierObj, const HardFilter& filterProcIn) { ApplyHardFilter(hierObj, filterProcIn); }
+
+private:
+    ApplyHardFilter(HierarchyObject& hierObj, const HardFilter& filterProcIn) : filterProc(filterProcIn)  { recurse(hierObj); }
 
-    void execute(zen::HierarchyObject& hierObj) const
+    void recurse(HierarchyObject& hierObj) const
     {
-        std::for_each(hierObj.refSubFiles().begin(), hierObj.refSubFiles().end(), [&](FilePair&    fileObj) { (*this)(fileObj); });
-        std::for_each(hierObj.refSubLinks().begin(), hierObj.refSubLinks().end(), [&](SymlinkPair& linkObj) { (*this)(linkObj); });
-        std::for_each(hierObj.refSubDirs ().begin(), hierObj.refSubDirs ().end(), [&](DirPair&      dirObj) { (*this)(dirObj); });
+        for (FilePair& fileObj : hierObj.refSubFiles())
+            processFile(fileObj);
+        for (SymlinkPair& linkObj : hierObj.refSubLinks())
+            processLink(linkObj);
+        for (DirPair& dirObj : hierObj.refSubDirs())
+            processDir(dirObj);
     };
 
-private:
-    void operator()(zen::FilePair& fileObj) const
+    void processFile(FilePair& fileObj) const
     {
         if (Eval<strategy>().process(fileObj))
             fileObj.setActive(filterProc.passFileFilter(fileObj.getObjRelativeName()));
     }
 
-    void operator()(zen::SymlinkPair& linkObj) const
+    void processLink(SymlinkPair& linkObj) const
     {
         if (Eval<strategy>().process(linkObj))
             linkObj.setActive(filterProc.passFileFilter(linkObj.getObjRelativeName()));
     }
 
-    void operator()(zen::DirPair& dirObj) const
+    void processDir(DirPair& dirObj) const
     {
         bool subObjMightMatch = true;
         const bool filterPassed = filterProc.passDirFilter(dirObj.getObjRelativeName(), &subObjMightMatch);
@@ -883,11 +867,11 @@ private:
 
         if (!subObjMightMatch) //use same logic like directory traversing here: evaluate filter in subdirs only if objects could match
         {
-            InOrExcludeAllRows<false>().execute(dirObj); //exclude all files dirs in subfolders
+            inOrExcludeAllRows<false>(dirObj); //exclude all files dirs in subfolders
             return;
         }
 
-        execute(dirObj);  //recursion
+        recurse(dirObj);
     }
 
     const HardFilter& filterProc;
@@ -901,17 +885,22 @@ template <FilterStrategy strategy>
 class ApplySoftFilter //falsify only! -> can run directly after "hard/base filter"
 {
 public:
-    ApplySoftFilter(const SoftFilter& timeSizeFilter) : timeSizeFilter_(timeSizeFilter) {}
+    static void execute(HierarchyObject& hierObj, const SoftFilter& timeSizeFilter) { ApplySoftFilter(hierObj, timeSizeFilter); }
 
-    void execute(zen::HierarchyObject& hierObj) const
+private:
+    ApplySoftFilter(HierarchyObject& hierObj, const SoftFilter& timeSizeFilter) : timeSizeFilter_(timeSizeFilter) { recurse(hierObj); }
+
+    void recurse(zen::HierarchyObject& hierObj) const
     {
-        std::for_each(hierObj.refSubFiles().begin(), hierObj.refSubFiles().end(), [&](FilePair&    fileObj) { (*this)(fileObj); });
-        std::for_each(hierObj.refSubLinks().begin(), hierObj.refSubLinks().end(), [&](SymlinkPair& linkObj) { (*this)(linkObj); });
-        std::for_each(hierObj.refSubDirs ().begin(), hierObj.refSubDirs ().end(), [&](DirPair&      dirObj) { (*this)(dirObj); });
+        for (FilePair& fileObj : hierObj.refSubFiles())
+            processFile(fileObj);
+        for (SymlinkPair& linkObj : hierObj.refSubLinks())
+            processLink(linkObj);
+        for (DirPair& dirObj : hierObj.refSubDirs())
+            processDir(dirObj);
     };
 
-private:
-    void operator()(zen::FilePair& fileObj) const
+    void processFile(FilePair& fileObj) const
     {
         if (Eval<strategy>().process(fileObj))
         {
@@ -926,14 +915,14 @@ private:
                 //the only case with partially unclear semantics:
                 //file and time filters may match or not match on each side, leaving a total of 16 combinations for both sides!
                 /*
-                               ST S T -         ST := match size and time
-                               ---------         S := match size only
-                            ST |X|X|X|X|         T := match time only
-                            ------------         - := no match
+                               ST S T -       ST := match size and time
+                               ---------       S := match size only
+                            ST |X|X|X|X|       T := match time only
+                            ------------       - := no match
                              S |X|O|?|O|
-                            ------------         X := include row
-                             T |X|?|O|O|         O := exclude row
-                            ------------         ? := unclear
+                            ------------       X := include row
+                             T |X|?|O|O|       O := exclude row
+                            ------------       ? := unclear
                              - |X|O|O|O|
                             ------------
                 */
@@ -946,7 +935,7 @@ private:
         }
     }
 
-    void operator()(zen::SymlinkPair& linkObj) const
+    void processLink(SymlinkPair& linkObj) const
     {
         if (Eval<strategy>().process(linkObj))
         {
@@ -960,12 +949,12 @@ private:
         }
     }
 
-    void operator()(zen::DirPair& dirObj) const
+    void processDir(DirPair& dirObj) const
     {
         if (Eval<strategy>().process(dirObj))
             dirObj.setActive(timeSizeFilter_.matchFolder()); //if date filter is active we deactivate all folders: effectively gets rid of empty folders!
 
-        execute(dirObj);  //recursion
+        recurse(dirObj);
     }
 
     template <SelectedSide side, class T>
@@ -987,14 +976,14 @@ private:
 
 void zen::addHardFiltering(BaseDirPair& baseDirObj, const Zstring& excludeFilter)
 {
-    ApplyHardFilter<STRATEGY_AND>(NameFilter(FilterConfig().includeFilter, excludeFilter)).execute(baseDirObj);
+    ApplyHardFilter<STRATEGY_AND>::execute(baseDirObj, NameFilter(FilterConfig().includeFilter, excludeFilter));
 }
 
 
 void zen::addSoftFiltering(BaseDirPair& baseDirObj, const SoftFilter& timeSizeFilter)
 {
     if (!timeSizeFilter.isNull()) //since we use STRATEGY_AND, we may skip a "null" filter
-        ApplySoftFilter<STRATEGY_AND>(timeSizeFilter).execute(baseDirObj);
+        ApplySoftFilter<STRATEGY_AND>::execute(baseDirObj, timeSizeFilter);
 }
 
 
@@ -1019,7 +1008,7 @@ void zen::applyFiltering(FolderComparison& folderCmp, const MainConfiguration& m
         const NormalizedFilter normFilter = normalizeFilters(mainCfg.globalFilter, it->localFilter);
 
         //"set" hard filter
-        ApplyHardFilter<STRATEGY_SET>(*normFilter.nameFilter).execute(baseDirectory);
+        ApplyHardFilter<STRATEGY_SET>::execute(baseDirectory, *normFilter.nameFilter);
 
         //"and" soft filter
         addSoftFiltering(baseDirectory, normFilter.timeSizeFilter);
@@ -1030,20 +1019,26 @@ void zen::applyFiltering(FolderComparison& folderCmp, const MainConfiguration& m
 class FilterByTimeSpan
 {
 public:
-    FilterByTimeSpan(const Int64& timeFrom,
+    static void execute(HierarchyObject& hierObj, const Int64& timeFrom, const Int64& timeTo) { FilterByTimeSpan(hierObj, timeFrom, timeTo); }
+
+private:
+    FilterByTimeSpan(HierarchyObject& hierObj,
+                     const Int64& timeFrom,
                      const Int64& timeTo) :
         timeFrom_(timeFrom),
-        timeTo_(timeTo) {}
+        timeTo_(timeTo) { recurse(hierObj); }
 
-    void execute(zen::HierarchyObject& hierObj) const
+    void recurse(HierarchyObject& hierObj) const
     {
-        std::for_each(hierObj.refSubFiles().begin(), hierObj.refSubFiles().end(), [&](FilePair&    fileObj) { (*this)(fileObj); });
-        std::for_each(hierObj.refSubLinks().begin(), hierObj.refSubLinks().end(), [&](SymlinkPair& linkObj) { (*this)(linkObj); });
-        std::for_each(hierObj.refSubDirs ().begin(), hierObj.refSubDirs ().end(), [&](DirPair&      dirObj) { (*this)(dirObj); });
+        for (FilePair& fileObj : hierObj.refSubFiles())
+            processFile(fileObj);
+        for (SymlinkPair& linkObj : hierObj.refSubLinks())
+            processLink(linkObj);
+        for (DirPair& dirObj : hierObj.refSubDirs())
+            processDir(dirObj);
     };
 
-private:
-    void operator()(zen::FilePair& fileObj) const
+    void processFile(FilePair& fileObj) const
     {
         if (fileObj.isEmpty<LEFT_SIDE>())
             fileObj.setActive(matchTime<RIGHT_SIDE>(fileObj));
@@ -1054,7 +1049,7 @@ private:
                               matchTime<LEFT_SIDE>(fileObj));
     }
 
-    void operator()(zen::SymlinkPair& linkObj) const
+    void processLink(SymlinkPair& linkObj) const
     {
         if (linkObj.isEmpty<LEFT_SIDE>())
             linkObj.setActive(matchTime<RIGHT_SIDE>(linkObj));
@@ -1065,10 +1060,10 @@ private:
                               matchTime<LEFT_SIDE> (linkObj));
     }
 
-    void operator()(zen::DirPair& dirObj) const
+    void processDir(DirPair& dirObj) const
     {
         dirObj.setActive(false);
-        execute(dirObj);  //recursion
+        recurse(dirObj);
     }
 
     template <SelectedSide side, class T>
@@ -1085,8 +1080,7 @@ private:
 
 void zen::applyTimeSpanFilter(FolderComparison& folderCmp, const Int64& timeFrom, const Int64& timeTo)
 {
-    FilterByTimeSpan spanFilter(timeFrom, timeTo);
-    std::for_each(begin(folderCmp), end(folderCmp), [&](BaseDirPair& baseDirObj) { spanFilter.execute(baseDirObj); });
+    std::for_each(begin(folderCmp), end(folderCmp), [&](BaseDirPair& baseDirObj) { FilterByTimeSpan::execute(baseDirObj, timeFrom, timeTo); });
 }
 
 
@@ -1235,9 +1229,9 @@ struct ItemDeleter : public FSObjectVisitor  //throw FileError, but nothrow cons
     {
         if (useRecycleBin_)
         {
-            txtRemovingFile      = _("Moving file %x to recycle bin"         );
-            txtRemovingDirectory = _("Moving folder %x to recycle bin"       );
-            txtRemovingSymlink   = _("Moving symbolic link %x to recycle bin");
+            txtRemovingFile      = _("Moving file %x to the recycle bin"         );
+            txtRemovingDirectory = _("Moving folder %x to the recycle bin"       );
+            txtRemovingSymlink   = _("Moving symbolic link %x to the recycle bin");
         }
         else
         {
@@ -1264,17 +1258,12 @@ struct ItemDeleter : public FSObjectVisitor  //throw FileError, but nothrow cons
         if (useRecycleBin_)
             zen::recycleOrDelete(linkObj.getFullName<side>()); //throw FileError
         else
-            switch (getSymlinkType(linkObj.getFullName<side>()))
-            {
-                case SYMLINK_TYPE_DIR:
-                    zen::removeDirectory(linkObj.getFullName<side>()); //throw FileError
-                    break;
-
-                case SYMLINK_TYPE_FILE:
-                case SYMLINK_TYPE_UNKNOWN:
-                    zen::removeFile(linkObj.getFullName<side>()); //throw FileError
-                    break;
-            }
+        {
+            if (dirExists(linkObj.getFullName<side>())) //dir symlink
+                zen::removeDirectory(linkObj.getFullName<side>()); //throw FileError
+            else //file symlink, broken symlink
+                zen::removeFile(linkObj.getFullName<side>()); //throw FileError
+        }
     }
 
     virtual void visit(const DirPair& dirObj)
@@ -1386,7 +1375,7 @@ void zen::deleteFromGridAndHD(const std::vector<FileSystemObject*>& rowsToDelete
                 {
                     SyncDirection newDir = SyncDirection::NONE;
 
-                    if (cfgIter->second.var == DirectionConfig::AUTOMATIC)
+                    if (cfgIter->second.var == DirectionConfig::TWOWAY)
                         newDir = fsObj.isEmpty<LEFT_SIDE>() ? SyncDirection::RIGHT : SyncDirection::LEFT;
                     else
                     {
@@ -1420,7 +1409,7 @@ void zen::deleteFromGridAndHD(const std::vector<FileSystemObject*>& rowsToDelete
     if (useRecycleBin &&
     std::any_of(hasRecyclerBuffer.begin(), hasRecyclerBuffer.end(), [](std::pair<Zstring, bool> item) { return !item.second; }))
     {
-        std::wstring msg = _("The Recycle Bin is not available for the following folders. Files will be deleted permanently instead:") + L"\n";
+        std::wstring msg = _("The recycle bin is not available for the following folders. Files will be deleted permanently instead:") + L"\n";
 
         for (auto it = hasRecyclerBuffer.begin(); it != hasRecyclerBuffer.end(); ++it)
             if (!it->second)