diff options
Diffstat (limited to 'lib/db_file.cpp')
| -rw-r--r-- | lib/db_file.cpp | 260 |
1 files changed, 133 insertions, 127 deletions
diff --git a/lib/db_file.cpp b/lib/db_file.cpp index e4e3d748..2f699e3a 100644 --- a/lib/db_file.cpp +++ b/lib/db_file.cpp @@ -12,7 +12,7 @@ #include <zen/serialize.h> #include <wx+/zlib_wrap.h> -#ifdef FFS_WIN +#ifdef ZEN_WIN #include <zen/win.h> //includes "windows.h" #include <zen/long_path_prefix.h> #endif @@ -25,6 +25,11 @@ namespace //------------------------------------------------------------------------------------------------------------------------------- const char FILE_FORMAT_DESCR[] = "FreeFileSync"; const int DB_FILE_FORMAT_VER = 9; + +warn_static("wee need two version ids!") +//const int DB_FILE_FORMAT_CONTAINER = 10; +//const int DB_FILE_FORMAT_STREAM = 1; + //------------------------------------------------------------------------------------------------------------------------------- typedef std::string UniqueId; @@ -34,22 +39,21 @@ typedef std::map<UniqueId, BinaryStream> StreamMapping; //list of streams ordere //| ensure 32/64 bit portability: use fixed size data types only e.g. std::uint32_t | //----------------------------------------------------------------------------------- - template <SelectedSide side> inline -Zstring getDBFilename(const BaseDirMapping& baseMap, bool tempfile = false) +Zstring getDBFilename(const BaseDirPair& baseDirObj, bool tempfile = false) { //Linux and Windows builds are binary incompatible: different file id?, problem with case sensitivity? are UTC file times really compatible? //what about endianess!? //however 32 and 64 bit db files *are* designed to be binary compatible! //Give db files different names. //make sure they end with ".ffs_db". These files will be excluded from comparison -#ifdef FFS_WIN +#ifdef ZEN_WIN Zstring dbname = Zstring(Zstr("sync")) + (tempfile ? Zstr(".tmp") : Zstr("")) + SYNC_DB_FILE_ENDING; -#elif defined FFS_LINUX || defined FFS_MAC +#elif defined ZEN_LINUX || defined ZEN_MAC //files beginning with dots are hidden e.g. in Nautilus Zstring dbname = Zstring(Zstr(".sync")) + (tempfile ? Zstr(".tmp") : Zstr("")) + SYNC_DB_FILE_ENDING; #endif - return baseMap.getBaseDirPf<side>() + dbname; + return baseDirObj.getBaseDirPf<side>() + dbname; } //####################################################################################################################################### @@ -76,7 +80,7 @@ void saveStreams(const StreamMapping& streamList, const Zstring& filename) //thr assert(!somethingExists(filename)); //orphan tmp files should be cleaned up already at this point! saveBinStream(filename, streamOut.get()); //throw FileError -#ifdef FFS_WIN +#ifdef ZEN_WIN //be careful to avoid CreateFile() + CREATE_ALWAYS on a hidden file -> see file_io.cpp ::SetFileAttributes(applyLongPathPrefix(filename).c_str(), FILE_ATTRIBUTE_HIDDEN); //(try to) hide database file #endif @@ -125,8 +129,8 @@ StreamMapping loadStreams(const Zstring& filename) //throw FileError, FileErrorD } catch (const std::bad_alloc& e) //still required? { - throw FileError(_("Database file is corrupt:") + L"\n" + fmtFileName(filename) + L"\n\n" + - _("Out of memory!") + L" " + utfCvrtTo<std::wstring>(e.what())); + throw FileError(_("Database file is corrupt:") + L"\n" + fmtFileName(filename), + _("Out of memory.") + L" " + utfCvrtTo<std::wstring>(e.what())); } } @@ -167,7 +171,7 @@ public: } catch (ZlibInternalError&) { - throw FileError(replaceCpy(_("Cannot write file %x."), L"%x", fmtFileName(filename)) + L" (zlib error)"); + throw FileError(replaceCpy(_("Cannot write file %x."), L"%x", fmtFileName(filename)), L"zlib internal error"); } }; @@ -201,31 +205,31 @@ public: private: void recurse(const InSyncDir& container) { - // for (const auto& filePair : container.files) { processFile(filePair); }); ! + // for (const auto& dbFile : container.files) { processFile(dbFile); }); ! writeNumber<std::uint32_t>(outputBoth, static_cast<std::uint32_t>(container.files.size())); - std::for_each(container.files.begin(), container.files.end(), [&](const std::pair<Zstring, InSyncFile>& filePair) { this->process(filePair); }); + std::for_each(container.files.begin(), container.files.end(), [&](const std::pair<Zstring, InSyncFile>& dbFile) { this->process(dbFile); }); writeNumber<std::uint32_t>(outputBoth, static_cast<std::uint32_t>(container.symlinks.size())); - std::for_each(container.symlinks.begin(), container.symlinks.end(), [&](const std::pair<Zstring, InSyncSymlink>& symlinkPair) { this->process(symlinkPair); }); + std::for_each(container.symlinks.begin(), container.symlinks.end(), [&](const std::pair<Zstring, InSyncSymlink>& dbSymlink) { this->process(dbSymlink); }); writeNumber<std::uint32_t>(outputBoth, static_cast<std::uint32_t>(container.dirs.size())); - std::for_each(container.dirs.begin(), container.dirs.end(), [&](const std::pair<Zstring, InSyncDir>& dirPair) { this->process(dirPair); }); + std::for_each(container.dirs.begin(), container.dirs.end(), [&](const std::pair<Zstring, InSyncDir>& dbDir) { this->process(dbDir); }); } static void writeUtf8(BinStreamOut& output, const Zstring& str) { writeContainer(output, utfCvrtTo<Zbase<char>>(str)); } - static void write(BinStreamOut& output, const FileDescriptor& descr) + static void writeFile(BinStreamOut& output, const InSyncDescrFile& descr, const UInt64& fileSize) { writeNumber<std:: int64_t>(output, to<std:: int64_t>(descr.lastWriteTimeRaw)); - writeNumber<std::uint64_t>(output, to<std::uint64_t>(descr.fileSize)); - writeNumber<std::uint64_t>(output, descr.devId); - writeNumber<std::uint64_t>(output, descr.fileIdx); - assert_static(sizeof(descr.devId ) <= sizeof(std::uint64_t)); - assert_static(sizeof(descr.fileIdx) <= sizeof(std::uint64_t)); + writeNumber<std::uint64_t>(output, to<std::uint64_t>(fileSize)); + writeNumber<std::uint64_t>(output, descr.fileId.first); + writeNumber<std::uint64_t>(output, descr.fileId.second); + assert_static(sizeof(descr.fileId.first ) <= sizeof(std::uint64_t)); + assert_static(sizeof(descr.fileId.second) <= sizeof(std::uint64_t)); } - static void write(BinStreamOut& output, const LinkDescriptor& descr) + static void writeLink(BinStreamOut& output, const InSyncDescrLink& descr) { writeNumber<std::int64_t>(output, to<std:: int64_t>(descr.lastWriteTimeRaw)); @@ -236,37 +240,39 @@ private: writeNumber<std::int32_t>(output, 0); } - static void write(BinStreamOut& output, const InSyncDir::InSyncStatus& status) + static void writeDir(BinStreamOut& output, const InSyncDir::InSyncStatus& status) { writeNumber<std::int32_t>(output, status); } - void process(const std::pair<Zstring, InSyncFile>& filePair) + void process(const std::pair<Zstring, InSyncFile>& dbFile) { - writeUtf8(outputBoth, filePair.first); - writeNumber<std::int32_t>(outputBoth, filePair.second.inSyncType); + writeUtf8(outputBoth, dbFile.first); + writeNumber<std::int32_t>(outputBoth, dbFile.second.inSyncType); - write(outputLeft, filePair.second.left); - write(outputRight, filePair.second.right); + warn_static("implement proper migration: get rid of duplicate fileSize!") + + writeFile(outputLeft, dbFile.second.left, dbFile.second.fileSize); + writeFile(outputRight, dbFile.second.right, dbFile.second.fileSize); } - void process(const std::pair<Zstring, InSyncSymlink>& symlinkPair) + void process(const std::pair<Zstring, InSyncSymlink>& dbSymlink) { - writeUtf8(outputBoth, symlinkPair.first); + writeUtf8(outputBoth, dbSymlink.first); warn_static("new parameter: imp proper migration!") - //writeNumber<std::int32_t>(outputBoth, symlinkPair.second.inSyncType); + //writeNumber<std::int32_t>(outputBoth, dbSymlink.second.inSyncType); - write(outputLeft, symlinkPair.second.left); - write(outputRight, symlinkPair.second.right); + writeLink(outputLeft, dbSymlink.second.left); + writeLink(outputRight, dbSymlink.second.right); } - void process(const std::pair<Zstring, InSyncDir>& dirPair) + void process(const std::pair<Zstring, InSyncDir>& dbDir) { - writeUtf8(outputBoth, dirPair.first); - write(outputBoth, dirPair.second.status); + writeUtf8(outputBoth, dbDir.first); + writeDir(outputBoth, dbDir.second.status); - recurse(dirPair.second); + recurse(dbDir.second); } BinStreamOut outputLeft; //data related to one side only @@ -291,7 +297,7 @@ public: } catch (ZlibInternalError&) { - throw FileError(replaceCpy(_("Cannot read file %x."), L"%x", fmtFileName(filename)) + L" (zlib error)"); + throw FileError(replaceCpy(_("Cannot read file %x."), L"%x", fmtFileName(filename)), L"zlib internal error"); } }; @@ -319,11 +325,11 @@ public: const BinaryStream tmpL = readContainer<BinaryStream>(inL); const BinaryStream tmpR = readContainer<BinaryStream>(inR); - auto output = std::make_shared<InSyncDir>(InSyncDir::STATUS_IN_SYNC); - StreamParser(decompStream(tmpL, filenameL), - decompStream(tmpR, filenameR), - decompStream(tmpB, filenameL + Zstr("/") + filenameR), - *output); //throw UnexpectedEndOfStreamError + auto output = std::make_shared<InSyncDir>(InSyncDir::DIR_STATUS_IN_SYNC); + StreamParser parser(decompStream(tmpL, filenameL), + decompStream(tmpR, filenameR), + decompStream(tmpB, filenameL + Zstr("/") + filenameR)); + parser.recurse(*output); //throw UnexpectedEndOfStreamError return output; } catch (const UnexpectedEndOfStreamError&) @@ -332,43 +338,46 @@ public: } catch (const std::bad_alloc& e) //still required? { - throw FileError(_("Database file is corrupt:") + L"\n" + fmtFileName(filenameL) + L"\n" + fmtFileName(filenameR) + L"\n\n" + - _("Out of memory!") + L" " + utfCvrtTo<std::wstring>(e.what())); + throw FileError(_("Database file is corrupt:") + L"\n" + fmtFileName(filenameL) + L"\n" + fmtFileName(filenameR), + _("Out of memory.") + L" " + utfCvrtTo<std::wstring>(e.what())); } } private: StreamParser(const BinaryStream& bufferL, const BinaryStream& bufferR, - const BinaryStream& bufferB, - InSyncDir& container) : + const BinaryStream& bufferB) : inputLeft (bufferL), inputRight(bufferR), - inputBoth (bufferB) { recurse(container); } + inputBoth (bufferB) {} static Zstring readUtf8(BinStreamIn& input) { return utfCvrtTo<Zstring>(readContainer<Zbase<char>>(input)); } //throw UnexpectedEndOfStreamError - static void read(BinStreamIn& input, FileDescriptor& descr) + static InSyncDescrFile readFile(BinStreamIn& input, UInt64& fileSize) { //attention: order of function argument evaluation is undefined! So do it one after the other... - descr.lastWriteTimeRaw = readNumber<std::int64_t>(input); //throw UnexpectedEndOfStreamError - descr.fileSize = readNumber<std::uint64_t>(input); - descr.devId = static_cast<DeviceId >(readNumber<std::uint64_t>(input)); // - descr.fileIdx = static_cast<FileIndex>(readNumber<std::uint64_t>(input)); //silence "loss of precision" compiler warnings + auto lastWriteTimeRaw = readNumber<std::int64_t>(input); //throw UnexpectedEndOfStreamError + warn_static("implement proper migration!") + fileSize = readNumber<std::uint64_t>(input); + auto devId = static_cast<DeviceId >(readNumber<std::uint64_t>(input)); // + auto fileIdx = static_cast<FileIndex>(readNumber<std::uint64_t>(input)); //silence "loss of precision" compiler warnings + return InSyncDescrFile(lastWriteTimeRaw, FileId(devId, fileIdx)); } - static void read(BinStreamIn& input, LinkDescriptor& descr) + static InSyncDescrLink readLink(BinStreamIn& input) { - descr.lastWriteTimeRaw = readNumber<std::int64_t>(input); + auto lastWriteTimeRaw = readNumber<std::int64_t>(input); warn_static("implement proper migration!") //descr.targetPath = readUtf8(input); readUtf8(input); //descr.type = static_cast<LinkDescriptor::LinkType>(readNumber<std::int32_t>(input)); readNumber<std::int32_t>(input); + + return InSyncDescrLink(lastWriteTimeRaw); } - static void read(BinStreamIn& input, InSyncDir::InSyncStatus& status) + static void readDir(BinStreamIn& input, InSyncDir::InSyncStatus& status) { status = static_cast<InSyncDir::InSyncStatus>(readNumber<std::int32_t>(input)); } @@ -378,15 +387,16 @@ private: size_t fileCount = readNumber<std::uint32_t>(inputBoth); while (fileCount-- != 0) { + warn_static("migrate from InSyncType to CompareVariant!!!") const Zstring shortName = readUtf8(inputBoth); const auto inSyncType = static_cast<InSyncType>(readNumber<std::int32_t>(inputBoth)); - FileDescriptor dataL; - FileDescriptor dataR; - read(inputLeft, dataL); - read(inputRight, dataR); + warn_static("implement proper migration: get rid of duplicate fileSize!") - container.addFile(shortName, dataL, dataR, inSyncType); + UInt64 fileSize; + const InSyncDescrFile dataL = readFile(inputLeft, fileSize); + const InSyncDescrFile dataR = readFile(inputRight, fileSize); + container.addFile(shortName, dataL, dataR, inSyncType, fileSize); } size_t linkCount = readNumber<std::uint32_t>(inputBoth); @@ -395,14 +405,11 @@ private: const Zstring shortName = readUtf8(inputBoth); warn_static("new parameter: imp proper migration!") - const auto inSyncType = IN_SYNC_BINARY_EQUAL; + const auto inSyncType = IN_SYNC_BINARY_EQUAL; //const auto inSyncType = static_cast<InSyncType>(readNumber<std::int32_t>(inputBoth)); - LinkDescriptor dataL; - LinkDescriptor dataR; - read(inputLeft, dataL); - read(inputRight, dataR); - + InSyncDescrLink dataL = readLink(inputLeft); + InSyncDescrLink dataR = readLink(inputRight); container.addSymlink(shortName, dataL, dataR, inSyncType); } @@ -411,8 +418,8 @@ private: { const Zstring shortName = readUtf8(inputBoth); - InSyncDir::InSyncStatus status = InSyncDir::STATUS_STRAW_MAN; - read(inputBoth, status); + InSyncDir::InSyncStatus status = InSyncDir::DIR_STATUS_STRAW_MAN; + readDir(inputBoth, status); InSyncDir& subDir = container.addDir(shortName, status); recurse(subDir); @@ -435,10 +442,10 @@ class UpdateLastSynchronousState => update all database entries! */ public: - static void execute(const BaseDirMapping& baseMapping, InSyncDir& dir) + static void execute(const BaseDirPair& baseDirObj, InSyncDir& dir) { bool binaryComparison = false; - switch (baseMapping.getCompVariant()) + switch (baseDirObj.getCompVariant()) { case CMP_BY_TIME_SIZE: break; @@ -447,8 +454,8 @@ public: break; } - UpdateLastSynchronousState updater(baseMapping.getFilter(), binaryComparison); - updater.recurse(baseMapping, dir); + UpdateLastSynchronousState updater(baseDirObj.getFilter(), binaryComparison); + updater.recurse(baseDirObj, dir); } private: @@ -469,7 +476,7 @@ private: auto rv = map.insert(typename M::value_type(key, value)); if (!rv.second) { -#if defined FFS_WIN || defined FFS_MAC //caveat: key must be updated, if there is a change in short name case!!! +#if defined ZEN_WIN || defined ZEN_MAC //caveat: key must be updated, if there is a change in short name case!!! if (rv.first->first != key) { map.erase(rv.first); @@ -490,7 +497,7 @@ private: auto it = map.lower_bound(key); if (it != map.end() && !(map.key_comp()(key, it->first))) { - #if defined FFS_WIN || defined FFS_MAC //caveat: key might need to be updated, too, if there is a change in short name case!!! + #if defined ZEN_WIN || defined ZEN_MAC //caveat: key might need to be updated, too, if there is a change in short name case!!! if (it->first != key) { map.erase(it); //don't fiddle with decrementing "it"! - you might lose while optimizing pointlessly @@ -507,38 +514,40 @@ private: void process(const HierarchyObject::SubFileVec& currentFiles, const Zstring& parentRelativeNamePf, InSyncDir::FileList& dbFiles) { hash_set<const InSyncFile*> toPreserve; //referencing fixed-in-memory std::map elements - std::for_each(currentFiles.begin(), currentFiles.end(), [&](const FileMapping& fileMap) + std::for_each(currentFiles.begin(), currentFiles.end(), [&](const FilePair& fileObj) { - if (!fileMap.isEmpty()) + if (!fileObj.isEmpty()) { - if (fileMap.getCategory() == FILE_EQUAL) //data in sync: write current state + if (fileObj.getCategory() == FILE_EQUAL) //data in sync: write current state { //Caveat: If FILE_EQUAL, we *implicitly* assume equal left and right short names matching case: InSyncDir's mapping tables use short name as a key! //This makes us silently dependent from code in algorithm.h!!! - assert(fileMap.getShortName<LEFT_SIDE>() == fileMap.getShortName<RIGHT_SIDE>()); + assert(fileObj.getShortName<LEFT_SIDE>() == fileObj.getShortName<RIGHT_SIDE>()); + //this should be taken for granted: + assert(fileObj.getFileSize<LEFT_SIDE>() == fileObj.getFileSize<RIGHT_SIDE>()); //create or update new "in-sync" state - InSyncFile& file = updateItem(dbFiles, fileMap.getObjShortName(), - InSyncFile(FileDescriptor(fileMap.getLastWriteTime<LEFT_SIDE>(), - fileMap.getFileSize <LEFT_SIDE>(), - fileMap.getFileId <LEFT_SIDE>()), - FileDescriptor(fileMap.getLastWriteTime<RIGHT_SIDE>(), - fileMap.getFileSize <RIGHT_SIDE>(), - fileMap.getFileId <RIGHT_SIDE>()), + InSyncFile& file = updateItem(dbFiles, fileObj.getObjShortName(), + InSyncFile(InSyncDescrFile(fileObj.getLastWriteTime<LEFT_SIDE>(), + fileObj.getFileId <LEFT_SIDE>()), + InSyncDescrFile(fileObj.getLastWriteTime<RIGHT_SIDE>(), + fileObj.getFileId <RIGHT_SIDE>()), binaryComparison_ ? IN_SYNC_BINARY_EQUAL : - IN_SYNC_ATTRIBUTES_EQUAL)); + IN_SYNC_ATTRIBUTES_EQUAL, + fileObj.getFileSize<LEFT_SIDE>())); toPreserve.insert(&file); } else //not in sync: preserve last synchronous state { - auto it = dbFiles.find(fileMap.getObjShortName()); + auto it = dbFiles.find(fileObj.getObjShortName()); if (it != dbFiles.end()) toPreserve.insert(&it->second); } } }); + warn_static("consider temporarily excluded items due to traveral error just like a fixed file filter here!?") //delete removed items (= "in-sync") from database map_remove_if(dbFiles, [&](const InSyncDir::FileList::value_type& v) -> bool { @@ -553,18 +562,18 @@ private: void process(const HierarchyObject::SubLinkVec& currentLinks, const Zstring& parentRelativeNamePf, InSyncDir::LinkList& dbLinks) { hash_set<const InSyncSymlink*> toPreserve; - std::for_each(currentLinks.begin(), currentLinks.end(), [&](const SymLinkMapping& linkMap) + std::for_each(currentLinks.begin(), currentLinks.end(), [&](const SymlinkPair& linkObj) { - if (!linkMap.isEmpty()) + if (!linkObj.isEmpty()) { - if (linkMap.getLinkCategory() == SYMLINK_EQUAL) //data in sync: write current state + if (linkObj.getLinkCategory() == SYMLINK_EQUAL) //data in sync: write current state { - assert(linkMap.getShortName<LEFT_SIDE>() == linkMap.getShortName<RIGHT_SIDE>()); + assert(linkObj.getShortName<LEFT_SIDE>() == linkObj.getShortName<RIGHT_SIDE>()); //create or update new "in-sync" state - InSyncSymlink& link = updateItem(dbLinks, linkMap.getObjShortName(), - InSyncSymlink(LinkDescriptor(linkMap.getLastWriteTime<LEFT_SIDE>()), - LinkDescriptor(linkMap.getLastWriteTime<RIGHT_SIDE>()), + InSyncSymlink& link = updateItem(dbLinks, linkObj.getObjShortName(), + InSyncSymlink(InSyncDescrLink(linkObj.getLastWriteTime<LEFT_SIDE>()), + InSyncDescrLink(linkObj.getLastWriteTime<RIGHT_SIDE>()), binaryComparison_ ? IN_SYNC_BINARY_EQUAL : IN_SYNC_ATTRIBUTES_EQUAL)); @@ -572,7 +581,7 @@ private: } else //not in sync: preserve last synchronous state { - auto it = dbLinks.find(linkMap.getObjShortName()); + auto it = dbLinks.find(linkObj.getObjShortName()); if (it != dbLinks.end()) toPreserve.insert(&it->second); } @@ -593,22 +602,21 @@ private: void process(const HierarchyObject::SubDirVec& currentDirs, const Zstring& parentRelativeNamePf, InSyncDir::DirList& dbDirs) { hash_set<const InSyncDir*> toPreserve; - std::for_each(currentDirs.begin(), currentDirs.end(), [&](const DirMapping& dirMap) + std::for_each(currentDirs.begin(), currentDirs.end(), [&](const DirPair& dirObj) { - if (!dirMap.isEmpty()) - { - switch (dirMap.getDirCategory()) + if (!dirObj.isEmpty()) + switch (dirObj.getDirCategory()) { case DIR_EQUAL: { - assert(dirMap.getShortName<LEFT_SIDE>() == dirMap.getShortName<RIGHT_SIDE>()); + assert(dirObj.getShortName<LEFT_SIDE>() == dirObj.getShortName<RIGHT_SIDE>()); //update directory entry only (shallow), but do *not touch* exising child elements!!! - const Zstring& key = dirMap.getObjShortName(); - auto insertResult = dbDirs.insert(std::make_pair(key, InSyncDir(InSyncDir::STATUS_IN_SYNC))); //get or create + const Zstring& key = dirObj.getObjShortName(); + auto insertResult = dbDirs.insert(std::make_pair(key, InSyncDir(InSyncDir::DIR_STATUS_IN_SYNC))); //get or create auto it = insertResult.first; -#if defined FFS_WIN || defined FFS_MAC //caveat: key might need to be updated, too, if there is a change in short name case!!! +#if defined ZEN_WIN || defined ZEN_MAC //caveat: key might need to be updated, too, if there is a change in short name case!!! const bool alreadyExisting = !insertResult.second; if (alreadyExisting && it->first != key) { @@ -618,9 +626,9 @@ private: } #endif InSyncDir& dir = it->second; - dir.status = InSyncDir::STATUS_IN_SYNC; //update immediate directory entry + dir.status = InSyncDir::DIR_STATUS_IN_SYNC; //update immediate directory entry toPreserve.insert(&dir); - recurse(dirMap, dir); + recurse(dirObj, dir); } break; @@ -630,9 +638,9 @@ private: //Example: directories on left and right differ in case while sub-files are equal { //reuse last "in-sync" if available or insert strawman entry (do not try to update thereby removing child elements!!!) - InSyncDir& dir = dbDirs.insert(std::make_pair(dirMap.getObjShortName(), InSyncDir(InSyncDir::STATUS_STRAW_MAN))).first->second; + InSyncDir& dir = dbDirs.insert(std::make_pair(dirObj.getObjShortName(), InSyncDir(InSyncDir::DIR_STATUS_STRAW_MAN))).first->second; toPreserve.insert(&dir); - recurse(dirMap, dir); + recurse(dirObj, dir); } break; @@ -640,16 +648,15 @@ private: case DIR_LEFT_SIDE_ONLY: case DIR_RIGHT_SIDE_ONLY: { - auto it = dbDirs.find(dirMap.getObjShortName()); + auto it = dbDirs.find(dirObj.getObjShortName()); if (it != dbDirs.end()) { toPreserve.insert(&it->second); - recurse(dirMap, it->second); //although existing sub-items cannot be in sync, items deleted on both sides *are* in-sync!!! + recurse(dirObj, it->second); //although existing sub-items cannot be in sync, items deleted on both sides *are* in-sync!!! } } break; } - } }); //delete removed items (= "in-sync") from database @@ -657,13 +664,12 @@ private: { if (toPreserve.find(&v.second) != toPreserve.end()) return false; - //all items not existing in "currentDirs" have either been deleted meanwhile or been excluded via filter: const Zstring& shortName = v.first; return filter_.passDirFilter(parentRelativeNamePf + shortName, nullptr); //if directory is not included in "currentDirs", it is either not existing anymore, in which case it should be deleted from database - //or it was excluded via filter, in which case the database entry should be preserved - //-> we can't tell and need to preserve the old db entry -> all child db elements are preserved since they are not recursed in the loop above!!! - //-> no problem with filter logic of excluding complete directory subtrees, if top folder is excluded directly! + //or it was excluded via filter, in which case the database entry should be preserved: + //=> all child db elements are also preserved since they are not recursed in the loop above!!! + //=> no problem with filter logic of excluding complete directory subtrees, if top folder is excluded directly! }); } @@ -674,17 +680,17 @@ private: //####################################################################################################################################### -std::shared_ptr<InSyncDir> zen::loadLastSynchronousState(const BaseDirMapping& baseMapping) //throw FileError, FileErrorDatabaseNotExisting -> return value always bound! +std::shared_ptr<InSyncDir> zen::loadLastSynchronousState(const BaseDirPair& baseDirObj) //throw FileError, FileErrorDatabaseNotExisting -> return value always bound! { - const Zstring fileNameLeft = getDBFilename<LEFT_SIDE >(baseMapping); - const Zstring fileNameRight = getDBFilename<RIGHT_SIDE>(baseMapping); + const Zstring fileNameLeft = getDBFilename<LEFT_SIDE >(baseDirObj); + const Zstring fileNameRight = getDBFilename<RIGHT_SIDE>(baseDirObj); - if (!baseMapping.isExisting<LEFT_SIDE >() || - !baseMapping.isExisting<RIGHT_SIDE>()) + if (!baseDirObj.isExisting<LEFT_SIDE >() || + !baseDirObj.isExisting<RIGHT_SIDE>()) { //avoid race condition with directory existence check: reading sync.ffs_db may succeed although first dir check had failed => conflicts! //https://sourceforge.net/tracker/?func=detail&atid=1093080&aid=3531351&group_id=234430 - const Zstring filename = !baseMapping.isExisting<LEFT_SIDE>() ? fileNameLeft : fileNameRight; + const Zstring filename = !baseDirObj.isExisting<LEFT_SIDE>() ? fileNameLeft : fileNameRight; throw FileErrorDatabaseNotExisting(_("Initial synchronization:") + L" \n" + //it could be due to a to-be-created target directory not yet existing => FileErrorDatabaseNotExisting replaceCpy(_("Database file %x does not yet exist."), L"%x", fmtFileName(filename))); } @@ -710,14 +716,14 @@ std::shared_ptr<InSyncDir> zen::loadLastSynchronousState(const BaseDirMapping& b } -void zen::saveLastSynchronousState(const BaseDirMapping& baseMapping) //throw FileError +void zen::saveLastSynchronousState(const BaseDirPair& baseDirObj) //throw FileError { //transactional behaviour! write to tmp files first - const Zstring dbNameLeftTmp = getDBFilename<LEFT_SIDE >(baseMapping, true); - const Zstring dbNameRightTmp = getDBFilename<RIGHT_SIDE>(baseMapping, true); + const Zstring dbNameLeftTmp = getDBFilename<LEFT_SIDE >(baseDirObj, true); + const Zstring dbNameRightTmp = getDBFilename<RIGHT_SIDE>(baseDirObj, true); - const Zstring dbNameLeft = getDBFilename<LEFT_SIDE >(baseMapping); - const Zstring dbNameRight = getDBFilename<RIGHT_SIDE>(baseMapping); + const Zstring dbNameLeft = getDBFilename<LEFT_SIDE >(baseDirObj); + const Zstring dbNameRight = getDBFilename<RIGHT_SIDE>(baseDirObj); //delete old tmp file, if necessary -> throws if deletion fails! removeFile(dbNameLeftTmp); // @@ -749,7 +755,7 @@ void zen::saveLastSynchronousState(const BaseDirMapping& baseMapping) //throw Fi } //load last synchrounous state - std::shared_ptr<InSyncDir> lastSyncState = std::make_shared<InSyncDir>(InSyncDir::STATUS_IN_SYNC); + std::shared_ptr<InSyncDir> lastSyncState = std::make_shared<InSyncDir>(InSyncDir::DIR_STATUS_IN_SYNC); if (streamIterLeftOld != streamListLeft .end() && streamIterRightOld != streamListRight.end()) try @@ -762,7 +768,7 @@ void zen::saveLastSynchronousState(const BaseDirMapping& baseMapping) //throw Fi catch (FileError&) {} //if error occurs: just overwrite old file! User is already informed about issues right after comparing! //update last synchrounous state - UpdateLastSynchronousState::execute(baseMapping, *lastSyncState); + UpdateLastSynchronousState::execute(baseDirObj, *lastSyncState); //serialize again BinaryStream updatedStreamLeft; |