diff options
Diffstat (limited to 'algorithm.cpp')
| -rw-r--r-- | algorithm.cpp | 1426 |
1 files changed, 0 insertions, 1426 deletions
diff --git a/algorithm.cpp b/algorithm.cpp deleted file mode 100644 index 44e3f643..00000000 --- a/algorithm.cpp +++ /dev/null @@ -1,1426 +0,0 @@ -// ************************************************************************** -// * This file is part of the FreeFileSync project. It is distributed under * -// * GNU General Public License: http://www.gnu.org/licenses/gpl.html * -// * Copyright (C) Zenju (zenju AT gmx DOT de) - All Rights Reserved * -// ************************************************************************** - -#include "algorithm.h" -#include <set> -#include <stdexcept> -#include <zen/file_handling.h> -#include <zen/recycler.h> -#include <zen/stl_tools.h> -#include <zen/scope_guard.h> -#include <zen/thread.h> -#include <wx+/image_resources.h> -#include "lib/norm_filter.h" -#include "lib/db_file.h" -#include "lib/cmp_filetime.h" -#include "lib/norm_filter.h" -#include "process_callback.h" //for UI_UPDATE_INTERVAL - -using namespace zen; -using namespace std::rel_ops; - - -void zen::swapGrids(const MainConfiguration& config, FolderComparison& folderCmp) -{ - std::for_each(begin(folderCmp), end(folderCmp), [](BaseDirPair& baseObj) { baseObj.flip(); }); - redetermineSyncDirection(config, folderCmp, [](const std::wstring&) {}); -} - -//---------------------------------------------------------------------------------------------- - -namespace -{ -class Redetermine -{ -public: - static void execute(const DirectionSet& dirCfgIn, HierarchyObject& hierObj) { Redetermine(dirCfgIn).recurse(hierObj); } - -private: - Redetermine(const DirectionSet& dirCfgIn) : dirCfg(dirCfgIn) {} - - void recurse(HierarchyObject& hierObj) const - { - for (FilePair& fileObj : hierObj.refSubFiles()) - processFile(fileObj); - for (SymlinkPair& linkObj : hierObj.refSubLinks()) - processLink(linkObj); - for (DirPair& dirObj : hierObj.refSubDirs()) - processDir(dirObj); - } - - void processFile(FilePair& fileObj) const - { - const CompareFilesResult cat = fileObj.getCategory(); - - //##################### 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); - else if (cat == FILE_RIGHT_SIDE_ONLY && endsWith(fileObj.getShortName<RIGHT_SIDE>(), TEMP_FILE_ENDING)) - return fileObj.setSyncDir(SyncDirection::RIGHT); - //#################################################################################### - - switch (cat) - { - case FILE_LEFT_SIDE_ONLY: - fileObj.setSyncDir(dirCfg.exLeftSideOnly); - break; - case FILE_RIGHT_SIDE_ONLY: - fileObj.setSyncDir(dirCfg.exRightSideOnly); - break; - case FILE_RIGHT_NEWER: - fileObj.setSyncDir(dirCfg.rightNewer); - break; - case FILE_LEFT_NEWER: - fileObj.setSyncDir(dirCfg.leftNewer); - break; - case FILE_DIFFERENT: - fileObj.setSyncDir(dirCfg.different); - break; - case FILE_CONFLICT: - case FILE_DIFFERENT_METADATA: //use setting from "conflict/cannot categorize" - if (dirCfg.conflict == SyncDirection::NONE) - fileObj.setSyncDirConflict(fileObj.getCatExtraDescription()); //take over category conflict - else - fileObj.setSyncDir(dirCfg.conflict); - break; - case FILE_EQUAL: - fileObj.setSyncDir(SyncDirection::NONE); - break; - } - } - - void processLink(SymlinkPair& linkObj) const - { - switch (linkObj.getLinkCategory()) - { - case SYMLINK_LEFT_SIDE_ONLY: - linkObj.setSyncDir(dirCfg.exLeftSideOnly); - break; - case SYMLINK_RIGHT_SIDE_ONLY: - linkObj.setSyncDir(dirCfg.exRightSideOnly); - break; - case SYMLINK_LEFT_NEWER: - linkObj.setSyncDir(dirCfg.leftNewer); - break; - case SYMLINK_RIGHT_NEWER: - linkObj.setSyncDir(dirCfg.rightNewer); - break; - case SYMLINK_CONFLICT: - case SYMLINK_DIFFERENT_METADATA: //use setting from "conflict/cannot categorize" - if (dirCfg.conflict == SyncDirection::NONE) - linkObj.setSyncDirConflict(linkObj.getCatExtraDescription()); //take over category conflict - else - linkObj.setSyncDir(dirCfg.conflict); - break; - case SYMLINK_DIFFERENT: - linkObj.setSyncDir(dirCfg.different); - break; - case SYMLINK_EQUAL: - linkObj.setSyncDir(SyncDirection::NONE); - break; - } - } - - void processDir(DirPair& dirObj) const - { - const CompareDirResult cat = dirObj.getDirCategory(); - - //########### schedule abandoned temporary recycle bin directory for deletion ########## - if (cat == DIR_LEFT_SIDE_ONLY && endsWith(dirObj.getShortName<LEFT_SIDE>(), TEMP_FILE_ENDING)) - return setSyncDirectionRec(SyncDirection::LEFT, dirObj); // - else if (cat == DIR_RIGHT_SIDE_ONLY && endsWith(dirObj.getShortName<RIGHT_SIDE>(), TEMP_FILE_ENDING)) - return setSyncDirectionRec(SyncDirection::RIGHT, dirObj); //don't recurse below! - //####################################################################################### - - switch (cat) - { - case DIR_LEFT_SIDE_ONLY: - dirObj.setSyncDir(dirCfg.exLeftSideOnly); - break; - case DIR_RIGHT_SIDE_ONLY: - dirObj.setSyncDir(dirCfg.exRightSideOnly); - break; - case DIR_EQUAL: - dirObj.setSyncDir(SyncDirection::NONE); - break; - case DIR_DIFFERENT_METADATA: //use setting from "conflict/cannot categorize" - if (dirCfg.conflict == SyncDirection::NONE) - dirObj.setSyncDirConflict(dirObj.getCatExtraDescription()); //take over category conflict - else - dirObj.setSyncDir(dirCfg.conflict); - break; - } - - recurse(dirObj); - } - - const DirectionSet dirCfg; -}; - -//--------------------------------------------------------------------------------------------------------------- - -//test if non-equal items exist in scanned data -bool allItemsCategoryEqual(const HierarchyObject& hierObj) -{ - 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.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), [](const BaseDirPair& baseObj) { return allItemsCategoryEqual(baseObj); }); -} - -//--------------------------------------------------------------------------------------------------------------- - -namespace -{ -template <SelectedSide side> inline -const InSyncDescrFile& getDescriptor(const InSyncFile& dbFile) { return dbFile.left; } - -template <> inline -const InSyncDescrFile& getDescriptor<RIGHT_SIDE>(const InSyncFile& dbFile) { return dbFile.right; } - - -//check whether database entry and current item match: *irrespective* of current comparison settings -template <SelectedSide side> inline -bool isEqual(const FilePair& fileObj, const InSyncDir::FileList::value_type* dbFile) -{ - if (fileObj.isEmpty<side>()) - return !dbFile; - else if (!dbFile) - return false; - - const Zstring& shortNameDb = dbFile->first; - const InSyncDescrFile& descrDb = getDescriptor<side>(dbFile->second); - - return fileObj.getShortName<side>() == shortNameDb && //detect changes in case (windows) - //respect 2 second FAT/FAT32 precision! copying a file to a FAT32 drive changes it's modification date by up to 2 seconds - sameFileTime(fileObj.getLastWriteTime<side>(), descrDb.lastWriteTimeRaw, 2) && - fileObj.getFileSize<side>() == dbFile->second.fileSize; - //note: we do *not* consider FileId here, but are only interested in *visual* changes. Consider user moving data to some other medium, this is not a change! -} - - -//check whether database entry is in sync considering *current* comparison settings -inline -bool stillInSync(const InSyncFile& dbFile, CompareVariant compareVar, size_t fileTimeTolerance) -{ - switch (compareVar) - { - case 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; - //dbFile.left.fileSize == dbFile.right.fileSize; - - case CMP_BY_CONTENT: - //case-sensitive short name match is a database invariant! - return dbFile.cmpVar == CMP_BY_CONTENT; - //in contrast to comparison, we don't care about modification time here! - } - assert(false); - return false; -} - -//-------------------------------------------------------------------- - -template <SelectedSide side> inline -const InSyncDescrLink& getDescriptor(const InSyncSymlink& dbLink) { return dbLink.left; } - -template <> inline -const InSyncDescrLink& getDescriptor<RIGHT_SIDE>(const InSyncSymlink& dbLink) { return dbLink.right; } - - -//check whether database entry and current item match: *irrespective* of current comparison settings -template <SelectedSide side> inline -bool isEqual(const SymlinkPair& linkObj, const InSyncDir::LinkList::value_type* dbLink) -{ - if (linkObj.isEmpty<side>()) - return !dbLink; - else if (!dbLink) - return false; - - const Zstring& shortNameDb = dbLink->first; - const InSyncDescrLink& descrDb = getDescriptor<side>(dbLink->second); - - return linkObj.getShortName<side>() == shortNameDb && - //respect 2 second FAT/FAT32 precision! copying a file to a FAT32 drive changes its modification date by up to 2 seconds - sameFileTime(linkObj.getLastWriteTime<side>(), descrDb.lastWriteTimeRaw, 2); -} - - -//check whether database entry is in sync considering *current* comparison settings -inline -bool stillInSync(const InSyncSymlink& dbLink, CompareVariant compareVar, size_t fileTimeTolerance) -{ - switch (compareVar) - { - case 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.cmpVar == CMP_BY_CONTENT; - //in contrast to comparison, we don't care about modification time here! - } - assert(false); - return false; -} - -//-------------------------------------------------------------------- - -//check whether database entry and current item match: *irrespective* of current comparison settings -template <SelectedSide side> inline -bool isEqual(const DirPair& dirObj, const InSyncDir::DirList::value_type* dbDir) -{ - if (dirObj.isEmpty<side>()) - return !dbDir || dbDir->second.status == InSyncDir::DIR_STATUS_STRAW_MAN; - else if (!dbDir || dbDir->second.status == InSyncDir::DIR_STATUS_STRAW_MAN) - return false; - - const Zstring& shortNameDb = dbDir->first; - - return dirObj.getShortName<side>() == shortNameDb; -} - - -inline -bool stillInSync(const InSyncDir& dbDir) -{ - //case-sensitive short name match is a database invariant! - //InSyncDir::DIR_STATUS_STRAW_MAN considered - return true; -} - -//---------------------------------------------------------------------------------------------- - -class DetectMovedFiles -{ -public: - static void execute(BaseDirPair& baseDirectory, const InSyncDir& dbContainer) { DetectMovedFiles(baseDirectory, dbContainer); } - -private: - DetectMovedFiles(BaseDirPair& baseDirectory, const InSyncDir& dbContainer) : - cmpVar(baseDirectory.getCompVariant()), - fileTimeTolerance(baseDirectory.getFileTimeTolerance()) - { - recurse(baseDirectory); - - if (!exLeftOnly.empty() && !exRightOnly.empty()) - detectFilePairs(dbContainer); - } - - void recurse(HierarchyObject& hierObj) - { - for (FilePair& fileObj : hierObj.refSubFiles()) - { - const CompareFilesResult cat = fileObj.getCategory(); - - 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); - } - - void detectFilePairs(const InSyncDir& container) const - { - for (auto& dbFile : container.files) - findAndSetMovePair(dbFile.second); - - for (auto& dbDir : container.dirs) - detectFilePairs(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()); // - } - } - } - } - - 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 - { - 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) const - { - const CompareFilesResult cat = fileObj.getCategory(); - if (cat == FILE_EQUAL) - return; - - //##################### 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); - else if (cat == FILE_RIGHT_SIDE_ONLY && endsWith(fileObj.getShortName<RIGHT_SIDE>(), TEMP_FILE_ENDING)) - return fileObj.setSyncDir(SyncDirection::RIGHT); - //#################################################################################### - - //try to find corresponding database entry - const InSyncDir::FileList::value_type* dbEntry = nullptr; - if (dbContainer) - { - auto it = dbContainer->files.find(fileObj.getObjShortName()); - if (it != dbContainer->files.end()) - dbEntry = &*it; - } - - //evaluation - const bool changeOnLeft = !isEqual<LEFT_SIDE >(fileObj, dbEntry); - const bool changeOnRight = !isEqual<RIGHT_SIDE>(fileObj, dbEntry); - - if (changeOnLeft != changeOnRight) - { - //if database entry not in sync according to current settings! -> do not set direction based on async status! - if (dbEntry && !stillInSync(dbEntry->second, cmpVar, fileTimeTolerance)) - fileObj.setSyncDirConflict(txtDbNotInSync); - else - fileObj.setSyncDir(changeOnLeft ? SyncDirection::RIGHT : SyncDirection::LEFT); - } - else - { - if (changeOnLeft) - fileObj.setSyncDirConflict(txtBothSidesChanged); - else - fileObj.setSyncDirConflict(txtNoSideChanged); - } - } - - void processSymlink(SymlinkPair& linkObj, const InSyncDir* dbContainer) const - { - const CompareSymlinkResult cat = linkObj.getLinkCategory(); - if (cat == SYMLINK_EQUAL) - return; - - //try to find corresponding database entry - const InSyncDir::LinkList::value_type* dbEntry = nullptr; - if (dbContainer) - { - auto it = dbContainer->symlinks.find(linkObj.getObjShortName()); - if (it != dbContainer->symlinks.end()) - dbEntry = &*it; - } - - //evaluation - const bool changeOnLeft = !isEqual<LEFT_SIDE >(linkObj, dbEntry); - const bool changeOnRight = !isEqual<RIGHT_SIDE>(linkObj, dbEntry); - - if (changeOnLeft != changeOnRight) - { - //if database entry not in sync according to current settings! -> do not set direction based on async status! - if (dbEntry && !stillInSync(dbEntry->second, cmpVar, fileTimeTolerance)) - linkObj.setSyncDirConflict(txtDbNotInSync); - else - linkObj.setSyncDir(changeOnLeft ? SyncDirection::RIGHT : SyncDirection::LEFT); - } - else - { - if (changeOnLeft) - linkObj.setSyncDirConflict(txtBothSidesChanged); - else - linkObj.setSyncDirConflict(txtNoSideChanged); - } - } - - void processDir(DirPair& dirObj, const InSyncDir* dbContainer) const - { - const CompareDirResult cat = dirObj.getDirCategory(); - - //########### schedule abandoned temporary recycle bin directory for deletion ########## - if (cat == DIR_LEFT_SIDE_ONLY && endsWith(dirObj.getShortName<LEFT_SIDE>(), TEMP_FILE_ENDING)) - return setSyncDirectionRec(SyncDirection::LEFT, dirObj); // - else if (cat == DIR_RIGHT_SIDE_ONLY && endsWith(dirObj.getShortName<RIGHT_SIDE>(), TEMP_FILE_ENDING)) - return setSyncDirectionRec(SyncDirection::RIGHT, dirObj); //don't recurse below! - //####################################################################################### - - //try to find corresponding database entry - const InSyncDir::DirList::value_type* dbEntry = nullptr; - if (dbContainer) - { - auto it = dbContainer->dirs.find(dirObj.getObjShortName()); - if (it != dbContainer->dirs.end()) - dbEntry = &*it; - } - - if (cat != DIR_EQUAL) - { - //evaluation - const bool changeOnLeft = !isEqual<LEFT_SIDE >(dirObj, dbEntry); - const bool changeOnRight = !isEqual<RIGHT_SIDE>(dirObj, dbEntry); - - if (changeOnLeft != changeOnRight) - { - //if database entry not in sync according to current settings! -> do not set direction based on async status! - if (dbEntry && !stillInSync(dbEntry->second)) - dirObj.setSyncDirConflict(txtDbNotInSync); - else - dirObj.setSyncDir(changeOnLeft ? SyncDirection::RIGHT : SyncDirection::LEFT); - } - else - { - if (changeOnLeft) - dirObj.setSyncDirConflict(txtBothSidesChanged); - else - dirObj.setSyncDirConflict(txtNoSideChanged); - } - } - - recurse(dirObj, dbEntry ? &dbEntry->second : nullptr); - } - - const std::wstring txtBothSidesChanged; - const std::wstring txtNoSideChanged; - const std::wstring txtDbNotInSync; - - const CompareVariant cmpVar; - const size_t fileTimeTolerance; -}; -} - -//--------------------------------------------------------------------------------------------------------------- - -std::vector<DirectionConfig> zen::extractDirectionCfg(const MainConfiguration& mainCfg) -{ - //merge first and additional pairs - std::vector<FolderPairEnh> allPairs; - allPairs.push_back(mainCfg.firstPair); - allPairs.insert(allPairs.end(), - mainCfg.additionalPairs.begin(), //add additional pairs - mainCfg.additionalPairs.end()); - - std::vector<DirectionConfig> output; - std::for_each(allPairs.begin(), allPairs.end(), - [&](const FolderPairEnh& fp) - { - output.push_back(fp.altSyncConfig.get() ? fp.altSyncConfig->directionCfg : mainCfg.syncCfg.directionCfg); - }); - - return output; -} - - -void zen::redetermineSyncDirection(const DirectionConfig& dirCfg, BaseDirPair& baseDirectory, std::function<void(const std::wstring&)> reportWarning) -{ - //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) - { - 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); -} - - -void zen::redetermineSyncDirection(const MainConfiguration& mainCfg, FolderComparison& folderCmp, std::function<void(const std::wstring&)> reportWarning) -{ - if (folderCmp.empty()) - return; - - std::vector<DirectionConfig> directCfgs = extractDirectionCfg(mainCfg); - - if (folderCmp.size() != directCfgs.size()) - throw std::logic_error("Programming Error: Contract violation! " + std::string(__FILE__) + ":" + numberTo<std::string>(__LINE__)); - - for (auto it = folderCmp.begin(); it != folderCmp.end(); ++it) - { - const DirectionConfig& cfg = directCfgs[it - folderCmp.begin()]; - redetermineSyncDirection(cfg, **it, reportWarning); - } -} - -//--------------------------------------------------------------------------------------------------------------- - -struct SetNewDirection -{ - static void execute(FilePair& fileObj, SyncDirection newDirection) - { - if (fileObj.getCategory() != FILE_EQUAL) - fileObj.setSyncDir(newDirection); - } - - static void execute(SymlinkPair& linkObj, SyncDirection newDirection) - { - if (linkObj.getLinkCategory() != SYMLINK_EQUAL) - linkObj.setSyncDir(newDirection); - } - - static void execute(DirPair& dirObj, SyncDirection newDirection) - { - if (dirObj.getDirCategory() != DIR_EQUAL) - 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); - } -}; - - -void zen::setSyncDirectionRec(SyncDirection newDirection, FileSystemObject& fsObj) -{ - //process subdirectories also! - struct Recurse: public FSObjectVisitor - { - Recurse(SyncDirection newDir) : newDir_(newDir) {} - virtual void visit(const FilePair& fileObj) - { - SetNewDirection::execute(const_cast<FilePair&>(fileObj), newDir_); //phyiscal object is not const in this method anyway - } - virtual void visit(const SymlinkPair& linkObj) - { - SetNewDirection::execute(const_cast<SymlinkPair&>(linkObj), newDir_); // - } - virtual void visit(const DirPair& dirObj) - { - SetNewDirection::execute(const_cast<DirPair&>(dirObj), newDir_); // - } - private: - SyncDirection newDir_; - } setDirVisitor(newDirection); - fsObj.accept(setDirVisitor); -} - -//--------------- functions related to filtering ------------------------------------------------------------------------------------ - -namespace -{ -template <bool include> -void inOrExcludeAllRows(zen::HierarchyObject& hierObj) -{ - for (FilePair& fileObj : hierObj.refSubFiles()) - fileObj.setActive(include); - for (SymlinkPair& linkObj : hierObj.refSubLinks()) - linkObj.setActive(include); - for (DirPair& dirObj : hierObj.refSubDirs()) - { - dirObj.setActive(include); - inOrExcludeAllRows<include>(dirObj); //recurse - } -} -} - - -void zen::setActiveStatus(bool newStatus, zen::FolderComparison& folderCmp) -{ - if (newStatus) - std::for_each(begin(folderCmp), end(folderCmp), [](BaseDirPair& baseDirObj) { inOrExcludeAllRows<true>(baseDirObj); }); //include all rows - else - std::for_each(begin(folderCmp), end(folderCmp), [](BaseDirPair& baseDirObj) { inOrExcludeAllRows<false>(baseDirObj); }); //exclude all rows -} - - -void zen::setActiveStatus(bool newStatus, zen::FileSystemObject& fsObj) -{ - fsObj.setActive(newStatus); - - //process subdirectories also! - struct Recurse: public FSObjectVisitor - { - Recurse(bool newStat) : newStatus_(newStat) {} - virtual void visit(const FilePair& fileObj) {} - virtual void visit(const SymlinkPair& linkObj) {} - virtual void visit(const DirPair& dirObj) - { - if (newStatus_) - inOrExcludeAllRows<true>(const_cast<DirPair&>(dirObj)); //object is not physically const here anyway - else - inOrExcludeAllRows<false>(const_cast<DirPair&>(dirObj)); // - } - private: - const bool newStatus_; - } recurse(newStatus); - fsObj.accept(recurse); -} - -namespace -{ -enum FilterStrategy -{ - STRATEGY_SET, - STRATEGY_AND, - STRATEGY_OR -}; - -template <FilterStrategy strategy> struct Eval; - -template <> -struct Eval<STRATEGY_SET> //process all elements -{ - template <class T> - bool process(const T& obj) const { return true; } -}; - -template <> -struct Eval<STRATEGY_AND> -{ - template <class T> - bool process(const T& obj) const { return obj.isActive(); } -}; - -template <> -struct Eval<STRATEGY_OR> -{ - template <class T> - bool process(const T& obj) const { return !obj.isActive(); } -}; - - -template <FilterStrategy strategy> -class ApplyHardFilter -{ -public: - static void execute(HierarchyObject& hierObj, const HardFilter& filterProcIn) { ApplyHardFilter(hierObj, filterProcIn); } - -private: - ApplyHardFilter(HierarchyObject& hierObj, const HardFilter& filterProcIn) : filterProc(filterProcIn) { recurse(hierObj); } - - void recurse(HierarchyObject& hierObj) const - { - for (FilePair& fileObj : hierObj.refSubFiles()) - processFile(fileObj); - for (SymlinkPair& linkObj : hierObj.refSubLinks()) - processLink(linkObj); - for (DirPair& dirObj : hierObj.refSubDirs()) - processDir(dirObj); - }; - - void processFile(FilePair& fileObj) const - { - if (Eval<strategy>().process(fileObj)) - fileObj.setActive(filterProc.passFileFilter(fileObj.getObjRelativeName())); - } - - void processLink(SymlinkPair& linkObj) const - { - if (Eval<strategy>().process(linkObj)) - linkObj.setActive(filterProc.passFileFilter(linkObj.getObjRelativeName())); - } - - void processDir(DirPair& dirObj) const - { - bool subObjMightMatch = true; - const bool filterPassed = filterProc.passDirFilter(dirObj.getObjRelativeName(), &subObjMightMatch); - - if (Eval<strategy>().process(dirObj)) - dirObj.setActive(filterPassed); - - if (!subObjMightMatch) //use same logic like directory traversing here: evaluate filter in subdirs only if objects could match - { - inOrExcludeAllRows<false>(dirObj); //exclude all files dirs in subfolders - return; - } - - recurse(dirObj); - } - - const HardFilter& filterProc; -}; - -template <> -class ApplyHardFilter<STRATEGY_OR>; //usage of InOrExcludeAllRows doesn't allow for strategy "or" - - -template <FilterStrategy strategy> -class ApplySoftFilter //falsify only! -> can run directly after "hard/base filter" -{ -public: - static void execute(HierarchyObject& hierObj, const SoftFilter& timeSizeFilter) { ApplySoftFilter(hierObj, timeSizeFilter); } - -private: - ApplySoftFilter(HierarchyObject& hierObj, const SoftFilter& timeSizeFilter) : timeSizeFilter_(timeSizeFilter) { recurse(hierObj); } - - void recurse(zen::HierarchyObject& hierObj) const - { - for (FilePair& fileObj : hierObj.refSubFiles()) - processFile(fileObj); - for (SymlinkPair& linkObj : hierObj.refSubLinks()) - processLink(linkObj); - for (DirPair& dirObj : hierObj.refSubDirs()) - processDir(dirObj); - }; - - void processFile(FilePair& fileObj) const - { - if (Eval<strategy>().process(fileObj)) - { - if (fileObj.isEmpty<LEFT_SIDE>()) - fileObj.setActive(matchSize<RIGHT_SIDE>(fileObj) && - matchTime<RIGHT_SIDE>(fileObj)); - else if (fileObj.isEmpty<RIGHT_SIDE>()) - fileObj.setActive(matchSize<LEFT_SIDE>(fileObj) && - matchTime<LEFT_SIDE>(fileObj)); - else - { - //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 - S |X|O|?|O| - ------------ X := include row - T |X|?|O|O| O := exclude row - ------------ ? := unclear - - |X|O|O|O| - ------------ - */ - //let's set ? := O - fileObj.setActive((matchSize<RIGHT_SIDE>(fileObj) && - matchTime<RIGHT_SIDE>(fileObj)) || - (matchSize<LEFT_SIDE>(fileObj) && - matchTime<LEFT_SIDE>(fileObj))); - } - } - } - - void processLink(SymlinkPair& linkObj) const - { - if (Eval<strategy>().process(linkObj)) - { - if (linkObj.isEmpty<LEFT_SIDE>()) - linkObj.setActive(matchTime<RIGHT_SIDE>(linkObj)); - else if (linkObj.isEmpty<RIGHT_SIDE>()) - linkObj.setActive(matchTime<LEFT_SIDE>(linkObj)); - else - linkObj.setActive(matchTime<RIGHT_SIDE>(linkObj) || - matchTime<LEFT_SIDE> (linkObj)); - } - } - - 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! - - recurse(dirObj); - } - - template <SelectedSide side, class T> - bool matchTime(const T& obj) const - { - return timeSizeFilter_.matchTime(obj.template getLastWriteTime<side>()); - } - - template <SelectedSide side, class T> - bool matchSize(const T& obj) const - { - return timeSizeFilter_.matchSize(obj.template getFileSize<side>()); - } - - const SoftFilter timeSizeFilter_; -}; -} - - -void zen::addHardFiltering(BaseDirPair& baseDirObj, const Zstring& excludeFilter) -{ - 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>::execute(baseDirObj, timeSizeFilter); -} - - -void zen::applyFiltering(FolderComparison& folderCmp, const MainConfiguration& mainCfg) -{ - if (folderCmp.empty()) - return; - else if (folderCmp.size() != mainCfg.additionalPairs.size() + 1) - throw std::logic_error("Programming Error: Contract violation! " + std::string(__FILE__) + ":" + numberTo<std::string>(__LINE__)); - - //merge first and additional pairs - std::vector<FolderPairEnh> allPairs; - allPairs.push_back(mainCfg.firstPair); - allPairs.insert(allPairs.end(), - mainCfg.additionalPairs.begin(), //add additional pairs - mainCfg.additionalPairs.end()); - - for (auto it = allPairs.begin(); it != allPairs.end(); ++it) - { - BaseDirPair& baseDirectory = *folderCmp[it - allPairs.begin()]; - - const NormalizedFilter normFilter = normalizeFilters(mainCfg.globalFilter, it->localFilter); - - //"set" hard filter - ApplyHardFilter<STRATEGY_SET>::execute(baseDirectory, *normFilter.nameFilter); - - //"and" soft filter - addSoftFiltering(baseDirectory, normFilter.timeSizeFilter); - } -} - - -class FilterByTimeSpan -{ -public: - 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) { recurse(hierObj); } - - void recurse(HierarchyObject& hierObj) const - { - for (FilePair& fileObj : hierObj.refSubFiles()) - processFile(fileObj); - for (SymlinkPair& linkObj : hierObj.refSubLinks()) - processLink(linkObj); - for (DirPair& dirObj : hierObj.refSubDirs()) - processDir(dirObj); - }; - - void processFile(FilePair& fileObj) const - { - if (fileObj.isEmpty<LEFT_SIDE>()) - fileObj.setActive(matchTime<RIGHT_SIDE>(fileObj)); - else if (fileObj.isEmpty<RIGHT_SIDE>()) - fileObj.setActive(matchTime<LEFT_SIDE>(fileObj)); - else - fileObj.setActive(matchTime<RIGHT_SIDE>(fileObj) || - matchTime<LEFT_SIDE>(fileObj)); - } - - void processLink(SymlinkPair& linkObj) const - { - if (linkObj.isEmpty<LEFT_SIDE>()) - linkObj.setActive(matchTime<RIGHT_SIDE>(linkObj)); - else if (linkObj.isEmpty<RIGHT_SIDE>()) - linkObj.setActive(matchTime<LEFT_SIDE>(linkObj)); - else - linkObj.setActive(matchTime<RIGHT_SIDE>(linkObj) || - matchTime<LEFT_SIDE> (linkObj)); - } - - void processDir(DirPair& dirObj) const - { - dirObj.setActive(false); - recurse(dirObj); - } - - template <SelectedSide side, class T> - bool matchTime(const T& obj) const - { - return timeFrom_ <= obj.template getLastWriteTime<side>() && - obj.template getLastWriteTime<side>() <= timeTo_; - } - - const Int64 timeFrom_; - const Int64 timeTo_; -}; - - -void zen::applyTimeSpanFilter(FolderComparison& folderCmp, const Int64& timeFrom, const Int64& timeTo) -{ - std::for_each(begin(folderCmp), end(folderCmp), [&](BaseDirPair& baseDirObj) { FilterByTimeSpan::execute(baseDirObj, timeFrom, timeTo); }); -} - - -//############################################################################################################ -std::pair<Zstring, int> zen::deleteFromGridAndHDPreview(const std::vector<FileSystemObject*>& selectionLeft, - const std::vector<FileSystemObject*>& selectionRight, - bool deleteOnBothSides) -{ - //don't use wxString here, it's linear allocation strategy would bring perf down to a crawl; Zstring: exponential growth! - Zstring fileList; - int totalDelCount = 0; - - if (deleteOnBothSides) - { - //mix selected rows from left and right (without changing order) - std::vector<FileSystemObject*> selection; - { - hash_set<FileSystemObject*> objectsUsed; - std::copy_if(selectionLeft .begin(), selectionLeft .end(), std::back_inserter(selection), [&](FileSystemObject* fsObj) { return objectsUsed.insert(fsObj).second; }); - std::copy_if(selectionRight.begin(), selectionRight.end(), std::back_inserter(selection), [&](FileSystemObject* fsObj) { return objectsUsed.insert(fsObj).second; }); - } - - std::for_each(selection.begin(), selection.end(), - [&](const FileSystemObject* fsObj) - { - if (!fsObj->isEmpty<LEFT_SIDE>()) - { - fileList += fsObj->getFullName<LEFT_SIDE>() + Zstr('\n'); - ++totalDelCount; - } - - if (!fsObj->isEmpty<RIGHT_SIDE>()) - { - fileList += fsObj->getFullName<RIGHT_SIDE>() + Zstr('\n'); - ++totalDelCount; - } - - fileList += Zstr('\n'); - }); - } - else //delete selected files only - { - std::for_each(selectionLeft.begin(), selectionLeft.end(), - [&](const FileSystemObject* fsObj) - { - if (!fsObj->isEmpty<LEFT_SIDE>()) - { - fileList += fsObj->getFullName<LEFT_SIDE>() + Zstr('\n'); - ++totalDelCount; - } - }); - - std::for_each(selectionRight.begin(), selectionRight.end(), - [&](const FileSystemObject* fsObj) - { - if (!fsObj->isEmpty<RIGHT_SIDE>()) - { - fileList += fsObj->getFullName<RIGHT_SIDE>() + Zstr('\n'); - ++totalDelCount; - } - }); - } - - return std::make_pair(fileList, totalDelCount); -} - - -namespace -{ -template <typename Function> inline -bool tryReportingError(Function cmd, DeleteFilesHandler& handler) //return "true" on success, "false" if error was ignored -{ - for (;;) - try - { - cmd(); //throw FileError - return true; - } - catch (FileError& error) - { - switch (handler.reportError(error.toString())) //may throw! - { - case DeleteFilesHandler::IGNORE_ERROR: - return false; - case DeleteFilesHandler::RETRY: - break; //continue with loop - default: - assert(false); - break; - } - } -} - -#ifdef ZEN_WIN -//recycleBinStatus() blocks seriously if recycle bin is really full and drive is slow -StatusRecycler recycleBinStatusUpdating(const Zstring& dirname, DeleteFilesHandler& callback) -{ - const std::wstring msg = replaceCpy(_("Checking recycle bin availability for folder %x..."), L"%x", fmtFileName(dirname), false); - - auto ft = async([=] { return recycleBinStatus(dirname); }); - while (!ft.timed_wait(boost::posix_time::milliseconds(UI_UPDATE_INTERVAL / 2))) - callback.reportStatus(msg); //may throw! - return ft.get(); -} -#endif - - -template <SelectedSide side> -void categorize(const std::set<FileSystemObject*>& rowsIn, - std::vector<FileSystemObject*>& deletePermanent, - std::vector<FileSystemObject*>& deleteRecyler, - bool useRecycleBin, - std::map<Zstring, bool, LessFilename>& hasRecyclerBuffer, - DeleteFilesHandler& callback) -{ - auto hasRecycler = [&](const FileSystemObject& fsObj) -> bool - { -#ifdef ZEN_WIN - const Zstring& baseDirPf = fsObj.root().getBaseDirPf<side>(); - - auto it = hasRecyclerBuffer.find(baseDirPf); - if (it != hasRecyclerBuffer.end()) - return it->second; - return hasRecyclerBuffer.insert(std::make_pair(baseDirPf, recycleBinStatusUpdating(baseDirPf, callback) == STATUS_REC_EXISTS)).first->second; -#elif defined ZEN_LINUX || defined ZEN_MAC - return true; -#endif - }; - - for (auto it = rowsIn.begin(); it != rowsIn.end(); ++it) - if (!(*it)->isEmpty<side>()) - { - if (useRecycleBin && hasRecycler(**it)) //Windows' ::SHFileOperation() will delete permanently anyway, but we have a superior deletion routine - deleteRecyler.push_back(*it); - else - deletePermanent.push_back(*it); - } -} - - -template <SelectedSide side> -struct ItemDeleter : public FSObjectVisitor //throw FileError, but nothrow constructor!!! -{ - ItemDeleter(bool useRecycleBin, DeleteFilesHandler& handler) : - handler_(handler), useRecycleBin_(useRecycleBin), remCallback(*this) - { - if (useRecycleBin_) - { - 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 - { - txtRemovingFile = _("Deleting file %x" ); - txtRemovingDirectory = _("Deleting folder %x" ); - txtRemovingSymlink = _("Deleting symbolic link %x"); - } - } - - virtual void visit(const FilePair& fileObj) - { - notifyFileDeletion(fileObj.getFullName<side>()); - - if (useRecycleBin_) - zen::recycleOrDelete(fileObj.getFullName<side>()); //throw FileError - else - zen::removeFile(fileObj.getFullName<side>()); //throw FileError - } - - virtual void visit(const SymlinkPair& linkObj) - { - notifySymlinkDeletion(linkObj.getFullName<side>()); - - if (useRecycleBin_) - zen::recycleOrDelete(linkObj.getFullName<side>()); //throw FileError - else - { - 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) - { - notifyDirectoryDeletion(dirObj.getFullName<side>()); //notfied twice! see RemoveCallbackImpl -> no big deal - - if (useRecycleBin_) - zen::recycleOrDelete(dirObj.getFullName<side>()); //throw FileError - else - zen::removeDirectory(dirObj.getFullName<side>(), &remCallback); //throw FileError - } - -private: - struct RemoveCallbackImpl : public zen::CallbackRemoveDir - { - RemoveCallbackImpl(ItemDeleter& itemDeleter) : itemDeleter_(itemDeleter) {} - - virtual void onBeforeFileDeletion(const Zstring& filename) { itemDeleter_.notifyFileDeletion (filename); } - virtual void onBeforeDirDeletion (const Zstring& dirname) { itemDeleter_.notifyDirectoryDeletion(dirname ); } - - private: - ItemDeleter& itemDeleter_; - }; - - void notifyFileDeletion (const Zstring& objName) { notifyItemDeletion(txtRemovingFile , objName); } - void notifyDirectoryDeletion(const Zstring& objName) { notifyItemDeletion(txtRemovingDirectory, objName); } - void notifySymlinkDeletion (const Zstring& objName) { notifyItemDeletion(txtRemovingSymlink , objName); } - - void notifyItemDeletion(const std::wstring& statusText, const Zstring& objName) - { - handler_.reportStatus(replaceCpy(statusText, L"%x", fmtFileName(objName))); - } - - DeleteFilesHandler& handler_; - const bool useRecycleBin_; - RemoveCallbackImpl remCallback; - - std::wstring txtRemovingFile; - std::wstring txtRemovingDirectory; - std::wstring txtRemovingSymlink; -}; - - -template <SelectedSide side> -void deleteFromGridAndHDOneSide(std::vector<FileSystemObject*>& ptrList, - bool useRecycleBin, - DeleteFilesHandler& handler) -{ - ItemDeleter<side> deleter(useRecycleBin, handler); - - for (auto it = ptrList.begin(); it != ptrList.end(); ++it) //VS 2010 bug prevents replacing this by std::for_each + lamba - { - FileSystemObject& fsObj = **it; //all pointers are required(!) to be bound - if (!fsObj.isEmpty<side>()) //element may be implicitly deleted, e.g. if parent folder was deleted first - tryReportingError([&] - { - fsObj.accept(deleter); //throw FileError - fsObj.removeObject<side>(); //if directory: removes recursively! - }, handler); - } -} -} - -void zen::deleteFromGridAndHD(const std::vector<FileSystemObject*>& rowsToDeleteOnLeft, //refresh GUI grid after deletion to remove invalid rows - const std::vector<FileSystemObject*>& rowsToDeleteOnRight, //all pointers need to be bound! - FolderComparison& folderCmp, //attention: rows will be physically deleted! - const std::vector<DirectionConfig>& directCfgs, - bool deleteOnBothSides, - bool useRecycleBin, - DeleteFilesHandler& statusHandler, - bool& warningRecyclerMissing) -{ - if (folderCmp.empty()) - return; - else if (folderCmp.size() != directCfgs.size()) - throw std::logic_error("Programming Error: Contract violation! " + std::string(__FILE__) + ":" + numberTo<std::string>(__LINE__)); - - //build up mapping from base directory to corresponding direction config - hash_map<const BaseDirPair*, DirectionConfig> baseDirCfgs; - for (auto it = folderCmp.begin(); it != folderCmp.end(); ++it) - baseDirCfgs[&** it] = directCfgs[it - folderCmp.begin()]; - - std::set<FileSystemObject*> deleteLeft (rowsToDeleteOnLeft .begin(), rowsToDeleteOnLeft .end()); - std::set<FileSystemObject*> deleteRight(rowsToDeleteOnRight.begin(), rowsToDeleteOnRight.end()); - if (deleteOnBothSides) - { - deleteLeft.insert(deleteRight.begin(), deleteRight.end()); - deleteRight = deleteLeft; - } - - set_remove_if(deleteLeft, [](const FileSystemObject* fsObj) { return fsObj->isEmpty<LEFT_SIDE >(); }); //still needed? - set_remove_if(deleteRight, [](const FileSystemObject* fsObj) { return fsObj->isEmpty<RIGHT_SIDE>(); }); // - - //ensure cleanup: redetermination of sync-directions and removal of invalid rows - auto updateDirection = [&]() - { - //update sync direction: we cannot do a full redetermination since the user may already have entered manual changes - std::set<FileSystemObject*> deletedTotal = deleteLeft; - deletedTotal.insert(deleteRight.begin(), deleteRight.end()); - - for (auto it = deletedTotal.begin(); it != deletedTotal.end(); ++it) - { - FileSystemObject& fsObj = **it; //all pointers are required(!) to be bound - - if (fsObj.isEmpty<LEFT_SIDE>() != fsObj.isEmpty<RIGHT_SIDE>()) //make sure objects exists on one side only - { - auto cfgIter = baseDirCfgs.find(&fsObj.root()); - if (cfgIter != baseDirCfgs.end()) - { - SyncDirection newDir = SyncDirection::NONE; - - if (cfgIter->second.var == DirectionConfig::TWOWAY) - newDir = fsObj.isEmpty<LEFT_SIDE>() ? SyncDirection::RIGHT : SyncDirection::LEFT; - else - { - const DirectionSet& dirCfg = extractDirections(cfgIter->second); - newDir = fsObj.isEmpty<LEFT_SIDE>() ? dirCfg.exRightSideOnly : dirCfg.exLeftSideOnly; - } - - setSyncDirectionRec(newDir, fsObj); //set new direction (recursively) - } - else - assert(!"this should not happen!"); - } - } - - //last step: cleanup empty rows: this one invalidates all pointers! - std::for_each(begin(folderCmp), end(folderCmp), BaseDirPair::removeEmpty); - }; - ZEN_ON_SCOPE_EXIT(updateDirection()); //MSVC: assert is a macro and it doesn't play nice with ZEN_ON_SCOPE_EXIT, surprise... wasn't there something about macros being "evil"? - - //categorize rows into permanent deletion and recycle bin - std::vector<FileSystemObject*> deletePermanentLeft; - std::vector<FileSystemObject*> deletePermanentRight; - std::vector<FileSystemObject*> deleteRecylerLeft; - std::vector<FileSystemObject*> deleteRecylerRight; - - std::map<Zstring, bool, LessFilename> hasRecyclerBuffer; - categorize<LEFT_SIDE >(deleteLeft, deletePermanentLeft, deleteRecylerLeft, useRecycleBin, hasRecyclerBuffer, statusHandler); - categorize<RIGHT_SIDE>(deleteRight, deletePermanentRight, deleteRecylerRight, useRecycleBin, hasRecyclerBuffer, statusHandler); - - //windows: check if recycle bin really exists; if not, Windows will silently delete, which is wrong - 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"; - - for (auto it = hasRecyclerBuffer.begin(); it != hasRecyclerBuffer.end(); ++it) - if (!it->second) - msg += std::wstring(L"\n") + it->first; - - statusHandler.reportWarning(msg, warningRecyclerMissing); - } - - deleteFromGridAndHDOneSide<LEFT_SIDE>(deleteRecylerLeft, true, statusHandler); - deleteFromGridAndHDOneSide<LEFT_SIDE>(deletePermanentLeft, false, statusHandler); - - deleteFromGridAndHDOneSide<RIGHT_SIDE>(deleteRecylerRight, true, statusHandler); - deleteFromGridAndHDOneSide<RIGHT_SIDE>(deletePermanentRight, false, statusHandler); -} |