Migrate to std::filesystem usage in FilePath

C/c4BlobStore.cc

@@ -91,7 +91,7 @@ static optional<C4BlobKey> BlobKeyFromFilename(slice filename) {
 
 C4BlobStore::C4BlobStore(slice dirPath, C4DatabaseFlags flags, const C4EncryptionKey& key)
     : _dirPath(dirPath), _flags(flags), _encryptionKey(key) {
-    FilePath dir(_dirPath, "");
+    FilePath dir(_dirPath);
     if ( dir.exists() ) {
         dir.mustExistAsDir();
     } else if ( !(flags & kC4DB_ReadOnly) ) {
@@ -103,9 +103,9 @@ C4BlobStore::~C4BlobStore() = default;
 
 void C4BlobStore::deleteStore() { dir().delRecursive(); }
 
-FilePath C4BlobStore::dir() const { return {_dirPath, ""}; }
+FilePath C4BlobStore::dir() const { return filesystem::path(_dirPath); }
 
-FilePath C4BlobStore::pathForKey(C4BlobKey key) const { return {_dirPath, BlobKeyToFilename(key)}; }
+FilePath C4BlobStore::pathForKey(C4BlobKey key) const { return filesystem::path(_dirPath) / BlobKeyToFilename(key); }
 
 alloc_slice C4BlobStore::getFilePath(C4BlobKey key) const {
     FilePath path = pathForKey(key);

C/c4Database.cc

@@ -27,6 +27,7 @@
 #include <cinttypes>
 #include <optional>
 #include <regex>
+#include <filesystem>
 
 
 // NOTE: Most of C4Database is implemented in its concrete subclass DatabaseImpl.
@@ -71,11 +72,12 @@ void C4Database::enableExtension(slice name, slice path) {
 
 static FilePath dbPath(slice name, slice parentDir) {
     if ( name.size == 0 || parentDir.size == 0 ) C4Error::raise(LiteCoreDomain, kC4ErrorInvalidParameter);
-    return FilePath(string(parentDir), string(name)).addingExtension(kC4DatabaseFilenameExtension);
+    return FilePath(filesystem::path(parentDir.asString()) / name.asString())
+            .addingExtension(kC4DatabaseFilenameExtension);
 }
 
 static void ensureConfigDirExists(const C4DatabaseConfig2& config) {
-    if ( !(config.flags & kC4DB_ReadOnly) ) (void)FilePath(slice(config.parentDirectory), "").mkdir();
+    if ( !(config.flags & kC4DB_ReadOnly) ) (void)FilePath(slice(config.parentDirectory).asString()).mkdir();
 }
 
 static C4DatabaseConfig newToOldConfig(const C4DatabaseConfig2& config2) {
@@ -99,7 +101,7 @@ static C4DatabaseConfig newToOldConfig(const C4DatabaseConfig2& config2) {
 
 /*static*/ bool C4Database::deleteAtPath(slice dbPath) {
     // Find the db file in the bundle:
-    FilePath bundle{dbPath, ""};
+    FilePath bundle(dbPath.asString());
     if ( bundle.exists() ) {
         try {
             C4StorageEngine storageEngine = nullptr;
@@ -143,21 +145,21 @@ constexpr const char* kInvalidDbNameMsgTemplate =
 /*static*/ Retained<C4Database> C4Database::openAtPath(slice path, C4DatabaseFlags flags, const C4EncryptionKey* key) {
     C4DatabaseConfig config = {flags};
     if ( key ) config.encryptionKey = *key;
-    return DatabaseImpl::open(FilePath(path, ""), config);
+    return DatabaseImpl::open(FilePath(path.asString()), config);
 }
 
 /*static*/ void C4Database::copyNamed(slice sourcePath, slice destinationName, const Config& config) {
     if ( !isValidDbName(destinationName) ) { Warn(kInvalidDbNameMsgTemplate, destinationName.asString().c_str()); }
 
     ensureConfigDirExists(config);
-    FilePath         from(sourcePath, "");
+    FilePath         from(sourcePath.asString());
     FilePath         to        = dbPath(destinationName, config.parentDirectory);
     C4DatabaseConfig oldConfig = newToOldConfig(config);
     CopyPrebuiltDB(from, to, &oldConfig);
 }
 
 /*static*/ void C4Database::copyFileToPath(slice sourcePath, slice destinationPath, const C4DatabaseConfig& config) {
-    return CopyPrebuiltDB(FilePath(sourcePath), FilePath(destinationPath), &config);
+    return CopyPrebuiltDB(FilePath(sourcePath.asString()), FilePath(destinationPath.asString()), &config);
 }
 
 /*static*/ bool C4Database::deleteNamed(slice name, slice inDirectory) {

C/tests/c4DatabaseTest.cc

@@ -34,6 +34,7 @@
 #include <iostream>
 #include <mutex>
 #include <thread>
+#include <filesystem>
 
 #include "sqlite3.h"
 
@@ -183,7 +184,7 @@ N_WAY_TEST_CASE_METHOD(C4DatabaseTest, "Database OpenNamed", "[Database][C][!thr
     REQUIRE(bundle);
     CHECK(c4db_getName(bundle) == kTestBundleName);
     C4SliceResult path = c4db_getPath(bundle);
-    CHECK(path == TEMPDIR("cbl_core_test_bundle.cblite2" kPathSeparator));  // note trailing '/'
+    CHECK(path == TEMPDIR("cbl_core_test_bundle.cblite2"));
     c4slice_free(path);
     REQUIRE(c4db_close(bundle, WITH_ERROR()));
     c4db_release(bundle);
@@ -912,21 +913,22 @@ N_WAY_TEST_CASE_METHOD(C4DatabaseTest, "Database copy", "[Database][C]") {
 
     createRev(doc1ID, kRevID, kFleeceBody);
     createRev(doc2ID, kRevID, kFleeceBody);
-    string srcPathStr = toString(c4db_getPath(db));
+    string srcPathStr = toString(c4db_getPath(db)) + "/";
 
     C4DatabaseConfig2 config = *c4db_getConfig2(db);
 
-    string nuPath = string(slice(config.parentDirectory)) + string(kNuName) + ".cblite2" + kPathSeparator;
+    auto nuPath    = filesystem::path(string(slice(config.parentDirectory))) / (string(kNuName) + ".cblite2");
+    auto nuPathStr = nuPath.string() + "/";
 
     C4Error error;
 
     SECTION("WITH SLASH") {}
     SECTION("WITHOUT SLASH") {
         srcPathStr.pop_back();
-        nuPath.pop_back();
+        nuPathStr.pop_back();
     }
 
-    if ( !c4db_deleteNamed(kNuName, slice(nuPath), &error) ) { REQUIRE(error.code == 0); }
+    if ( !c4db_deleteNamed(kNuName, slice(nuPathStr), &error) ) { REQUIRE(error.code == 0); }
 
     {
         ExpectingExceptions x;
@@ -1116,8 +1118,8 @@ N_WAY_TEST_CASE_METHOD(C4DatabaseTest, "Database Create Upgrade Fixture", "[.Mai
 
     closeDB();
 
-    litecore::FilePath fixturePath(C4DatabaseTest::sFixturesDir + kVersionedFixturesSubDir + filename, "");
-    litecore::FilePath(string(path), "").moveToReplacingDir(fixturePath, false);
+    litecore::FilePath fixturePath(C4DatabaseTest::sFixturesDir + kVersionedFixturesSubDir + filename);
+    litecore::FilePath(string(path)).moveToReplacingDir(fixturePath, false);
     C4Log("New fixture is at %s", string(fixturePath).c_str());
 }
 

C/tests/c4PerfTest.cc

@@ -43,7 +43,7 @@ class PerfTest : public C4Test {
     explicit PerfTest(int variation) : C4Test(variation) {
         const char* showFastDir = getenv("CBL_SHOWFAST_DIR");
         if ( showFastDir ) {
-            litecore::FilePath showFastPath(showFastDir, "");
+            litecore::FilePath showFastPath(showFastDir);
             if ( showFastPath.exists() && showFastPath.isDir() ) { _showFastDir = showFastDir; }
         }
 
@@ -251,7 +251,7 @@ class PerfTest : public C4Test {
         if ( isEncrypted() ) { filename += "_encrypted"; }
 
         filename += ".json";
-        litecore::FilePath sfPath(_showFastDir, filename);
+        litecore::FilePath sfPath(filesystem::path(string(_showFastDir)) / filename);
 
         ofstream fout(sfPath.path(), ios::trunc | ios::out);
         fout.exceptions(ostream::failbit | ostream::badbit);
@@ -300,7 +300,7 @@ N_WAY_TEST_CASE_METHOD(PerfTest, "Import iTunesMusicLibrary", "[Perf][C][.slow]"
     st.stop();
     st.printReport("******** Importing JSON w/spaces", numDocs, "doc");
 
-    litecore::FilePath path(alloc_slice(c4db_getPath(db)).asString(), "db.sqlite3");
+    litecore::FilePath path(filesystem::path(slice(c4db_getPath(db)).asString()) / "db.sqlite3");
     fprintf(stderr, "******** DB size is %" PRIi64 "\n", path.dataSize());
     reopenDB();
     string sf = generateShowfast((double)numDocs / st.elapsed(), "tunes_import_json");

C/tests/c4Test.cc

@@ -304,8 +304,8 @@ void C4Test::deleteAndRecreateDB(C4Database*& db) {
 /*static*/ alloc_slice C4Test::copyFixtureDB(const string& name) { return copyFixtureDB(sFixturesDir, name); }
 
 alloc_slice C4Test::copyFixtureDB(const string& parentDir, const string& name) {
-    auto               srcPath = litecore::FilePath(parentDir + name, "");
-    litecore::FilePath destDir(TempDir(), "");
+    auto               srcPath = litecore::FilePath(parentDir + name);
+    litecore::FilePath destDir(TempDir());
     auto               dbPath = destDir[srcPath.fileOrDirName() + "/"];
     dbPath.delRecursive();
     srcPath.copyTo(dbPath);

C/tests/c4Test.hh

@@ -129,7 +129,7 @@ class WITH_ERROR {
 
 
 // Temporary directory to use for tests.
-#define TEMPDIR(PATH) c4str((TempDir() + (PATH)).c_str())
+#define TEMPDIR(PATH) c4str((TempDir() + kPathSeparator + (PATH)).c_str())
 
 const std::string& TempDir();
 

C/tests/cmake/platform_linux.cmake

@@ -2,7 +2,6 @@ function(setup_build)
     target_sources(
         C4Tests PRIVATE
         ${TOP}Crypto/mbedUtils.cc
-        ${TOP}LiteCore/Unix/strlcat.c
     )
 
     target_link_libraries(

C/tests/cmake/platform_win.cmake

@@ -12,9 +12,6 @@ function(setup_build)
         ${TOP}LiteCore/Support/PlatformIO.cc
         ${TOP}MSVC/vasprintf-msvc.c
         ${TOP}MSVC/asprintf.c
-        ${TOP}MSVC/mkdtemp.cc
-        ${TOP}MSVC/mkstemp.cc
-        ${TOP}MSVC/strlcat.c
         ${TOP}MSVC/asprintf.c
     )
 

LiteCore/BlobStore/BlobStreams.cc

@@ -15,6 +15,7 @@
 #include "EncryptedStream.hh"
 #include "Error.hh"
 #include "Logging.hh"
+#include <filesystem>
 
 namespace litecore {
     using namespace std;
@@ -38,7 +39,7 @@ namespace litecore {
 
     BlobWriteStream::BlobWriteStream(const string& blobsDir, EncryptionAlgorithm algorithm, slice encryptionKey) {
         FILE* file;
-        _tmpPath = FilePath(blobsDir, "incoming_").mkTempFile(&file);
+        _tmpPath = FilePath(filesystem::path(blobsDir) / "incoming_").mkTempFile(&file);
         _writer  = shared_ptr<WriteStream>{new FileWriteStream(file)};
         if ( algorithm != EncryptionAlgorithm::kNoEncryption )
             _writer = make_shared<EncryptedWriteStream>(_writer, algorithm, encryptionKey);

LiteCore/Database/DatabaseImpl.cc

@@ -68,7 +68,7 @@ namespace litecore {
     // `path` is path to bundle; return value is path to db file. Updates config.storageEngine. */
     /*static*/ FilePath DatabaseImpl::findOrCreateBundle(const string& path, bool canCreate,
                                                          C4StorageEngine& storageEngine) {
-        FilePath bundle(path, "");
+        FilePath bundle(path);
         bool     createdDir = (canCreate && bundle.mkdir());
         if ( !createdDir ) bundle.mustExistAsDir();
 
@@ -118,7 +118,7 @@ namespace litecore {
                         if ( bundlePath.isDir() ) {
                             bundlePath.delRecursive();
                         } else {
-                            FilePath{bundlePath.path(), ""}.delRecursive();
+                            FilePath{bundlePath.path()}.delRecursive();
                         }
                     }
                 } catch ( ... ) {

LiteCore/Logging/LogFiles.cc

@@ -128,7 +128,7 @@ namespace litecore {
         }
 
         void purgeOldLogs() {
-            FilePath logDir(_options.directory, "");
+            FilePath logDir(_options.directory);
             if ( !logDir.existsAsDir() ) { return; }
 
             multimap<time_t, FilePath> logFiles;

LiteCore/Storage/DataFile.cc

@@ -20,7 +20,6 @@
 #include "Instrumentation.hh"
 #include <algorithm>
 #include <cerrno>
-#include <dirent.h>
 #include <exception>
 #include <iomanip>
 #include <sstream>

LiteCore/Support/DatabasePool.cc

@@ -86,7 +86,9 @@ namespace litecore {
         logInfo("...all databases closed!");
     }
 
-    FilePath DatabasePool::databasePath() const { return FilePath{_dbDir, _dbName + kC4DatabaseFilenameExtension}; }
+    FilePath DatabasePool::databasePath() const {
+        return filesystem::path(_dbDir.asString()) / (_dbName + kC4DatabaseFilenameExtension);
+    }
 
     unsigned DatabasePool::capacity() const noexcept {
         unique_lock lock(_mutex);